Feat: Get Diagnostics as task

.editorconfig

@@ -9,7 +9,7 @@ indent_size = 4
 # Microsoft .NET properties
 csharp_new_line_before_members_in_object_initializers = false
 csharp_new_line_before_open_brace = none
-csharp_preferred_modifier_order = public, internal, protected, private, static, async, virtual, file, new, sealed, override, required, abstract, extern, volatile, unsafe, readonly:suggestion
+csharp_preferred_modifier_order = public, internal, protected, private, static, override, async, virtual, file, new, sealed, required, abstract, extern, volatile, unsafe, readonly:suggestion
 csharp_style_prefer_utf8_string_literals = true:suggestion
 csharp_style_var_elsewhere = false:none
 csharp_style_var_for_built_in_types = false:suggestion

src/CodeOfChaos.Testing.TUnit/Conditions/Library/ContainsDiagnosticAssertCondition.cs

@@ -10,16 +10,16 @@ namespace CodeOfChaos.Testing.TUnit.Conditions.Library;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public class ContainsDiagnosticAssertCondition<T>(Func<T, ImmutableArray<Diagnostic>> getDiagnosticsAction, string expectedId): ExpectedValueAssertCondition<T, string>(expectedId) {
+public class ContainsDiagnosticAssertCondition<T>(Func<T, ValueTask<ImmutableArray<Diagnostic>>> getDiagnosticsAction, string expectedId): ExpectedValueAssertCondition<T, string>(expectedId) {
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
     protected override string GetExpectation() => $"to have a diagnostic with Id \"{ExpectedValue}\"";
-    protected override Task<AssertionResult> GetResult(T? actualValue, string? expectedValue) {
+    protected override async Task<AssertionResult> GetResult(T? actualValue, string? expectedValue) {
         if (actualValue is null) return AssertionResult.Fail($"{nameof(T)} is null");
         if (expectedValue is null) return AssertionResult.Fail("Expected value is null");
 
-        ImmutableArray<Diagnostic> diagnostics = getDiagnosticsAction(actualValue);
+        ImmutableArray<Diagnostic> diagnostics = await getDiagnosticsAction(actualValue);
         if (!diagnostics.Any()) return FailWithMessage("No diagnostics");
         if (diagnostics.Any(d => d.Id == expectedValue)) return AssertionResult.Passed;
         return FailWithMessage("No diagnostic with Id");

src/CodeOfChaos.Testing.TUnit/Conditions/Library/ContainsDiagnosticsExclusivelyAssertCondition.cs

@@ -10,18 +10,18 @@ namespace CodeOfChaos.Testing.TUnit.Conditions.Library;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public class ContainsDiagnosticsExclusivelyAssertCondition<T>(Func<T, ImmutableArray<Diagnostic>> getDiagnosticsAction, string[] expectedIds)
+public class ContainsDiagnosticsExclusivelyAssertCondition<T>(Func<T, ValueTask<ImmutableArray<Diagnostic>>> getDiagnosticsAction, string[] expectedIds)
     : ExpectedValueAssertCondition<T, string[]>(expectedIds) {
 
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
     protected override string GetExpectation() => $"to have a compilation output with the following Ids \"{ExpectedValue}\"";
-    protected override Task<AssertionResult> GetResult(T? actualValue, string[]? expectedValues) {
+    protected override async Task<AssertionResult> GetResult(T? actualValue, string[]? expectedValues) {
         if (actualValue is null) return AssertionResult.Fail($"{nameof(T)} is null");
         if (expectedValues is null) return AssertionResult.Fail("Expected value is null");
 
-        ImmutableArray<Diagnostic> diagnostics = getDiagnosticsAction(actualValue);
+        ImmutableArray<Diagnostic> diagnostics = await getDiagnosticsAction(actualValue);
         if (!diagnostics.Any() && expectedValues.Length == 0) return AssertionResult.Passed;
         if (!diagnostics.Any()) return FailWithMessage("No diagnostics");
         if (expectedValues.Length != diagnostics.Length) return FailWithMessage("Wrong number of diagnostics");

src/CodeOfChaos.Testing.TUnit/Conditions/Library/DoesNotContainDiagnosticAssertCondition.cs

@@ -10,19 +10,19 @@ namespace CodeOfChaos.Testing.TUnit.Conditions.Library;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-public class DoesNotContainDiagnosticAssertCondition<T>(Func<T, ImmutableArray<Diagnostic>> getDiagnosticsAction, string expectedId)
+public class DoesNotContainDiagnosticAssertCondition<T>(Func<T, ValueTask<ImmutableArray<Diagnostic>>> getDiagnosticsAction, string expectedId)
     : ExpectedValueAssertCondition<T, string>(expectedId) {
 
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
 
     protected override string GetExpectation() => $"to not have a diagnostic with Id \"{ExpectedValue}\"";
-    protected override Task<AssertionResult> GetResult(T? actualValue, string? expectedValue) {
+    protected override async Task<AssertionResult> GetResult(T? actualValue, string? expectedValue) {
         if (actualValue is null) return AssertionResult.Fail($"{nameof(T)} is null");
         if (expectedValue is null) return AssertionResult.Fail("Expected value is null");
 
-        ImmutableArray<Diagnostic> diagnostics = getDiagnosticsAction(actualValue);
+        ImmutableArray<Diagnostic> diagnostics = await getDiagnosticsAction(actualValue);
 
         if (diagnostics.Any(d => d.Id == expectedValue)) return FailWithMessage("Diagnostic with Id");
 

src/CodeOfChaos.Testing.TUnit/Extensions/TUnitExtensionsCompilation.cs

@@ -19,7 +19,7 @@ public static class TUnitExtensionsCompilation {
     public static InvokableValueAssertionBuilder<Compilation> ContainsDiagnostic(this IValueSource<Compilation> valueSource, string expectedId, [CallerArgumentExpression(nameof(expectedId))] string doNotPopulateThisValue1 = "") {
         return valueSource.RegisterAssertion(
             assertCondition: new ContainsDiagnosticAssertCondition<Compilation>(
-                static compilation => compilation.GetDiagnostics(), 
+                static compilation => ValueTask.FromResult(compilation.GetDiagnostics()), 
                 expectedId
             ),
             argumentExpressions: [doNotPopulateThisValue1]
@@ -29,7 +29,7 @@ public static InvokableValueAssertionBuilder<Compilation> ContainsDiagnostic(thi
     public static InvokableValueAssertionBuilder<Compilation> DoesNotContainDiagnostic(this IValueSource<Compilation> valueSource, string expectedId, [CallerArgumentExpression(nameof(expectedId))] string doNotPopulateThisValue1 = "") {
         return valueSource.RegisterAssertion(
             assertCondition: new DoesNotContainDiagnosticAssertCondition<Compilation>(
-                static compilation => compilation.GetDiagnostics(), 
+                static compilation => ValueTask.FromResult(compilation.GetDiagnostics()), 
                 expectedId
             ),
             argumentExpressions: [doNotPopulateThisValue1]
@@ -39,7 +39,7 @@ public static InvokableValueAssertionBuilder<Compilation> DoesNotContainDiagnost
     public static InvokableValueAssertionBuilder<Compilation> ContainsDiagnosticsExclusively(this IValueSource<Compilation> valueSource, string[] expectedIds, [CallerArgumentExpression(nameof(expectedIds))] string doNotPopulateThisValue1 = "") {
         return valueSource.RegisterAssertion(
             assertCondition: new ContainsDiagnosticsExclusivelyAssertCondition<Compilation>(
-                static compilation => compilation.GetDiagnostics(), 
+                static compilation => ValueTask.FromResult(compilation.GetDiagnostics()), 
                 expectedIds
             ),
             argumentExpressions: [doNotPopulateThisValue1]

src/CodeOfChaos.Testing.TUnit/Extensions/TUnitExtensionsCompilationWithAnalyzers.cs

@@ -0,0 +1,47 @@
+// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+using CodeOfChaos.Testing.TUnit.Conditions.Library;
+using Microsoft.CodeAnalysis.Diagnostics;
+using System.Runtime.CompilerServices;
+using TUnit.Assertions.AssertConditions.Interfaces;
+using TUnit.Assertions.AssertionBuilders;
+
+namespace CodeOfChaos.Testing.TUnit;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+// ReSharper disable once InconsistentNaming
+public static class TUnitExtensionsCompilationWithAnalyzers {
+    public static InvokableValueAssertionBuilder<CompilationWithAnalyzers> ContainsDiagnostic(this IValueSource<CompilationWithAnalyzers> valueSource, string expectedId, [CallerArgumentExpression(nameof(expectedId))] string doNotPopulateThisValue1 = "") {
+        return valueSource.RegisterAssertion(
+            assertCondition: new ContainsDiagnosticAssertCondition<CompilationWithAnalyzers>(
+                async static compilation => await compilation.GetAllDiagnosticsAsync(), 
+                expectedId
+            ),
+            argumentExpressions: [doNotPopulateThisValue1]
+        );
+    }
+
+    public static InvokableValueAssertionBuilder<CompilationWithAnalyzers> DoesNotContainDiagnostic(this IValueSource<CompilationWithAnalyzers> valueSource, string expectedId, [CallerArgumentExpression(nameof(expectedId))] string doNotPopulateThisValue1 = "") {
+        return valueSource.RegisterAssertion(
+            assertCondition: new DoesNotContainDiagnosticAssertCondition<CompilationWithAnalyzers>(
+                async static compilation => await compilation.GetAllDiagnosticsAsync(), 
+                expectedId
+            ),
+            argumentExpressions: [doNotPopulateThisValue1]
+        );
+    }
+
+    public static InvokableValueAssertionBuilder<CompilationWithAnalyzers> ContainsDiagnosticsExclusively(this IValueSource<CompilationWithAnalyzers> valueSource, string[] expectedIds, [CallerArgumentExpression(nameof(expectedIds))] string doNotPopulateThisValue1 = "") {
+        return valueSource.RegisterAssertion(
+            assertCondition: new ContainsDiagnosticsExclusivelyAssertCondition<CompilationWithAnalyzers>(
+                async static compilation => await compilation.GetAllDiagnosticsAsync(), 
+                expectedIds
+            ),
+            argumentExpressions: [doNotPopulateThisValue1]
+        );
+    }
+
+}

src/CodeOfChaos.Testing.TUnit/Extensions/TUnitExtensionsDiagnosticsImmutableArray.cs

@@ -18,7 +18,7 @@ public static class TUnitExtensionsDiagnosticsImmutableArray {
     public static InvokableValueAssertionBuilder<ImmutableArray<Diagnostic>> ContainsDiagnostic(this IValueSource<ImmutableArray<Diagnostic>> valueSource, string expectedId, [CallerArgumentExpression(nameof(expectedId))] string doNotPopulateThisValue1 = "") {
         return valueSource.RegisterAssertion(
             assertCondition: new ContainsDiagnosticAssertCondition<ImmutableArray<Diagnostic>>(
-                static diagnostics => diagnostics,
+                static diagnostics => ValueTask.FromResult(diagnostics),
                 expectedId
             ),
             argumentExpressions: [doNotPopulateThisValue1]
@@ -28,7 +28,7 @@ public static InvokableValueAssertionBuilder<ImmutableArray<Diagnostic>> Contain
     public static InvokableValueAssertionBuilder<ImmutableArray<Diagnostic>> DoesNotContainDiagnostic(this IValueSource<ImmutableArray<Diagnostic>> valueSource, string expectedId, [CallerArgumentExpression(nameof(expectedId))] string doNotPopulateThisValue1 = "") {
         return valueSource.RegisterAssertion(
             assertCondition: new DoesNotContainDiagnosticAssertCondition<ImmutableArray<Diagnostic>>(
-                static diagnostics => diagnostics,
+                static diagnostics => ValueTask.FromResult(diagnostics),
                 expectedId
             ),
             argumentExpressions: [doNotPopulateThisValue1]
@@ -38,7 +38,7 @@ public static InvokableValueAssertionBuilder<ImmutableArray<Diagnostic>> DoesNot
     public static InvokableValueAssertionBuilder<ImmutableArray<Diagnostic>> ContainsDiagnosticsExclusively(this IValueSource<ImmutableArray<Diagnostic>> valueSource, string[] expectedIds, [CallerArgumentExpression(nameof(expectedIds))] string doNotPopulateThisValue1 = "") {
         return valueSource.RegisterAssertion(
             assertCondition: new ContainsDiagnosticsExclusivelyAssertCondition<ImmutableArray<Diagnostic>>(
-                static diagnostics => diagnostics,
+                static diagnostics => ValueTask.FromResult(diagnostics),
                 expectedIds
             ),
             argumentExpressions: [doNotPopulateThisValue1]

src/CodeOfChaos.Testing.TUnit/Extensions/TUnitExtensionsGeneratorResult.cs

@@ -26,7 +26,7 @@ public static InvokableValueAssertionBuilder<GeneratorDriverRunResult> HasSource
     public static InvokableValueAssertionBuilder<GeneratorDriverRunResult> ContainsDiagnostic(this IValueSource<GeneratorDriverRunResult> valueSource, string expectedId, [CallerArgumentExpression(nameof(expectedId))] string doNotPopulateThisValue1 = "") {
         return valueSource.RegisterAssertion(
             assertCondition: new ContainsDiagnosticAssertCondition<GeneratorDriverRunResult>(
-                static runResult => runResult.Diagnostics,
+                static runResult => ValueTask.FromResult(runResult.Diagnostics),
                 expectedId
             ),
             argumentExpressions: [doNotPopulateThisValue1]
@@ -36,7 +36,7 @@ public static InvokableValueAssertionBuilder<GeneratorDriverRunResult> ContainsD
     public static InvokableValueAssertionBuilder<GeneratorDriverRunResult> DoesNotContainDiagnostic(this IValueSource<GeneratorDriverRunResult> valueSource, string expectedId, [CallerArgumentExpression(nameof(expectedId))] string doNotPopulateThisValue1 = "") {
         return valueSource.RegisterAssertion(
             assertCondition: new DoesNotContainDiagnosticAssertCondition<GeneratorDriverRunResult>(
-                static runResult => runResult.Diagnostics,
+                static runResult => ValueTask.FromResult(runResult.Diagnostics),
                 expectedId
             ),
             argumentExpressions: [doNotPopulateThisValue1]
@@ -46,7 +46,7 @@ public static InvokableValueAssertionBuilder<GeneratorDriverRunResult> DoesNotCo
     public static InvokableValueAssertionBuilder<GeneratorDriverRunResult> ContainsDiagnosticsExclusively(this IValueSource<GeneratorDriverRunResult> valueSource, string[] expectedIds, [CallerArgumentExpression(nameof(expectedIds))] string doNotPopulateThisValue1 = "") {
         return valueSource.RegisterAssertion(
             assertCondition: new ContainsDiagnosticsExclusivelyAssertCondition<GeneratorDriverRunResult>(
-                static runResult => runResult.Diagnostics,
+                static runResult => ValueTask.FromResult(runResult.Diagnostics),
                 expectedIds
             ),
             argumentExpressions: [doNotPopulateThisValue1]