chore(mutation): add per-BC Stryker tooling and exclude i18n registration from scope

dotnet-tools.json

@@ -0,0 +1,13 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "dotnet-stryker": {
+      "version": "4.14.2",
+      "commands": [
+        "dotnet-stryker"
+      ],
+      "rollForward": false
+    }
+  }
+}

src/Coaching/Coaching.Application.UnitTests/DomainTests/CoachingIdTests.cs

@@ -0,0 +1,56 @@
+namespace Coaching.Application.UnitTests.DomainTests;
+
+public sealed class CoachingIdTests
+{
+    [Fact]
+    public void Should_RejectEmptyGuid_When_PlayerCoachingProfileIdFromEmpty()
+    {
+        var act = () => PlayerCoachingProfileId.From(Guid.Empty);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Fact]
+    public void Should_WrapValue_When_PlayerCoachingProfileIdFromGuid()
+    {
+        var guid = Guid.NewGuid();
+
+        PlayerCoachingProfileId.From(guid).Value.Should().Be(guid);
+    }
+
+    [Fact]
+    public void Should_BeEqual_When_PlayerCoachingProfileIdsShareValue()
+    {
+        var guid = Guid.NewGuid();
+
+        PlayerCoachingProfileId.From(guid).Should().Be(PlayerCoachingProfileId.From(guid));
+    }
+
+    [Fact]
+    public void Should_GenerateDistinctIds_When_PlayerCoachingProfileIdCreated()
+    {
+        PlayerCoachingProfileId.Create().Should().NotBe(PlayerCoachingProfileId.Create());
+    }
+
+    [Fact]
+    public void Should_RejectEmptyGuid_When_UserWeeklyProgressionIdFromEmpty()
+    {
+        var act = () => UserWeeklyProgressionId.From(Guid.Empty);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Fact]
+    public void Should_BeEqual_When_UserWeeklyProgressionIdsShareValue()
+    {
+        var guid = Guid.NewGuid();
+
+        UserWeeklyProgressionId.From(guid).Should().Be(UserWeeklyProgressionId.From(guid));
+    }
+
+    [Fact]
+    public void Should_GenerateDistinctIds_When_UserWeeklyProgressionIdCreated()
+    {
+        UserWeeklyProgressionId.Create().Should().NotBe(UserWeeklyProgressionId.Create());
+    }
+}

src/Coaching/Coaching.Application.UnitTests/DomainTests/IsoWeekTests.cs

@@ -42,6 +42,87 @@ public void Should_RejectOutOfRangeWeek_When_WeekIsZero()
         act.Should().Throw<ArgumentException>();
     }
 
