Feature/448427 pom subs validation

src/EPR.ProducerContentValidation.Application.UnitTests/Clients/CompanyDetailsApiClientTests.cs

@@ -0,0 +1,150 @@
+using System.Net;
+using EPR.ProducerContentValidation.Application.Clients;
+using EPR.ProducerContentValidation.Data.Config;
+using EPR.ProducerContentValidation.Data.Models.Subsidiary;
+using FluentAssertions;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using Moq.Protected;
+using Newtonsoft.Json;
+
+namespace EPR.ProducerContentValidation.Application.UnitTests.Clients
+{
+    [TestClass]
+    public class CompanyDetailsApiClientTests
+    {
+        private CompanyDetailsApiConfig? _config;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            _config = new CompanyDetailsApiConfig
+            {
+                BaseUrl = "https://www.testurl.com",
+                ClientId = "test-client-id",
+                Timeout = 5,
+            };
+        }
+
+        [TestMethod]
+        public async Task GetSubsidiaryDetails_ShouldReturnSubsidiaryDetailsRequest_OnSuccess()
+        {
+            // Arrange
+            var request = new SubsidiaryDetailsRequest();
+            var content = JsonConvert.SerializeObject(request);
+            var responseMessage = new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.OK,
+                Content = new StringContent(content),
+            };
+            var handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
+            handlerMock
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>(
+            "SendAsync",
+            ItExpr.IsAny<HttpRequestMessage>(),
+            ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(new HttpResponseMessage()
+            {
+                StatusCode = HttpStatusCode.OK,
+                Content = new StringContent(content),
+            })
+            .Verifiable();
+            var httpClient = new HttpClient(handlerMock.Object)
+            {
+                BaseAddress = new Uri(_config.BaseUrl),
+                Timeout = TimeSpan.FromSeconds(_config.Timeout),
+            };
+            var sut = new CompanyDetailsApiClient(httpClient, NullLogger<CompanyDetailsApiClient>.Instance);
+
+            // Act
+            var result = await sut.GetSubsidiaryDetails(request);
+
+            // Assert
+            result.Should().BeEquivalentTo(request);
+            handlerMock.Protected().Verify(
+                "SendAsync",
+                Times.Once(),
+                ItExpr.Is<HttpRequestMessage>(req =>
+                    req.Method == HttpMethod.Post &&
+                    req.RequestUri.ToString().EndsWith("api/subsidiary-details")),
+                ItExpr.IsAny<CancellationToken>());
+        }
+
+        [DataRow(HttpStatusCode.Conflict)]
+        [DataRow(HttpStatusCode.BadRequest)]
+        [DataRow(HttpStatusCode.BadGateway)]
+        [DataRow(HttpStatusCode.Unauthorized)]
+        [TestMethod]
+        public async Task GetSubsidiaryDetails_WhenSendAsyncNotSuccessful_ThrowsError(HttpStatusCode statusCode)
+        {
+            // Arrange
+            var handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
+            handlerMock
+                .Protected()
+                .Setup<Task<HttpResponseMessage>>(
+                    "SendAsync",
+                    ItExpr.IsAny<HttpRequestMessage>(),
+                    ItExpr.IsAny<CancellationToken>())
+                .ReturnsAsync(new HttpResponseMessage()
+                {
+                    StatusCode = statusCode,
+                })
+                .Verifiable();
+
+            var httpClient = new HttpClient(handlerMock.Object)
+            {
+                BaseAddress = new Uri(_config.BaseUrl),
+                Timeout = TimeSpan.FromSeconds(_config.Timeout),
+            };
+            var sut = new CompanyDetailsApiClient(httpClient, NullLogger<CompanyDetailsApiClient>.Instance);
+
+            // Act
+            Func<Task> act = () => sut.GetSubsidiaryDetails(new SubsidiaryDetailsRequest());
+
+            // Assert
+            await act.Should().ThrowAsync<Exception>();
+        }
+
+        [TestMethod]
+        public async Task GetSubsidiaryDetails_ShouldReturnDefault_WhenResponseContentIsEmpty()
+        {
+            // Arrange
+            var request = new SubsidiaryDetailsRequest();
+            var handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
+            handlerMock
+                .Protected()
+                .Setup<Task<HttpResponseMessage>>(
+                    "SendAsync",
+                    ItExpr.IsAny<HttpRequestMessage>(),
+                    ItExpr.IsAny<CancellationToken>())
+                .ReturnsAsync(new HttpResponseMessage()
+                {
+                    StatusCode = HttpStatusCode.OK,
+                    Content = new StringContent(string.Empty), // Simulate empty content
+                })
+                .Verifiable();
+
+            var httpClient = new HttpClient(handlerMock.Object)
+            {
+                BaseAddress = new Uri(_config.BaseUrl),
+                Timeout = TimeSpan.FromSeconds(_config.Timeout),
+            };
+            var sut = new CompanyDetailsApiClient(httpClient, NullLogger<CompanyDetailsApiClient>.Instance);
+
+            // Act
+            var result = await sut.GetSubsidiaryDetails(request);
+
+            // Assert
+            result.Should().BeNull(); // Since default for reference type is null
+            handlerMock.Protected().Verify(
+                "SendAsync",
+                Times.Once(),
+                ItExpr.Is<HttpRequestMessage>(req =>
+                    req.Method == HttpMethod.Post &&
+                    req.RequestUri.ToString().EndsWith("api/subsidiary-details")),
+                ItExpr.IsAny<CancellationToken>());
+        }
+    }
+}

