feat: adding unit tests and dependancy injection

Signed-off-by: Tyrrellion <samuel.tyrell1@nhs.net>

Author: SamTyrrellNHS

src/ServiceLayer.Mesh/Functions/DiscoveryFunction.cs

@@ -1,4 +1,3 @@
-using Azure.Identity;
 using Azure.Storage.Queues;
 using Microsoft.Azure.Functions.Worker;
 using Microsoft.EntityFrameworkCore;
@@ -14,68 +13,57 @@ public class DiscoveryFunction
         private readonly ILogger _logger;
         private readonly IMeshInboxService _meshInboxService;
         private readonly ServiceLayerDbContext _serviceLayerDbContext;
+        private readonly QueueClient _queueClient;
 
-        public DiscoveryFunction(ILoggerFactory loggerFactory, IMeshInboxService meshInboxService, ServiceLayerDbContext serviceLayerDbContext)
+        public DiscoveryFunction(ILogger<DiscoveryFunction> logger, IMeshInboxService meshInboxService, ServiceLayerDbContext serviceLayerDbContext, QueueClient queueClient)
         {
-            _logger = loggerFactory.CreateLogger<DiscoveryFunction>();
+            _logger = logger;
             _meshInboxService = meshInboxService;
             _serviceLayerDbContext = serviceLayerDbContext;
+            _queueClient = queueClient;
         }
 
         [Function("DiscoveryFunction")]
         public async Task Run([TimerTrigger("0 */1 * * * *")] TimerInfo myTimer)
         {
-            _logger.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
+            _logger.LogInformation($"DiscoveryFunction started at: {DateTime.Now}");
 
             var mailboxId = Environment.GetEnvironmentVariable("MailboxId")
                 ?? throw new InvalidOperationException($"Environment variable 'MailboxId' is not set or is empty.");
 
             var response = await _meshInboxService.GetMessagesAsync(mailboxId);
 
-            if (response.Response.Messages.Count() > 500)
-            {
-                // TODO: Get next page
-                // dotnet-mesh-client needs to be updated to support pagination for when inbox containers more than 500 messages
-            }
+            _queueClient.CreateIfNotExists();
 
             foreach (var messageId in response.Response.Messages)
             {
-                // Check if message has been seen before
-                var doesFileIdExist = await _serviceLayerDbContext.MeshFiles.AnyAsync(m => m.FileId == messageId.ToString());
+                using var transaction = await _serviceLayerDbContext.Database.BeginTransactionAsync();
+
+                var existing = await _serviceLayerDbContext.MeshFiles
+                    .AsNoTracking()
+                    .FirstOrDefaultAsync(f => f.FileId == messageId);
 
-                if (!doesFileIdExist)
+                if (existing == null)
                 {
-                    var meshFile = new MeshFile()
+                    _serviceLayerDbContext.MeshFiles.Add(new MeshFile
                     {
                         FileId = messageId,
-                        FileType = "",
+                        FileType = MeshFileType.NbssAppointmentEvents,
                         MailboxId = mailboxId,
-                        Status = "Discovered"
-                    };
+                        Status = MeshFileStatus.Discovered,
+                        FirstSeenUtc = DateTime.UtcNow,
+                        LastUpdatedUtc = DateTime.UtcNow
+                    });
 
-                    await _serviceLayerDbContext.MeshFiles.AddAsync(meshFile);
                     await _serviceLayerDbContext.SaveChangesAsync();
+                    await transaction.CommitAsync();
 
-                    QueueClient queueClient;
-
-                    if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
-                    {
-                        queueClient = new QueueClient("UseDevelopmentStorage=true", "my-local-queue");
-                    }
-                    else
-                    {
-                        var credential = new ManagedIdentityCredential();
-                        queueClient = new QueueClient(new Uri(Environment.GetEnvironmentVariable("QueueUrl")), credential);
-                    }
-
-                    queueClient.CreateIfNotExists();
-                    queueClient.SendMessage(messageId);
+                    _queueClient.SendMessage(messageId);
+                }
+                else
+                {
+                    await transaction.RollbackAsync();
                 }
-            }
-
-            if (myTimer.ScheduleStatus is not null)
-            {
-                _logger.LogInformation($"Next timer schedule at: {myTimer.ScheduleStatus.Next}");
             }
         }
     }

