Merge pull request #12 from agenixframework/feature/refactor-prometheus-config-structure

Refactor Dockerfiles for optimized caching, add label-matching tests,…

Author: asuruceanu

.github/workflows/publish-nuget-and-containers.yml

@@ -9,6 +9,22 @@ on:
     tags:
       - 'v*.*.*'
       - 'v*.*.*-*'
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      publish_nuget:
+        description: "Publish to NuGet?"
+        required: true
+        type: choice
+        options: [ "no", "yes" ]
+        default: "no"
+      publish_containers:
+        description: "Publish container images?"
+        required: true
+        type: choice
+        options: [ "no", "yes" ]
+        default: "no"
 
 permissions:
   contents: write
@@ -172,13 +188,16 @@ jobs:
       always() &&
       needs.build.result == 'success' &&
       (needs.security-scan.result == 'success' || needs.security-scan.result == 'skipped') &&
-      github.event_name == 'push' &&
       (
-        github.ref == 'refs/heads/main' ||
-        github.ref == 'refs/heads/develop' ||
-        startsWith(github.ref, 'refs/heads/release/') ||
-        startsWith(github.ref, 'refs/heads/hotfix/') ||
-        startsWith(github.ref, 'refs/tags/v')
+        github.event_name == 'release' ||
+        (github.event_name == 'workflow_dispatch' && inputs.publish_nuget == 'yes') ||
+        (github.event_name == 'push' && (
+          github.ref == 'refs/heads/main' ||
+          github.ref == 'refs/heads/develop' ||
+          startsWith(github.ref, 'refs/heads/release/') ||
+          startsWith(github.ref, 'refs/heads/hotfix/') ||
+          startsWith(github.ref, 'refs/tags/v')
+        ))
       )
 
     environment:
@@ -242,13 +261,16 @@ jobs:
       always() &&
       needs.build.result == 'success' &&
       (needs.security-scan.result == 'success' || needs.security-scan.result == 'skipped') &&
-      github.event_name == 'push' &&
       (
-        github.ref == 'refs/heads/main' ||
-        github.ref == 'refs/heads/develop' ||
-        startsWith(github.ref, 'refs/heads/release/') ||
-        startsWith(github.ref, 'refs/heads/hotfix/') ||
-        startsWith(github.ref, 'refs/tags/v')
+        github.event_name == 'release' ||
+        (github.event_name == 'workflow_dispatch' && inputs.publish_containers == 'yes') ||
+        (github.event_name == 'push' && (
+          github.ref == 'refs/heads/main' ||
+          github.ref == 'refs/heads/develop' ||
+          startsWith(github.ref, 'refs/heads/release/') ||
+          startsWith(github.ref, 'refs/heads/hotfix/') ||
+          startsWith(github.ref, 'refs/tags/v')
+        ))
       )
 
     steps:

Agenix.PlaywrightGrid.Domain.Tests/Agenix.PlaywrightGrid.Domain.Tests.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AssemblyName>Agenix.PlaywrightGrid.Domain.Tests</AssemblyName>
+    <RootNamespace>Agenix.PlaywrightGrid.Domain.Tests</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../Agenix.PlaywrightGrid.Domain/Agenix.PlaywrightGrid.Domain.csproj" />
+  </ItemGroup>
+</Project>

Agenix.PlaywrightGrid.Domain.Tests/LabelKeyTests.cs

