Integration tests

.gitignore

@@ -10,15 +10,16 @@
 _ReSharper*
 .dotnetcli
 .vs
+.DS_Store
 artifacts
 bin
+lint.db
 obj
 out
 packages
 project.lock.json
+thumbs.db
+BenchmarkDotNet.Artifacts
 TestResult.xml
+UpgradeLog*.htm
 !3rdparty/*/bin
-lint.db
-BenchmarkDotNet.Artifacts
-.DS_Store
-thumbs.db

Build.ps1

@@ -17,7 +17,8 @@ $libraryProjects = @(
 )
 
 $testProjects = @(
-    (Join-Path $solutionPath "JustSaying.UnitTests\JustSaying.UnitTests.csproj")
+    (Join-Path $solutionPath "JustSaying.UnitTests\JustSaying.UnitTests.csproj"),
+    (Join-Path $solutionPath "JustSaying.IntegrationTests\JustSaying.IntegrationTests.csproj")
 )
 
 $dotnetVersion = (Get-Content $sdkFile | Out-String | ConvertFrom-Json).sdk.version
@@ -139,6 +140,12 @@ ForEach ($libraryProject in $libraryProjects) {
     DotNetPack $libraryProject
 }
 
+if ($env:CI -ne $null) {
+    & docker pull pafortin/goaws
+    & docker run -d --name goaws -p 4100:4100 pafortin/goaws
+    $env:AWS_SERVICE_URL="http://localhost:4100"
+}
+
 if ($SkipTests -eq $false) {
     Write-Host "Running tests..." -ForegroundColor Green
     ForEach ($testProject in $testProjects) {

JustSaying.IntegrationTests/AwsFactAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+using JustSaying.TestingFramework;
+using Xunit;
+
+namespace JustSaying.IntegrationTests
+{
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+    public sealed class AwsFactAttribute : FactAttribute
+    {
+        public AwsFactAttribute()
+            : base()
+        {
+            if (!TestEnvironment.IsSimulatorConfigured && !TestEnvironment.HasCredentials)
+            {
+                Skip = "This test requires either an AWS simulator URL or AWS credentials to be configured.";
+            }
+        }
+    }
+}

JustSaying.IntegrationTests/AwsTheoryAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+using JustSaying.TestingFramework;
+using Xunit;
+
+namespace JustSaying.IntegrationTests
+{
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+    public sealed class AwsTheoryAttribute : TheoryAttribute
+    {
+        public AwsTheoryAttribute()
+            : base()
+        {
+            if (!TestEnvironment.IsSimulatorConfigured && !TestEnvironment.HasCredentials)
+            {
+                Skip = "This test requires either an AWS simulator URL or AWS credentials to be configured.";
+            }
+        }
+    }
+}

JustSaying.IntegrationTests/AwsTools/BasicHandlingThrottlingTest.cs

@@ -1,96 +1,130 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading;
 using System.Threading.Tasks;
-using Amazon;
 using Amazon.SQS.Model;
 using JustSaying.AwsTools.MessageHandling;
 using JustSaying.AwsTools.QueueCreation;
 using JustSaying.Messaging.MessageHandling;
 using JustSaying.Messaging.MessageSerialisation;
 using JustSaying.Messaging.Monitoring;
 using JustSaying.TestingFramework;
-using Microsoft.Extensions.Logging;
 using NSubstitute;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace JustSaying.IntegrationTests.AwsTools
 {
-    // OK, I know it ain't pretty, but we needed this asap & it does the job. Deal with it. :)]
     [Collection(GlobalSetup.CollectionName)]
     public class BasicHandlingThrottlingTest
     {
-        [Xunit.Theory(Skip= "Explicitly ran")]
+        public BasicHandlingThrottlingTest(ITestOutputHelper outputHelper)
+        {
+            OutputHelper = outputHelper;
+        }
+
+        private ITestOutputHelper OutputHelper { get; }
+
+        [AwsTheory]
         [InlineData(1000)]
-        // Use this to manually test the performance / throttling of getting messages out of the queue.
         public async Task HandlingManyMessages(int throttleMessageCount)
         {
-            var locker = new object();
-            var awsQueueClient = CreateMeABus.DefaultClientFactory().GetSqsClient(RegionEndpoint.EUWest1);
+            // Arrange
+            var fixture = new JustSayingFixture(OutputHelper);
+            var client = fixture.CreateSqsClient();
+
+            var queue = new SqsQueueByName(fixture.Region, fixture.UniqueName, client, 1, fixture.LoggerFactory);
 
-            var q = new SqsQueueByName(RegionEndpoint.EUWest1, "throttle_test", awsQueueClient, 1, new LoggerFactory());
-            if (!await q.ExistsAsync())
+            if (!await queue.ExistsAsync())
             {
-                await q.CreateAsync(new SqsBasicConfiguration());
-                await Task.Delay(TimeSpan.FromMinutes(1));  // wait 60 secs for queue creation to be guaranteed completed by aws. :(
+                await queue.CreateAsync(new SqsBasicConfiguration());
+
+                if (!fixture.IsSimulator)
+                {
+                    // Wait for up to 60 secs for queue creation to be guaranteed completed by AWS
+                    using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1)))
+                    {
+                        while (!cts.IsCancellationRequested)
+                        {
+                            await Task.Delay(TimeSpan.FromSeconds(2));
+
+                            if (await queue.ExistsAsync())
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
             }
 
-            Assert.True(await q.ExistsAsync());
+            Assert.True(await queue.ExistsAsync(), "The queue was not created.");
 
-            Console.WriteLine($"{DateTime.Now} - Adding {throttleMessageCount} messages to the queue.");
+            OutputHelper.WriteLine($"{DateTime.Now} - Adding {throttleMessageCount} messages to the queue.");
 
             var entriesAdded = 0;
+
             // Add some messages
             do
             {
                 var entries = new List<SendMessageBatchRequestEntry>();
+
                 for (var j = 0; j < 10; j++)
                 {
                     var batchEntry = new SendMessageBatchRequestEntry
-                                         {
-                                             MessageBody = "{\"Subject\":\"GenericMessage\", \"Message\": \"" + entriesAdded.ToString() + "\"}",
-                                             Id = Guid.NewGuid().ToString()
-                                         };
+                    {
+                        MessageBody = $"{{\"Subject\":\"GenericMessage\", \"Message\": \"{entriesAdded}\"}}",
+                        Id = Guid.NewGuid().ToString()
+                    };
+
                     entries.Add(batchEntry);
                     entriesAdded++;
                 }
-                await awsQueueClient.SendMessageBatchAsync(new SendMessageBatchRequest { QueueUrl = q.Url, Entries = entries });
+
+                await client.SendMessageBatchAsync(queue.Url, entries);
             }
             while (entriesAdded < throttleMessageCount);
 
-            Console.WriteLine($"{DateTime.Now} - Done adding messages.");
+            OutputHelper.WriteLine($"{DateTime.Now} - Done adding messages.");
 
             var handleCount = 0;
             var serialisations = Substitute.For<IMessageSerialisationRegister>();
             var monitor = Substitute.For<IMessageMonitor>();
-            var handler = Substitute.For<IHandlerAsync<GenericMessage>>();
-            handler.Handle(null).ReturnsForAnyArgs(true).AndDoes(x => {lock (locker) { handleCount++; } });
+            var handler = Substitute.For<IHandlerAsync<SimpleMessage>>();
+            handler.Handle(null).ReturnsForAnyArgs(true).AndDoes(_ => Interlocked.Increment(ref handleCount));
 
-            serialisations.DeserializeMessage(string.Empty).ReturnsForAnyArgs(new GenericMessage());
-            var listener = new SqsNotificationListener(q, serialisations, monitor, new LoggerFactory());
+            serialisations.DeserializeMessage(string.Empty).ReturnsForAnyArgs(new SimpleMessage());
+            var listener = new SqsNotificationListener(queue, serialisations, monitor, fixture.LoggerFactory);
             listener.AddMessageHandler(() => handler);
 
-            var stopwatch = new Stopwatch();
-            stopwatch.Start();
+            // Act
+            var stopwatch = Stopwatch.StartNew();
+
             listener.Listen();
-            var waitCount = 0;
-            do
+
+            using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(5)))
             {
-                await Task.Delay(TimeSpan.FromSeconds(5));
-                Console.WriteLine($"{DateTime.Now} - Handled {handleCount} messages. Waiting for completion.");
-                waitCount++;
+                do
+                {
+                    if (!fixture.IsSimulator)
+                    {
+                        await Task.Delay(TimeSpan.FromSeconds(5));
+                    }
+
+                    OutputHelper.WriteLine($"{DateTime.Now} - Handled {handleCount} messages. Waiting for completion.");
+                }
+                while (handleCount < throttleMessageCount && !cts.IsCancellationRequested);
             }
-            while (handleCount < throttleMessageCount && waitCount < 100);
 
             listener.StopListening();
             stopwatch.Stop();
 
-            Console.WriteLine($"{DateTime.Now} - Handled {handleCount} messages.");
-            Console.WriteLine($"{DateTime.Now} - Took {stopwatch.ElapsedMilliseconds} ms");
-            Console.WriteLine(
-                $"{DateTime.Now} - Throughput {(float) handleCount/stopwatch.ElapsedMilliseconds*1000} msg/sec");
+            OutputHelper.WriteLine($"{DateTime.Now} - Handled {handleCount:N0} messages.");
+            OutputHelper.WriteLine($"{DateTime.Now} - Took {stopwatch.ElapsedMilliseconds} ms");
+            OutputHelper.WriteLine($"{DateTime.Now} - Throughput {(float)handleCount / stopwatch.ElapsedMilliseconds * 1000} messages/second");
+
+            // Assert
             Assert.Equal(throttleMessageCount, handleCount);
         }
-
     }
 }

JustSaying.IntegrationTests/AwsTools/NoTopicCreationAwsClientFactory.cs

@@ -8,31 +8,26 @@
 
 namespace JustSaying.IntegrationTests.AwsTools
 {
-    public class NoTopicCreationAwsClientFactory : IAwsClientFactory
+    internal class NoTopicCreationAwsClientFactory : IAwsClientFactory
     {
-
         public IAmazonSimpleNotificationService GetSnsClient(RegionEndpoint region)
         {
             var innerClient = CreateMeABus.DefaultClientFactory().GetSnsClient(region);
             var client = Substitute.For<IAmazonSimpleNotificationService>();
 
             client.CreateTopicAsync(Arg.Any<CreateTopicRequest>())
-                .ThrowsForAnyArgs(x => new AuthorizationErrorException("Denied"));
+                  .ThrowsForAnyArgs(x => new AuthorizationErrorException("Denied"));
 
             client.FindTopicAsync(Arg.Any<string>())
-                .ReturnsForAnyArgs(r => innerClient.FindTopicAsync(r.Arg<string>()));
+                  .ReturnsForAnyArgs(r => innerClient.FindTopicAsync(r.Arg<string>()));
 
             client.GetTopicAttributesAsync(Arg.Any<string>())
-                .ReturnsForAnyArgs(r => innerClient.GetTopicAttributesAsync(r.Arg<string>()));
+                  .ReturnsForAnyArgs(r => innerClient.GetTopicAttributesAsync(r.Arg<string>()));
 
             return client;
         }
 
-
         public IAmazonSQS GetSqsClient(RegionEndpoint region)
-        {
-            var innerClient = CreateMeABus.DefaultClientFactory().GetSqsClient(region);
-            return innerClient;
-        }
+            => CreateMeABus.DefaultClientFactory().GetSqsClient(region);
     }
 }