src/ServiceLayer.Mesh/Models/MeshFile.cs

@@ -5,9 +5,9 @@ namespace ServiceLayer.Mesh.Models;
 public class MeshFile
 {
     public required string FileId { get; set; }
-    public required string FileType { get; set; }
+    public required MeshFileType FileType { get; set; }
     public required string MailboxId { get; set; }
-    public required string Status { get; set; }
+    public required MeshFileStatus Status { get; set; }
     public string? BlobPath { get; set; }
     public DateTime FirstSeenUtc { get; set; }
     public DateTime LastUpdatedUtc { get; set; }

src/ServiceLayer.Mesh/Models/MeshFileStatus.cs

@@ -0,0 +1,12 @@
+namespace ServiceLayer.Mesh.Models;
+
+public enum MeshFileStatus
+{
+    Discovered,
+    Extracting,
+    Extracted,
+    Transforming,
+    Transformed,
+    FailedExtract,
+    FailedTransform
+}

src/ServiceLayer.Mesh/Models/MeshFileType.cs

@@ -0,0 +1,6 @@
+namespace ServiceLayer.Mesh.Models;
+
+public enum MeshFileType
+{
+    NbssAppointmentEvents
+}

src/ServiceLayer.Mesh/Program.cs

@@ -1,30 +1,53 @@
 using Microsoft.Azure.Functions.Worker.Builder;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Azure.Storage.Queues;
+using Azure.Identity;
+using Microsoft.EntityFrameworkCore;
 using NHS.MESH.Client;
 using ServiceLayer.Mesh.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
 
 var host = new HostBuilder()
     .ConfigureFunctionsWebApplication()
     .ConfigureServices(services =>
     {
+        // MESH Client config
         services
             .AddMeshClient(_ => _.MeshApiBaseUrl = Environment.GetEnvironmentVariable("MeshApiBaseUrl"))
             .AddMailbox(Environment.GetEnvironmentVariable("BSSMailBox"), new NHS.MESH.Client.Configuration.MailboxConfiguration
             {
                 Password = Environment.GetEnvironmentVariable("MeshPassword"),
                 SharedKey = Environment.GetEnvironmentVariable("MeshSharedKey"),
-                //Cert = cert
             }).Build();
 
+        // EF Core DbContext
         services.AddDbContext<ServiceLayerDbContext>(options =>
         {
-            var databaseConnectionString = Environment.GetEnvironmentVariable("DatabaseConnectionString");
-            if (string.IsNullOrEmpty(databaseConnectionString))
+            var connectionString = Environment.GetEnvironmentVariable("DatabaseConnectionString");
+            if (string.IsNullOrEmpty(connectionString))
                 throw new InvalidOperationException("The connection string has not been initialized.");
 
-            options.UseSqlServer(databaseConnectionString);
+            options.UseSqlServer(connectionString);
+        });
+
+        // Register QueueClient as singleton
+        services.AddSingleton(provider =>
+        {
+            var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+            var queueUrl = Environment.GetEnvironmentVariable("QueueUrl");
+
+            if (string.IsNullOrWhiteSpace(queueUrl))
+                throw new InvalidOperationException("QueueUrl environment variable is not set.");
+
+            if (environment == "Development")
+            {
+                return new QueueClient("UseDevelopmentStorage=true", "my-local-queue");
+            }
+            else
+            {
+                var credential = new ManagedIdentityCredential();
+                return new QueueClient(new Uri(queueUrl), credential);
+            }
         });
     });
 
@@ -35,5 +58,4 @@
 //     .ConfigureFunctionsApplicationInsights();
 
 var app = host.Build();
-
 await app.RunAsync();

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

@@ -0,0 +1,111 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+using ServiceLayer.Mesh.Functions;
+using ServiceLayer.Mesh.Models;
+using ServiceLayer.Mesh.Data;
+using Microsoft.EntityFrameworkCore;
+using NHS.MESH.Client.Contracts.Services;
+using Microsoft.Azure.Functions.Worker;
+using NHS.MESH.Client.Models;
+using Azure.Storage.Queues;
+using Azure.Storage.Queues.Models;
+using Azure;
+
+public class DiscoveryFunctionTests
+{
+    private readonly Mock<ILogger<DiscoveryFunction>> _loggerMock;
+    private readonly Mock<IMeshInboxService> _meshInboxServiceMock;
+    private readonly ServiceLayerDbContext _dbContext;
+    private readonly Mock<QueueClient> _queueClientMock;
+    private readonly DiscoveryFunction _function;
+
+    public DiscoveryFunctionTests()
+    {
+        _loggerMock = new Mock<ILogger<DiscoveryFunction>>();
+        _meshInboxServiceMock = new Mock<IMeshInboxService>();
+        _queueClientMock = new Mock<QueueClient>();
+
+        var options = new DbContextOptionsBuilder<ServiceLayerDbContext>()
+            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .ConfigureWarnings(warnings =>
+                warnings.Ignore(Microsoft.EntityFrameworkCore.Diagnostics.InMemoryEventId.TransactionIgnoredWarning))
+            .Options;
+
+        _dbContext = new ServiceLayerDbContext(options);
+
+        Environment.SetEnvironmentVariable("MailboxId", "test-mailbox");
+        Environment.SetEnvironmentVariable("QueueUrl", "https://fakestorageaccount.queue.core.windows.net/testqueue");
+
+        _function = new DiscoveryFunction(
+            _loggerMock.Object,
+            _meshInboxServiceMock.Object,
+            _dbContext,
+            _queueClientMock.Object
+        );
+    }
+
+    [Fact]
+    public async Task Run_AddsNewMessageToDbAndQueue()
+    {
+        // Arrange
+        var testMessageId = "test-message-123";
+
+        _meshInboxServiceMock.Setup(s => s.GetMessagesAsync("test-mailbox"))
+            .ReturnsAsync(new MeshResponse<CheckInboxResponse>
+            {
+                Response = new CheckInboxResponse { Messages = new[] { testMessageId } }
+            });
+
+        _queueClientMock
+            .Setup(q => q.SendMessage(It.IsAny<string>(), null, null, It.IsAny<CancellationToken>()))
+            .Returns(Response.FromValue<SendReceipt>(null, Mock.Of<Response>()));
+
+        // Act
+        await _function.Run(null);
+
+        // Assert
+        var meshFile = _dbContext.MeshFiles.FirstOrDefault(f => f.FileId == testMessageId);
+        Assert.NotNull(meshFile);
+        Assert.Equal(MeshFileStatus.Discovered, meshFile.Status);
+        Assert.Equal("test-mailbox", meshFile.MailboxId);
+
+        _queueClientMock.Verify(q => q.SendMessage(It.IsAny<string>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task Run_DoesNotAddDuplicateMessageOrQueueIt()
+    {
+        // Arrange
+        var duplicateMessageId = "existing-message";
+        _dbContext.MeshFiles.Add(new MeshFile
+        {
+            FileId = duplicateMessageId,
+            FileType = MeshFileType.NbssAppointmentEvents,
+            MailboxId = "test-mailbox",
+            Status = MeshFileStatus.Discovered,
+            FirstSeenUtc = DateTime.UtcNow,
+            LastUpdatedUtc = DateTime.UtcNow
+        });
+        await _dbContext.SaveChangesAsync();
+
+        _meshInboxServiceMock.Setup(s => s.GetMessagesAsync("test-mailbox"))
+            .ReturnsAsync(new MeshResponse<CheckInboxResponse>
+            {
+                Response = new CheckInboxResponse { Messages = new[] { duplicateMessageId } }
+            });
+
+        // Act
+        await _function.Run(null);
+
+        // Assert
+        var count = _dbContext.MeshFiles.Count(f => f.FileId == duplicateMessageId);
+        Assert.Equal(1, count);
+
+        _queueClientMock.Verify(q => q.SendMessage(It.IsAny<string>()), Times.Never);
+    }
+}

tests/ServiceLayer.Mesh.Tests/ServiceLayer.Mesh.Tests.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="9.0.4" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../src/ServiceLayer.Mesh/ServiceLayer.Mesh.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>