@@ -0,0 +1,114 @@
+using NUnit.Framework;
+using Agenix.PlaywrightGrid.Domain;
+
+namespace Agenix.PlaywrightGrid.Domain.Tests;
+
+public class LabelKeyTests
+{
+    [Test]
+    public void TryParse_Valid_MinSegments_Two_AppBrowser_DefaultOptions()
+    {
+        var ok = LabelKey.TryParse("MyApp:Chromium", out var lk);
+        Assert.That(ok, Is.True);
+        Assert.That(lk, Is.Not.Null);
+        Assert.That(lk!.Original, Is.EqualTo("MyApp:Chromium"));
+        Assert.That(lk.Normalized, Is.EqualTo("MyApp:Chromium"));
+        Assert.That(lk.Segments, Has.Count.EqualTo(2));
+        Assert.That(lk.App, Is.EqualTo("MyApp"));
+        Assert.That(lk.Browser, Is.EqualTo("Chromium"));
+        Assert.That(lk.Env, Is.EqualTo(""));
+    }
+
+    [Test]
+    public void TryParse_Trims_And_Rejects_LeadingTrailingColons_And_DoubleColons()
+    {
+        Assert.That(LabelKey.TryParse(":A:Chromium", out _), Is.False);
+        Assert.That(LabelKey.TryParse("A:Chromium:", out _), Is.False);
+        Assert.That(LabelKey.TryParse("A::Chromium", out _), Is.False);
+        Assert.That(LabelKey.TryParse("  A:Chromium  ", out var lk), Is.True);
+        Assert.That(lk!.Original, Is.EqualTo("A:Chromium"));
+        Assert.That(lk.Normalized, Is.EqualTo("A:Chromium"));
+    }
+
+    [Test]
+    public void TryParse_EnforceBrowserSecond_DefaultTrue_Rejects_UnknownBrowser()
+    {
+        Assert.That(LabelKey.TryParse("AppX:NotABrowser:UAT", out _), Is.False);
+    }
+
+    [Test]
+    public void TryParse_EnforceBrowserSecond_False_Allows_Any_Second_Segment()
+    {
+        var opts = new LabelKeyParsingOptions { EnforceBrowserSecond = false };
+        Assert.That(LabelKey.TryParse("AppX:NotABrowser:UAT", out var lk, opts), Is.True);
+        Assert.That(lk!.Browser, Is.EqualTo("NotABrowser"));
+    }
+
+    [Test]
+    public void TryParse_CasePolicy_Lower_And_Upper_Are_Applied_To_Normalized()
+    {
+        var lower = new LabelKeyParsingOptions { CasePolicy = LabelKeyCasePolicy.Lower, EnforceBrowserSecond = false };
+        Assert.That(LabelKey.TryParse("MyApp:Chromium:Staging:US", out var lkLower, lower), Is.True);
+        Assert.That(lkLower!.Normalized, Is.EqualTo("myapp:chromium:staging:us"));
+        Assert.That(lkLower.Original, Is.EqualTo("MyApp:Chromium:Staging:US"));
+
+        var upper = new LabelKeyParsingOptions { CasePolicy = LabelKeyCasePolicy.Upper, EnforceBrowserSecond = false };
+        Assert.That(LabelKey.TryParse("MyApp:Firefox:Uat:eu", out var lkUpper, upper), Is.True);
+        Assert.That(lkUpper!.Normalized, Is.EqualTo("MYAPP:FIREFOX:UAT:EU"));
+        Assert.That(lkUpper.Original, Is.EqualTo("MyApp:Firefox:Uat:eu"));
+    }
+
+    [Test]
+    public void TryParse_ForbiddenChars_Default_Rejects_Whitespace_In_Segments()
+    {
+        // Default ForbiddenChars include whitespace; spaces within segments should be rejected
+        Assert.That(LabelKey.TryParse("My App:Chromium:UAT", out _), Is.False);
+        Assert.That(LabelKey.TryParse("MyApp:Chrom ium:UAT", out _), Is.False);
+    }
+
+    [Test]
+    public void TryParse_SegmentCount_OutOfBounds_Fails()
+    {
+        var tooFew = new LabelKeyParsingOptions { MinSegments = 3 };
+        Assert.That(LabelKey.TryParse("App:Chromium", out _, tooFew), Is.False);
+
+        var tooMany = new LabelKeyParsingOptions { MaxSegments = 3 };
+        Assert.That(LabelKey.TryParse("A:B:C:D", out _, tooMany), Is.False);
+    }
+
+    [Test]
+    public void Equality_And_HashCode_Use_Normalized()
+    {
+        var lower = new LabelKeyParsingOptions { CasePolicy = LabelKeyCasePolicy.Lower, EnforceBrowserSecond = false };
+        Assert.That(LabelKey.TryParse("MyApp:Chromium:UAT", out var a, lower), Is.True);
+        Assert.That(LabelKey.TryParse("myapp:chromium:uat", out var b, lower), Is.True);
+        Assert.That(a!.Equals(b), Is.True);
+        Assert.That(a.GetHashCode(), Is.EqualTo(b!.GetHashCode()));
+
+        // With Keep policy, differing case leads to different Normalized values
+        var keep = new LabelKeyParsingOptions { CasePolicy = LabelKeyCasePolicy.Keep, EnforceBrowserSecond = false };
+        Assert.That(LabelKey.TryParse("MyApp:Chromium:UAT", out var c, keep), Is.True);
+        Assert.That(LabelKey.TryParse("myapp:chromium:uat", out var d, keep), Is.True);
+        Assert.That(c!.Equals(d), Is.False);
+    }
+
+    [Test]
+    public void Accessors_App_Browser_Env_Work_With_Missing_Segments()
+    {
+        var opts = new LabelKeyParsingOptions { EnforceBrowserSecond = false };
+        Assert.That(LabelKey.TryParse("OnlyApp:OnlyBrowser", out var two, opts), Is.True);
+        Assert.That(two!.App, Is.EqualTo("OnlyApp"));
+        Assert.That(two.Browser, Is.EqualTo("OnlyBrowser"));
+        Assert.That(two.Env, Is.EqualTo(""));
+
+        Assert.That(LabelKey.TryParse("A:B:C", out var three, opts), Is.True);
+        Assert.That(three!.Env, Is.EqualTo("C"));
+    }
+
+    [Test]
+    public void TryParse_Null_Or_Empty_Returns_False()
+    {
+        Assert.That(LabelKey.TryParse(null, out _), Is.False);
+        Assert.That(LabelKey.TryParse("   ", out _), Is.False);
+    }
+}

