@juangcarmona/lighthouse 0.4.0 → 0.6.0

package/assets/dotnet-template/global.json

@@ -0,0 +1,6 @@
+{
+  "sdk": {
+    "version": "10.0.112",
+    "rollForward": "latestPatch"
+  }
+}

package/assets/dotnet-template/tests/Lighthouse.Analyzers.Tests/BackendContractTests.cs

@@ -0,0 +1,102 @@
+using System.Collections.Immutable;
+using JuanGCarmona.Lighthouse.Analyzers;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using Xunit;
+
+namespace JuanGCarmona.Lighthouse.Tests;
+
+public class BackendContractTests
+{
+    private const string Contracts = """
+        namespace JuanGCarmona.Lighthouse.Cqrs {
+            public interface ICommandHandler<TCommand, TResponse> { }
+            public interface IQueryHandler<TQuery, TResponse> { }
+        }
+        """;
+    private static readonly ImmutableArray<MetadataReference> References =
+        ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator)
+            .Select(p => (MetadataReference)MetadataReference.CreateFromFile(p)).ToImmutableArray();
+
+    [Theory]
+    [InlineData("public sealed class Save : JuanGCarmona.Lighthouse.Cqrs.ICommandHandler<int, int> {}")]
+    [InlineData("internal class Save : JuanGCarmona.Lighthouse.Cqrs.ICommandHandler<int, int> {}")]
+    [InlineData("public sealed record Read : JuanGCarmona.Lighthouse.Cqrs.IQueryHandler<int, int>;")]
+    public async Task HandlerContractReportsVisibilityOrInheritanceExposure(string declaration)
+    {
+        var diagnostics = await Analyze(Compile(Contracts + declaration));
+        Assert.Single(diagnostics, d => d.Id == "LH1001" && d.Severity == DiagnosticSeverity.Error);
+    }
+
+    [Fact]
+    public async Task InternalSealedHandlerPassesAndANameAloneDoesNotTriggerARule()
+    {
+        var source = Contracts + """
+            internal sealed class Save : JuanGCarmona.Lighthouse.Cqrs.ICommandHandler<int, int> {}
+            public class PresentationHandler {}
+            """;
+        Assert.Empty(await Analyze(Compile(source)));
+    }
+
+    [Fact]
+    public async Task GeneratedHandlerIsIgnored()
+    {
+        Assert.Empty(await Analyze(Compile("// <auto-generated/>\n" + Contracts +
+            "public class Generated : JuanGCarmona.Lighthouse.Cqrs.ICommandHandler<int, int> {}")));
+    }
+
+    [Fact]
+    public async Task RuleIsOptInForModuleProjects()
+    {
+        var source = Contracts + "public class Save : JuanGCarmona.Lighthouse.Cqrs.ICommandHandler<int, int> {}";
+        Assert.Empty(await Analyze(Compile(source), enabled: false));
+    }
+
+    [Theory]
+    [InlineData("JuanGCarmona.Fixture.Modules.Other", true)]
+    [InlineData("JuanGCarmona.Fixture.Modules.Other.Contracts", false)]
+    [InlineData("SomeLibrary.Modules.Other", false)]
+    public async Task ModuleRuleDistinguishesImplementationContractAndUnrelatedLibrary(string dependency, bool forbidden)
+    {
+        var assembly = Compile("public sealed class Export {}", dependency);
+        using var stream = new MemoryStream();
+        var emitted = assembly.Emit(stream);
+        Assert.True(emitted.Success, string.Join("\n", emitted.Diagnostics));
+        var reference = MetadataReference.CreateFromImage(stream.ToArray());
+        var source = Compile("internal sealed class Local {}", "JuanGCarmona.Fixture.Modules.Main")
+            .AddReferences(reference);
+        var diagnostics = await Analyze(source);
+        Assert.Equal(forbidden ? 1 : 0, diagnostics.Count(d => d.Id == "LH1002"));
+    }
+
+    private static CSharpCompilation Compile(string source, string name = "JuanGCarmona.Fixture.Modules.Main") =>
+        CSharpCompilation.Create(name, [CSharpSyntaxTree.ParseText(source)], References,
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+    private static async Task<ImmutableArray<Diagnostic>> Analyze(CSharpCompilation compilation, bool enabled = true)
+    {
+        Assert.Empty(compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error));
+        var options = new AnalyzerOptions(ImmutableArray<AdditionalText>.Empty, new ModuleOptions(enabled));
+        return await compilation.WithAnalyzers(
+            ImmutableArray.Create<DiagnosticAnalyzer>(new BackendContractAnalyzer()), options)
+            .GetAnalyzerDiagnosticsAsync();
+    }
+
+    private sealed class ModuleOptions(bool enabled) : AnalyzerConfigOptionsProvider
+    {
+        public override AnalyzerConfigOptions GlobalOptions { get; } = new Values(enabled);
+        public override AnalyzerConfigOptions GetOptions(SyntaxTree tree) => GlobalOptions;
+        public override AnalyzerConfigOptions GetOptions(AdditionalText textFile) => GlobalOptions;
+    }
+
+    private sealed class Values(bool enabled) : AnalyzerConfigOptions
+    {
+        public override bool TryGetValue(string key, out string value)
+        {
+            value = enabled ? "true" : "false";
+            return key == "build_property.LighthouseModule";
+        }
+    }
+}

