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.Application.Config;
+using EPR.ProducerContentValidation.Application.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/Data/CompanyDetailsDataItemTests.cs

@@ -0,0 +1,83 @@
+using EPR.ProducerContentValidation.Application.Models.CompanyDetailsApi;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+
+namespace EPR.ProducerContentValidation.Application.UnitTests
+{
+    [TestClass]
+    public class CompanyDetailsDataItemTests
+    {
+        [TestMethod]
+        public void SerializeCompanyDetailsDataItem_ToJson_ContainsCorrectJsonPropertyNames()
+        {
+            // Arrange
+            var companyDetails = new CompanyDetailsDataItem
+            {
+                ReferenceNumber = "REF123",
+                CompaniesHouseNumber = "CHN456"
+            };
+
+            // Act
+            var json = JsonConvert.SerializeObject(companyDetails);
+
+            // Assert
+            json.Should().Contain("\"RN\":\"REF123\"")
+                .And.Contain("\"CHN\":\"CHN456\"");
+        }
+
+        [TestMethod]
+        public void DeserializeCompanyDetailsDataItem_FromJson_HasCorrectPropertyValues()
+        {
+            // Arrange
+            var json = "{\"RN\":\"REF123\", \"CHN\":\"CHN456\"}";
+
+            // Act
+            var companyDetails = JsonConvert.DeserializeObject<CompanyDetailsDataItem>(json);
+
+            // Assert
+            companyDetails.Should().NotBeNull();
+            companyDetails!.ReferenceNumber.Should().Be("REF123");
+            companyDetails.CompaniesHouseNumber.Should().Be("CHN456");
+        }
+
+        [TestMethod]
+        public void SerializeCompanyDetailsDataItem_NullValues_HasNullJsonProperties()
+        {
+            // Arrange
+            var companyDetails = new CompanyDetailsDataItem
+            {
+                ReferenceNumber = null,
+                CompaniesHouseNumber = null
+            };
+
+            // Act
+            var json = JsonConvert.SerializeObject(companyDetails);
+
+            // Assert
+            json.Should().Contain("\"RN\":null")
+                .And.Contain("\"CHN\":null");
+        }
+
+        [TestMethod]
+        public void DeserializeCompanyDetailsDataItem_NullOrMissingValues_PropertiesAreNull()
+        {
+            // Arrange
+            var jsonWithNulls = "{\"RN\":null, \"CHN\":null}";
+            var jsonWithoutKeys = "{}";
+
+            // Act
+            var companyDetailsWithNulls = JsonConvert.DeserializeObject<CompanyDetailsDataItem>(jsonWithNulls);
+            var companyDetailsWithoutKeys = JsonConvert.DeserializeObject<CompanyDetailsDataItem>(jsonWithoutKeys);
+
+            // Assert
+            companyDetailsWithNulls.Should().NotBeNull();
+            companyDetailsWithNulls!.ReferenceNumber.Should().BeNull();
+            companyDetailsWithNulls.CompaniesHouseNumber.Should().BeNull();
+
+            companyDetailsWithoutKeys.Should().NotBeNull();
+            companyDetailsWithoutKeys!.ReferenceNumber.Should().BeNull();
+            companyDetailsWithoutKeys.CompaniesHouseNumber.Should().BeNull();
+        }
+    }
+}

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]