fix: add internal modules and validators with corresponding tests

Author: vinhdev17

test/Carter.Tests/CarterExtensionTests.cs

@@ -2,6 +2,7 @@ namespace Carter.Tests
 {
     using System.Linq;
     using Carter.Tests.ContentNegotiation;
+    using Carter.Tests.InternalRooms;
     using Carter.Tests.ModelBinding;
     using Carter.Tests.StreamTests;
     using FluentValidation;
@@ -123,7 +124,7 @@ public void Should_register_responsenegotiators_passed_in_by_configurator_and_de
         }
 
         [Fact]
-        public void Should_register_multiple_responsenegotiators_passed_in_by_configurator_and_default_json_negotiator()
+        public void Should_register_multiple_response_negotiators_passed_in_by_configurator_and_default_json_negotiator()
         {
             //Given
             var serviceCollection = new ServiceCollection();
@@ -132,8 +133,8 @@ public void Should_register_multiple_responsenegotiators_passed_in_by_configurat
             serviceCollection.AddCarter(configurator: configurator => configurator.WithResponseNegotiators(typeof(TestResponseNegotiator), typeof(TestXmlResponseNegotiator)));
 
             //Then
-            var responsenegotiators = serviceCollection.Where(x => x.ServiceType == typeof(IResponseNegotiator));
-            Assert.Equal(3,responsenegotiators.Count());
+            var responseNegotiators = serviceCollection.Where(x => x.ServiceType == typeof(IResponseNegotiator));
+            Assert.Equal(3, responseNegotiators.Count());
         }
 
         [Fact]
@@ -177,5 +178,180 @@ public void Should_register_no_response_negotiators_passed_in_by_configurator()
             var responseNegotiators = serviceCollection.Where(x => x.ServiceType == typeof(IResponseNegotiator));
             Assert.Single(responseNegotiators);
         }
+        
+        [Fact]
+        public void Should_register_internal_modules_when_assembly_scanned()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter();
+
+            //Then
+            var modules = serviceCollection.Where(x => x.ServiceType == typeof(ICarterModule));
+            var internalModule = modules.FirstOrDefault(x => x.ImplementationType == typeof(InternalRoomModule));
+            Assert.NotNull(internalModule);
+        }
+
+        [Fact]
+        public void Should_register_internal_module_passed_in_by_configurator()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter(configurator: configurator => configurator.WithModule<InternalRoomModule>());
+
+            //Then
+            var modules = serviceCollection.Where(x => x.ServiceType == typeof(ICarterModule));
+            var internalModule = modules.FirstOrDefault(x => x.ImplementationType == typeof(InternalRoomModule));
+            Assert.NotNull(internalModule);
+        }
+
+        [Fact]
+        public void Should_register_multiple_internal_modules_passed_in_by_configurator()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter(configurator: configurator => 
+                configurator.WithModules(typeof(InternalRoomModule), typeof(NestedInternalRoomModuleWrapper.NestedInternalRoomModule)));
+
+            //Then
+            var modules = serviceCollection.Where(x => x.ServiceType == typeof(ICarterModule)).ToList();
+            Assert.Contains(modules, m => m.ImplementationType == typeof(InternalRoomModule));
+            Assert.Contains(modules, m => m.ImplementationType == typeof(NestedInternalRoomModuleWrapper.NestedInternalRoomModule));
+            Assert.Equal(2, modules.Count());
+        }
+
+        [Fact]
+        public void Should_register_internal_validators_when_assembly_scanned()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter();
+
+            //Then
+            var validators = serviceCollection.Where(x => x.ServiceType == typeof(IValidator));
+            var internalValidator = validators.FirstOrDefault(x => x.ImplementationType == typeof(InternalRoomModelValidator));
+            Assert.NotNull(internalValidator);
+        }
+
+        [Fact]
+        public void Should_register_internal_validator_passed_in_by_configurator()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter(configurator: configurator => configurator.WithValidator<InternalRoomModelValidator>());
+
+            //Then
+            var validators = serviceCollection.Where(x => x.ServiceType == typeof(IValidator)).ToList();
+            var internalValidator = validators.FirstOrDefault(x => x.ImplementationType == typeof(InternalRoomModelValidator));
+            Assert.NotNull(internalValidator);
+            Assert.Single(validators);
+        }
+
+        [Fact]
+        public void Should_register_multiple_internal_validators_passed_in_by_configurator()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter(configurator: configurator => 
+                configurator.WithValidators(typeof(InternalRoomModelValidator), typeof(NestedInternalTestModelValidatorWrapper.InternalTestModelValidator)));
+
+            //Then
+            var validators = serviceCollection.Where(x => x.ServiceType == typeof(IValidator)).ToList();
+            Assert.Contains(validators, v => v.ImplementationType == typeof(InternalRoomModelValidator));
+            Assert.Contains(validators, v => v.ImplementationType == typeof(NestedInternalTestModelValidatorWrapper.InternalTestModelValidator));
+            Assert.Equal(2, validators.Count());
+        }
+
+        [Fact]
+        public void Should_register_internal_response_negotiators_when_assembly_scanned()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter();
+
+            //Then
+            var responseNegotiators = serviceCollection.Where(x => x.ServiceType == typeof(IResponseNegotiator));
+            var internalNegotiator = responseNegotiators.FirstOrDefault(x => x.ImplementationType == typeof(InternalResponseNegotiator));
+            Assert.NotNull(internalNegotiator);
+        }
+
+        [Fact]
+        public void Should_register_internal_response_negotiator_passed_in_by_configurator()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter(configurator: configurator => configurator.WithResponseNegotiator<InternalResponseNegotiator>());
+
+            //Then
+            var responseNegotiators = serviceCollection.Where(x => x.ServiceType == typeof(IResponseNegotiator));
+            var internalNegotiator = responseNegotiators.FirstOrDefault(x => x.ImplementationType == typeof(InternalResponseNegotiator));
+            Assert.NotNull(internalNegotiator);
+        }
+
+        [Fact]
+        public void Should_register_multiple_internal_response_negotiators_passed_in_by_configurator()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter(configurator: configurator => 
+                configurator.WithResponseNegotiators(typeof(InternalResponseNegotiator), typeof(NestedInternalResponseNegotiatorWrapper.NestedInternalResponseNegotiator)));
+
+            //Then
+            var responseNegotiators = serviceCollection.Where(x => x.ServiceType == typeof(IResponseNegotiator)).ToList();
+            Assert.Contains(responseNegotiators, r => r.ImplementationType == typeof(InternalResponseNegotiator));
+            Assert.Contains(responseNegotiators, r => r.ImplementationType == typeof(NestedInternalResponseNegotiatorWrapper.NestedInternalResponseNegotiator));
+        }
+
+        [Fact]
+        public void Should_register_mix_of_public_and_internal_modules()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter(configurator: configurator => 
+                configurator.WithModules(typeof(TestModule), typeof(InternalRoomModule)));
+
+            //Then
+            var modules = serviceCollection.Where(x => x.ServiceType == typeof(ICarterModule)).ToList();
+            Assert.Contains(modules, m => m.ImplementationType == typeof(TestModule));
+            Assert.Contains(modules, m => m.ImplementationType == typeof(InternalRoomModule));
+            Assert.Equal(2, modules.Count());
+        }
+
+        [Fact]
+        public void Should_register_mix_of_public_and_internal_validators()
+        {
+            //Given
+            var serviceCollection = new ServiceCollection();
+
+            //When
+            serviceCollection.AddCarter(configurator: configurator => 
+                configurator.WithValidators(typeof(TestModelValidator), typeof(InternalRoomModelValidator)));
+
+            //Then
+            var validators = serviceCollection.Where(x => x.ServiceType == typeof(IValidator)).ToList();
+            Assert.Contains(validators, v => v.ImplementationType == typeof(TestModelValidator));
+            Assert.Contains(validators, v => v.ImplementationType == typeof(InternalRoomModelValidator));
+            Assert.Equal(2, validators.Count());
+        }
     }
 }