Agenix.PlaywrightGrid.Domain.Tests/LabelMatcherTests.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Agenix.PlaywrightGrid.Domain;
+
+namespace Agenix.PlaywrightGrid.Domain.Tests;
+
+public class LabelMatcherTests
+{
+    private static LabelKey L(string s)
+    {
+        var opts = new LabelKeyParsingOptions { EnforceBrowserSecond = false };
+        if (!LabelKey.TryParse(s, out var lk, opts)) throw new ArgumentException($"Invalid label: {s}");
+        return lk!;
+    }
+
+    [Test]
+    public void Exact_Match_Returns_Requested_Label()
+    {
+        var requested = L("AppA:Chromium:UAT");
+        var available = new[] { L("AppA:Chromium:UAT"), L("AppA:Chromium"), L("Other:Firefox:UAT") };
+        var matcher = new LabelMatcher(new LabelMatchingOptions { WildcardsEnabled = false });
+
+        var match = matcher.TryMatch(requested, available);
+        Assert.That(match, Is.Not.Null);
+        Assert.That(match!.Normalized, Is.EqualTo("AppA:Chromium:UAT"));
+    }
+
+    [Test]
+    public void Trailing_Fallback_Drops_To_MinSegments_Default_2()
+    {
+        var requested = L("AppA:Chromium:UAT:EU");
+        var available = new[] { L("AppA:Chromium"), L("AppA:Chromium:UAT") };
+        var matcher = new LabelMatcher(new LabelMatchingOptions { TrailingFallbackEnabled = true, PrefixExpansionEnabled = false });
+
+        var match = matcher.TryMatch(requested, available);
+        // exact missing; fallback from 4->3 matches 3-segment entry
+        Assert.That(match, Is.Not.Null);
+        Assert.That(match!.Normalized, Is.EqualTo("AppA:Chromium:UAT"));
+    }
+
+    [Test]
+    public void Trailing_Fallback_Respects_MinSegmentsForFallback()
+    {
+        var requested = L("AppA:Chromium:UAT");
+        var available = new[] { L("AppA:Chromium") };
+        var matcher = new LabelMatcher(new LabelMatchingOptions { TrailingFallbackEnabled = true, MinSegmentsForFallback = 3, PrefixExpansionEnabled = false });
+
+        var match = matcher.TryMatch(requested, available);
+        Assert.That(match, Is.Null, "Should not fallback below 3 segments");
+    }
+
+    [Test]
+    public void Prefix_Expansion_Picks_Shortest_More_Specific_Then_Lexicographical()
+    {
+        var requested = L("AppB:Chromium");
+        var available = new[] { L("AppB:Chromium:UAT:x"), L("AppB:Chromium:UAT:y"), L("AppB:Chromium:UAT:zz") };
+        var matcher = new LabelMatcher(new LabelMatchingOptions { PrefixExpansionEnabled = true, TrailingFallbackEnabled = false });
+
+        var match = matcher.TryMatch(requested, available);
+        Assert.That(match, Is.Not.Null);
+        // Shortest length (3 segments). Among equals, lexicographically first is x
+        Assert.That(match!.Normalized, Is.EqualTo("AppB:Chromium:UAT:x"));
+    }
+
+    [Test]
+    public void Wildcards_Disabled_Do_Not_Match_Asterisk_Segments()
+    {
+        var requested = L("AppA:*:UAT");
+        var available = new[] { L("AppA:Firefox:UAT") };
+        var matcher = new LabelMatcher(new LabelMatchingOptions { WildcardsEnabled = false, PrefixExpansionEnabled = true, TrailingFallbackEnabled = true });
+
+        var match = matcher.TryMatch(requested, available);
+        Assert.That(match, Is.Null);
+    }
+
+    [Test]
+    public void Wildcards_Enabled_Match_Any_Segment_In_Exact_And_Prefix()
+    {
+        var requested = L("AppA:*:UAT");
+        var available = new[] { L("AppA:Firefox:UAT"), L("AppA:Chromium:UAT:EU") };
+        var matcher = new LabelMatcher(new LabelMatchingOptions { WildcardsEnabled = true, TrailingFallbackEnabled = false, PrefixExpansionEnabled = true });
+
+        var match = matcher.TryMatch(requested, available);
+        // Exact should win (3 segments) before prefix expansion to 4
+        Assert.That(match, Is.Not.Null);
+        Assert.That(match!.Normalized, Is.EqualTo("AppA:Firefox:UAT"));
+    }
+}

Agenix.PlaywrightGrid.Domain/Agenix.PlaywrightGrid.Domain.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

Agenix.PlaywrightGrid.Domain/ILabelMatcher.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace Agenix.PlaywrightGrid.Domain;
+
+/// <summary>
+/// Central label matching strategy service.
+/// Implements ordered resolution: exact → trailing fallback → prefix expansion → optional wildcards.
+/// </summary>
+public interface ILabelMatcher
+{
+    /// <summary>
+    /// Attempts to find the best matching available label for the requested <see cref="LabelKey"/>.
+    /// Returns null when no match is found according to the configured <see cref="LabelMatchingOptions"/>.
+    /// </summary>
+    LabelKey? TryMatch(LabelKey requested, IEnumerable<LabelKey> available);
+}