[INT-324] [C#] Support Parallel Test Sessions (#243)

Co-authored-by: Sebastian Alex <[email protected]>

Author: titusfortner

visual-dotnet/SauceLabs.Visual.Tests/BuildFactoryParallelTest.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using RichardSzalay.MockHttp;
+using SauceLabs.Visual.GraphQL;
+using SauceLabs.Visual.Models;
+using System.Collections.Generic;
+using Moq;
+using GraphQL;
+
+namespace SauceLabs.Visual.Tests;
+
+public class BuildFactoryParallelTest
+{
+    MockHttpMessageHandler MockedHandler;
+    private const string _username = "dummy-username";
+    private const string _accessKey = "dummy-key";
+    private int _buildCounter = 0;
+
+    [SetUp]
+    public void Setup()
+    {
+        MockedHandler = new MockHttpMessageHandler();
+        _buildCounter = 0;
+
+        var createHandler = () =>
+        {
+            _buildCounter++;
+
+            var id = RandomString(32);
+            var content = new VisualBuild(id, $"http://dummy/test/{id}", BuildMode.Running);
+            var resp = new HttpResponseMessage(HttpStatusCode.OK);
+            resp.Content = new ReadOnlyMemoryContent(ToResult(content));
+            resp.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+            return Task.FromResult(resp);
+        };
+
+        var base64EncodedAuthenticationString =
+            Convert.ToBase64String(Encoding.ASCII.GetBytes($"{_username}:{_accessKey}"));
+        var regions = new[] { Region.Staging, Region.UsEast4, Region.EuCentral1, Region.UsWest1 };
+        foreach (var r in regions)
+        {
+            MockedHandler
+                .When(r.Value.ToString())
+                .WithHeaders($"Authorization: Basic {base64EncodedAuthenticationString}")
+                .WithPartialContent($"\"operationName\":\"{CreateBuildMutation.OperationName}\"")
+                .Respond(createHandler);
+            MockedHandler
+                .When(r.Value.ToString())
+                .WithHeaders($"Authorization: Basic {base64EncodedAuthenticationString}")
+                .WithPartialContent($"\"operationName\":\"{FinishBuildMutation.OperationName}\"")
+                .Respond(createHandler);
+        }
+        MockedHandler.Fallback.Throw(new InvalidOperationException("No matching mock handler"));
+    }
+
+    [TearDown]
+    public async Task Cleanup()
+    {
+        await BuildFactory.CloseBuilds();
+        MockedHandler.Dispose();
+    }
+
+    private string RandomString(int length)
+    {
+        const string chars = "abcdef0123456789";
+        return new string(Enumerable.Repeat(chars, length).Select(s => s[Random.Shared.Next(s.Length)]).ToArray());
+    }
+
+    private byte[] ToResult(object o)
+    {
+        var nestedContent = new
+        {
+            Data = new
+            {
+                Result = o
+            },
+        };
+        return Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(nestedContent));
+    }
+
+    [Test]
+    public async Task BuildFactory_CreateOnlyOneBuildWhenCalledInParallel()
+    {
+        var api = new VisualApi(Region.Staging, _username, _accessKey, MockedHandler.ToHttpClient());
+        var options = new CreateBuildOptions { Name = "ParallelBuildTest" };
+        const int parallelCalls = 6;
+
+        var tasks = Enumerable.Range(0, parallelCalls)
+            .Select(_ => BuildFactory.Get(api, options))
+            .ToArray();
+
+        var builds = await Task.WhenAll(tasks);
+
+        var firstBuild = builds[0];
+        Assert.That(builds, Is.All.EqualTo(firstBuild), "All builds should be the same instance");
+        Assert.AreEqual(1, _buildCounter, "Only one build should have been created");
+    }
+
+    [Test]
+    public async Task BuildFactory_CreateDifferentBuildsWhenCalledInParallelWithDifferentNames()
+    {
+        var api = new VisualApi(Region.Staging, _username, _accessKey, MockedHandler.ToHttpClient());
+        const int parallelCalls = 3;
+
+        var tasks = Enumerable.Range(0, parallelCalls)
+            .Select(i => BuildFactory.Get(api, new CreateBuildOptions { Name = $"ParallelBuildTest-{i}" }))
+            .ToArray();
+
+        var builds = await Task.WhenAll(tasks);
+
+        Assert.That(builds.Distinct().Count(), Is.EqualTo(builds.Length), "All builds should be different instances");
+        Assert.AreEqual(parallelCalls, _buildCounter, $"Expected {parallelCalls} builds to be created");
+    }
+
+    [Test]
+    public async Task BuildFactory_CreateDifferentBuildsWhenCalledInParallelWithNamesEqualToRegionNames()
+    {
+        var api = new VisualApi(Region.Staging, _username, _accessKey, MockedHandler.ToHttpClient());
+
+        var buildOptions = new[]{
+            new CreateBuildOptions {
+                Name = "ParallelBuildTest-1"
+            },
+            new CreateBuildOptions {
+                Name = "ParallelBuildTest-2"
+            },
+            new CreateBuildOptions {
+                Name = Region.Staging.Name,
+            },
+        };
+        var parallelCalls = buildOptions.Length;
+
+        var tasks = buildOptions
+            .Select(opts => BuildFactory.Get(api, opts))
+            .ToArray();
+
+        var builds = await Task.WhenAll(tasks);
+
+        Assert.That(builds.Distinct().Count(), Is.EqualTo(builds.Length), "All builds should be different instances");
+        Assert.AreEqual(parallelCalls, _buildCounter, $"Expected {parallelCalls} builds to be created");
+    }
+}