+    [Fact]
+    public void Should_RejectOutOfRangeWeek_When_WeekAbove53()
+    {
+        var act = () => IsoWeek.From(2026, 54);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Theory]
+    [InlineData(1899)]
+    [InlineData(10000)]
+    public void Should_RejectOutOfRangeYear_When_YearOutsideSupportedRange(int year)
+    {
+        var act = () => IsoWeek.From(year, 10);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Fact]
+    public void Should_AcceptBoundaryValues_When_YearAndWeekAtLimits()
+    {
+        IsoWeek.From(1900, 1).Should().NotBeNull();
+        IsoWeek.From(9999, 53).Should().NotBeNull();
+    }
+
+    [Fact]
+    public void Should_RollIntoNextWeek_When_NextIsCalled()
+    {
+        var week = IsoWeek.From(2026, 20);
+
+        var next = week.Next();
+
+        next.Year.Should().Be(2026);
+        next.Week.Should().Be(21);
+    }
+
+    [Fact]
+    public void Should_RollAcrossYearBoundary_When_NextIsCalledOnLastWeek()
+    {
+        var last = IsoWeek.FromDate(new DateOnly(2026, 12, 31));
+
+        var next = last.Next();
+
+        next.Year.Should().Be(2027);
+    }
+
+    [Fact]
+    public void Should_MapToContainingWeek_When_BuiltFromUtcInstant()
+    {
+        var week = IsoWeek.FromUtc(new DateTime(2026, 5, 21, 14, 30, 0, DateTimeKind.Utc));
+
+        week.Should().Be(IsoWeek.From(2026, 21));
+    }
+
+    [Fact]
+    public void Should_SpanMondayToSunday_When_StartAndEndRequested()
+    {
+        var week = IsoWeek.From(2026, 21);
+
+        week.StartDate().Should().Be(new DateOnly(2026, 5, 18));
+        week.EndDate().Should().Be(new DateOnly(2026, 5, 24));
+    }
+
+    [Fact]
+    public void Should_RankAfterNull_When_ComparedToNull()
+    {
+        IsoWeek.From(2026, 21).CompareTo(null).Should().BeGreaterThan(0);
+    }
+
+    [Fact]
+    public void Should_NotBeEqual_When_WeekDiffers()
+    {
+        IsoWeek.From(2026, 21).Should().NotBe(IsoWeek.From(2026, 22));
+    }
+
+    [Fact]
+    public void Should_NotBeEqual_When_YearDiffers()
+    {
+        IsoWeek.From(2026, 21).Should().NotBe(IsoWeek.From(2025, 21));
+    }
+
     [Fact]
     public void Should_BeEqual_When_SameYearAndWeek()
     {

src/Coaching/Coaching.Application.UnitTests/DomainTests/LeverImpactEstimateTests.cs

@@ -0,0 +1,44 @@
+namespace Coaching.Application.UnitTests.DomainTests;
+
+public sealed class LeverImpactEstimateTests
+{
+    [Fact]
+    public void Should_ExposeBothDimensions_When_Constructed()
+    {
+        var estimate = new LeverImpactEstimate(12.5, 2.0);
+
+        estimate.EstimatedDpsGainPct.Should().Be(12.5);
+        estimate.EstimatedDeathsAvoided.Should().Be(2.0);
+    }
+
+    [Theory]
+    [InlineData(double.NaN, 1.0)]
+    [InlineData(double.PositiveInfinity, 1.0)]
+    [InlineData(1.0, double.NaN)]
+    [InlineData(1.0, double.NegativeInfinity)]
+    public void Should_RefuseConstruction_When_AnyDimensionIsNotFinite(double dps, double deaths)
+    {
+        var act = () => new LeverImpactEstimate(dps, deaths);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Theory]
+    [InlineData(-0.1, 1.0)]
+    [InlineData(1.0, -0.1)]
+    public void Should_RefuseConstruction_When_AnyDimensionIsNegative(double dps, double deaths)
+    {
+        var act = () => new LeverImpactEstimate(dps, deaths);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Fact]
+    public void Should_AllowZero_When_LeverHasNoEstimatedGain()
+    {
+        var estimate = new LeverImpactEstimate(0, 0);
+
+        estimate.EstimatedDpsGainPct.Should().Be(0);
+        estimate.EstimatedDeathsAvoided.Should().Be(0);
+    }
+}

src/Coaching/Coaching.Application.UnitTests/DomainTests/StopsMetricsTests.cs

@@ -0,0 +1,77 @@
+namespace Coaching.Application.UnitTests.DomainTests;
+
+public sealed class StopsMetricsTests
+{
+    private static StopsMetrics WithOneNegative(int index)
+    {
+        var v = new int[12];
+        for (var i = 0; i < v.Length; i++)
+            v[i] = 1;
+        v[index] = -1;
+        return new StopsMetrics(
+            v[0], v[1], v[2], v[3], v[4], v[5],
+            v[6], v[7], v[8], v[9], v[10], v[11]);
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    [InlineData(4)]
+    [InlineData(5)]
+    [InlineData(6)]
+    [InlineData(7)]
+    [InlineData(8)]
+    [InlineData(9)]
+    [InlineData(10)]
+    [InlineData(11)]
+    public void Should_RefuseConstruction_When_AnyCountIsNegative(int negativeField)
+    {
+        var act = () => WithOneNegative(negativeField);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Fact]
+    public void Should_ExposeEveryCount_When_Constructed()
+    {
+        var metrics = new StopsMetrics(
+            totalStops: 1, kickCount: 2, crowdControlCount: 3,
+            correctStopCount: 4, acceptableStopCount: 5, wastedKickCount: 6,
+            successfulStopCount: 7, lateNoEffectCount: 8, immuneCount: 9,
+            overcappedStopCount: 10, missedOpportunityCount: 11, runCount: 12);
+
+        metrics.TotalStops.Should().Be(1);
+        metrics.KickCount.Should().Be(2);
+        metrics.CrowdControlCount.Should().Be(3);
+        metrics.CorrectStopCount.Should().Be(4);
+        metrics.AcceptableStopCount.Should().Be(5);
+        metrics.WastedKickCount.Should().Be(6);
+        metrics.SuccessfulStopCount.Should().Be(7);
+        metrics.LateNoEffectCount.Should().Be(8);
+        metrics.ImmuneCount.Should().Be(9);
+        metrics.OvercappedStopCount.Should().Be(10);
+        metrics.MissedOpportunityCount.Should().Be(11);
+        metrics.RunCount.Should().Be(12);
+    }
+
+    [Fact]
+    public void Should_BeAllZero_When_Empty()
+    {
+        var empty = StopsMetrics.Empty;
+
+        empty.TotalStops.Should().Be(0);
+        empty.KickCount.Should().Be(0);
+        empty.CrowdControlCount.Should().Be(0);
+        empty.CorrectStopCount.Should().Be(0);
+        empty.AcceptableStopCount.Should().Be(0);
+        empty.WastedKickCount.Should().Be(0);
+        empty.SuccessfulStopCount.Should().Be(0);
+        empty.LateNoEffectCount.Should().Be(0);
+        empty.ImmuneCount.Should().Be(0);
+        empty.OvercappedStopCount.Should().Be(0);
+        empty.MissedOpportunityCount.Should().Be(0);
+        empty.RunCount.Should().Be(0);
+    }
+}

src/Coaching/Coaching.Application.UnitTests/DomainTests/UseCaseKeyTests.cs

@@ -0,0 +1,63 @@
+namespace Coaching.Application.UnitTests.DomainTests;
+
+public sealed class UseCaseKeyTests
+{
+    [Theory]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void Should_RefuseConstruction_When_Blank(string value)
+    {
+        var act = () => UseCaseKey.From(value);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Fact]
+    public void Should_RefuseConstruction_When_LongerThanMaxLength()
+    {
+        var tooLong = new string('a', UseCaseKey.MaxLength + 1);
+
+        var act = () => UseCaseKey.From(tooLong);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Theory]
+    [InlineData("Kick Uptime")]
+    [InlineData("kick_uptime")]
+    [InlineData("-kick")]
+    [InlineData("kick--uptime")]
+    [InlineData("kické")]
+    public void Should_RefuseConstruction_When_NotKebabCaseAscii(string value)
+    {
+        var act = () => UseCaseKey.From(value);
+
+        act.Should().Throw<ArgumentException>();
+    }
+
+    [Fact]
+    public void Should_NormalizeToLowerTrimmed_When_GivenPaddedMixedCase()
+    {
+        UseCaseKey.From("  Kick-Uptime  ").Value.Should().Be("kick-uptime");
+    }
+
+    [Fact]
+    public void Should_AcceptMaxLength_When_ExactlyAtLimit()
+    {
+        var atLimit = new string('a', UseCaseKey.MaxLength);
+
+        UseCaseKey.From(atLimit).Value.Should().Be(atLimit);
+    }
+
+    [Fact]
+    public void Should_BeEqual_When_SameNormalizedValue()
+    {
+        UseCaseKey.From("kick-uptime").Should().Be(UseCaseKey.From("KICK-UPTIME"));
+    }
+
+    [Fact]
+    public void Should_NotBeEqual_When_DifferentValue()
+    {
+        UseCaseKey.From("kick-uptime").Should().NotBe(UseCaseKey.From("dispel-debuff"));
+    }
+}