Merge pull request #23 from agenixframework/feature/add-playwright-grid-helm-chart

Add Playwright Grid Helm chart with Redis, Ingress templates, and enh…

Author: asuruceanu

Agenix.PlaywrightGrid.Domain.Tests/DtoSerializationTests.cs

@@ -0,0 +1,134 @@
+#region License
+// Copyright (c) 2025 Agenix
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using NUnit.Framework;
+
+namespace Agenix.PlaywrightGrid.Domain.Tests;
+
+public class DtoSerializationTests
+{
+    private static readonly JsonSerializerOptions WebJson = new(JsonSerializerDefaults.Web)
+    {
+        // Explicitly mirror Web defaults: camelCase + ignore null
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+    };
+
+    [Test]
+    public void BorrowRequestDto_Serializes_With_RunName_When_Present()
+    {
+        var dto = new BorrowRequestDto
+        {
+            LabelKey = "AppB:Chromium:UAT",
+            RunId = "rid-123",
+            RunName = "My Run"
+        };
+
+        var json = JsonSerializer.Serialize(dto, WebJson);
+        TestContext.WriteLine(json);
+        // Assert camelCase property names and runName included
+        Assert.That(json, Does.Contain("\"labelKey\":\"AppB:Chromium:UAT\""));
+        Assert.That(json, Does.Contain("\"runId\":\"rid-123\""));
+        Assert.That(json, Does.Contain("\"runName\":\"My Run\""));
+    }
+
+    [Test]
+    public void BorrowRequestDto_Omits_RunName_When_Null()
+    {
+        var dto = new BorrowRequestDto
+        {
+            LabelKey = "AppB:Chromium:UAT",
+            RunId = "rid-456",
+            RunName = null
+        };
+
+        var json = JsonSerializer.Serialize(dto, WebJson);
+        TestContext.WriteLine(json);
+        Assert.That(json, Does.Contain("\"labelKey\":\"AppB:Chromium:UAT\""));
+        Assert.That(json, Does.Contain("\"runId\":\"rid-456\""));
+        Assert.That(json, Does.Not.Contain("runName"));
+    }
+
+    [Test]
+    public void BorrowResponseDto_Serializes_RunName_When_Present_And_Omits_When_Null()
+    {
+        var withName = new BorrowResponseDto
+        {
+            BrowserId = "b1",
+            WebSocketEndpoint = "ws://h/ws/b1",
+            LabelKey = "AppB:Chromium:UAT",
+            BrowserType = "chromium",
+            RunName = "Some Display Name"
+        };
+        var withNameJson = JsonSerializer.Serialize(withName, WebJson);
+        TestContext.WriteLine(withNameJson);
+        Assert.That(withNameJson, Does.Contain("\"browserId\":\"b1\""));
+        Assert.That(withNameJson, Does.Contain("\"webSocketEndpoint\":\"ws://h/ws/b1\""));
+        Assert.That(withNameJson, Does.Contain("\"labelKey\":\"AppB:Chromium:UAT\""));
+        Assert.That(withNameJson, Does.Contain("\"browserType\":\"chromium\""));
+        Assert.That(withNameJson, Does.Contain("\"runName\":\"Some Display Name\""));
+
+        var withoutName = new BorrowResponseDto
+        {
+            BrowserId = "b2",
+            WebSocketEndpoint = "ws://h/ws/b2",
+            LabelKey = "AppB:Chromium:UAT",
+            BrowserType = null,
+            RunName = null
+        };
+        var withoutNameJson = JsonSerializer.Serialize(withoutName, WebJson);
+        TestContext.WriteLine(withoutNameJson);
+        Assert.That(withoutNameJson, Does.Contain("\"browserId\":\"b2\""));
+        Assert.That(withoutNameJson, Does.Contain("\"webSocketEndpoint\":\"ws://h/ws/b2\""));
+        Assert.That(withoutNameJson, Does.Contain("\"labelKey\":\"AppB:Chromium:UAT\""));
+        Assert.That(withoutNameJson, Does.Not.Contain("browserType"));
+        Assert.That(withoutNameJson, Does.Not.Contain("runName"));
+    }
+
+    [Test]
+    public void Run_And_RunSummary_Serialize_With_Optional_RunName()
+    {
+        var run = new Run { RunId = "r1", RunName = null };
+        var runJson = JsonSerializer.Serialize(run, WebJson);
+        TestContext.WriteLine(runJson);
+        Assert.That(runJson, Does.Contain("\"runId\":\"r1\""));
+        Assert.That(runJson, Does.Not.Contain("runName"));
+
+        var summary = new RunSummary
+        {
+            RunId = "r2",
+            RunName = "Display Name",
+            App = "AppA",
+            Browser = "Chromium",
+            Env = "UAT",
+            Status = "Running",
+            TotalTests = 10,
+            Passed = 5,
+            Failed = 1
+        };
+        var summaryJson = JsonSerializer.Serialize(summary, WebJson);
+        TestContext.WriteLine(summaryJson);
+        Assert.That(summaryJson, Does.Contain("\"runId\":\"r2\""));
+        Assert.That(summaryJson, Does.Contain("\"runName\":\"Display Name\""));
+        Assert.That(summaryJson, Does.Contain("\"app\":\"AppA\""));
+        Assert.That(summaryJson, Does.Contain("\"browser\":\"Chromium\""));
+        Assert.That(summaryJson, Does.Contain("\"env\":\"UAT\""));
+        Assert.That(summaryJson, Does.Contain("\"status\":\"Running\""));
+    }
+}

