chore: Add tests to ensure Command/Queries always returns a Result (#6)

* chore: Add tests to ensure Command/Queries always returns a Result

* nit

tests/Core.Tests/ArchitectureTests.cs

@@ -1,11 +1,13 @@
 using System.Reflection;
+using Core.Tests.Rules;
 using FluentAssertions;
+using MediatR;
 using NetArchTest.Rules;
 using Xunit.Abstractions;
 
 namespace Core.Tests;
 
-public class ArchitectureTests()
+public class ArchitectureTests(ITestOutputHelper testOutputHelper)
 {
     private static readonly Assembly ApiAssembly = Assembly.GetAssembly(typeof(Api.Program));
     private static readonly Assembly InfrastructureAssembly = Assembly.GetAssembly(typeof(Infrastructure.DependencyInjection));
@@ -21,6 +23,8 @@ public void Api_Should_Not_Depend_On_Infrastructure_Except_For_Setting_Up_Depend
             .ShouldNot()
             .HaveDependencyOn("Infrastructure")
             .GetResult();
+
+        LogIfFailure(result);
 
         result.IsSuccessful.Should().BeTrue();
     }
@@ -32,6 +36,8 @@ public void Infrastructure_Should_Not_Depend_On_Api()
             .ShouldNot()
             .HaveDependencyOn("Api")
             .GetResult();
+
+        LogIfFailure(result);
 
         result.IsSuccessful.Should().BeTrue();
     }
@@ -43,6 +49,8 @@ public void Application_Should_Not_Depend_On_Api_Or_Infrastructure()
             .ShouldNot()
             .HaveDependencyOnAny("Api", "Infrastructure")
             .GetResult();
+
+        LogIfFailure(result);
 
         result.IsSuccessful.Should().BeTrue();
     }
@@ -54,7 +62,47 @@ public void Domain_Should_Not_Have_Dependency_On_Any_Of_The_Other_Layers()
             .ShouldNot()
             .HaveDependencyOnAny("Api", "Infrastructure", "Application")
             .GetResult();
+
+        LogIfFailure(result);
 
         result.IsSuccessful.Should().BeTrue();
     }
+
+    [Fact]
+    public void IRequests_Should_Return_Result_Or_ResultOfT()
+    {
+        var requestShouldWrapResultRule = new RequestShouldWrapResultRule();
+
+        var result = Types
+            .InAssembly(ApplicationAssembly)
+            .That()
+            .ImplementInterface(typeof(IRequest<>))
+            .Should()
+            .MeetCustomRule(requestShouldWrapResultRule)
+            .GetResult();
+
+        LogIfFailure(result);
+
+        result.IsSuccessful.Should().BeTrue();
+    }
+
+    [Fact]
+    public void IRequests_Should_Not_Implement_Plain_Request()
+    {
+        var result = Types
+            .InAssembly(ApplicationAssembly)
+            .ShouldNot()
+            .ImplementInterface(typeof(IRequest))
+            .GetResult();
+
+        LogIfFailure(result);
+        result.IsSuccessful.Should().BeTrue();
+    }
+
+    private void LogIfFailure(TestResult result)
+    {
+        if (result.IsSuccessful) return;
+
+        testOutputHelper.WriteLine("Types that failed to meet the rule: " + string.Join(", ", result.FailingTypes));
+    }
 }

tests/Core.Tests/Rules/RequestShouldWrapResultRule.cs

@@ -0,0 +1,33 @@
+using FluentResults;
+using MediatR;
+using Mono.Cecil;
+using NetArchTest.Rules;
+
+namespace Core.Tests.Rules;
+
+public class RequestShouldWrapResultRule : ICustomRule
+{
+    private static readonly Type ResultType = typeof(Result);
+    private static readonly Type ResultGenericType = typeof(Result<>);
+    private static readonly Type RequestGenericType = typeof(IRequest<>);
+
+    public bool MeetsRule(TypeDefinition typeDefinition)
+    {
+        // Should be a single interface that is IRequest<T>
+        var requestType = typeDefinition.Interfaces
+            .Single(i => 
+                TypeReferenceMatchesType(i.InterfaceType, RequestGenericType))
+            .InterfaceType as GenericInstanceType;
+
+        var responseType = requestType.GenericArguments[0];
+
+        // Response type should be Result or Result<T>
+        return TypeReferenceMatchesType(responseType, ResultType)
+               || TypeReferenceMatchesType(responseType, ResultGenericType);
+    }
+
+    private static bool TypeReferenceMatchesType(TypeReference typeReference, Type type)
+    {
+        return typeReference.Name == type.Name && typeReference.Namespace == type.Namespace;
+    }
+}