feat: MESH-Handshake

.env.example

@@ -13,6 +13,7 @@ NbssMailboxId=X26ABC1
 MeshApiBaseUrl=http://localhost:8700/messageexchange
 ASPNETCORE_ENVIRONMENT=Development
 FileDiscoveryTimerExpression=*/5 * * * *
+MeshHandshakeTimerExpression=0 0 0 * * * # Midnight
 QueueUrl=http://127.0.0.1:10001
 FileExtractQueueName=file-extract
 FileTransformQueueName=file-transform

src/ServiceLayer.Mesh/Configuration/AppConfiguration.cs

@@ -4,7 +4,8 @@ public class AppConfiguration :
     IFileDiscoveryFunctionConfiguration,
     IFileExtractFunctionConfiguration,
     IFileExtractQueueClientConfiguration,
-    IFileTransformQueueClientConfiguration
+    IFileTransformQueueClientConfiguration,
+    IMeshHandshakeFunctionConfiguration
 {
     public string NbssMeshMailboxId => GetRequired("NbssMailboxId");
 

src/ServiceLayer.Mesh/Configuration/IMeshHandshakeFunctionConfiguration.cs

@@ -0,0 +1,7 @@
+namespace ServiceLayer.Mesh.Configuration
+{
+    public interface IMeshHandshakeFunctionConfiguration
+    {
+        string NbssMeshMailboxId { get; }
+    }
+}

src/ServiceLayer.Mesh/Functions/MeshHandshakeFunction.cs

@@ -1,6 +1,43 @@
-namespace ServiceLayer.Mesh.Functions;
+using Azure;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Logging;
+using NHS.MESH.Client.Contracts.Services;
+using ServiceLayer.Mesh.Configuration;
 
-public class MeshHandshakeFunction
+namespace ServiceLayer.Mesh.Functions
 {
+    public class MeshHandshakeFunction(
+        ILogger<MeshHandshakeFunction> logger,
+        IMeshOperationService meshOperationService,
+        IMeshHandshakeFunctionConfiguration configuration)
+    {
+        [Function("MeshHandshakeFunction")]
+        public async Task Run([TimerTrigger("%MeshHandshakeTimerExpression%")] TimerInfo myTimer)
+        {
+            logger.LogInformation("{FunctionName} started at: {Time}", nameof(MeshHandshakeFunction), DateTime.UtcNow);
 
+            try
+            {
+                var response = await meshOperationService.MeshHandshakeAsync(configuration.NbssMeshMailboxId);
+
+                if (response.IsSuccessful)
+                {
+                    logger.LogInformation("Mesh handshake completed successfully for mailbox {MailboxId} at {Time}. Status: {Status}",
+                    response.Response.MailboxId, DateTime.UtcNow, response.IsSuccessful);
+                }
+                else
+                {
+                    logger.LogWarning("Mesh handshake failed for mailbox {MailboxId} at {Time}. Error: {Error}",
+                    configuration.NbssMeshMailboxId, DateTime.UtcNow, response.Error);
+                }
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "An error occurred during mesh handshake for mailbox {MailboxId} at {Time}", configuration.NbssMeshMailboxId, DateTime.UtcNow);
+                return;
+            }
+
+            logger.LogInformation("{FunctionName} completed at: {Time}", nameof(MeshHandshakeFunction), DateTime.UtcNow);
+        }
+    }
 }

src/ServiceLayer.Mesh/Program.cs

@@ -9,6 +9,8 @@
 using Azure.Storage.Blobs;
 using ServiceLayer.Mesh.Configuration;
 using ServiceLayer.Mesh.Messaging;
+using NHS.MESH.Client.Contracts.Services;
+using NHS.MESH.Client.Services;
 
 var host = new HostBuilder()
     .ConfigureFunctionsWebApplication()
@@ -51,6 +53,7 @@
 
         services.AddSingleton<IFileExtractQueueClient, FileExtractQueueClient>();
         services.AddSingleton<IFileTransformQueueClient, FileTransformQueueClient>();
+        services.AddSingleton<IMeshOperationService, MeshOperationService>();
 
         services.AddSingleton(provider =>
         {
@@ -63,6 +66,7 @@
         services.AddTransient<IFileExtractFunctionConfiguration, AppConfiguration>();
         services.AddTransient<IFileExtractQueueClientConfiguration, AppConfiguration>();
         services.AddTransient<IFileTransformQueueClientConfiguration, AppConfiguration>();
+        services.AddTransient<IMeshHandshakeFunctionConfiguration, AppConfiguration>();
     });
 
 

tests/ServiceLayer.Mesh.Tests/Functions/MeshHandshakeFunctionTests.cs

