Add Tests

Author: mckaragoz

src/CodeBeam.UltimateAuth.Client/AssemblyVisibility.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("CodeBeam.UltimateAuth.Tests.Unit")]

tests/CodeBeam.UltimateAuth.Tests.Unit/Client/BlazorServerSessionCoordinatorTests.cs

@@ -0,0 +1,91 @@
+using CodeBeam.UltimateAuth.Client.Contracts;
+using CodeBeam.UltimateAuth.Client.Diagnostics;
+using CodeBeam.UltimateAuth.Client.Infrastructure;
+using CodeBeam.UltimateAuth.Client.Options;
+using CodeBeam.UltimateAuth.Core.Domain;
+using CodeBeam.UltimateAuth.Tests.Unit.Fake;
+using Microsoft.Extensions.Options;
+
+namespace CodeBeam.UltimateAuth.Tests.Unit.Client
+{
+    public sealed class BlazorServerSessionCoordinatorTests
+    {
+        [Fact]
+        public async Task StartAsync_MarksStarted_AndAutomaticRefresh()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            var client = new FakeUAuthClient(RefreshOutcome.NoOp);
+            var nav = new TestNavigationManager();
+
+            var options = Options.Create(new UAuthClientOptions
+            {
+                Refresh = { Interval = TimeSpan.FromMilliseconds(10) }
+            });
+
+            var coordinator = new BlazorServerSessionCoordinator(
+                client,
+                nav,
+                options,
+                diagnostics);
+
+            await coordinator.StartAsync();
+            await Task.Delay(30);
+            await coordinator.StopAsync();
+
+            Assert.Equal(1, diagnostics.StartCount);
+            Assert.True(diagnostics.AutomaticRefreshCount >= 1);
+        }
+
+        [Fact]
+        public async Task ReauthRequired_ShouldTerminateAndNavigate()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            var client = new FakeUAuthClient(RefreshOutcome.ReauthRequired);
+            var nav = new TestNavigationManager();
+
+            var options = Options.Create(new UAuthClientOptions
+            {
+                Refresh = { Interval = TimeSpan.FromMilliseconds(5) },
+                Reauth =
+                {
+                    Behavior = ReauthBehavior.RedirectToLogin,
+                    LoginPath = "/login"
+                }
+            });
+
+            var coordinator = new BlazorServerSessionCoordinator(
+                client,
+                nav,
+                options,
+                diagnostics);
+
+            await coordinator.StartAsync();
+            await Task.Delay(20);
+
+            Assert.True(diagnostics.IsTerminated);
+            Assert.Equal(CoordinatorTerminationReason.ReauthRequired, diagnostics.TerminationReason);
+            Assert.Equal("/login", nav.LastNavigatedTo);
+        }
+
+        [Fact]
+        public async Task StopAsync_ShouldMarkStopped()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            var client = new FakeUAuthClient();
+            var nav = new TestNavigationManager();
+
+            var options = Options.Create(new UAuthClientOptions());
+
+            var coordinator = new BlazorServerSessionCoordinator(
+                client,
+                nav,
+                options,
+                diagnostics);
+
+            await coordinator.StartAsync();
+            await coordinator.StopAsync();
+
+            Assert.Equal(1, diagnostics.StopCount);
+        }
+    }
+}

tests/CodeBeam.UltimateAuth.Tests.Unit/Client/ClientDiagnosticsTests.cs

