Consolidating snapshot tests (#18)

* Adding references to solution explorer

* Consolidating snapshot tests

* Making one test more robust

* Switch namespace declarations from file scoped to block scoped for consistency reasons.

* Simplifying interface naming resolver logic

---------

Co-authored-by: Dmytro Ett <dmytro.ett@outlook.com>

Author: dmytroett

AttributedDI.slnx

@@ -6,8 +6,8 @@
   </Configurations>
   <Folder Name="/Solution Items/">
     <File Path=".editorconfig" />
-    <File Path=".github/copilot-instructions.md" />
-    <File Path=".github/instructions/source-generators.instructions.md" />
+    <File Path="AGENTS.md" />
+    <File Path="Directory.Build.props" />
     <File Path=".github/workflows/pr.yml" />
     <File Path=".github/workflows/release.yml" />
     <File Path="README.md" />
@@ -26,5 +26,7 @@
     <Project Path="test/assets/Company.TeamName.Project.API/Company.TeamName.Project.API.csproj" />
     <Project Path="test/assets/CustomModuleName/CustomModuleName.csproj" />
     <Project Path="test/assets/GeneratedInterfacesSut/GeneratedInterfacesSut.csproj" />
+    <File Path="test/assets/.editorconfig" />
+    <File Path="test/assets/Directory.Build.props" />
   </Folder>
 </Solution>

src/AttributedDI.SourceGenerator/AttributedDI.SourceGenerator.csproj

@@ -15,4 +15,8 @@
     <PackageReference Include="PolySharp" Version="1.15.0" PrivateAssets="all" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Include="AGENTS.md" />
+  </ItemGroup>
+
 </Project>

src/AttributedDI.SourceGenerator/InterfacesGeneration/GeneratedInterfaceNamingResolver.cs

@@ -5,10 +5,7 @@ namespace AttributedDI.SourceGenerator.InterfacesGeneration;
 
 internal static class GeneratedInterfaceNamingResolver
 {
-    internal static bool TryResolve(
-        INamedTypeSymbol typeSymbol,
-        AttributeData attribute,
-        out GeneratedInterfaceNaming? naming)
+    internal static GeneratedInterfaceNaming Resolve(INamedTypeSymbol typeSymbol, AttributeData attribute)
     {
         var interfaceNameArgument = GetOptionalStringArgument(attribute, position: 0, name: "InterfaceName");
         var interfaceNamespaceArgument = GetOptionalStringArgument(attribute, position: 1, name: "InterfaceNamespace");
@@ -22,10 +19,9 @@ internal static bool TryResolve(
                 ? ParseInterfaceName(interfaceNameArgument!)
                 : (Name: defaultInterfaceName, Namespace: string.Empty);
 
-            naming = new GeneratedInterfaceNaming(
+            return new GeneratedInterfaceNaming(
                 parsed.Name,
                 NormalizeNamespace(interfaceNamespaceArgument));
-            return true;
         }
 
         if (!string.IsNullOrWhiteSpace(interfaceNameArgument))
@@ -35,12 +31,10 @@ internal static bool TryResolve(
                 ? defaultNamespace
                 : NormalizeNamespace(parsed.Namespace);
 
-            naming = new GeneratedInterfaceNaming(parsed.Name, resolvedNamespace);
-            return true;
+            return new GeneratedInterfaceNaming(parsed.Name, resolvedNamespace);
         }
 
-        naming = new GeneratedInterfaceNaming(defaultInterfaceName, defaultNamespace);
-        return true;
+        return new GeneratedInterfaceNaming(defaultInterfaceName, defaultNamespace);
     }
 
     private static string? GetOptionalStringArgument(AttributeData attribute, int position, string name)

src/AttributedDI.SourceGenerator/InterfacesGeneration/GeneratedInterfacesCodeEmitter.cs

@@ -32,29 +32,35 @@ private static string BuildInterfaceSource(GeneratedInterfaceInfo interfaceInfo)
         builder.AppendLine();
 
         var interfaceNamespace = NormalizeNamespace(interfaceInfo.InterfaceNamespace);
-        if (!string.IsNullOrWhiteSpace(interfaceNamespace))
+        var hasNamespace = !string.IsNullOrWhiteSpace(interfaceNamespace);
+        if (hasNamespace)
         {
-            builder.Append("namespace ").Append(interfaceNamespace).AppendLine(";");
-            builder.AppendLine();
+            builder.Append("namespace ").Append(interfaceNamespace).AppendLine();
+            builder.AppendLine("{");
         }
 
-        GeneratedCodeHelper.AppendGeneratedCodeAttribute(builder, 0);
-        builder.Append(interfaceInfo.Accessibility)
+        var indent = hasNamespace ? "    " : string.Empty;
+        GeneratedCodeHelper.AppendGeneratedCodeAttribute(builder, hasNamespace ? 1 : 0);
+        builder.Append(indent)
+            .Append(interfaceInfo.Accessibility)
             .Append(" interface ")
             .Append(interfaceInfo.InterfaceName)
             .Append(interfaceInfo.ClassTypeParameters)
             .AppendLine();
 
         if (!string.IsNullOrWhiteSpace(interfaceInfo.TypeParameterConstraints))
         {
-            builder.Append(interfaceInfo.TypeParameterConstraints).AppendLine();
+            builder.Append(indent)
+                .Append(interfaceInfo.TypeParameterConstraints)
+                .AppendLine();
         }
 
-        builder.AppendLine("{");
+        builder.Append(indent).AppendLine("{");
 
+        var memberIndent = indent + "    ";
         foreach (var member in interfaceInfo.MemberSignatures)
         {
-            builder.Append("    ").Append(member);
+            builder.Append(memberIndent).Append(member);
             var needsSemicolon = !member.Contains("{", StringComparison.Ordinal) && !member.EndsWith(";", StringComparison.Ordinal);
             if (needsSemicolon)
             {
@@ -64,7 +70,11 @@ private static string BuildInterfaceSource(GeneratedInterfaceInfo interfaceInfo)
             builder.AppendLine();
         }
 
-        builder.AppendLine("}");
+        builder.Append(indent).AppendLine("}");
+        if (hasNamespace)
+        {
+            builder.AppendLine("}");
+        }
 
         return builder.ToString();
     }
@@ -77,17 +87,20 @@ private static string BuildPartialClassSource(GeneratedInterfaceInfo interfaceIn
         builder.AppendLine();
 
         var classNamespace = NormalizeNamespace(interfaceInfo.ClassNamespace);
-        if (!string.IsNullOrWhiteSpace(classNamespace))
+        var hasNamespace = !string.IsNullOrWhiteSpace(classNamespace);
+        if (hasNamespace)
         {
-            builder.Append("namespace ").Append(classNamespace).AppendLine(";");
-            builder.AppendLine();
+            builder.Append("namespace ").Append(classNamespace).AppendLine();
+            builder.AppendLine("{");
         }
 
-        GeneratedCodeHelper.AppendGeneratedCodeAttribute(builder, 0);
+        var indent = hasNamespace ? "    " : string.Empty;
+        GeneratedCodeHelper.AppendGeneratedCodeAttribute(builder, hasNamespace ? 1 : 0);
         // Build the partial class declaration that implements the interface
         var fullyQualifiedInterfaceName = BuildFullyQualifiedName(interfaceInfo.InterfaceNamespace, interfaceInfo.InterfaceName);
 
-        builder.Append(interfaceInfo.Accessibility)
+        builder.Append(indent)
+            .Append(interfaceInfo.Accessibility)
             .Append(" partial class ")
             .Append(interfaceInfo.ClassName)
             .Append(interfaceInfo.ClassTypeParameters)
@@ -106,8 +119,12 @@ private static string BuildPartialClassSource(GeneratedInterfaceInfo interfaceIn
         }
 
         builder.AppendLine();
-        builder.AppendLine("{");
-        builder.AppendLine("}");
+        builder.Append(indent).AppendLine("{");
+        builder.Append(indent).AppendLine("}");
+        if (hasNamespace)
+        {
+            builder.AppendLine("}");
+        }
 
         return builder.ToString();
     }

src/AttributedDI.SourceGenerator/InterfacesGeneration/InterfaceGenerationPipeline.cs

@@ -46,12 +46,7 @@ internal static class InterfaceGenerationBuilder
             return null;
         }
 
-        if (!GeneratedInterfaceNamingResolver.TryResolve(typeSymbol, context.Attributes[0], out var naming) || naming is null)
-        {
-            return null;
-        }
-
-        var resolvedNaming = naming;
+        var resolvedNaming = GeneratedInterfaceNamingResolver.Resolve(typeSymbol, context.Attributes[0]);
         var interfaceName = StripTypeParameters(resolvedNaming.InterfaceName);
         var members = CollectMembers(typeSymbol, ct);
         var accessibility = ResolveAccessibility(typeSymbol.DeclaredAccessibility);

src/AttributedDI.SourceGenerator/ServiceModulesGeneration/RegistrationCandidatesCollector.cs

@@ -178,12 +178,7 @@ private static ImmutableArray<RegistrationCandidate> ExtractRegisterAsGeneratedI
         }
 
         var attribute = context.Attributes[0];
-        if (!GeneratedInterfaceNamingResolver.TryResolve(symbol, attribute, out var naming) || naming is null)
-        {
-            // TODO: emit diagnostic when generated interface naming cannot be resolved.
-            return ImmutableArray<RegistrationCandidate>.Empty;
-        }
-
+        var naming = GeneratedInterfaceNamingResolver.Resolve(symbol, attribute);
         var implementationTypeName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
         var isOpenGeneric = IsOpenGenericDefinition(symbol);
         var unboundImplementationTypeName = ResolveUnboundName(symbol, implementationTypeName, isOpenGeneric);

src/AttributedDI/AttributedDI.csproj

@@ -9,6 +9,7 @@
     <IsTrimmable>true</IsTrimmable>
     <IsPackable>true</IsPackable>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/dmytroett/AttributedDI</PackageProjectUrl>
     <RepositoryUrl>https://github.com/dmytroett/AttributedDI</RepositoryUrl>
     <PackageTags>dependencyinjection;di;AoP;sourcegenerator;aot</PackageTags>

test/AttributedDI.SourceGenerator.UnitTests/BasicServicesRegistrationTests.cs

@@ -3,16 +3,20 @@ namespace AttributedDI.SourceGenerator.UnitTests;
 public class BasicServicesRegistrationTests
 {
     [Fact]
-    public async Task RegistersServicesWithDifferentLifetimesAndInterfaces()
+    public async Task RegistersServicesAcrossCommonScenarios()
     {
-        // Tests: RegisterAsSelf with lifetimes plus interface registrations
+        // Tests: RegisterAsSelf/implemented interfaces, multiple registrations, disposables, and nested namespaces.
         var code = """
                    using AttributedDI;
+                   using System;
+                   using System.Threading.Tasks;
 
                    namespace MyApp
                    {
                        public interface IMyService { }
                        public interface IOtherService { }
+                       public interface IService { }
+                       public interface IRepository { }
 
                        [Transient]
                        public class ShouldBeRegisteredAsTransient { } 
@@ -31,66 +35,38 @@ public class MyServiceImpl : IMyService { }
 
                        [RegisterAs<IOtherService>, Singleton]
                        public class OtherServiceImpl : IOtherService { }
-                   }
-                   """;
-
-        var (output, diagnostics) = new SourceGeneratorTestFixture()
-            .WithSourceCode(code)
-            .AddGenerator<ServiceRegistrationGenerator>()
-            .RunAndGetOutput();
-
-        Assert.Empty(diagnostics);
-
-        await Verify(output);
-    }
-
-    [Fact]
-    public async Task RegistersAsImplementedInterfaces()
-    {
-        // Tests: RegisterAsImplementedInterfaces for types implementing multiple interfaces
-        var code = """
-                   using AttributedDI;
-
-                   namespace MyApp
-                   {
-                       public interface IService { }
-                       public interface IRepository { }
 
                        [RegisterAsImplementedInterfaces]
                        public class ServiceImpl : IService { }
 
                        [RegisterAsImplementedInterfaces, Scoped]
                        public class MultiImpl : IService, IRepository { }
-                   }
-                   """;
-
-        var (output, diagnostics) = new SourceGeneratorTestFixture()
-            .WithSourceCode(code)
-            .AddGenerator<ServiceRegistrationGenerator>()
-            .RunAndGetOutput();
 
-        Assert.Empty(diagnostics);
+                       [RegisterAsSelf]
+                       [RegisterAs<IService>]
+                       [RegisterAs<IRepository>]
+                       [Singleton]
+                       public class MultiRegistration : IService, IRepository { }
 
-        await Verify(output);
-    }
+                       [RegisterAsImplementedInterfaces]
+                       public class DisposableService : IService, IDisposable, IAsyncDisposable
+                       {
+                           public void Dispose() { }
 
-    [Fact]
-    public async Task RegistersMultipleServicesFromSameType()
-    {
-        // Tests: Multiple registration attributes on single type
-        var code = """
-                   using AttributedDI;
+                           public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+                       }
+                   }
 
-                   namespace MyApp
+                   namespace MyApp.Services
                    {
-                       public interface IService { }
-                       public interface IRepository { }
+                       [RegisterAsSelf, Singleton]
+                       public class OuterService { }
+                   }
 
+                   namespace MyApp.Services.Internal
+                   {
                        [RegisterAsSelf]
-                       [RegisterAs<IService>]
-                       [RegisterAs<IRepository>]
-                       [Singleton]
-                       public class MultiRegistration : IService, IRepository { }
+                       public class InnerService { }
                    }
                    """;
 
@@ -130,7 +106,7 @@ public class MyService { }
     }
 
     [Fact]
-    public async Task HandlesEmptyAssembly()
+    public void HandlesEmptyAssembly()
     {
         // Tests: No services to register (should generate nothing)
         var code = """
@@ -148,71 +124,7 @@ public class RegularClass { }
             .RunAndGetOutput();
 
         Assert.Empty(diagnostics);
-
-        await Verify(output);
-    }
-
-    [Fact]
-    public async Task HandlesDisposable()
-    {
-        // Tests: Service implementing IDisposable and IAsyncDisposable
-        var code = """
-                   using AttributedDI;
-                   using System;
-                   using System.Threading.Tasks;
-
-                   namespace MyApp
-                   {
-                       public interface IService { }
-
-                       [RegisterAsImplementedInterfaces]
-                       public class DisposableService : IService, IDisposable, IAsyncDisposable
-                       {
-                           public void Dispose() { }
-
-                           public ValueTask DisposeAsync() => ValueTask.CompletedTask;
-                       }
-                   }
-                   """;
-
-        var (output, diagnostics) = new SourceGeneratorTestFixture()
-            .WithSourceCode(code)
-            .AddGenerator<ServiceRegistrationGenerator>()
-            .RunAndGetOutput();
-
-        Assert.Empty(diagnostics);
-
-        await Verify(output);
-    }
-
-    [Fact]
-    public async Task RegistersServicesInNestedNamespaces()
-    {
-        // Tests: Services across different nested namespaces
-        var code = """
-                   using AttributedDI;
-
-                   namespace MyApp.Services
-                   {
-                       [RegisterAsSelf, Singleton]
-                       public class OuterService { }
-                   }
-
-                   namespace MyApp.Services.Internal
-                   {
-                       [RegisterAsSelf]
-                       public class InnerService { }
-                   }
-                   """;
-
-        var (output, diagnostics) = new SourceGeneratorTestFixture()
-            .WithSourceCode(code)
-            .AddGenerator<ServiceRegistrationGenerator>()
-            .RunAndGetOutput();
-
-        Assert.Empty(diagnostics);
-
-        await Verify(output);
+        Assert.DoesNotContain("RegularClass", output);
     }
 
     [Fact(Skip = "Pending diagnostics for conflicting lifetime attributes on a single type.")]