Raise Workflow service and exposure coverage above 95%

.github/workflows/publish.yml

@@ -88,8 +88,8 @@ jobs:
           "Services and exposures line coverage: $coveredLines/$($lines.Count) ($percentage)" |
             Write-Output
 
-          if ($lineRate -le 0.90) {
-            throw "Services and exposures line coverage must be greater than 90%; actual: $percentage."
+          if ($lineRate -le 0.95) {
+            throw "Services and exposures line coverage must be greater than 95%; actual: $percentage."
           }
 
       - name: Upload test results
@@ -207,4 +207,4 @@ jobs:
 
       - name: Deploy coverage report
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v4

src/cCoder.Workflow.Engine.Tests/FlowCommunicationProcessingServiceTests.ConnectWorkflowRequestAsync.cs

@@ -0,0 +1,103 @@
+// ---------------------------------------------------------------
+// Copyright (c) Paul.Ward@ccoder.co.uk
+// ---------------------------------------------------------------
+
+using cCoder.Workflow.Activities.Models;
+using Moq;
+using Xunit;
+
+namespace cCoder.Workflow.Engine.Tests;
+
+public sealed partial class FlowCommunicationProcessingServiceTests
+{
+    [Fact]
+    public async Task ShouldConnectWorkflowRequestAsync()
+    {
+        // Given
+        WorkflowRequest request = CreateWorkflowRequest();
+
+        workflowHubConnectionBrokerMock
+            .Setup(expression: broker => broker.ConnectAsync(
+                url: $"{request.Api}Hubs/Workflow"))
+            .Returns(value: Task.CompletedTask);
+
+        workflowHubConnectionBrokerMock
+            .Setup(expression: broker => broker.SendAsync(
+                level: "info",
+                message: It.IsAny<string>(),
+                instanceId: request.InstanceId.ToString()))
+            .Returns(value: Task.CompletedTask);
+
+        var service = CreateService();
+
+        // When
+        await service.ConnectWorkflowRequestAsync(workflowRequest: request);
+
+        // Then
+        workflowHubConnectionBrokerMock.VerifyAll();
+        loggingBrokerMock.VerifyNoOtherCalls();
+    }
+
+    [Fact]
+    public async Task ShouldLogWarningWhenWorkflowConnectionFailsAsync()
+    {
+        // Given
+        WorkflowRequest request = CreateWorkflowRequest();
+
+        workflowHubConnectionBrokerMock
+            .Setup(expression: broker => broker.ConnectAsync(
+                url: $"{request.Api}Hubs/Workflow"))
+            .Throws(exception: new InvalidOperationException());
+
+        workflowHubConnectionBrokerMock
+            .Setup(expression: broker => broker.DisconnectAsync())
+            .Returns(value: ValueTask.CompletedTask);
+
+        var service = CreateService();
+
+        // When
+        await service.ConnectWorkflowRequestAsync(workflowRequest: request);
+
+        // Then
+        workflowHubConnectionBrokerMock.VerifyAll();
+        loggingBrokerMock.VerifyNoOtherCalls();
+    }
+
+    [Fact]
+    public async Task ShouldDisconnectAndLogWhenWorkflowSendFailsAsync()
+    {
+        // Given
+        WorkflowRequest request = CreateWorkflowRequest();
+
+        workflowHubConnectionBrokerMock
+            .Setup(expression: broker => broker.ConnectAsync(
+                url: $"{request.Api}Hubs/Workflow"))
+            .Returns(value: Task.CompletedTask);
+
+        workflowHubConnectionBrokerMock
+            .Setup(expression: broker => broker.SendAsync(
+                level: "info",
+                message: It.IsAny<string>(),
+                instanceId: request.InstanceId.ToString()))
+            .Throws(exception: new InvalidOperationException("send failed"));
+
+        workflowHubConnectionBrokerMock
+            .Setup(expression: broker => broker.DisconnectAsync())
+            .Returns(value: ValueTask.CompletedTask);
+
+        var service = CreateService();
+
+        // When
+        await service.ConnectWorkflowRequestAsync(workflowRequest: request);
+
+        // Then
+        workflowHubConnectionBrokerMock.VerifyAll();
+
+        loggingBrokerMock.Verify(
+            expression: broker => broker.LogError(
+                message: "{Message}",
+                args: It.Is<object[]>(match: arguments =>
+                    arguments.Single() as string == "send failed")),
+            times: Times.Once());
+    }
+}

src/cCoder.Workflow.Engine.Tests/FlowCommunicationProcessingServiceTests.Exceptions.cs

@@ -0,0 +1,50 @@
+// ---------------------------------------------------------------
+// Copyright (c) Paul.Ward@ccoder.co.uk
+// ---------------------------------------------------------------
+
+using cCoder.Workflow.Activities.Models;
+using FluentAssertions;
+using Moq;
+using Xunit;
+
+namespace cCoder.Workflow.Engine.Tests;
+
+public sealed partial class FlowCommunicationProcessingServiceTests
+{
+    [Theory]
+    [MemberData(
+        nameof(WorkflowRequestOrchestrationServiceTests.ExceptionMappings),
+        MemberType = typeof(WorkflowRequestOrchestrationServiceTests))]
+    public async Task ShouldMapLogWorkflowRequestAsyncFailure(
+        Exception exception,
+        Type expectedType)
+    {
+        // Given
+        const string message = "message";
+        WorkflowRequest request = CreateWorkflowRequest();
+
+        loggingBrokerMock
+            .Setup(expression: broker => broker.LogError(
+                message: "{Message}",
+                args: It.IsAny<object[]>()))
+            .Throws(exception: exception);
+
+        var service = CreateService();
+
+        // When
+        Func<Task> action = async () => await service
+            .LogWorkflowRequestAsync(
+                workflowRequest: request,
+                level: WorkflowLogLevel.Error,
+                message: message);
+
+        // Then
+        Exception thrown = (await action
+            .Should()
+            .ThrowAsync<Exception>()).Which;
+
+        thrown
+            .Should()
+            .BeOfType(expectedType: expectedType);
+    }
+}

src/cCoder.Workflow.Engine.Tests/FlowCommunicationProcessingServiceTests.LogWorkflowRequestAsync.cs

@@ -0,0 +1,106 @@
+// ---------------------------------------------------------------
+// Copyright (c) Paul.Ward@ccoder.co.uk
+// ---------------------------------------------------------------
+
+using cCoder.Workflow.Activities.Models;
+using cCoder.Workflow.Engine.Models.Exceptions;
+using FluentAssertions;
+using Moq;
+using Xunit;
+
+namespace cCoder.Workflow.Engine.Tests;
+
+public sealed partial class FlowCommunicationProcessingServiceTests
+{
+    [Fact]
+    public async Task ShouldLogWorkflowRequestAsync()
+    {
+        // Given
+        const string message = "message";
+        WorkflowRequest request = CreateWorkflowRequest();
+        var service = CreateService();
+
+        // When
+        await service.LogWorkflowRequestAsync(
+            workflowRequest: request,
+            level: WorkflowLogLevel.Info,
+            message: message);
+
+        await service.LogWorkflowRequestAsync(
+            workflowRequest: request,
+            level: WorkflowLogLevel.Error,
+            message: message);
+
+        await service.LogWorkflowRequestAsync(
+            workflowRequest: request,
+            level: WorkflowLogLevel.Fatal,
+            message: message);
+
+        // Then
+        loggingBrokerMock.Verify(
+            expression: broker => broker.LogError(
+                message: "{Message}",
+                args: It.Is<object[]>(match: arguments =>
+                    arguments.Single() as string == message)),
+            times: Times.Exactly(callCount: 2));
+    }
+
+    [Fact]
+    public async Task ShouldTruncateLongWorkflowRequestLogAsync()
+    {
+        // Given
+        string message = new(c: 'a', count: 4001);
+        string loggedMessage = null;
+        WorkflowRequest request = CreateWorkflowRequest();
+
+        loggingBrokerMock
+            .Setup(expression: broker => broker.LogError(
+                message: "{Message}",
+                args: It.IsAny<object[]>()))
+            .Callback<string, object[]>(action: (_, arguments) =>
+                loggedMessage = arguments.Single() as string);
+
+        var service = CreateService();
+
+        // When
+        await service.LogWorkflowRequestAsync(
+            workflowRequest: request,
+            level: WorkflowLogLevel.Error,
+            message: message);
+
+        // Then
+        loggedMessage.Length
+            .Should()
+            .BeLessThan(expected: message.Length);
+
+        loggedMessage
+            .Should()
+            .Contain(expected: "characters cut");
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData(" ")]
+    public async Task ShouldRejectInvalidWorkflowRequestAsync(string api)
+    {
+        // Given
+        WorkflowRequest request = CreateWorkflowRequest();
+        request.Api = api;
+        var service = CreateService();
+
+        // When
+        Func<Task> action = async () => await service
+            .LogWorkflowRequestAsync(
+                workflowRequest: request,
+                level: WorkflowLogLevel.Info,
+                message: "message");
+
+        // Then
+        await action
+            .Should()
+            .ThrowAsync<WorkflowEngineValidationException>();
+
+        loggingBrokerMock.VerifyNoOtherCalls();
+    }
+}

src/cCoder.Workflow.Engine.Tests/FlowCommunicationProcessingServiceTests.cs

@@ -0,0 +1,33 @@
+// ---------------------------------------------------------------
+// Copyright (c) Paul.Ward@ccoder.co.uk
+// ---------------------------------------------------------------
+
+using cCoder.Workflow.Activities.Models;
+using cCoder.Workflow.Engine.Brokers;
+using cCoder.Workflow.Engine.Brokers.Loggings;
+using cCoder.Workflow.Engine.Services.Processings;
+using Moq;
+
+namespace cCoder.Workflow.Engine.Tests;
+
+public sealed partial class FlowCommunicationProcessingServiceTests
+{
+    private readonly Mock<ILoggingBroker> loggingBrokerMock = new();
+
+    private readonly Mock<IWorkflowHubConnectionBroker>
+        workflowHubConnectionBrokerMock =
+            new(behavior: MockBehavior.Strict);
+
+    private FlowCommunicationProcessingService CreateService() =>
+        new(
+            logger: loggingBrokerMock.Object,
+            workflowHubConnectionBroker:
+                workflowHubConnectionBrokerMock.Object);
+
+    private static WorkflowRequest CreateWorkflowRequest() =>
+        new(
+            api: "https://localhost/",
+            token: "token",
+            flowId: Guid.NewGuid(),
+            instanceId: Guid.NewGuid());
+}

src/cCoder.Workflow.Engine.Tests/FlowExecutionOrchestrationAdapterTests.ExecuteAsync.cs

@@ -0,0 +1,42 @@
+// ---------------------------------------------------------------
+// Copyright (c) Paul.Ward@ccoder.co.uk
+// ---------------------------------------------------------------
+
+using cCoder.Workflow.Activities.Models;
+using cCoder.Workflow.Engine.Exposures;
+using cCoder.Workflow.Engine.Services.Orchestrations;
+using Moq;
+using Xunit;
+
+namespace cCoder.Workflow.Engine.Tests;
+
+public sealed partial class FlowExecutionOrchestrationAdapterTests
+{
+    [Fact]
+    public async Task ShouldExecuteAsync()
+    {
+        // Given
+        WorkflowRequest request = new(
+            api: "https://localhost/",
+            token: "token",
+            flowId: Guid.NewGuid(),
+            instanceId: Guid.NewGuid());
+
+        Mock<IWorkflowRequestOrchestrationService> serviceMock =
+            new(behavior: MockBehavior.Strict);
+
+        serviceMock
+            .Setup(expression: service => service
+                .ExecuteWorkflowRequestAsync(workflowRequest: request))
+            .Returns(value: ValueTask.CompletedTask);
+
+        FlowExecutionOrchestrationAdapter adapter =
+            new(workflowRequestOrchestrationService: serviceMock.Object);
+
+        // When
+        await adapter.ExecuteAsync(request: request);
+
+        // Then
+        serviceMock.VerifyAll();
+    }
+}