Testing infrastructure

.github/workflows/ci.yml

@@ -0,0 +1,75 @@
+name: CI
+on:
+  push:
+    branches:
+      - main
+      - release-*
+  pull_request:
+  workflow_dispatch:
+env:
+  DOTNET_NOLOGO: true
+defaults:
+  run:
+    shell: pwsh
+jobs:
+  build:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: windows-latest
+            name: Windows
+          - os: ubuntu-latest
+            name: Linux
+      fail-fast: false
+    steps:
+      - name: Check for secrets
+        env:
+          SECRETS_AVAILABLE: ${{ secrets.SECRETS_AVAILABLE }}
+        run: exit $(If ($env:SECRETS_AVAILABLE -eq 'true') { 0 } Else { 1 })
+      - name: Checkout
+        uses: actions/checkout@v6.0.2
+        with:
+          fetch-depth: 0
+      - name: Setup .NET SDK
+        uses: actions/setup-dotnet@v5.1.0
+        with:
+          global-json-file: global.json
+      - name: Build
+        run: dotnet build src --configuration Release
+      - name: Upload packages
+        if: matrix.name == 'Windows'
+        uses: actions/upload-artifact@v6.0.0
+        with:
+          name: NuGet packages
+          path: nugets/
+          retention-days: 7
+      - name: Azure login
+        uses: azure/login@v2.3.0
+        with:
+          creds: ${{ secrets.AZURE_ACI_CREDENTIALS }}
+      - name: Setup Azure Service Bus
+        uses: Particular/setup-azureservicebus-action@v2.0.0
+        with:
+          connection-string-name: AzureWebJobsServiceBus
+          azure-credentials: ${{ secrets.AZURE_ACI_CREDENTIALS }}
+          tag: ASBWorkerFunctions
+      - name: Setup functions app
+        id: setup-functions
+        uses: Particular/setup-azurefunctions-action@v1.0.0
+        with:
+          azure-credentials: ${{ secrets.AZURE_ACI_CREDENTIALS }}
+          tag: NSB.AzureFunctions
+          env-vars-to-promote: AzureWebJobsServiceBus
+      - name: Deploy IntegrationTest app
+        uses: azure/webapps-deploy@v2.2.17 # Do not upgrade to v3, see https://github.com/Azure/webapps-deploy/issues/386
+        with:
+          app-name: ${{ steps.setup-functions.outputs.app-name }}
+          publish-profile: ${{ steps.setup-functions.outputs.publish-profile }}
+          # TODO: Build to a non-tfm-dependent path
+          package: src/IntegrationTest/bin/Release/net10.0
+      - name: Run tests
+        uses: Particular/run-tests-action@v1.7.0
+        env:
+          INTEGRATION_APP_HOSTNAME: ${{ steps.setup-functions.outputs.hostname }}

src/AcceptanceTests/.editorconfig

@@ -0,0 +1,7 @@
+[*.cs]
+
+# ConfigureAwait - not a library
+dotnet_diagnostic.CA2007.severity = none
+
+# Add a CancellationToken - not a library
+dotnet_diagnostic.PS0018.severity = none

src/AcceptanceTests/NServiceBus.AzureFunctions.AcceptanceTests.csproj

@@ -3,7 +3,6 @@
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
     <SignAssembly>true</SignAssembly>
-    <AssemblyOriginatorKeyFile>..\NServiceBusTests.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
 
   <ItemGroup>
@@ -16,22 +15,10 @@
     <PackageReference Include="NUnit.Analyzers" Version="4.11.2" PrivateAssets="All" />
     <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" PrivateAssets="All" />
     <PackageReference Include="Particular.Approvals" Version="2.0.1" PrivateAssets="All" />
-    <PackageReference Include="Particular.Packaging" Version="4.5.0" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="NServiceBus.AcceptanceTesting" Version="10.1.0" />
   </ItemGroup>
 
