Feature/message broker refactor

.github/workflows/dotnetcore.yml

@@ -27,7 +27,7 @@ jobs:
     - name: Build
       run: dotnet build --configuration Release --no-restore
     - name: Install dotnet-ef tool
-      run: dotnet tool install --global dotnet-ef --version 3.1.0
+      run: dotnet tool install --global dotnet-ef
     - name: Apply Migrations
       run: dotnet ef database update -s Microservice.Api/Microservice.Api.csproj -p Microservice.Db/Microservice.Db.csproj -c MicroserviceDbContext
     - name: Test

Dockerfile

@@ -5,7 +5,7 @@ COPY ./Microservice.Api/*.csproj ./Microservice.Api/
 COPY ./Microservice.Db/*.csproj ./Microservice.Db/
 COPY ./Microservice.Logic/*.csproj ./Microservice.Logic/
 COPY ./Microservice.HangfireBackgroundJobServer/*.csproj ./Microservice.HangfireBackgroundJobServer/
-COPY ./Microservice.RabbitMessageBroker/*.csproj ./Microservice.RabbitMessageBroker/
+COPY ./Microservice.RabbitMessageBrokerHelpers/*.csproj ./Microservice.RabbitMessageBrokerHelpers/
 COPY ./Microservice.RabbitMessageBroker.Integration.Tests/*.csproj ./Microservice.RabbitMessageBroker.Integration.Tests/
 COPY ./Microservice.Api.Integration.Tests/*.csproj ./Microservice.Api.Integration.Tests/
 RUN dotnet restore

Microservice.Api.Integration.Tests/Infrastructure/APIWebApplicationFactoryExtensions.cs

@@ -1,12 +1,30 @@
-using System;
-using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.AspNetCore.Mvc.Testing;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting.Internal;
+using System;
+using System.Collections.Generic;
+using System.IO;
 
 namespace Microservice.Api.Integration.Tests.Infrastructure
 {
     public static class APIWebApplicationFactoryExtensions
     {
+        public static WebApplicationFactory<TStartup> WithAppSettings<TStartup>(
+            this WebApplicationFactory<TStartup> factory,
+            IEnumerable<KeyValuePair<string, string>> customSettings = null)
+            where TStartup : class
+            => factory.WithWebHostBuilder(x =>
+            {
+                var projDir = Directory.GetCurrentDirectory();
+                var configpath = Path.Combine(projDir, "appsettings.json");
+                x.ConfigureServices(c => c.AddSingleton(new HostingEnvironment {EnvironmentName = "Testing"}));
+                x.ConfigureAppConfiguration((c, d) => d.AddJsonFile(configpath));
+                if (customSettings != null)
+                    x.ConfigureAppConfiguration((c, d) => d.AddInMemoryCollection(customSettings));
+            });
+
         public static WebApplicationFactory<TStartup> Seed<TStartup, TDbContext>(
             this WebApplicationFactory<TStartup> factory,
             Action<TDbContext> seed)
@@ -22,5 +40,13 @@ public static WebApplicationFactory<TStartup> Seed<TStartup, TDbContext>(
             }
             return factory;
         }
+
+        public static TService GetScopedService<TStartup, TService>(
+            this WebApplicationFactory<TStartup> factory)
+            where TStartup : class
+            => factory.Server.Services.CreateScope().ServiceProvider.GetService<TService>();
+
+
+
     }
 }

Microservice.Api.Integration.Tests/Infrastructure/BaseControllerTest.cs

@@ -0,0 +1,41 @@
+using Microservice.Db;
+using Microservice.RabbitMQMessageBrokerExtension;
+using Microservice.RabbitMQMessageBrokerExtension.Configuration;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using NUnit.Framework;
+using System.Net.Http;
+
+namespace Microservice.Api.Integration.Tests.Infrastructure
+{
+    public class BaseControllerTest
+    {
+        protected internal WebApplicationFactory<Startup> Factory;
+        protected internal HttpClient Client;
+        protected internal IRabbitMessageBrokerClient MessageBrokerClient;
+        public string BaseRoute { get; set; }
+
+        [OneTimeSetUp]
+        public void Setup()
+        {
+            Factory = new WebApplicationFactory<Startup>()
+                .WithWebHostBuilder(builder =>
+                {
+                    builder.ConfigureServices(services =>
+                    {
+                        services.RemoveAll(typeof(DbContextOptions));
+                        services.RemoveAll(typeof(MicroserviceDbContext));
+                        services.AddDbContext<MicroserviceDbContext>();
+                        services.AddRabbitMqMessageBroker(ConfigurationBuilderExtensions.GetCustomSection("RabbitMessageBrokerSettings"));
+                    });
+                });
+
+            Client = Factory.CreateClient();
+            MessageBrokerClient = Factory.Services.GetService<IRabbitMessageBrokerClient>();
+        }
+
+        public  string GetBaseRoute() => $"api/{BaseRoute}";
+    }
+}

Microservice.Api.Integration.Tests/Infrastructure/BaseEventSubscriptionTest.cs

@@ -0,0 +1,37 @@
+using Microservice.RabbitMQMessageBrokerExtension;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using NUnit.Framework;
+
+namespace Microservice.Api.Integration.Tests.Infrastructure
+{
+    public class BaseEventSubscriptionTest
+    {
+        private MockRepository _mockRepository; 
+        protected internal Mock<IRabbitMessageBrokerClient> MessageBrokerClient;
+        protected internal  WebApplicationFactory<Startup> Factory;
+
+        [OneTimeSetUp]
+        public void Setup()
+        {
+            _mockRepository = new MockRepository(MockBehavior.Strict);
+            MessageBrokerClient = _mockRepository.Create<IRabbitMessageBrokerClient>(MockBehavior.Loose);
+            Factory = new WebApplicationFactory<Startup>()
+
+                    .WithWebHostBuilder(x =>
+                    {
+                        x.ConfigureAppConfiguration((c, b) => { b.AddConfiguration(ConfigurationBuilderExtensions.GetConfigurationRoot()); });
+                        x.ConfigureTestServices(s => { s.AddTransient(_ => MessageBrokerClient.Object); });
+                    })
+                ;
+        }
+        [TearDown]
+        public void TearDown()
+        {
+            _mockRepository.VerifyAll();
+        }
+    }
+}

Microservice.Api.Integration.Tests/Infrastructure/ConfigurationBuilderExtensions.cs

@@ -0,0 +1,27 @@
+using Microsoft.Extensions.Configuration;
+using System.IO;
+
+namespace Microservice.Api.Integration.Tests.Infrastructure
+{
+    public static class ConfigurationBuilderExtensions
+    {
+        public static IConfigurationSection GetCustomSection(string section)
+        {
+            var configBuilder = new ConfigurationBuilder()
+                .SetBasePath(Directory.GetCurrentDirectory())
+                .AddJsonFile("appsettings.json", optional: true);
+            var config = configBuilder.Build();
+
+            return config.GetSection(section);
+        }
+
+        public static IConfigurationRoot GetConfigurationRoot()
+        {
+            var configBuilder = new ConfigurationBuilder()
+                .SetBasePath(Directory.GetCurrentDirectory())
+                .AddJsonFile("appsettings.json", optional: true);
+
+            return  configBuilder.Build();
+        }
+    }
+}

Microservice.Api.Integration.Tests/Infrastructure/HttpClientUtils.cs

@@ -17,7 +17,7 @@ public static Task<HttpResponseMessage> PostAsJsonAsync<T>(
             return httpClient.PostAsync(url, content);
         }
 
-        public static Task<HttpResponseMessage> PutAsJsonAsync<T>(
+        public static Task<HttpResponseMessage>  PutAsJsonAsync<T>(
             this HttpClient httpClient, string url, T data)
         {
             var dataAsString = JsonConvert.SerializeObject(data);

Microservice.Api.Integration.Tests/Microservice.Api.Integration.Tests.csproj

@@ -9,23 +9,38 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <None Remove="appsettings.json" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="appsettings.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
+      <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microservice.RabbitMQMessageBrokerExtension" Version="1.3.18" />
     <PackageReference Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" Version="3.1.3" />
     <PackageReference Include="Microsoft.AspNetCore.JsonPatch" Version="3.1.3" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.3" />
+    <PackageReference Include="Microsoft.AspNetCore.TestHost" Version="3.1.3" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.3" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="3.1.3" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="3.1.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="3.1.3" />
+    <PackageReference Include="Moq" Version="4.14.1" />
     <PackageReference Include="nunit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.16.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
-    <PackageReference Include="RabbitMQ.Client" Version="5.1.2" />
+    <PackageReference Include="RabbitMQ.Client" Version="6.1.0" />
   </ItemGroup>
 
   <ItemGroup>

Microservice.Api.Integration.Tests/OrderPlacedEventSubscriptionHandlerTest.cs

@@ -0,0 +1,55 @@
+using Microservice.Api.Integration.Tests.Infrastructure;
+using Microservice.Db;
+using Microservice.Db.EntityModels;
+using Microservice.Logic.Orders.Events;
+using NUnit.Framework;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Microservice.Api.Integration.Tests
+{
+    [TestFixture]
+    public class OrderPlacedEventSubscriptionHandlerTest: BaseEventSubscriptionTest
+    {
+        [Test]
+        public async Task Given_OrderPlacedSubscriptionEvent_Expect_OrderResponse_With_OrderPlacedEvent_Published()
+        {
+            // Arrange
+            var order = new Order
+            {
+                Id = 2,
+                Name = "product zero two",
+                Quantity = 5
+            };
+
+            var orderPlacedSubscriptionEvent = new OrderPlacedSubscriptionEvent
+            {
+                Id = order.Id,
+                Quantity = 2,
+                PersonId = 33
+            };
+
+            Factory.Seed<Startup, MicroserviceDbContext>(db =>
+            {
+                db.Clear();
+                db.Orders.Add(order);
+            });
+
+            // Act
+            var handler = MessageBrokerClient.Invocations.
+                    First(i => (string)i.Arguments[0] == "OrderPlaced")
+                    .Arguments[2] as Func<object, Task>;
+
+            await handler.Invoke(orderPlacedSubscriptionEvent);
+
+            var dbContext = Factory.GetScopedService<Startup, MicroserviceDbContext>();
+
+            var orderResult = dbContext.Orders.Find(order.Id);
+
+            // Assert handler
+            Assert.That(orderResult, Is.Not.Null);
+            Assert.That(orderResult.Quantity, Is.EqualTo(order.Quantity - orderPlacedSubscriptionEvent.Quantity));
+        }
+    }
+}