Added inital specflow testing

.github/workflows/createrelease.yml

@@ -37,14 +37,14 @@ jobs:
         dotnet test "MessagingService.EmailAggregate.Tests\MessagingService.EmailAggregate.Tests.csproj"
         dotnet test "MessagingService.Tests\MessagingService.Tests.csproj"
 
-    #- name: Build Docker Image
-    #  run: docker build . --file MessagingService/Dockerfile --tag stuartferguson/messagingservice:latest --tag stuartferguson/messagingservice:${{ steps.get_version.outputs.VERSION }}
+    - name: Build Docker Image
+      run: docker build . --file MessagingService/Dockerfile --tag stuartferguson/messagingservice:latest --tag stuartferguson/messagingservice:${{ steps.get_version.outputs.VERSION }}
 
-    #- name: Publish Images to Docker Hub
-    #  run: |
-    #    docker login --username=${{ secrets.DOCKER_USERNAME }} --password=${{ secrets.DOCKER_PASSWORD }}
-    #    docker push stuartferguson/messagingservice:latest
-    #    docker push stuartferguson/messagingservice:${{ steps.get_version.outputs.VERSION }}
+    - name: Publish Images to Docker Hub
+      run: |
+        docker login --username=${{ secrets.DOCKER_USERNAME }} --password=${{ secrets.DOCKER_PASSWORD }}
+        docker push stuartferguson/messagingservice:latest
+        docker push stuartferguson/messagingservice:${{ steps.get_version.outputs.VERSION }}
 
     - name: Publish API
       run: dotnet publish "MessagingService\MessagingService.csproj" --configuration Release --output publishOutput

.github/workflows/pullrequest.yml

@@ -34,8 +34,8 @@ jobs:
         dotnet test "MessagingService.EmailAggregate.Tests\MessagingService.EmailAggregate.Tests.csproj"
         dotnet test "MessagingService.Tests\MessagingService.Tests.csproj"
 
-    #- name: Build Docker Image
-    #  run: docker build . --file MessagingService/Dockerfile --tag messagingservice:latest
+    - name: Build Docker Image
+      run: docker build . --file MessagingService/Dockerfile --tag messagingservice:latest
 
-    #- name: Run Integration Tests
-    #  run: dotnet test "MessagingService.IntegrationTests\MessagingService.IntegrationTests.csproj" --filter Category=PRTest
+    - name: Run Integration Tests
+      run: dotnet test "MessagingService.IntegrationTests\MessagingService.IntegrationTests.csproj" --filter Category=PRTest

MessagingService.IntegrationTests/Common/DockerHelper.cs