src/EPR.ProducerContentValidation.Application.UnitTests/Performance/ValidatorsPerformanceTests.cs

@@ -1,18 +1,22 @@
 using System.Diagnostics;
 using Bogus;
+using EPR.ProducerContentValidation.Application.Clients;
 using EPR.ProducerContentValidation.Application.Constants;
 using EPR.ProducerContentValidation.Application.Models;
 using EPR.ProducerContentValidation.Application.Options;
 using EPR.ProducerContentValidation.Application.Profiles;
 using EPR.ProducerContentValidation.Application.ReferenceData;
 using EPR.ProducerContentValidation.Application.Services;
+using EPR.ProducerContentValidation.Application.Services.Helpers.Interfaces;
 using EPR.ProducerContentValidation.Application.Services.Interfaces;
+using EPR.ProducerContentValidation.Application.Services.Subsidiary;
 using EPR.ProducerContentValidation.Application.Validators;
 using EPR.ProducerContentValidation.Application.Validators.Factories;
 using EPR.ProducerContentValidation.TestSupport;
 using FluentAssertions;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Microsoft.FeatureManagement;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
 
@@ -28,6 +32,11 @@ public ValidatorsPerformanceTests()
         Mock<IOptions<ValidationOptions>> validationOptionsMock = new();
         Mock<IIssueCountService> errorCountServiceMock = new();
         Mock<ILogger<ValidationService>> loggerMock = new();
+        Mock<IFeatureManager> featureManagerMock = new();
+        Mock<ISubsidiaryDetailsRequestBuilder> subsidiaryDetailsRequestBuilderMock = new();
+        Mock<ICompanyDetailsApiClient> companyDetailsApiClientMock = new();
+        Mock<IRequestValidator> requestValidatorMock = new();
+        Mock<IValidationServiceProducerRowValidator> validationServiceProducerRowValidatorMock = new();
 
         var submissionConfigOptions = new Mock<IOptions<List<SubmissionPeriodOption>>>();
 
@@ -54,7 +63,12 @@ public ValidatorsPerformanceTests()
             compositeValidatorUnderTest,
             AutoMapperHelpers.GetMapper<ProducerProfile>(),
             errorCountServiceMock.Object,
-            Microsoft.Extensions.Options.Options.Create(new StorageAccountOptions { PomContainer = "ContainerName" }));
+            Microsoft.Extensions.Options.Options.Create(new StorageAccountOptions { PomContainer = "ContainerName" }),
+            featureManagerMock.Object,
+            subsidiaryDetailsRequestBuilderMock.Object,
+            companyDetailsApiClientMock.Object,
+            requestValidatorMock.Object,
+            validationServiceProducerRowValidatorMock.Object);
     }
 
     [TestMethod]

src/EPR.ProducerContentValidation.Application.UnitTests/Services/Helpers/FindMatchingProducerTests.cs