-  <PropertyGroup>
-    <PackageId>NServiceBus.AzureFunctions.AcceptanceTests.Sources</PackageId>
-    <Description>Acceptance tests for NServiceBus Azure Functions functionality</Description>
-    <IncludeBuildOutput>false</IncludeBuildOutput>
-    <IncludeSourceFilesInPackage>true</IncludeSourceFilesInPackage>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <RemoveSourceFileFromPackage Include="AssemblyInfo.cs" />
-  </ItemGroup>
-
 </Project>

src/AcceptanceTests/PlaceholderTest.cs

@@ -0,0 +1,12 @@
+namespace NServiceBus.AzureFunctions.AcceptanceTests;
+
+using NUnit.Framework;
+
+public class PlaceholderTest
+{
+    [Test]
+    public void Placeholder()
+    {
+        Assert.Pass("Just a placeholder for now");
+    }
+}

src/IntegrationTest.Contracts/ExceptionInfo.cs

@@ -0,0 +1,3 @@
+namespace IntegrationTest.Contracts;
+
+public record ExceptionInfo(string FunctionName, string Type, string Message, string StackTrace);

src/IntegrationTest.Contracts/InfoResult.cs

@@ -0,0 +1,3 @@
+namespace IntegrationTest.Contracts;
+
+public record InfoResult(string Version, TimeSpan Uptime);

src/IntegrationTest.Contracts/IntegrationTest.Contracts.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+</Project>

src/IntegrationTest.Contracts/MessageReceived.cs

@@ -0,0 +1,3 @@
+namespace IntegrationTest.Contracts;
+
+public record MessageReceived(string MessageType, int Order, string SendingEndpoint, string ReceivingEndpoint);

src/IntegrationTest.Contracts/Payload.cs

@@ -0,0 +1,3 @@
+namespace IntegrationTest.Contracts;
+
+public record Payload(MessageReceived[] MessagesReceived);

src/IntegrationTest/.editorconfig

@@ -1,4 +1,7 @@
 [*.cs]
 
+# ConfigureAwait - not a library
+dotnet_diagnostic.CA2007.severity = none
+
 # Add a CancellationToken - not a library
 dotnet_diagnostic.PS0018.severity = none

src/IntegrationTest/HttpSender.cs