@@ -0,0 +1,244 @@
+namespace MessagingService.IntegrationTests.Common
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Net.Http;
+    using System.Threading.Tasks;
+    using Ductus.FluentDocker.Builders;
+    using Ductus.FluentDocker.Common;
+    using Ductus.FluentDocker.Model.Builders;
+    using Ductus.FluentDocker.Services;
+    using Ductus.FluentDocker.Services.Extensions;
+    using global::Shared.Logger;
+    using SecurityService.Client;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="Shared.IntegrationTesting.DockerHelper" />
+    public class DockerHelper : global::Shared.IntegrationTesting.DockerHelper
+    {
+        #region Fields
+
+        /// <summary>
+        /// The security service client
+        /// </summary>
+        public ISecurityServiceClient SecurityServiceClient;
+
+        public HttpClient MessagingServiceClient;
+
+        /// <summary>
+        /// The test identifier
+        /// </summary>
+        public Guid TestId;
+
+        /// <summary>
+        /// The containers
+        /// </summary>
+        protected List<IContainerService> Containers;
+
+        /// <summary>
+        /// The event store container name
+        /// </summary>
+        protected String EventStoreContainerName;
+
+        /// <summary>
+        /// The event store HTTP port
+        /// </summary>
+        protected Int32 EventStoreHttpPort;
+
+        /// <summary>
+        /// The security service container name
+        /// </summary>
+        protected String SecurityServiceContainerName;
+
+        /// <summary>
+        /// The messaging service container name
+        /// </summary>
+        protected String MessagingServiceContainerName;
+
+        /// <summary>
+        /// The security service port
+        /// </summary>
+        protected Int32 SecurityServicePort;
+
+        /// <summary>
+        /// The messaging service port
+        /// </summary>
+        protected Int32 MessagingServicePort;
+
+        /// <summary>
+        /// The test networks
+        /// </summary>
+        protected List<INetworkService> TestNetworks;
+
+        /// <summary>
+        /// The logger
+        /// </summary>
+        private readonly NlogLogger Logger;
+
+        /// <summary>
+        /// The testing context
+        /// </summary>
+        private readonly TestingContext TestingContext;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DockerHelper"/> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="testingContext">The testing context.</param>
+        public DockerHelper(NlogLogger logger,
+                            TestingContext testingContext)
+        {
+            this.Logger = logger;
+            this.TestingContext = testingContext;
+            this.Containers = new List<IContainerService>();
+            this.TestNetworks = new List<INetworkService>();
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Starts the containers for scenario run.
+        /// </summary>
+        /// <param name="scenarioName">Name of the scenario.</param>
+        public override async Task StartContainersForScenarioRun(String scenarioName)
+        {
+            String traceFolder = FdOs.IsWindows() ? $"D:\\home\\txnproc\\trace\\{scenarioName}" : $"//home//txnproc//trace//{scenarioName}";
+
+            Logging.Enabled();
+
+            Guid testGuid = Guid.NewGuid();
+            this.TestId = testGuid;
+
+            this.Logger.LogInformation($"Test Id is {testGuid}");
+
+            // Setup the container names
+            this.SecurityServiceContainerName = $"securityservice{testGuid:N}";
+            this.EventStoreContainerName = $"eventstore{testGuid:N}";
+            this.MessagingServiceContainerName = $"messagingservice{testGuid:N}";
+
+            (String, String, String) dockerCredentials = ("https://www.docker.com", "stuartferguson", "Sc0tland");
+
+            INetworkService testNetwork = DockerHelper.SetupTestNetwork();
+            this.TestNetworks.Add(testNetwork);
+            IContainerService eventStoreContainer =
+                DockerHelper.SetupEventStoreContainer(this.EventStoreContainerName, this.Logger, "eventstore/eventstore:release-5.0.2", testNetwork, traceFolder);
+
+            IContainerService securityServiceContainer = DockerHelper.SetupSecurityServiceContainer(this.SecurityServiceContainerName,
+                                                                                                    this.Logger,
+                                                                                                    "stuartferguson/securityservice",
+                                                                                                    testNetwork,
+                                                                                                    traceFolder,
+                                                                                                    dockerCredentials,
+                                                                                                    true);
+
+            IContainerService messagingServiceContainer = DockerHelper.SetupMessagingServiceContainer(this.MessagingServiceContainerName,
+                                                                                                      this.Logger,
+                                                                                                      "messagingservice",
+                                                                                                      new List<INetworkService>{
+                                                                                                                                    testNetwork
+                                                                                                                               },
+                                                                                                      traceFolder,
+                                                                                                      dockerCredentials,
+                                                                                                      this.SecurityServiceContainerName,
+                                                                                                      this.EventStoreContainerName,
+                                                                                                      ("serviceClient", "Secret1"));
+
+            this.Containers.AddRange(new List<IContainerService>
+                                     {
+                                         eventStoreContainer,
+                                         securityServiceContainer,
+                                         messagingServiceContainer
+                                     });
+
+            // Cache the ports
+            this.SecurityServicePort = securityServiceContainer.ToHostExposedEndpoint("5001/tcp").Port;
+            this.EventStoreHttpPort = eventStoreContainer.ToHostExposedEndpoint("2113/tcp").Port;
+            this.MessagingServicePort = messagingServiceContainer.ToHostExposedEndpoint("5006/tcp").Port;
+
+            // Setup the base address resolvers
+            String SecurityServiceBaseAddressResolver(String api) => $"http://127.0.0.1:{this.SecurityServicePort}";
+
+            HttpClient httpClient = new HttpClient();
+            this.SecurityServiceClient = new SecurityServiceClient(SecurityServiceBaseAddressResolver, httpClient);
+
+            this.MessagingServiceClient = new HttpClient();
+            this.MessagingServiceClient.BaseAddress = new Uri($"http://127.0.0.1:{this.MessagingServicePort}");
+        }
+
+        /// <summary>
+        /// Stops the containers for scenario run.
+        /// </summary>
+        public override async Task StopContainersForScenarioRun()
+        {
+            if (this.Containers.Any())
+            {
+                foreach (IContainerService containerService in this.Containers)
+                {
+                    containerService.StopOnDispose = true;
+                    containerService.RemoveOnDispose = true;
+                    containerService.Dispose();
+                }
+            }
+
+            if (this.TestNetworks.Any())
+            {
+                foreach (INetworkService networkService in this.TestNetworks)
+                {
+                    networkService.Stop();
+                    networkService.Remove(true);
+                }
+            }
+        }
+
+        public const int MessagingServiceDockerPort = 5006;
+        public static IContainerService SetupMessagingServiceContainer(String containerName,
+                                                                       ILogger logger,
+                                                                       String imageName,
+                                                                       List<INetworkService> networkServices,
+                                                                       String hostFolder,
+                                                                       (String URL, String UserName, String Password)? dockerCredentials,
+                                                                       String securityServiceContainerName,
+                                                                       String eventStoreContainerName,
+                                                                       (String clientId, String clientSecret) clientDetails,
+                                                                       Boolean forceLatestImage = false,
+                                                                       Int32 securityServicePort = DockerHelper.SecurityServiceDockerPort)
+        {
+            logger.LogInformation("About to Start Messaging Service Container");
+
+            List<String> environmentVariables = new List<String>();
+            environmentVariables
+                .Add($"EventStoreSettings:ConnectionString=ConnectTo=tcp://admin:changeit@{eventStoreContainerName}:{DockerHelper.EventStoreTcpDockerPort};VerboseLogging=true;");
+            environmentVariables.Add($"AppSettings:SecurityService=http://{securityServiceContainerName}:{securityServicePort}");
+            environmentVariables.Add($"SecurityConfiguration:Authority=http://{securityServiceContainerName}:{securityServicePort}");
+            environmentVariables.Add($"urls=http://*:{DockerHelper.MessagingServiceDockerPort}");
+            environmentVariables.Add("AppSettings:EmailProxy=Integration");
+
+            ContainerBuilder messagingServiceContainer = new Builder().UseContainer().WithName(containerName).WithEnvironment(environmentVariables.ToArray())
+                                                                      .UseImage(imageName, forceLatestImage).ExposePort(DockerHelper.MessagingServiceDockerPort)
+                                                                      .UseNetwork(networkServices.ToArray()).Mount(hostFolder, "/home", MountType.ReadWrite);
+
+            if (dockerCredentials.HasValue)
+            {
+                messagingServiceContainer.WithCredential(dockerCredentials.Value.URL, dockerCredentials.Value.UserName, dockerCredentials.Value.Password);
+            }
+
+            // Now build and return the container                
+            IContainerService builtContainer = messagingServiceContainer.Build().Start().WaitForPort($"{DockerHelper.MessagingServiceDockerPort}/tcp", 30000);
+
+            logger.LogInformation("Messaging Service Container Started");
+
+            return builtContainer;
+        }
+
+        #endregion
+    }
+}

