Restructure solution layout by module

src/Authority/StellaOps.Authority/StellaOps.Authority.Plugins.Abstractions.Tests/AuthorityClientRegistrationTests.cs

@@ -0,0 +1,32 @@
+using System;
+using StellaOps.Authority.Plugins.Abstractions;
+
+namespace StellaOps.Authority.Plugins.Abstractions.Tests;
+
+public class AuthorityClientRegistrationTests
+{
+    [Fact]
+    public void Constructor_Throws_WhenClientIdMissing()
+    {
+        Assert.Throws<ArgumentException>(() => new AuthorityClientRegistration(string.Empty, false, null, null));
+    }
+
+    [Fact]
+    public void Constructor_RequiresSecret_ForConfidentialClients()
+    {
+        Assert.Throws<ArgumentException>(() => new AuthorityClientRegistration("cli", true, null, null));
+    }
+
+    [Fact]
+    public void WithClientSecret_ReturnsCopy()
+    {
+        var registration = new AuthorityClientRegistration("cli", false, null, null, tenant: "Tenant-Alpha");
+
+        var updated = registration.WithClientSecret("secret");
+
+        Assert.Equal("cli", updated.ClientId);
+        Assert.Equal("secret", updated.ClientSecret);
+        Assert.False(updated.Confidential);
+        Assert.Equal("tenant-alpha", updated.Tenant);
+    }
+}

src/Authority/StellaOps.Authority/StellaOps.Authority.Plugins.Abstractions.Tests/AuthorityCredentialVerificationResultTests.cs

@@ -0,0 +1,51 @@
+using System;
+using StellaOps.Authority.Plugins.Abstractions;
+using StellaOps.Cryptography.Audit;
+
+namespace StellaOps.Authority.Plugins.Abstractions.Tests;
+
+public class AuthorityCredentialVerificationResultTests
+{
+    [Fact]
+    public void Success_SetsUserAndClearsFailure()
+    {
+        var user = new AuthorityUserDescriptor("subject-1", "user", "User", false);
+
+        var auditProperties = new[]
+        {
+            new AuthEventProperty { Name = "test", Value = ClassifiedString.Public("value") }
+        };
+
+        var result = AuthorityCredentialVerificationResult.Success(user, "ok", auditProperties);
+
+        Assert.True(result.Succeeded);
+        Assert.Equal(user, result.User);
+        Assert.Null(result.FailureCode);
+        Assert.Equal("ok", result.Message);
+        Assert.Collection(result.AuditProperties, property => Assert.Equal("test", property.Name));
+    }
+
+    [Fact]
+    public void Success_Throws_WhenUserNull()
+    {
+        Assert.Throws<ArgumentNullException>(() => AuthorityCredentialVerificationResult.Success(null!));
+    }
+
+    [Fact]
+    public void Failure_SetsFailureCode()
+    {
+        var auditProperties = new[]
+        {
+            new AuthEventProperty { Name = "reason", Value = ClassifiedString.Public("lockout") }
+        };
+
+        var result = AuthorityCredentialVerificationResult.Failure(AuthorityCredentialFailureCode.LockedOut, "locked", TimeSpan.FromMinutes(5), auditProperties);
+
+        Assert.False(result.Succeeded);
+        Assert.Null(result.User);
+        Assert.Equal(AuthorityCredentialFailureCode.LockedOut, result.FailureCode);
+        Assert.Equal("locked", result.Message);
+        Assert.Equal(TimeSpan.FromMinutes(5), result.RetryAfter);
+        Assert.Collection(result.AuditProperties, property => Assert.Equal("reason", property.Name));
+    }
+}

src/Authority/StellaOps.Authority/StellaOps.Authority.Plugins.Abstractions.Tests/AuthorityIdentityProviderCapabilitiesTests.cs

@@ -0,0 +1,42 @@
+using System;
+using StellaOps.Authority.Plugins.Abstractions;
+
+namespace StellaOps.Authority.Plugins.Abstractions.Tests;
+
+public class AuthorityIdentityProviderCapabilitiesTests
+{
+    [Fact]
+    public void FromCapabilities_SetsFlags_WhenTokensPresent()
+    {
+        var capabilities = AuthorityIdentityProviderCapabilities.FromCapabilities(new[]
+        {
+            "password",
+            "mfa",
+            "clientProvisioning"
+        });
+
+        Assert.True(capabilities.SupportsPassword);
+        Assert.True(capabilities.SupportsMfa);
+        Assert.True(capabilities.SupportsClientProvisioning);
+    }
+
+    [Fact]
+    public void FromCapabilities_DefaultsToFalse_WhenEmpty()
+    {
+        var capabilities = AuthorityIdentityProviderCapabilities.FromCapabilities(Array.Empty<string>());
+
+        Assert.False(capabilities.SupportsPassword);
+        Assert.False(capabilities.SupportsMfa);
+        Assert.False(capabilities.SupportsClientProvisioning);
+    }
+
+    [Fact]
+    public void FromCapabilities_IgnoresNullSet()
+    {
+        var capabilities = AuthorityIdentityProviderCapabilities.FromCapabilities(null!);
+
+        Assert.False(capabilities.SupportsPassword);
+        Assert.False(capabilities.SupportsMfa);
+        Assert.False(capabilities.SupportsClientProvisioning);
+    }
+}

src/Authority/StellaOps.Authority/StellaOps.Authority.Plugins.Abstractions.Tests/AuthorityPluginHealthResultTests.cs