visual-dotnet/SauceLabs.Visual/BuildFactory.cs

@@ -1,83 +1,120 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Concurrent;
 using System.Linq;
 using System.Threading.Tasks;
 using SauceLabs.Visual.GraphQL;
 using SauceLabs.Visual.Utils;
 
 namespace SauceLabs.Visual
 {
+    /// <summary>
+    /// Factory for creating and managing Visual builds.
+    /// This class is thread-safe and supports parallel execution.
+    /// </summary>
     internal static class BuildFactory
     {
-        private static readonly Dictionary<string, ApiBuildPair> Builds = new Dictionary<string, ApiBuildPair>();
+
+        private static readonly ConcurrentDictionary<BuildKey, Lazy<Task<ApiBuildPair>>> Builds =
+            new ConcurrentDictionary<BuildKey, Lazy<Task<ApiBuildPair>>>();
 
         /// <summary>
-        /// <c>Get</c> returns the build matching with the requested region.
+        /// <c>Get</c> returns the build matching with the requested region or name.
         /// If none is available, it returns a newly created build with <c>options</c>.
         /// It will also clone the input <c>api</c> to be able to close the build later.
+        /// This method is thread-safe and ensures only one build is created when called concurrently with the same key.
         /// </summary>
         /// <param name="api">the api to use to create build</param>
         /// <param name="options">the options to use when creating the build</param>
-        /// <returns></returns>
+        /// <returns>A VisualBuild instance</returns>
         internal static async Task<VisualBuild> Get(VisualApi api, CreateBuildOptions options)
         {
-            // Check if there is already a build for the current region.
-            if (Builds.TryGetValue(api.Region.Name, out var build))
+            BuildKey buildKey;
+            if (!string.IsNullOrEmpty(options.Name))
+            {
+                buildKey = BuildKey.OfBuildName(options.Name);
+            }
+            else
             {
-                return build.Build;
+                buildKey = BuildKey.OfRegion(api.Region);
             }
 
-            var createdBuild = await Create(api, options);
-            Builds[api.Region.Name] = new ApiBuildPair(api.Clone(), createdBuild);
-            return createdBuild;
+            var lazyBuild = Builds.GetOrAdd(buildKey, key => new Lazy<Task<ApiBuildPair>>(async () =>
+            {
+                var createdBuild = await Create(api, options);
+                return new ApiBuildPair(api.Clone(), createdBuild);
+            }));
+
+            try
+            {
+                ApiBuildPair storedBuildPair = await lazyBuild.Value;
+                return storedBuildPair.Build;
+            }
+            catch
+            {
+                // If resolving build fails, remove the lazy task
+                // so subsequent calls do not fail with the same result
+                Builds.TryRemove(buildKey, out _);
+                throw;
+            }
         }
 
         /// <summary>
-        /// <c>FindRegionByBuild</c> returns the region matching the passed build.
+        /// <c>FindBuildKey</c> returns the key (build name or region) matching the passed build.
         /// </summary>
         /// <param name="build"></param>
-        /// <returns>the matching region name</returns>
-        private static string? FindRegionByBuild(VisualBuild build)
+        /// <returns>the matching build key</returns>
+        private static BuildKey? FindBuildKey(VisualBuild build)
         {
-            return Builds.Where(n => n.Value.Build == build).Select(n => n.Key).FirstOrDefault();
+            return Builds.Where(n => n.Value.IsValueCreated && n.Value.Value.IsCompleted && n.Value.Value.Result.Build == build)
+                .Select(n => n.Key)
+                .FirstOrDefault();
         }
 
         /// <summary>
-        /// <c>Close</c> finishes and forget about <c>build</c>
+        /// <c>Close</c> finishes and removes the specified build from the cache.
+        /// This method is thread-safe and can be called from multiple threads.
         /// </summary>
         /// <param name="build">the build to finish</param>
         internal static async Task Close(VisualBuild build)
         {
-            var key = FindRegionByBuild(build);
-            if (key != null)
+            var key = FindBuildKey(build);
+            if (key != null && Builds.TryGetValue(key, out var lazyBuildPair) && lazyBuildPair.IsValueCreated)
             {
-                await Close(key, Builds[key]);
+                var buildPair = await lazyBuildPair.Value;
+                await Close(key, buildPair);
             }
         }
 
         /// <summary>
-        /// <c>Close</c> finishes and forget about <c>build</c>
+        /// <c>Close</c> finishes and removes the build from the cache.
         /// </summary>
-        /// <param name="region">the build to finish</param>
+        /// <param name="buildKey">the build key (name or region) to finish</param>
         /// <param name="entry">the api/build pair</param>
-        private static async Task Close(string region, ApiBuildPair entry)
+        private static async Task Close(BuildKey buildKey, ApiBuildPair entry)
         {
             if (!entry.Build.IsExternal)
             {
                 await entry.Api.FinishBuild(entry.Build.Id);
             }
-            Builds.Remove(region);
+
+            Builds.TryRemove(buildKey, out _);
             entry.Api.Dispose();
         }
 
         /// <summary>
-        /// <c>CloseBuilds</c> closes all build that are still open.
+        /// <c>CloseBuilds</c> closes all builds that are still open.
+        /// This method is thread-safe and should be called during application shutdown.
         /// </summary>
         internal static async Task CloseBuilds()
         {
-            var regions = Builds.Keys;
-            foreach (var region in regions)
+            var buildsToClose = Builds.ToArray();
+            foreach (var kvp in buildsToClose)
             {
-                await Close(region, Builds[region]);
+                if (kvp.Value.IsValueCreated && kvp.Value.Value.IsCompleted)
+                {
+                    var buildPair = await kvp.Value.Value;
+                    await Close(kvp.Key, buildPair);
+                }
             }
         }
 
@@ -189,4 +226,4 @@ private static async Task<VisualBuild> Create(VisualApi api, CreateBuildOptions
             return null;
         }
     }
-}
+}