@@ -0,0 +1,124 @@
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NHS.MESH.Client.Contracts.Services;
+using NHS.MESH.Client.Models;
+using ServiceLayer.Mesh.Configuration;
+using ServiceLayer.Mesh.Functions;
+
+namespace ServiceLayer.Mesh.Tests.Functions;
+
+public class MeshHandshakeFunctionTests
+{
+    private readonly Mock<ILogger<MeshHandshakeFunction>> _loggerMock;
+    private readonly Mock<IMeshOperationService> _meshOperationServiceMock;
+    private readonly Mock<IMeshHandshakeFunctionConfiguration> _configurationMock;
+    private readonly MeshHandshakeFunction _function;
+    private readonly TimerInfo _timerInfo;
+    private const string TestMailboxId = "test-mailbox-123";
+
+    public MeshHandshakeFunctionTests()
+    {
+        _loggerMock = new Mock<ILogger<MeshHandshakeFunction>>();
+        _meshOperationServiceMock = new Mock<IMeshOperationService>();
+        _configurationMock = new Mock<IMeshHandshakeFunctionConfiguration>();
+        _timerInfo = new TimerInfo();
+
+        _configurationMock.Setup(c => c.NbssMeshMailboxId).Returns(TestMailboxId);
+        _function = new MeshHandshakeFunction(
+            _loggerMock.Object,
+            _meshOperationServiceMock.Object,
+            _configurationMock.Object
+        );
+    }
+
+    [Fact]
+    public async Task Run_SuccessfulHandshake_LogsSuccessAndCompletion()
+    {
+        // Arrange
+        var successfulResponse = new MeshResponse<HandshakeResponse>
+        {
+            IsSuccessful = true,
+            Response = new HandshakeResponse { MailboxId = TestMailboxId }
+        };
+        _meshOperationServiceMock
+            .Setup(s => s.MeshHandshakeAsync(TestMailboxId))
+            .ReturnsAsync(successfulResponse);
+
+        // Act
+        await _function.Run(_timerInfo);
+
+        // Assert
+        _meshOperationServiceMock.Verify(s => s.MeshHandshakeAsync(TestMailboxId), Times.Once());
+        VerifyLogMessage(LogLevel.Information, "MeshHandshakeFunction started at");
+        VerifyLogMessage(LogLevel.Information, "Mesh handshake completed successfully");
+        VerifyLogMessage(LogLevel.Information, "MeshHandshakeFunction completed at");
+    }
+
+    [Fact]
+    public async Task Run_FailedHandshake_LogsWarningAndCompletion()
+    {
+        // Arrange
+        var failedResponse = new MeshResponse<HandshakeResponse>
+        {
+            IsSuccessful = false,
+            Error = new APIErrorResponse
+            {
+                ErrorDescription = "Authentication failed"
+            }
+        };
+        _meshOperationServiceMock
+            .Setup(s => s.MeshHandshakeAsync(TestMailboxId))
+            .ReturnsAsync(failedResponse);
+
+        // Act
+        await _function.Run(_timerInfo);
+
+        // Assert
+        _meshOperationServiceMock.Verify(s => s.MeshHandshakeAsync(TestMailboxId), Times.Once());
+        VerifyLogMessage(LogLevel.Information, "MeshHandshakeFunction started at");
+        VerifyLogMessage(LogLevel.Warning, "Mesh handshake failed");
+        VerifyLogMessage(LogLevel.Information, "MeshHandshakeFunction completed at");
+    }
+
+    [Fact]
+    public async Task Run_ExceptionThrown_LogsErrorAndCompletion()
+    {
+        // Arrange
+        _meshOperationServiceMock.Reset();
+        _loggerMock.Reset();
+
+        var expectedException = new InvalidOperationException("Connection failed");
+        _meshOperationServiceMock
+            .Setup(s => s.MeshHandshakeAsync(TestMailboxId))
+            .ThrowsAsync(expectedException);
+
+        // Act
+        await _function.Run(_timerInfo);
+
+        // Assert
+        _meshOperationServiceMock.Verify(s => s.MeshHandshakeAsync(TestMailboxId), Times.Once());
+        VerifyLogMessage(LogLevel.Information, "MeshHandshakeFunction started at");
+        VerifyLogMessage(LogLevel.Error, "An error occurred during mesh handshake");
+        _loggerMock.Verify(
+            x => x.Log(
+                LogLevel.Error,
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                expectedException,
+                It.IsAny<Func<It.IsAnyType, Exception, string>>()),
+            Times.Once);
+    }
+
+    private void VerifyLogMessage(LogLevel level, string expectedMessage)
+    {
+        _loggerMock.Verify(
+            x => x.Log(
+                level,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => v.ToString().Contains(expectedMessage)),
+                It.IsAny<Exception>(),
+                It.IsAny<Func<It.IsAnyType, Exception, string>>()),
+            Times.Once);
+    }
+}