Refactored test tooling for additional flexibility

Author: Arlodotexe

CommunityToolkit.Tooling.SampleGen.Tests/Helpers/InMemoryAdditionalText.cs

@@ -0,0 +1,19 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+
+internal class InMemoryAdditionalText : AdditionalText
+{
+    private readonly SourceText _content;
+
+    public InMemoryAdditionalText(string path, string content)
+    {
+        Path = path;
+        _content = SourceText.From(content, Encoding.UTF8);
+    }
+
+    public override string Path { get; }
+
+    public override SourceText GetText(CancellationToken cancellationToken = default) => _content;
+}

CommunityToolkit.Tooling.SampleGen.Tests/Helpers/SourceGeneratorRunResult.cs

@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+
+public record SourceGeneratorRunResult(Compilation Compilation, ImmutableArray<Diagnostic> Diagnostics);

CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs

@@ -0,0 +1,59 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+
+public static partial class TestHelpers
+{
+    internal static IEnumerable<MetadataReference> GetAllReferencedAssemblies()
+    {
+        return from assembly in AppDomain.CurrentDomain.GetAssemblies()
+               where !assembly.IsDynamic
+               let reference = MetadataReference.CreateFromFile(assembly.Location)
+               select reference;
+    }
+
+    internal static SyntaxTree ToSyntaxTree(this string source)
+    {
+        return CSharpSyntaxTree.ParseText(source,
+            CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp10));
+    }
+
+    internal static CSharpCompilation CreateCompilation(this SyntaxTree syntaxTree, string assemblyName, IEnumerable<MetadataReference>? references = null)
+    {
+        return CSharpCompilation.Create(assemblyName, new[] { syntaxTree }, references ?? GetAllReferencedAssemblies(), new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+    }
+
+    internal static CSharpCompilation CreateCompilation(this IEnumerable<SyntaxTree> syntaxTree, string assemblyName, IEnumerable<MetadataReference>? references = null)
+    {
+        return CSharpCompilation.Create(assemblyName, syntaxTree, references ?? GetAllReferencedAssemblies(), new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+    }
+
+    internal static GeneratorDriver CreateSourceGeneratorDriver(this SyntaxTree syntaxTree, IIncrementalGenerator generator)
+    {
+        return CSharpGeneratorDriver.Create(generator).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
+    }
+
+    internal static GeneratorDriver CreateSourceGeneratorDriver(this SyntaxTree syntaxTree, params IIncrementalGenerator[] generators)
+    {
+        return CSharpGeneratorDriver.Create(generators).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
+    }
+
+    internal static GeneratorDriver WithMarkdown(this GeneratorDriver driver, params string[] markdownFilesToCreate)
+    {
+        foreach (var markdown in markdownFilesToCreate)
+        {
+            if (!string.IsNullOrWhiteSpace(markdown))
+            {
+                var text = new InMemoryAdditionalText(@"C:\pathtorepo\components\experiment\samples\experiment.Samples\documentation.md", markdown);
+                driver = driver.AddAdditionalTexts(ImmutableArray.Create<AdditionalText>(text));
+            }
+        }
+
+        return driver;
+    }
+}

CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs

@@ -0,0 +1,59 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+
+public static partial class TestHelpers
+{
+    internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this string source, string assemblyName, string markdown = "") where TGenerator : class, IIncrementalGenerator, new() => RunSourceGenerator<TGenerator>(source.ToSyntaxTree(), assemblyName, markdown);
+
+    internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this SyntaxTree syntaxTree, string assemblyName, string markdown = "")
+        where TGenerator : class, IIncrementalGenerator, new()
+    {
+        var references = GetAllReferencedAssemblies();
+        var compilation = syntaxTree.CreateCompilation(assemblyName, references); // assembly name should always be supplied in param
+        return RunSourceGenerator<TGenerator>(syntaxTree, compilation, markdown);
+    }
+
+    internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this SyntaxTree syntaxTree, Compilation compilation, string markdown = "")
+        where TGenerator : class, IIncrementalGenerator, new()
+    {
+        // Create a driver for the source generator
+        var driver = syntaxTree
+            .CreateSourceGeneratorDriver(new TGenerator())
+            .WithMarkdown(markdown);
+
+        // Update the original compilation using the source generator
+        _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation generatorCompilation, out ImmutableArray<Diagnostic> postGeneratorCompilationDiagnostics);
+
+        return new(generatorCompilation, postGeneratorCompilationDiagnostics);
+    }
+
+    internal static void AssertDiagnosticsAre(this IEnumerable<Diagnostic> diagnostics, params DiagnosticDescriptor[] expectedDiagnosticDescriptors)
+    {
+        var expectedIds = expectedDiagnosticDescriptors.Select(x => x.Id).ToHashSet();
+        var resultingIds = diagnostics.Select(diagnostic => diagnostic.Id).ToHashSet();
+
+        Assert.IsTrue(resultingIds.SetEquals(expectedIds), $"Expected [{string.Join(", ", expectedIds)}] diagnostic Ids. Got [{string.Join(", ", resultingIds)}]");
+    }
+
+    internal static void AssertNoCompilationErrors(this Compilation outputCompilation)
+    {
+        var generatedCompilationDiagnostics = outputCompilation.GetDiagnostics();
+        Assert.IsTrue(generatedCompilationDiagnostics.All(x => x.Severity != DiagnosticSeverity.Error), $"Expected no generated compilation errors. Got: \n{string.Join("\n", generatedCompilationDiagnostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x => $"[{x.Id}: {x.GetMessage()}]"))}");
+    }
+
+    internal static void AssertSourceGenerated(this Compilation compilation, string filename, string expectedContents)
+    {
+        var generatedTree = compilation.SyntaxTrees.SingleOrDefault(tree => Path.GetFileName(tree.FilePath) == filename);
+
+        Assert.IsNotNull(generatedTree, $"No file named {filename} was generated");
+        Assert.AreEqual(expectedContents, generatedTree.ToString(), "Unexpected code generated");
+    }
+
+    internal static void AssertDiagnosticsAre(this SourceGeneratorRunResult result, params DiagnosticDescriptor[] expectedDiagnosticDescriptors) => AssertDiagnosticsAre(result.Diagnostics, expectedDiagnosticDescriptors);
+
+    internal static void AssertNoCompilationErrors(this SourceGeneratorRunResult result) => AssertNoCompilationErrors(result.Compilation);
+
+    internal static void AssertSourceGenerated(this SourceGeneratorRunResult result, string filename, string expectedContents) => AssertSourceGenerated(result.Compilation, filename, expectedContents);
+}