@@ -0,0 +1,127 @@
+using EPR.ProducerContentValidation.Application.DTOs.SubmissionApi;
+using EPR.ProducerContentValidation.Application.Models;
+using EPR.ProducerContentValidation.Application.Services.Helpers;
+using EPR.ProducerContentValidation.Application.Services.Helpers.Interfaces;
+using EPR.ProducerContentValidation.Data.Models.Subsidiary;
+using EPR.ProducerContentValidation.TestSupport;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace EPR.ProducerContentValidation.Application.UnitTests.Services.Helpers
+{
+    [TestClass]
+    public class FindMatchingProducerTests
+    {
+        private readonly Mock<IOrganisationMatcher> _organisationMatcherMock;
+        private readonly Mock<ISubsidiaryMatcher> _subsidiaryMatcherMock;
+        private readonly Mock<ISubsidiaryValidationEvaluator> _subsidiaryValidationEvaluatorMock;
+        private readonly FindMatchingProducer _findMatchingProducer;
+
+        public FindMatchingProducerTests()
+        {
+            _organisationMatcherMock = new Mock<IOrganisationMatcher>();
+            _subsidiaryMatcherMock = new Mock<ISubsidiaryMatcher>();
+            _subsidiaryValidationEvaluatorMock = new Mock<ISubsidiaryValidationEvaluator>();
+
+            _findMatchingProducer = new FindMatchingProducer(
+                _organisationMatcherMock.Object,
+                _subsidiaryMatcherMock.Object,
+                _subsidiaryValidationEvaluatorMock.Object);
+        }
+
+        [TestMethod]
+        public void Match_NoMatchingOrganisation_ReturnsNull()
+        {
+            // Arrange
+            var row = ModelGenerator.CreateProducerRow(1);
+            var response = new SubsidiaryDetailsResponse();
+
+            _organisationMatcherMock
+                .Setup(m => m.FindMatchingOrganisation(row, response))
+                .Returns((SubsidiaryOrganisationDetail?)null);
+
+            // Act
+            var result = _findMatchingProducer.Match(row, response, 1);
+
+            // Assert
+            Assert.IsNull(result);
+            _organisationMatcherMock.Verify(m => m.FindMatchingOrganisation(row, response), Times.Once);
+            _subsidiaryMatcherMock.Verify(m => m.FindMatchingSubsidiary(It.IsAny<ProducerRow>(), It.IsAny<SubsidiaryOrganisationDetail>()), Times.Never);
+            _subsidiaryValidationEvaluatorMock.Verify(m => m.EvaluateSubsidiaryValidation(It.IsAny<ProducerRow>(), It.IsAny<SubsidiaryDetail>(), It.IsAny<int>()), Times.Never);
+        }
+
+        [TestMethod]
+        public void Match_NoMatchingSubsidiary_ReturnsNull()
+        {
+            // Arrange
+            var row = ModelGenerator.CreateProducerRow(1);
+            var response = new SubsidiaryDetailsResponse();
+            var matchingOrg = new SubsidiaryOrganisationDetail();
+
+            _organisationMatcherMock
+                .Setup(m => m.FindMatchingOrganisation(row, response))
+                .Returns(matchingOrg);
+
+            _subsidiaryMatcherMock
+                .Setup(m => m.FindMatchingSubsidiary(row, matchingOrg))
+                .Returns((SubsidiaryDetail?)null);
+
+            // Act
+            var result = _findMatchingProducer.Match(row, response, 1);
+
+            // Assert
+            Assert.IsNull(result);
+            _organisationMatcherMock.Verify(m => m.FindMatchingOrganisation(row, response), Times.Once);
+            _subsidiaryMatcherMock.Verify(m => m.FindMatchingSubsidiary(row, matchingOrg), Times.Once);
+            _subsidiaryValidationEvaluatorMock.Verify(m => m.EvaluateSubsidiaryValidation(It.IsAny<ProducerRow>(), It.IsAny<SubsidiaryDetail>(), It.IsAny<int>()), Times.Never);
+        }
+
+        [TestMethod]
+        public void Match_MatchingOrganisationAndSubsidiary_ReturnsValidationResult()
+        {
+            // Arrange
+            var row = ModelGenerator.CreateProducerRow(1);
+            var response = new SubsidiaryDetailsResponse();
+            var matchingOrg = new SubsidiaryOrganisationDetail();
+            var matchingSub = new SubsidiaryDetail();
+            var expectedValidationResult = new ProducerValidationEventIssueRequest(
+                                                    SubsidiaryId: "S123",
+                                                    DataSubmissionPeriod: "2024-Q1",
+                                                    RowNumber: 1,
+                                                    ProducerId: "P456",
+                                                    ProducerType: "Large",
+                                                    ProducerSize: "Large",
+                                                    WasteType: "Plastic",
+                                                    PackagingCategory: "Containers",
+                                                    MaterialType: "Polyethylene",
+                                                    MaterialSubType: "High-Density",
+                                                    FromHomeNation: "UK",
+                                                    ToHomeNation: "Germany",
+                                                    QuantityKg: "100",
+                                                    QuantityUnits: "200",
+                                                    BlobName: "ExampleBlobName",
+                                                    ErrorCodes: new List<string> { "E001", "E002" });
+
+            _organisationMatcherMock
+                .Setup(m => m.FindMatchingOrganisation(row, response))
+                .Returns(matchingOrg);
+
+            _subsidiaryMatcherMock
+                .Setup(m => m.FindMatchingSubsidiary(row, matchingOrg))
+                .Returns(matchingSub);
+
+            _subsidiaryValidationEvaluatorMock
+                .Setup(m => m.EvaluateSubsidiaryValidation(row, matchingSub, 1))
+                .Returns(expectedValidationResult);
+
+            // Act
+            var result = _findMatchingProducer.Match(row, response, 1);
+
+            // Assert
+            Assert.AreEqual(expectedValidationResult, result);
+            _organisationMatcherMock.Verify(m => m.FindMatchingOrganisation(row, response), Times.Once);
+            _subsidiaryMatcherMock.Verify(m => m.FindMatchingSubsidiary(row, matchingOrg), Times.Once);
+            _subsidiaryValidationEvaluatorMock.Verify(m => m.EvaluateSubsidiaryValidation(row, matchingSub, 1), Times.Once);
+        }
+    }
+}