@@ -0,0 +1,106 @@
+using System;
+using CodeBeam.UltimateAuth.Client.Contracts;
+using CodeBeam.UltimateAuth.Client.Diagnostics;
+using Xunit;
+
+namespace CodeBeam.UltimateAuth.Tests.Unit.Client
+{
+    public class ClientDiagnosticsTests
+    {
+        [Fact]
+        public void MarkStarted_ShouldSetStartedAt_AndIncrementCounter()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            diagnostics.MarkStarted();
+
+            Assert.NotNull(diagnostics.StartedAt);
+            Assert.Equal(1, diagnostics.StartCount);
+            Assert.False(diagnostics.IsTerminated);
+        }
+
+        [Fact]
+        public void MarkStopped_ShouldSetStoppedAt_AndIncrementCounter()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            diagnostics.MarkStopped();
+
+            Assert.NotNull(diagnostics.StoppedAt);
+            Assert.Equal(1, diagnostics.StopCount);
+        }
+
+        [Fact]
+        public void MarkManualRefresh_ShouldIncrementManualAndTotalCounters()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            diagnostics.MarkManualRefresh();
+
+            Assert.Equal(1, diagnostics.RefreshAttemptCount);
+            Assert.Equal(1, diagnostics.ManualRefreshCount);
+            Assert.Equal(0, diagnostics.AutomaticRefreshCount);
+        }
+
+        [Fact]
+        public void MarkAutomaticRefresh_ShouldIncrementAutomaticAndTotalCounters()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            diagnostics.MarkAutomaticRefresh();
+
+            Assert.Equal(1, diagnostics.RefreshAttemptCount);
+            Assert.Equal(1, diagnostics.AutomaticRefreshCount);
+            Assert.Equal(0, diagnostics.ManualRefreshCount);
+        }
+
+        [Fact]
+        public void MarkRefreshOutcomes_ShouldIncrementCorrectCounters()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            diagnostics.MarkRefreshTouched();
+            diagnostics.MarkRefreshNoOp();
+            diagnostics.MarkRefreshReauthRequired();
+            diagnostics.MarkRefreshUnknown();
+
+            Assert.Equal(1, diagnostics.RefreshTouchedCount);
+            Assert.Equal(1, diagnostics.RefreshNoOpCount);
+            Assert.Equal(1, diagnostics.RefreshReauthRequiredCount);
+            Assert.Equal(1, diagnostics.RefreshUnknownCount);
+        }
+
+        [Fact]
+        public void MarkTerminated_ShouldSetTerminationState_AndIncrementCounter()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            diagnostics.MarkTerminated(CoordinatorTerminationReason.ReauthRequired);
+
+            Assert.True(diagnostics.IsTerminated);
+            Assert.Equal(CoordinatorTerminationReason.ReauthRequired, diagnostics.TerminationReason);
+            Assert.Equal(1, diagnostics.TerminatedCount);
+        }
+
+        [Fact]
+        public void ChangedEvent_ShouldFire_OnStateChanges()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            int changeCount = 0;
+
+            diagnostics.Changed += () => changeCount++;
+
+            diagnostics.MarkStarted();
+            diagnostics.MarkManualRefresh();
+            diagnostics.MarkRefreshTouched();
+            diagnostics.MarkTerminated(CoordinatorTerminationReason.ReauthRequired);
+
+            Assert.Equal(4, changeCount);
+        }
+
+        [Fact]
+        public void MarkTerminated_ShouldBeIdempotent_ForStateButCountShouldIncrease()
+        {
+            var diagnostics = new UAuthClientDiagnostics();
+            diagnostics.MarkTerminated(CoordinatorTerminationReason.ReauthRequired);
+            diagnostics.MarkTerminated(CoordinatorTerminationReason.ReauthRequired);
+
+            Assert.True(diagnostics.IsTerminated);
+            Assert.Equal(2, diagnostics.TerminatedCount);
+        }
+    }
+}

tests/CodeBeam.UltimateAuth.Tests.Unit/Client/RefreshOutcomeParserTests.cs

@@ -0,0 +1,34 @@
+using CodeBeam.UltimateAuth.Client.Infrastructure;
+using CodeBeam.UltimateAuth.Core.Domain;
+using Xunit;
+
+namespace CodeBeam.UltimateAuth.Tests.Unit
+{
+    public sealed class RefreshOutcomeParserTests
+    {
+        [Theory]
+        [InlineData("no-op", RefreshOutcome.NoOp)]
+        [InlineData("touched", RefreshOutcome.Touched)]
+        [InlineData("reauth-required", RefreshOutcome.ReauthRequired)]
+        public void Parse_KnownValues_ReturnsExpectedOutcome(string input, RefreshOutcome expected)
+        {
+            var result = RefreshOutcomeParser.Parse(input);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("   ")]
+        [InlineData("unknown")]
+        [InlineData("NO-OP")]
+        [InlineData("Touched")]
+        public void Parse_UnknownOrInvalidValues_ReturnsNone(string? input)
+        {
+            var result = RefreshOutcomeParser.Parse(input);
+
+            Assert.Equal(RefreshOutcome.None, result);
+        }
+    }
+}

tests/CodeBeam.UltimateAuth.Tests.Unit/Fake/FakeNavigationManager.cs

@@ -0,0 +1,19 @@
+using Microsoft.AspNetCore.Components;
+
+namespace CodeBeam.UltimateAuth.Tests.Unit.Fake
+{
+    internal sealed class TestNavigationManager : NavigationManager
+    {
+        public string? LastNavigatedTo { get; private set; }
+
+        public TestNavigationManager()
+        {
+            Initialize("http://localhost/", "http://localhost/");
+        }
+
+        protected override void NavigateToCore(string uri, bool forceLoad)
+        {
+            LastNavigatedTo = uri;
+        }
+    }
+}

tests/CodeBeam.UltimateAuth.Tests.Unit/Fake/FakeUAuthClient.cs

@@ -0,0 +1,51 @@
+using CodeBeam.UltimateAuth.Client;
+using CodeBeam.UltimateAuth.Client.Contracts;
+using CodeBeam.UltimateAuth.Core.Contracts;
+using CodeBeam.UltimateAuth.Core.Domain;
+
+namespace CodeBeam.UltimateAuth.Tests.Unit
+{
+    internal sealed class FakeUAuthClient : IUAuthClient
+    {
+        private readonly Queue<RefreshOutcome> _outcomes;
+
+        public FakeUAuthClient(params RefreshOutcome[] outcomes)
+        {
+            _outcomes = new Queue<RefreshOutcome>(outcomes);
+        }
+
+        public Task LoginAsync(LoginRequest request)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task LogoutAsync()
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task ReauthAsync()
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<RefreshResult> RefreshAsync(bool isAuto = false)
+        {
+            var outcome = _outcomes.Count > 0
+                ? _outcomes.Dequeue()
+                : RefreshOutcome.None;
+
+            return Task.FromResult(new RefreshResult
+            {
+                Ok = true,
+                Outcome = outcome
+            });
+        }
+
+        public Task<AuthValidationResult> ValidateAsync()
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+}