@@ -0,0 +1,32 @@
+using StellaOps.Authority.Plugins.Abstractions;
+
+namespace StellaOps.Authority.Plugins.Abstractions.Tests;
+
+public class AuthorityPluginHealthResultTests
+{
+    [Fact]
+    public void Healthy_ReturnsHealthyStatus()
+    {
+        var result = AuthorityPluginHealthResult.Healthy("ready");
+
+        Assert.Equal(AuthorityPluginHealthStatus.Healthy, result.Status);
+        Assert.Equal("ready", result.Message);
+        Assert.NotNull(result.Details);
+    }
+
+    [Fact]
+    public void Degraded_ReturnsDegradedStatus()
+    {
+        var result = AuthorityPluginHealthResult.Degraded("slow");
+
+        Assert.Equal(AuthorityPluginHealthStatus.Degraded, result.Status);
+    }
+
+    [Fact]
+    public void Unavailable_ReturnsUnavailableStatus()
+    {
+        var result = AuthorityPluginHealthResult.Unavailable("down");
+
+        Assert.Equal(AuthorityPluginHealthStatus.Unavailable, result.Status);
+    }
+}

src/Authority/StellaOps.Authority/StellaOps.Authority.Plugins.Abstractions.Tests/AuthorityPluginOperationResultTests.cs

@@ -0,0 +1,60 @@
+using System;
+using StellaOps.Authority.Plugins.Abstractions;
+
+namespace StellaOps.Authority.Plugins.Abstractions.Tests;
+
+public class AuthorityPluginOperationResultTests
+{
+    [Fact]
+    public void Success_ReturnsSucceededResult()
+    {
+        var result = AuthorityPluginOperationResult.Success("ok");
+
+        Assert.True(result.Succeeded);
+        Assert.Null(result.ErrorCode);
+        Assert.Equal("ok", result.Message);
+    }
+
+    [Fact]
+    public void Failure_PopulatesErrorCode()
+    {
+        var result = AuthorityPluginOperationResult.Failure("ERR_CODE", "failure");
+
+        Assert.False(result.Succeeded);
+        Assert.Equal("ERR_CODE", result.ErrorCode);
+        Assert.Equal("failure", result.Message);
+    }
+
+    [Fact]
+    public void Failure_Throws_WhenErrorCodeMissing()
+    {
+        Assert.Throws<ArgumentException>(() => AuthorityPluginOperationResult.Failure(string.Empty));
+    }
+
+    [Fact]
+    public void GenericSuccess_ReturnsValue()
+    {
+        var result = AuthorityPluginOperationResult<string>.Success("value", "created");
+
+        Assert.True(result.Succeeded);
+        Assert.Equal("value", result.Value);
+        Assert.Equal("created", result.Message);
+    }
+
+    [Fact]
+    public void GenericFailure_PopulatesErrorCode()
+    {
+        var result = AuthorityPluginOperationResult<int>.Failure("CONFLICT", "duplicate");
+
+        Assert.False(result.Succeeded);
+        Assert.Equal(default, result.Value);
+        Assert.Equal("CONFLICT", result.ErrorCode);
+        Assert.Equal("duplicate", result.Message);
+    }
+
+    [Fact]
+    public void GenericFailure_Throws_WhenErrorCodeMissing()
+    {
+        Assert.Throws<ArgumentException>(() => AuthorityPluginOperationResult<string>.Failure(" "));
+    }
+}

src/Authority/StellaOps.Authority/StellaOps.Authority.Plugins.Abstractions.Tests/AuthorityUserDescriptorTests.cs

@@ -0,0 +1,28 @@
+using System;
+using StellaOps.Authority.Plugins.Abstractions;
+
+namespace StellaOps.Authority.Plugins.Abstractions.Tests;
+
+public class AuthorityUserDescriptorTests
+{
+    [Fact]
+    public void Constructor_Throws_WhenSubjectMissing()
+    {
+        Assert.Throws<ArgumentException>(() => new AuthorityUserDescriptor(string.Empty, "user", null, false));
+    }
+
+    [Fact]
+    public void Constructor_Throws_WhenUsernameMissing()
+    {
+        Assert.Throws<ArgumentException>(() => new AuthorityUserDescriptor("subject", " ", null, false));
+    }
+
+    [Fact]
+    public void Constructor_MaterialisesCollections()
+    {
+        var descriptor = new AuthorityUserDescriptor("subject", "user", null, false);
+
+        Assert.NotNull(descriptor.Roles);
+        Assert.NotNull(descriptor.Attributes);
+    }
+}

src/Authority/StellaOps.Authority/StellaOps.Authority.Plugins.Abstractions.Tests/AuthorityUserRegistrationTests.cs

@@ -0,0 +1,25 @@
+using System;
+using StellaOps.Authority.Plugins.Abstractions;
+
+namespace StellaOps.Authority.Plugins.Abstractions.Tests;
+
+public class AuthorityUserRegistrationTests
+{
+    [Fact]
+    public void Constructor_Throws_WhenUsernameMissing()
+    {
+        Assert.Throws<ArgumentException>(() => new AuthorityUserRegistration(string.Empty, null, null, null, false));
+    }
+
+    [Fact]
+    public void WithPassword_ReturnsCopyWithPassword()
+    {
+        var registration = new AuthorityUserRegistration("alice", null, "Alice", null, true);
+
+        var updated = registration.WithPassword("secret");
+
+        Assert.Equal("alice", updated.Username);
+        Assert.Equal("secret", updated.Password);
+        Assert.True(updated.RequirePasswordReset);
+    }
+}

src/Authority/StellaOps.Authority/StellaOps.Authority.Plugins.Abstractions.Tests/StellaOps.Authority.Plugins.Abstractions.Tests.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\StellaOps.Authority.Plugins.Abstractions\StellaOps.Authority.Plugins.Abstractions.csproj" />
+  </ItemGroup>
+</Project>