fix: resolve Playwright resource leaks and improve disposal robustness

Browser contexts were not closed on test failure paths in BrowserTest,
leading to leaked browser resources. Additionally, if any single context
or service disposal threw an exception, remaining resources were skipped
entirely. This change ensures all contexts and services are always
disposed via try/catch loops that collect exceptions, adds null-safety
to BrowserService.DisposeAsync, protects the context list with a lock,
and falls back to full disposal when WorkerAwareTest.ResetAsync fails.

Author: thomhurst

TUnit.Playwright/BrowserService.cs

@@ -51,5 +51,14 @@ private static async Task<IBrowser> CreateBrowser(
     }
 
     public Task ResetAsync() => Task.CompletedTask;
-    public Task DisposeAsync() => Browser.CloseAsync();
+
+    public async Task DisposeAsync()
+    {
+        var browser = Browser;
+
+        if (browser != null)
+        {
+            await browser.CloseAsync().ConfigureAwait(false);
+        }
+    }
 }

TUnit.Playwright/BrowserTest.cs

@@ -17,12 +17,18 @@ public BrowserTest(BrowserTypeLaunchOptions options)
     public IBrowser Browser { get; internal set; } = null!;
 
     private readonly List<IBrowserContext> _contexts = [];
+    private readonly object _contextsLock = new();
     private readonly BrowserTypeLaunchOptions _options;
 
     public async Task<IBrowserContext> NewContext(BrowserNewContextOptions options)
     {
         var context = await Browser.NewContextAsync(options).ConfigureAwait(false);
-        _contexts.Add(context);
+
+        lock (_contextsLock)
+        {
+            _contexts.Add(context);
+        }
+
         return context;
     }
 
@@ -33,22 +39,42 @@ public async Task BrowserSetup()
         {
             throw new InvalidOperationException($"BrowserType is not initialized. This may indicate that {nameof(PlaywrightTest)}.{nameof(Playwright)} is not initialized or {nameof(PlaywrightTest)}.{nameof(PlaywrightSetup)} did not execute properly.");
         }
-        
+
         var service = await BrowserService.Register(this, BrowserType, _options).ConfigureAwait(false);
         Browser = service.Browser;
     }
 
     [After(HookType.Test, "", 0)]
     public async Task BrowserTearDown(TestContext testContext)
     {
-        if (TestOk(testContext))
+        List<IBrowserContext> contextsSnapshot;
+
+        lock (_contextsLock)
+        {
+            contextsSnapshot = [.. _contexts];
+            _contexts.Clear();
+        }
+
+        List<Exception>? exceptions = null;
+
+        foreach (var context in contextsSnapshot)
         {
-            foreach (var context in _contexts)
+            try
             {
                 await context.CloseAsync().ConfigureAwait(false);
             }
+            catch (Exception ex)
+            {
+                exceptions ??= [];
+                exceptions.Add(ex);
+            }
         }
-        _contexts.Clear();
+
         Browser = null!;
+
+        if (exceptions is { Count: > 0 })
+        {
+            throw new AggregateException("One or more browser contexts failed to close.", exceptions);
+        }
     }
 }

TUnit.Playwright/WorkerAwareTest.cs

@@ -22,12 +22,14 @@ private class Worker
 
     public async Task<T> RegisterService<T>(string name, Func<Task<T>> factory) where T : class, IWorkerService
     {
-        if (!_currentWorker.Services.ContainsKey(name))
+        if (!_currentWorker.Services.TryGetValue(name, out var existing))
         {
-            _currentWorker.Services[name] = await factory().ConfigureAwait(false);
+            var service = await factory().ConfigureAwait(false);
+            _currentWorker.Services[name] = service;
+            return service;
         }
 
-        return (_currentWorker.Services[name] as T)!;
+        return (existing as T)!;
     }
 
     [Before(HookType.Test, "", 0)]
@@ -44,23 +46,58 @@ public void WorkerSetup()
     [After(HookType.Test, "", 0)]
     public async Task WorkerTeardown(TestContext testContext)
     {
+        var worker = _currentWorker;
+
+        if (worker == null)
+        {
+            return;
+        }
+
         if (TestOk(testContext))
         {
-            foreach (var kv in _currentWorker.Services)
+            try
             {
-                await kv.Value.ResetAsync().ConfigureAwait(false);
-            }
+                foreach (var kv in worker.Services)
+                {
+                    await kv.Value.ResetAsync().ConfigureAwait(false);
+                }
 
-            AllWorkers.Push(_currentWorker);
+                AllWorkers.Push(worker);
+            }
+            catch
+            {
+                await DisposeAllServicesAsync(worker).ConfigureAwait(false);
+                throw;
+            }
         }
         else
         {
-            foreach (var kv in _currentWorker.Services)
+            await DisposeAllServicesAsync(worker).ConfigureAwait(false);
+        }
+    }
+
+    private static async Task DisposeAllServicesAsync(Worker worker)
+    {
+        List<Exception>? exceptions = null;
+
+        foreach (var kv in worker.Services)
+        {
+            try
             {
                 await kv.Value.DisposeAsync().ConfigureAwait(false);
             }
+            catch (Exception ex)
+            {
+                exceptions ??= [];
+                exceptions.Add(ex);
+            }
+        }
 
-            _currentWorker.Services.Clear();
+        worker.Services.Clear();
+
+        if (exceptions is { Count: > 0 })
+        {
+            throw new AggregateException("One or more worker services failed to dispose.", exceptions);
         }
     }