@@ -12,17 +12,16 @@ class HttpSender([FromKeyedServices("SenderEndpoint")] IMessageSession session,
 {
     [Function("HttpSenderV4")]
     public async Task<HttpResponseData> Run(
-        [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestData req,
+        [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestData req,
         FunctionContext executionContext)
     {
         _ = executionContext; // For now
         logger.LogInformation("C# HTTP trigger function received a request.");
 
-        await session.Send("ReceiverEndpoint", new TriggerMessage()).ConfigureAwait(false);
+        await session.StartTestWithMessage("FirstTest", "ReceiverEndpoint", new TriggerMessage());
 
         var r = req.CreateResponse(HttpStatusCode.OK);
-        await r.WriteStringAsync($"{nameof(TriggerMessage)} sent.")
-            .ConfigureAwait(false);
+        await r.WriteStringAsync($"{nameof(TriggerMessage)} sent.");
         return r;
     }
 }

src/IntegrationTest/Infrastructure/ExceptionTrackingMiddleware.cs

@@ -0,0 +1,36 @@
+namespace IntegrationTest.Infrastructure;
+
+using System.Collections.Concurrent;
+using Contracts;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Middleware;
+
+public class ExceptionTrackingMiddleware : IFunctionsWorkerMiddleware
+{
+    static ConcurrentQueue<ExceptionInfo> collectedExceptions = [];
+
+    public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
+    {
+        try
+        {
+            await next(context);
+        }
+        catch (Exception e)
+        {
+
+            var info = new ExceptionInfo(context.FunctionDefinition.Name, e.GetType().FullName ?? "<UnknownType>", e.Message, e.ToString());
+            collectedExceptions.Enqueue(info);
+            throw;
+        }
+    }
+
+    public static ExceptionInfo[] GetErrors()
+    {
+        while (collectedExceptions.Count > 20)
+        {
+            _ = collectedExceptions.TryDequeue(out _);
+        }
+
+        return [.. collectedExceptions];
+    }
+}

src/IntegrationTest/Infrastructure/MessageSessionExtensions.cs

@@ -0,0 +1,14 @@
+namespace IntegrationTest;
+
+public static class MessageSessionExtensions
+{
+    public static Task StartTestWithMessage<T>(this IMessageSession session, string testCaseName, string destination, T message)
+        where T : class
+    {
+        var opts = new SendOptions();
+        opts.SetDestination(destination);
+        opts.SetHeader("TestCaseName", testCaseName);
+
+        return session.Send(message, opts);
+    }
+}

src/IntegrationTest/Infrastructure/TestBehaviors.cs

@@ -0,0 +1,52 @@
+namespace IntegrationTest.Infrastructure;
+
+using NServiceBus.Pipeline;
+
+public class IncomingTestBehavior(TestStorage storage) : IBehavior<IInvokeHandlerContext, IInvokeHandlerContext>
+{
+    public async Task Invoke(IInvokeHandlerContext context, Func<IInvokeHandlerContext, Task> next)
+    {
+        var testCaseName = context.MessageHeaders.GetValueOrDefault("TestCaseName") ?? "<unknown-test>";
+        context.Extensions.Set("TestCaseName", testCaseName);
+
+        var orderString = context.MessageHeaders.GetValueOrDefault("TestStorageOrder");
+        var order = int.TryParse(orderString, out var storageOrder) ? storageOrder : 0;
+        context.Extensions.Set("TestStorageOrder", order);
+
+        try
+        {
+            await next(context);
+            storage.LogMessage(testCaseName, context.MessageBeingHandled, context);
+        }
+        catch (OperationCanceledException) when (context.CancellationToken.IsCancellationRequested)
+        {
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine(e);
+            throw;
+        }
+    }
+}
+
+public class OutgoingTestBehavior : IBehavior<IOutgoingPhysicalMessageContext, IOutgoingPhysicalMessageContext>
+{
+    public Task Invoke(IOutgoingPhysicalMessageContext context, Func<IOutgoingPhysicalMessageContext, Task> next)
+    {
+        if (context.Extensions.TryGet<string>("TestCaseName", out var testCaseName))
+        {
+            context.Headers.Add("TestCaseName", testCaseName);
+        }
+
+        if (!context.Extensions.TryGet<int>("TestStorageOrder", out var order))
+        {
+            order = 0;
+        }
+
+        order++;
+
+        context.Headers.Add("TestStorageOrder", order.ToString());
+
+        return next(context);
+    }
+}

src/IntegrationTest/Infrastructure/TestDataFunction.cs

@@ -0,0 +1,48 @@
+namespace IntegrationTest.Infrastructure;
+
+using System.Reflection;
+using Contracts;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+
+class TestDataFunction(GlobalTestStorage storage)
+{
+    static readonly string InformationalVersion;
+    static readonly DateTime StartTime;
+
+    static TestDataFunction()
+    {
+        InformationalVersion = typeof(TestDataFunction).Assembly
+            .GetCustomAttributes<AssemblyInformationalVersionAttribute>()
+            .First()
+            .InformationalVersion;
+
+        StartTime = DateTime.UtcNow;
+    }
+
+    [Function(nameof(GetTestData))]
+    public Payload GetTestData([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "testing/data/{testName}")] HttpRequestData _, string testName)
+    {
+        var payload = storage.CreatePayload(testName);
+        return payload;
+    }
+
+    [Function(nameof(ClearTestData))]
+    public IActionResult ClearTestData([HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "testing/data/{testName}")] HttpRequestData _, string testName)
+    {
+        storage.Clear(testName);
+        return new OkResult();
+    }
+
+    [Function(nameof(GetInfo))]
+    public InfoResult GetInfo([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "testing")] HttpRequestData _)
+    {
+        var result = new InfoResult(InformationalVersion, DateTime.UtcNow - StartTime);
+        return result;
+    }
+
+    [Function(nameof(GetErrors))]
+    public ExceptionInfo[] GetErrors([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "testing/errors")] HttpRequestData _)
+        => ExceptionTrackingMiddleware.GetErrors();
+}