Agenix.PlaywrightGrid.Domain.Tests/LabelMatcherEdgeTests.cs

@@ -0,0 +1,70 @@
+#region License
+// Copyright (c) 2025 Agenix
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+using NUnit.Framework;
+
+namespace Agenix.PlaywrightGrid.Domain.Tests;
+
+public class LabelMatcherEdgeTests
+{
+    private static LabelKey L(string s)
+    {
+        var opts = new LabelKeyParsingOptions { EnforceBrowserSecond = false };
+        if (!LabelKey.TryParse(s, out var lk, opts))
+        {
+            Assert.Fail($"Invalid test label: {s}");
+        }
+        return lk!;
+    }
+
+    [Test]
+    public void Wildcards_Enabled_Exact_Length_Chooses_Lexicographically_First()
+    {
+        var requested = L("AppZ:*:UAT");
+        var available = new[] { L("AppZ:Chromium:UAT"), L("AppZ:Firefox:UAT") };
+        var matcher = new LabelMatcher(new LabelMatchingOptions
+        {
+            WildcardsEnabled = true,
+            TrailingFallbackEnabled = false,
+            PrefixExpansionEnabled = false
+        });
+
+        var match = matcher.TryMatch(requested, available);
+        Assert.That(match, Is.Not.Null);
+        // Among exact-length matches, Normalized order picks Chromium before Firefox
+        Assert.That(match!.Normalized, Is.EqualTo("AppZ:Chromium:UAT"));
+    }
+
+    [Test]
+    public void Fallback_Beats_PrefixExpansion_When_Both_Enabled()
+    {
+        var requested = L("AppA:Chromium:UAT:EU");
+        var available = new[] { L("AppA:Chromium:UAT"), L("AppA:Chromium:UAT:EU:extra") };
+        var matcher = new LabelMatcher(new LabelMatchingOptions
+        {
+            TrailingFallbackEnabled = true,
+            PrefixExpansionEnabled = true,
+            WildcardsEnabled = false
+        });
+
+        var match = matcher.TryMatch(requested, available);
+        Assert.That(match, Is.Not.Null);
+        // Trailing fallback to 3 segments should be preferred before expanding to longer prefixes
+        Assert.That(match!.Normalized, Is.EqualTo("AppA:Chromium:UAT"));
+    }
+}

Agenix.PlaywrightGrid.Domain.Tests/RedisKeysTests.cs