visual-dotnet/SauceLabs.Visual/BuildKey.cs

@@ -0,0 +1,66 @@
+using RegionModel = SauceLabs.Visual.Region;
+
+namespace SauceLabs.Visual
+{
+    internal class BuildKey
+    {
+        public static Region OfRegion(RegionModel region)
+        {
+            return new Region(region);
+        }
+
+        public static BuildName OfBuildName(string buildName)
+        {
+            return new BuildName(buildName);
+        }
+
+        public class Region : BuildKey
+        {
+            public RegionModel Value { get; }
+
+            public Region(RegionModel region)
+            {
+                Value = region;
+            }
+
+            public override bool Equals(object obj)
+            {
+                return obj switch
+                {
+                    Region key => key.Value.Equals(Value),
+                    _ => false
+                };
+            }
+
+            public override int GetHashCode()
+            {
+                return Value.GetHashCode();
+            }
+        }
+
+        public class BuildName : BuildKey
+        {
+            public string Value { get; }
+
+            public BuildName(string buildName)
+            {
+                Value = buildName;
+            }
+
+            public override bool Equals(object obj)
+            {
+                return obj switch
+                {
+                    BuildName key => key.Value.Equals(Value),
+                    _ => false
+                };
+            }
+
+            public override int GetHashCode()
+            {
+                return Value.GetHashCode();
+            }
+        }
+    }
+}
+