MessagingService.IntegrationTests/Common/GenericSteps.cs

@@ -0,0 +1,50 @@
+using NLog;
+using Shared.Logger;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TechTalk.SpecFlow;
+
+namespace MessagingService.IntegrationTests.Common
+{
+    [Binding]
+    [Scope(Tag = "base")]
+    public class GenericSteps
+    {
+        private readonly ScenarioContext ScenarioContext;
+
+        private readonly TestingContext TestingContext;
+
+        public GenericSteps(ScenarioContext scenarioContext,
+                            TestingContext testingContext)
+        {
+            this.ScenarioContext = scenarioContext;
+            this.TestingContext = testingContext;
+        }
+
+        [BeforeScenario]
+        public async Task StartSystem()
+        {
+            // Initialise a logger
+            String scenarioName = this.ScenarioContext.ScenarioInfo.Title.Replace(" ", "");
+            NlogLogger logger = new NlogLogger();
+            logger.Initialise(LogManager.GetLogger(scenarioName), scenarioName);
+            LogManager.AddHiddenAssembly(typeof(NlogLogger).Assembly);
+
+            this.TestingContext.DockerHelper = new DockerHelper(logger, this.TestingContext);
+            this.TestingContext.Logger = logger;
+            this.TestingContext.Logger.LogInformation("About to Start Containers for Scenario Run");
+            await this.TestingContext.DockerHelper.StartContainersForScenarioRun(scenarioName).ConfigureAwait(false);
+            this.TestingContext.Logger.LogInformation("Containers for Scenario Run Started");
+
+            await Task.Delay(TimeSpan.FromSeconds(20));
+        }
+
+        [AfterScenario]
+        public async Task StopSystem()
+        {
+            await this.TestingContext.DockerHelper.StopContainersForScenarioRun().ConfigureAwait(false);
+        }
+    }
+}