test/Carter.Tests/InternalRooms/InternalResponseNegotiator.cs

@@ -0,0 +1,19 @@
+namespace Carter.Tests.InternalRooms;
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Net.Http.Headers;
+
+internal class InternalResponseNegotiator: IResponseNegotiator
+{
+    public bool CanHandle(MediaTypeHeaderValue accept)
+    {
+        return true;
+    }
+
+    public Task Handle<T>(HttpRequest req, HttpResponse res, T model, CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+}

test/Carter.Tests/InternalRooms/InternalRoomModel.cs

@@ -0,0 +1,6 @@
+namespace Carter.Tests.InternalRooms;
+
+internal sealed class InternalRoomModel
+{
+    public string Name { get; set; }
+}

test/Carter.Tests/InternalRooms/InternalRoomModelValidator.cs

@@ -0,0 +1,11 @@
+namespace Carter.Tests.InternalRooms;
+
+using FluentValidation;
+
+internal class InternalRoomModelValidator : AbstractValidator<InternalRoomModel>
+{
+    public InternalRoomModelValidator()
+    {
+        this.RuleFor(x => x.Name).NotEmpty();
+    }
+}

test/Carter.Tests/InternalRooms/InternalRoomModule.cs

@@ -0,0 +1,17 @@
+namespace Carter.Tests.InternalRooms;
+
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+internal class InternalRoomModule : ICarterModule
+{
+    public void AddRoutes(IEndpointRouteBuilder app)
+    {
+        app.MapGet("/", (HttpResponse res) =>
+        {
+            res.StatusCode = 409;
+            return Results.Text("There's no place like 127.0.0.1");
+        });
+    }
+}

test/Carter.Tests/InternalRooms/NestedInternalResponseNegotiator.cs

@@ -0,0 +1,23 @@
+namespace Carter.Tests.InternalRooms;
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Net.Http.Headers;
+
+internal static class NestedInternalResponseNegotiatorWrapper
+{
+    internal class NestedInternalResponseNegotiator: IResponseNegotiator
+    {
+        public bool CanHandle(MediaTypeHeaderValue accept)
+        {
+            return true;
+        }
+        
+        public Task Handle<T>(HttpRequest req, HttpResponse res, T model, CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+    }
+}
+

test/Carter.Tests/InternalRooms/NestedInternalRoomModelValidator.cs

@@ -0,0 +1,15 @@
+namespace Carter.Tests.InternalRooms;
+
+using FluentValidation;
+
+internal static class NestedInternalTestModelValidatorWrapper
+{
+    internal class InternalTestModelValidator : AbstractValidator<InternalRoomModel>
+    {
+        public InternalTestModelValidator()
+        {
+            this.RuleFor(x => x.Name).NotEmpty();
+        }
+    }
+}
+

test/Carter.Tests/InternalRooms/NestedInternalRoomModule.cs

@@ -0,0 +1,22 @@
+namespace Carter.Tests.InternalRooms;
+
+using Carter;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+
+internal static class NestedInternalRoomModuleWrapper
+{
+    internal class NestedInternalRoomModule : ICarterModule
+    {
+        public void AddRoutes(IEndpointRouteBuilder app)
+        {
+            app.MapGet("/nested-room", (HttpResponse res) =>
+            {
+                res.StatusCode = 409;
+                return Results.Text("There's no place like 127.0.0.1");
+            });
+        }
+    }    
+}
+