Updated tests to simpler model.

Author: KristofferStrube

tests/BlazorServer/EvaluationContext.cs

@@ -1,10 +1,6 @@
-namespace BlazorServer;
+
+namespace BlazorServer;
 
 public class EvaluationContext
 {
-    public object? Result { get; set; }
-
-    public Exception? Exception { get; set; }
-
-    public Func<Task<object?>>? AfterRenderAsync { get; set; }
-}
+}

tests/BlazorServer/Pages/Index.razor

@@ -8,20 +8,9 @@
     [Inject]
     public required EvaluationContext EvaluationContext { get; set; }
 
-    protected override async Task OnAfterRenderAsync(bool firstRender)
+    protected override void OnAfterRender(bool firstRender)
     {
         if (!firstRender) return;
-        try
-        {
-            if (EvaluationContext.AfterRenderAsync is not null)
-            {
-                EvaluationContext.Result = await EvaluationContext.AfterRenderAsync.Invoke();
-            }
-        }
-        catch (Exception e)
-        {
-            EvaluationContext.Exception = e;
-        }
         result = "done";
         StateHasChanged();
     }

tests/IntegrationTests/Infrastructure/BlazorTest.cs

@@ -0,0 +1,108 @@
+using BlazorServer;
+using Microsoft.AspNetCore.Hosting.Server;
+using Microsoft.AspNetCore.Hosting.Server.Features;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.JSInterop;
+using Microsoft.Playwright;
+
+namespace KristofferStrube.Blazor.MediaCaptureStreams.IntegrationTests.Infrastructure;
+
+[TestFixture("Chrome")]
+public class BlazorTest(string browserName)
+{
+    private IHost? _host;
+
+    protected Uri RootUri;
+    protected virtual string[] Args => ["--use-fake-device-for-media-stream", "--use-fake-ui-for-media-stream"];
+
+    protected MediaDevicesEvaluationContext EvaluationContext { get; set; } = default!;
+    protected MediaDevicesEvaluationContext EvaluationContextCreator(IServiceProvider sp)
+    {
+        EvaluationContext = MediaDevicesEvaluationContext.Create(sp);
+        return EvaluationContext;
+    }
+
+    protected IJSRuntime JSRuntime => EvaluationContext.JSRuntime;
+    protected IMediaDevicesService MediaDevicesService => EvaluationContext.MediaDevicesService;
+
+    protected IPlaywright PlaywrightInstance { get; set; }
+    protected IBrowser Browser { get; set; }
+    protected IBrowserContext Context { get; set; }
+    protected IPage Page { get; set; }
+
+    [OneTimeSetUp]
+    public async Task Setup()
+    {
+        PlaywrightInstance = await Playwright.CreateAsync();
+
+        IBrowserType browserType = browserName switch
+        {
+            "Firefox" => PlaywrightInstance.Firefox,
+            _ => PlaywrightInstance.Chromium,
+        };
+
+        Browser = await browserType.LaunchAsync(new()
+        {
+            Args = Args,
+        });
+        // Create a new incognito browser context
+        Context = await Browser.NewContextAsync();
+        // Create a new page inside context.
+        Page = await Context.NewPageAsync();
+
+        _host = BlazorServer.Program.BuildWebHost([],
+            serviceBuilder =>
+            {
+                _ = serviceBuilder
+                    .AddScoped(typeof(EvaluationContext), EvaluationContextCreator)
+                    .AddMediaDevicesService();
+            }
+        );
+
+        await _host.StartAsync();
+
+        RootUri = new(_host.Services.GetRequiredService<IServer>().Features
+            .GetRequiredFeature<IServerAddressesFeature>()
+            .Addresses.Single());
+    }
+
+    [SetUp]
+    public async Task SetupBeforeEachTestRun()
+    {
+        await OnAfterRerenderAsync();
+    }
+
+    [OneTimeTearDown]
+    public async Task TearDown()
+    {
+        if (Page is not null)
+        {
+            await Page.CloseAsync();
+        }
+        if (Context is not null)
+        {
+            await Context.CloseAsync();
+        }
+        if (Browser is not null)
+        {
+            await Browser.CloseAsync();
+        }
+        if (PlaywrightInstance is not null)
+        {
+            PlaywrightInstance.Dispose();
+        }
+        if (_host is not null)
+        {
+            await _host.StopAsync();
+            _host.Dispose();
+        }
+    }
+
+    protected async Task OnAfterRerenderAsync()
+    {
+        _ = await Page.GotoAsync(RootUri.AbsoluteUri);
+        await Assertions.Expect(Page.GetByTestId("result")).ToHaveTextAsync($"done");
+    }
+}

tests/IntegrationTests/Infrastructure/MediaBlazorTest.cs

@@ -1,8 +1,20 @@
 using BlazorServer;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.JSInterop;
 
 namespace KristofferStrube.Blazor.MediaCaptureStreams.IntegrationTests.Infrastructure;
 
-public class MediaDevicesEvaluationContext(IMediaDevicesService mediaDeviceService) : EvaluationContext
+public class MediaDevicesEvaluationContext(IJSRuntime jSRuntime, IMediaDevicesService mediaDeviceService) : EvaluationContext
 {
+    public IJSRuntime JSRuntime => jSRuntime;
+
     public IMediaDevicesService MediaDevicesService => mediaDeviceService;
+
+    public static MediaDevicesEvaluationContext Create(IServiceProvider provider)
+    {
+        IMediaDevicesService mediaDevicesService = provider.GetRequiredService<IMediaDevicesService>();
+        IJSRuntime jSRuntime = provider.GetRequiredService<IJSRuntime>();
+
+        return new MediaDevicesEvaluationContext(jSRuntime, mediaDevicesService);
+    }
 }

tests/IntegrationTests/Infrastructure/MediaDevicesEvaluationContext.cs

@@ -2,26 +2,17 @@
 
 namespace KristofferStrube.Blazor.MediaCaptureStreams.IntegrationTests;
 
-public class MediaDevicesNotSupportedTest : MediaBlazorTest
+public class MediaDevicesNotSupportedTest(string browserName) : BlazorTest(browserName)
 {
     protected override string[] Args => [];
 
     [Test]
     public async Task GetUserMedia_Throws_NotSupportedErrorException_WhenNotSupported()
     {
         // Arrange
-        AfterRenderAsync = async () =>
-        {
-            await using MediaDevices mediaDevices = await EvaluationContext.MediaDevicesService.GetMediaDevicesAsync();
-            MediaStream mediaStream = await mediaDevices.GetUserMediaAsync(new() { Audio = true });
-            MediaStreamTrack[] videoTracks = await mediaStream.GetVideoTracksAsync();
-            return videoTracks.Length;
-        };
-
-        // Act
-        await DoneLoadingPageAsync();
+        await using MediaDevices mediaDevices = await MediaDevicesService.GetMediaDevicesAsync();
 
         // Assert
-        Assert.That(EvaluationContext.Exception, Is.InstanceOf<NotSupportedErrorException>().Or.InstanceOf<NotFoundErrorException>());
+        Assert.ThrowsAsync<NotSupportedErrorException>(async () => await mediaDevices.GetUserMediaAsync(new() { Audio = true }));
     }
 }