@@ -0,0 +1,98 @@
+#region License
+// Copyright (c) 2025 Agenix
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+using System;
+using Agenix.PlaywrightGrid.Domain;
+using NUnit.Framework;
+
+namespace Agenix.PlaywrightGrid.Domain.Tests;
+
+public class RedisKeysTests
+{
+    [Test]
+    public void Available_InUse_With_LabelKey_AreStable()
+    {
+        var key = "AppA:Chromium:UAT"; // Valid label
+        Assert.That(RedisKeys.Available(key), Is.EqualTo("available:AppA:Chromium:UAT"));
+        Assert.That(RedisKeys.InUse(key), Is.EqualTo("inuse:AppA:Chromium:UAT"));
+    }
+
+    [Test]
+    public void Maintenance_Keys_Compose_Correctly()
+    {
+        var key = "AppB:Firefox:Prod";
+        Assert.That(RedisKeys.MaintenanceFlag(key), Is.EqualTo("maintenance:AppB:Firefox:Prod"));
+        Assert.That(RedisKeys.MaintenanceTarget(key), Is.EqualTo("maintenance:target:AppB:Firefox:Prod"));
+        Assert.That(RedisKeys.MaintenanceSince(key), Is.EqualTo("maintenance:since:AppB:Firefox:Prod"));
+        Assert.That(RedisKeys.MaintenanceSnapInuse(key), Is.EqualTo("maintenance:snap_inuse:AppB:Firefox:Prod"));
+    }
+
+    [Test]
+    public void Node_And_Alive_Sanitize_Id()
+    {
+        var raw = "worker 1:region/eu"; // contains space, colon, slash
+        var node = RedisKeys.Node(raw);
+        var alive = RedisKeys.NodeAlive(raw);
+        Assert.That(node, Does.StartWith("node:"));
+        Assert.That(alive, Does.StartWith("node_alive:"));
+        // Ensure forbidden chars are replaced with '-'
+        Assert.That(node.Contains(' '), Is.False);
+        Assert.That(node.Contains(':'), Is.True); // prefix only
+        Assert.That(node.LastIndexOf(':'), Is.EqualTo(4)); // only the prefix colon
+        Assert.That(node, Does.Not.Contain("/"));
+        Assert.That(alive, Does.Not.Contain("/"));
+    }
+
+    [Test]
+    public void BorrowTtl_Sanitizes_BrowserId()
+    {
+        var raw = "bid:abc xyz";
+        var key = RedisKeys.BorrowTtl(raw);
+        Assert.That(key, Does.StartWith("borrow_ttl:"));
+        Assert.That(key, Does.Not.Contain(" "));
+        // After prefix, no additional ':' should remain
+        Assert.That(key.LastIndexOf(':'), Is.EqualTo("borrow_ttl".Length));
+    }
+
+    [Test]
+    public void Results_Keys_AreStable()
+    {
+        var runId = "run_123";
+        Assert.That(RedisKeys.ResultsRunsByStart(), Is.EqualTo("results:runs:byStart"));
+        Assert.That(RedisKeys.ResultsRun(runId), Is.EqualTo("results:run:run_123"));
+        Assert.That(RedisKeys.ResultsRunName(runId), Is.EqualTo("results:runname:run_123"));
+        Assert.That(RedisKeys.ResultsTests(runId), Is.EqualTo("results:tests:run_123"));
+        Assert.That(RedisKeys.ResultsCmd(runId), Is.EqualTo("results:cmd:run_123"));
+        Assert.That(RedisKeys.ResultsCmdCount(runId), Is.EqualTo("results:cmdcount:run_123"));
+    }
+
+    [Test]
+    public void Audit_Keys_AreStable()
+    {
+        Assert.That(RedisKeys.AuditEntries(), Is.EqualTo("audit:entries"));
+        Assert.That(RedisKeys.AuditSecretsRunnerFingerprint(), Is.EqualTo("audit:secrets:runner:fp"));
+        Assert.That(RedisKeys.AuditSecretsNodeFingerprint(), Is.EqualTo("audit:secrets:node:fp"));
+    }
+
+    [Test]
+    public void Available_Throws_On_Invalid_Label()
+    {
+        Assert.Throws<ArgumentException>(() => RedisKeys.Available(":invalid"));
+        Assert.Throws<ArgumentException>(() => RedisKeys.Available(""));
+    }
+}

Agenix.PlaywrightGrid.Domain.Tests/RunNameRulesTests.cs

@@ -0,0 +1,71 @@
+#region License
+// Copyright (c) 2025 Agenix
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+using NUnit.Framework;
+
+namespace Agenix.PlaywrightGrid.Domain.Tests;
+
+public class RunNameRulesTests
+{
+    [Test]
+    public void Null_Or_Whitespace_Is_Treated_As_Absent()
+    {
+        Assert.That(RunNameRules.TryNormalize(null, out var n1, out var e1), Is.True);
+        Assert.That(n1, Is.Null);
+        Assert.That(e1, Is.Null);
+
+        Assert.That(RunNameRules.TryNormalize("   ", out var n2, out var e2), Is.True);
+        Assert.That(n2, Is.Null);
+        Assert.That(e2, Is.Null);
+    }
+
+    [Test]
+    public void Trims_And_Preserves_Case()
+    {
+        Assert.That(RunNameRules.TryNormalize("  My Run.Name-01  ", out var n, out var e), Is.True);
+        Assert.That(e, Is.Null);
+        Assert.That(n, Is.EqualTo("My Run.Name-01"));
+    }
+
+    [Test]
+    public void Rejects_Control_And_Disallowed_Chars()
+    {
+        Assert.That(RunNameRules.TryNormalize("Bad@Name", out _, out var e1), Is.False);
+        Assert.That(e1, Does.Contain("invalid characters"));
+
+        Assert.That(RunNameRules.TryNormalize("Bad#Name", out _, out var e2), Is.False);
+        Assert.That(e2, Does.Contain("invalid characters"));
+
+        // control char (tab) should fail
+        Assert.That(RunNameRules.TryNormalize("Bad\tName", out _, out var e3), Is.False);
+        Assert.That(e3, Does.Contain("control characters"));
+    }
+
+    [Test]
+    public void Accepts_Max_Length_And_Rejects_Too_Long()
+    {
+        var ok = new string('A', RunNameRules.MaxLength);
+        Assert.That(RunNameRules.TryNormalize(ok, out var n1, out var e1), Is.True);
+        Assert.That(n1, Is.EqualTo(ok));
+        Assert.That(e1, Is.Null);
+
+        var tooLong = new string('B', RunNameRules.MaxLength + 1);
+        Assert.That(RunNameRules.TryNormalize(tooLong, out _, out var e2), Is.False);
+        Assert.That(e2, Does.Contain("maximum length"));
+    }
+}