package/assets/dotnet-template/tests/Lighthouse.Analyzers.Tests/Lighthouse.Analyzers.Tests.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
+    <ProjectReference Include="../../Lighthouse.Analyzers/Lighthouse.Analyzers.csproj" />
+  </ItemGroup>
+</Project>

package/assets/dotnet-template/tests/Lighthouse.Analyzers.Tests/packages.lock.json

@@ -0,0 +1,125 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Microsoft.CodeAnalysis.CSharp": {
+        "type": "Direct",
+        "requested": "[5.0.0, )",
+        "resolved": "5.0.0",
+        "contentHash": "5DSyJ9bk+ATuDy7fp2Zt0mJStDVKbBoiz1DyfAwSa+k4H4IwykAUcV3URelw5b8/iVbfSaOwkwmPUZH6opZKCw==",
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+          "Microsoft.CodeAnalysis.Common": "[5.0.0]"
+        }
+      },
+      "Microsoft.NET.Test.Sdk": {
+        "type": "Direct",
+        "requested": "[18.7.0, )",
+        "resolved": "18.7.0",
+        "contentHash": "49xH9j4UzCh2hMohJp53g3wUTvyycECw7CtVht4gfCz5ykudB1uBcF6D0TtgJPjCtP76UPW53bQElKdCeX+dUg==",
+        "dependencies": {
+          "Microsoft.CodeCoverage": "18.7.0",
+          "Microsoft.TestPlatform.TestHost": "18.7.0"
+        }
+      },
+      "xunit": {
+        "type": "Direct",
+        "requested": "[2.9.3, )",
+        "resolved": "2.9.3",
+        "contentHash": "TlXQBinK35LpOPKHAqbLY4xlEen9TBafjs0V5KnA4wZsoQLQJiirCR4CbIXvOH8NzkW4YeJKP5P/Bnrodm0h9Q==",
+        "dependencies": {
+          "xunit.analyzers": "1.18.0",
+          "xunit.assert": "2.9.3",
+          "xunit.core": "[2.9.3]"
+        }
+      },
+      "xunit.runner.visualstudio": {
+        "type": "Direct",
+        "requested": "[3.1.5, )",
+        "resolved": "3.1.5",
+        "contentHash": "tKi7dSTwP4m5m9eXPM2Ime4Kn7xNf4x4zT9sdLO/G4hZVnQCRiMTWoSZqI/pYTVeI27oPPqHBKYI/DjJ9GsYgA=="
+      },
+      "Microsoft.CodeAnalysis.Common": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "ZXRAdvH6GiDeHRyd3q/km8Z44RoM6FBWHd+gen/la81mVnAdHTEsEkO5J0TCNXBymAcx5UYKt5TvgKBhaLJEow==",
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.11.0"
+        }
+      },
+      "Microsoft.CodeCoverage": {
+        "type": "Transitive",
+        "resolved": "18.7.0",
+        "contentHash": "+wFfx9s7D9wegM0RziXMj2kvYDT4qcqXXtyjiQwSZOGQ2wwcOAJQcD6eQXk02jt0MvRNawtp8TJxTrV+wD8X1g=="
+      },
+      "Microsoft.TestPlatform.ObjectModel": {
+        "type": "Transitive",
+        "resolved": "18.7.0",
+        "contentHash": "6rmgU4q3/WOpOPcncI0YW0Q/QpcQtwR2TTEXDR5+4TfSimPBAk6Z/BgKLeGgp1SOun0ROVUCCafXhRLwsHaPpA=="
+      },
+      "Microsoft.TestPlatform.TestHost": {
+        "type": "Transitive",
+        "resolved": "18.7.0",
+        "contentHash": "kYwfmebCs8992zaxEDkvG7S+YEouTeKfYVKUFEkwh1W2dIoOaevBt80XSKVXCUFEhusjOIm1sFfHBnoJgygrRA==",
+        "dependencies": {
+          "Microsoft.TestPlatform.ObjectModel": "18.7.0",
+          "Newtonsoft.Json": "13.0.3"
+        }
+      },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.3",
+        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
+      },
+      "xunit.abstractions": {
+        "type": "Transitive",
+        "resolved": "2.0.3",
+        "contentHash": "pot1I4YOxlWjIb5jmwvvQNbTrZ3lJQ+jUGkGjWE3hEFM0l5gOnBWS+H3qsex68s5cO52g+44vpGzhAt+42vwKg=="
+      },
+      "xunit.analyzers": {
+        "type": "Transitive",
+        "resolved": "1.18.0",
+        "contentHash": "OtFMHN8yqIcYP9wcVIgJrq01AfTxijjAqVDy/WeQVSyrDC1RzBWeQPztL49DN2syXRah8TYnfvk035s7L95EZQ=="
+      },
+      "xunit.assert": {
+        "type": "Transitive",
+        "resolved": "2.9.3",
+        "contentHash": "/Kq28fCE7MjOV42YLVRAJzRF0WmEqsmflm0cfpMjGtzQ2lR5mYVj1/i0Y8uDAOLczkL3/jArrwehfMD0YogMAA=="
+      },
+      "xunit.core": {
+        "type": "Transitive",
+        "resolved": "2.9.3",
+        "contentHash": "BiAEvqGvyme19wE0wTKdADH+NloYqikiU0mcnmiNyXaF9HyHmE6sr/3DC5vnBkgsWaE6yPyWszKSPSApWdRVeQ==",
+        "dependencies": {
+          "xunit.extensibility.core": "[2.9.3]",
+          "xunit.extensibility.execution": "[2.9.3]"
+        }
+      },
+      "xunit.extensibility.core": {
+        "type": "Transitive",
+        "resolved": "2.9.3",
+        "contentHash": "kf3si0YTn2a8J8eZNb+zFpwfoyvIrQ7ivNk5ZYA5yuYk1bEtMe4DxJ2CF/qsRgmEnDr7MnW1mxylBaHTZ4qErA==",
+        "dependencies": {
+          "xunit.abstractions": "2.0.3"
+        }
+      },
+      "xunit.extensibility.execution": {
+        "type": "Transitive",
+        "resolved": "2.9.3",
+        "contentHash": "yMb6vMESlSrE3Wfj7V6cjQ3S4TXdXpRqYeNEI3zsX31uTsGMJjEw6oD5F5u1cHnMptjhEECnmZSsPxB6ChZHDQ==",
+        "dependencies": {
+          "xunit.extensibility.core": "[2.9.3]"
+        }
+      },
+      "JuanGCarmona.Lighthouse.Analyzers": {
+        "type": "Project"
+      },
+      "Microsoft.CodeAnalysis.Analyzers": {
+        "type": "CentralTransitive",
+        "requested": "[3.11.0, )",
+        "resolved": "3.11.0",
+        "contentHash": "v/EW3UE8/lbEYHoC2Qq7AR/DnmvpgdtAMndfQNmpuIMx/Mto8L5JnuCfdBYtgvalQOtfNCnxFejxuRrryvUTsg=="
+      }
+    }
+  }
+}

