Test JSRuntime for value type handling

Author: Regenhardt

src/Components/test/E2ETest/Tests/InteropValueTypesTest.cs

@@ -0,0 +1,71 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using BasicTestApp;
+using Microsoft.AspNetCore.Components.E2ETest;
+using Microsoft.AspNetCore.Components.E2ETest.Infrastructure;
+using Microsoft.AspNetCore.Components.E2ETest.Infrastructure.ServerFixtures;
+using Microsoft.AspNetCore.E2ETesting;
+using Microsoft.JSInterop;
+using OpenQA.Selenium;
+using Xunit.Abstractions;
+
+namespace Microsoft.AspNetCore.Components.E2ETests.Tests;
+
+public class InteropValueTypesTest: ServerTestBase<BlazorWasmTestAppFixture<Program>>
+{
+    public InteropValueTypesTest(
+        BrowserFixture browserFixture,
+        BlazorWasmTestAppFixture<Program> serverFixture,
+        ITestOutputHelper output)
+        : base(browserFixture, serverFixture, output)
+    {
+    }
+
+    protected override void InitializeAsyncCore()
+    {
+        Navigate(ServerPathBase);
+        Browser.MountTestComponent<InteropValueTypesComponent>();
+    }
+
+    [Fact]
+    public void CanRetrieveStoredGuidAsString()
+    {
+        Browser.Exists(By.Id("done-with-interop"));
+
+        var stringGuidElement = Browser.Exists(By.Id("string-get-by-interop"));
+
+        Browser.NotEqual(string.Empty, () => stringGuidElement.Text);
+        Browser.NotEqual(default, () => Guid.Parse(stringGuidElement.Text));
+    }
+
+    [Fact]
+    public void CanRetrieveStoredGuidAsGuid()
+    {
+        Browser.Exists(By.Id("done-with-interop"));
+
+        var guidElement = Browser.Exists(By.Id("guid-get-by-interop"));
+
+        Browser.NotEqual(default, () => Guid.Parse(guidElement.Text));
+    }
+
+    [Fact]
+    public void CanRetrieveStoredGuidAsNullableGuid()
+    {
+        Browser.Exists(By.Id("done-with-interop"));
+
+        var nullableGuidElement = Browser.Exists(By.Id("nullable-guid-get-by-interop"));
+
+        Browser.NotEqual(default, () => Guid.Parse(nullableGuidElement.Text));
+    }
+
+    [Fact]
+    public void CanRetrieveNullAsNullableGuid()
+    {
+        Browser.Exists(By.Id("done-with-interop"));
+
+        var nullableGuidElement = Browser.Exists(By.Id("null-loaded-into-nullable"));
+
+        Browser.Equal(false.ToString(), () => nullableGuidElement.Text);
+    }
+}

src/Components/test/E2ETest/Tests/StartupErrorNotificationTest.cs

@@ -27,7 +27,7 @@ public StartupErrorNotificationTest(
     public void DisplaysNotificationForStartupException(bool errorIsAsync)
     {
         var url = $"{ServerPathBase}?error={(errorIsAsync ? "async" : "sync")}";
-
+        
         Navigate(url);
         var errorUiElem = Browser.Exists(By.Id("blazor-error-ui"), TimeSpan.FromSeconds(10));
         Assert.NotNull(errorUiElem);

src/Components/test/testassets/BasicTestApp/InteropValueTypesComponent.razor

@@ -0,0 +1,70 @@
+@using Microsoft.JSInterop
+@inject IJSRuntime JSRuntime
+
+<p>
+    This component shows it's possible to save and load value types (in this case, a guid)
+    to and from localstorage,
+    and also that a null value can be loaded into a nullable value type, i.e. a Guid?.
+</p>
+
+<p>
+    String value from guid:
+    <strong id="string-get-by-interop">@(stringFromInterop ?? "No value yet")</strong>
+</p>
+
+<p>
+    Guid value from guid is default(Guid) if it wasn't loaded correctly:
+    <strong id="guid-get-by-interop">@guidFromInterop</strong>
+</p>
+
+<p>
+    Nullable Guid value from guid is null if it wasn't loaded correctly:
+    <strong id="nullable-guid-get-by-interop">@nullableGuidFromInterop</strong>
+</p>
+
+<p>
+    Nullable load result is false if the null value wasn't loaded into the nullable guid correctly:
+    <strong id="null-loaded-into-nullable">@nullableLoadResult</strong>
+</p>
+
+@if (doneWithInterop)
+{
+    <p id="done-with-interop">
+        Done with interop!
+    </p>
+}
+
+@code {
+    readonly Guid guid = Guid.NewGuid();
+    string stringFromInterop;
+    Guid guidFromInterop;
+    Guid? nullableGuidFromInterop;
+    bool nullableLoadResult;
+
+    bool doneWithInterop;
+
+    protected override async Task OnInitializedAsync()
+    {
+        // Store guid in localStorage
+        await JSRuntime.InvokeVoidAsync("localStorage.setItem", "guid", guid);
+
+        // Retrieve guid from localStorage as string because it's a simple conversion
+        stringFromInterop = await JSRuntime.InvokeAsync<string>("localStorage.getItem", "guid");
+
+        // Retrieve guid from localStorage as Guid
+        guidFromInterop = await JSRuntime.InvokeAsync<Guid>("localStorage.getItem", "guid");
+
+        // Retrieve guid from localStorage as Guid?
+        nullableGuidFromInterop = await JSRuntime.InvokeAsync<Guid?>("localStorage.getItem", "guid");
+
+        // Retrieve null from localStorage as Guid?
+        var nullableGuid = await JSRuntime.InvokeAsync<Guid?>("localStorage.getItem", "nothingHere");
+
+        // If the retrieval crashes, the bool stays false
+        nullableLoadResult = !nullableGuid.HasValue;
+
+        doneWithInterop = true;
+
+        StateHasChanged();
+    }
+}