package/assets/dotnet-template/tests/Lighthouse.Example.Tests/CatalogTests.cs

@@ -0,0 +1,111 @@
+using System.Net;
+using System.Net.Http.Json;
+using System.Security.Claims;
+using System.Text.Encodings.Web;
+using JuanGCarmona.Lighthouse.Example.Api;
+using JuanGCarmona.Lighthouse.Example.Modules.Catalog;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Xunit;
+
+namespace JuanGCarmona.Lighthouse.Tests;
+
+public class CatalogTests : IClassFixture<CatalogApplication>
+{
+    private readonly CatalogApplication application;
+    public CatalogTests(CatalogApplication application) => this.application = application;
+
+    [Fact]
+    public async Task AnonymousWriteIsUnauthorized()
+    {
+        using var client = application.CreateClient();
+        var response = await client.PostAsJsonAsync("/api/entries", new { name = "Socket" });
+        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task AuthenticatedReaderCannotWrite()
+    {
+        using var client = application.CreateClient();
+        client.DefaultRequestHeaders.Add("X-Test-Identity", "reader");
+        var response = await client.PostAsJsonAsync("/api/entries", new { name = "Socket" });
+        Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(" ")]
+    [InlineData(null)]
+    public async Task InvalidCommandReturnsValidationProblem(string? name)
+    {
+        using var client = Writer();
+        var response = await client.PostAsJsonAsync("/api/entries", new { name });
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        Assert.Equal("application/problem+json", response.Content.Headers.ContentType?.MediaType);
+        Assert.Contains("name", await response.Content.ReadAsStringAsync(), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task CommandThenQueryReturnsTheCreatedResource()
+    {
+        using var client = Writer();
+        var response = await client.PostAsJsonAsync("/api/entries", new { name = "  Socket  " });
+        Assert.Equal(HttpStatusCode.Created, response.StatusCode);
+        Assert.NotNull(response.Headers.Location);
+        var entry = await client.GetFromJsonAsync<EntryResponse>(response.Headers.Location);
+        Assert.NotNull(entry);
+        Assert.Equal("Socket", entry.Name);
+        Assert.NotEqual(Guid.Empty, entry.Id);
+    }
+
+    [Fact]
+    public async Task UnknownResourceReturnsNotFound()
+    {
+        using var client = Writer();
+        Assert.Equal(HttpStatusCode.NotFound, (await client.GetAsync($"/api/entries/{Guid.NewGuid()}")).StatusCode);
+    }
+
+    [Fact]
+    public void CompiledModuleDoesNotExposeHandlersOrReferenceASiblingImplementation()
+    {
+        var assembly = typeof(CatalogModule).Assembly;
+        Assert.DoesNotContain(assembly.GetExportedTypes(), type => type.GetInterfaces()
+            .Any(i => i.Namespace == "JuanGCarmona.Lighthouse.Cqrs"));
+        Assert.DoesNotContain(assembly.GetReferencedAssemblies(), reference =>
+            reference.Name!.StartsWith("JuanGCarmona.Lighthouse.Example.Modules.", StringComparison.Ordinal)
+            && !reference.Name.EndsWith(".Contracts", StringComparison.Ordinal));
+    }
+
+    private HttpClient Writer()
+    {
+        var client = application.CreateClient();
+        client.DefaultRequestHeaders.Add("X-Test-Identity", "writer");
+        return client;
+    }
+
+    private sealed record EntryResponse(Guid Id, string Name);
+}
+
+public sealed class CatalogApplication : WebApplicationFactory<Program>
+{
+    protected override void ConfigureWebHost(IWebHostBuilder builder) => builder.ConfigureServices(services =>
+        services.AddAuthentication("test-only").AddScheme<AuthenticationSchemeOptions, TestIdentity>("test-only", _ => { }));
+}
+
+public sealed class TestIdentity(IOptionsMonitor<AuthenticationSchemeOptions> options, ILoggerFactory logger,
+    UrlEncoder encoder) : AuthenticationHandler<AuthenticationSchemeOptions>(options, logger, encoder)
+{
+    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
+    {
+        var identity = Request.Headers["X-Test-Identity"].ToString();
+        if (identity is not ("writer" or "reader")) return Task.FromResult(AuthenticateResult.NoResult());
+        var claims = new List<Claim> { new(ClaimTypes.NameIdentifier, identity) };
+        if (identity == "writer") claims.Add(new Claim("permission", "catalog.write"));
+        var principal = new ClaimsPrincipal(new ClaimsIdentity(claims, Scheme.Name));
+        return Task.FromResult(AuthenticateResult.Success(new AuthenticationTicket(principal, Scheme.Name)));
+    }
+}

package/assets/dotnet-template/tests/Lighthouse.Example.Tests/Lighthouse.Example.Tests.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" />
+    <ProjectReference Include="../../examples/src/root/Lighthouse.Example.Api/Lighthouse.Example.Api.csproj" />
+  </ItemGroup>
+</Project>