TransactionProcessing · StuartFerguson · Jan 28, 2020 · Jan 28, 2020
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/TransactionDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/TransactionDomainServiceTests.cs
@@ -47,6 +47,7 @@ public async Task TransactionDomainService_ProcessLogonTransaction_TransactionIs
             Mock<ISecurityServiceClient> securityServiceClient = new Mock<ISecurityServiceClient>();
 
             securityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.TokenResponse);
+            estateClient.Setup(e => e.GetEstate(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEstateResponse);
             estateClient.Setup(e => e.GetMerchant(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                         .ReturnsAsync(TestData.GetMerchantResponse);
 
@@ -89,6 +90,7 @@ public async Task TransactionDomainService_ProcessLogonTransaction_MerchantWithN
             Mock<ISecurityServiceClient> securityServiceClient = new Mock<ISecurityServiceClient>();
 
             securityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.TokenResponse);
+            estateClient.Setup(e => e.GetEstate(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEstateResponse);
             estateClient.Setup(e => e.GetMerchant(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                         .ReturnsAsync(TestData.GetMerchantResponseWithNullDevices);
 
@@ -131,6 +133,7 @@ public async Task TransactionDomainService_ProcessLogonTransaction_MerchantWithN
             Mock<ISecurityServiceClient> securityServiceClient = new Mock<ISecurityServiceClient>();
 
             securityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.TokenResponse);
+            estateClient.Setup(e => e.GetEstate(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEstateResponse);
             estateClient.Setup(e => e.GetMerchant(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                         .ReturnsAsync(TestData.GetMerchantResponseWithNoDevices);
 
@@ -173,6 +176,7 @@ public async Task TransactionDomainService_ProcessLogonTransaction_IncorrectDevi
             Mock<ISecurityServiceClient> securityServiceClient = new Mock<ISecurityServiceClient>();
 
             securityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.TokenResponse);
+            estateClient.Setup(e => e.GetEstate(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEstateResponse);
             estateClient.Setup(e => e.GetMerchant(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                         .ReturnsAsync(TestData.GetMerchantResponse);
 
@@ -192,7 +196,48 @@ public async Task TransactionDomainService_ProcessLogonTransaction_IncorrectDevi
             response.ResponseMessage.ShouldBe(TestData.ResponseMessage);
         }
 
-        // Txn for a Different Device (Causes a Validation Exception)
+        [Fact]
+        public async Task TransactionDomainService_ProcessLogonTransaction_InvlaidEstate_TransactionIsProcessed()
+        {
+            IConfigurationRoot configurationRoot = new ConfigurationBuilder().AddInMemoryCollection(TestData.DefaultAppSettings).Build();
+            ConfigurationReader.Initialise(configurationRoot);
+
+            Logger.Initialise(NullLogger.Instance);
+
+            Mock<IAggregateRepositoryManager> aggregateRepositoryManager = new Mock<IAggregateRepositoryManager>();
+            Mock<IAggregateRepository<TransactionAggregate>> transactionAggregateRepository = new Mock<IAggregateRepository<TransactionAggregate>>();
+
+            aggregateRepositoryManager.Setup(x => x.GetAggregateRepository<TransactionAggregate>(It.IsAny<Guid>())).Returns(transactionAggregateRepository.Object);
+            transactionAggregateRepository.SetupSequence(t => t.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+                                          .ReturnsAsync(TestData.GetEmptyTransactionAggregate)
+                                          .ReturnsAsync(TestData.GetStartedTransactionAggregate)
+                                          .ReturnsAsync(TestData.GetLocallyAuthorisedTransactionAggregate)
+                                          .ReturnsAsync(TestData.GetCompletedTransactionAggregate);
+            transactionAggregateRepository.Setup(t => t.SaveChanges(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).Returns(Task.CompletedTask);
+
+            Mock<IEstateClient> estateClient = new Mock<IEstateClient>();
+            Mock<ISecurityServiceClient> securityServiceClient = new Mock<ISecurityServiceClient>();
+
+            securityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.TokenResponse);
+            estateClient.Setup(e => e.GetEstate(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEmptyEstateResponse);
+            estateClient.Setup(e => e.GetMerchant(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+                        .ReturnsAsync(TestData.GetMerchantResponse);
+
+            TransactionDomainService transactionDomainService =
+                new TransactionDomainService(aggregateRepositoryManager.Object, estateClient.Object, securityServiceClient.Object);
+
+            ProcessLogonTransactionResponse response = await transactionDomainService.ProcessLogonTransaction(TestData.TransactionId,
+                                                                                                              TestData.EstateId,
+                                                                                                              TestData.MerchantId,
+                                                                                                              TestData.TransactionDateTime,
+                                                                                                              TestData.TransactionNumber,
+                                                                                                              TestData.DeviceIdentifier1,
+                                                                                                              CancellationToken.None);
+
+            response.ShouldNotBeNull();
+            response.ResponseCode.ShouldBe(TestData.ResponseCode);
+            response.ResponseMessage.ShouldBe(TestData.ResponseMessage);
+        }
 
     }
 }
diff --git a/TransactionProcessor.BusinessLogic/Services/TransactionDomainService.cs b/TransactionProcessor.BusinessLogic/Services/TransactionDomainService.cs
@@ -147,6 +147,21 @@ public async Task<ProcessLogonTransactionResponse> ProcessLogonTransaction(Guid
                 TokenResponse token = await this.SecurityServiceClient.GetToken(clientId, clientSecret, cancellationToken);
                 Logger.LogInformation($"Token is {token.AccessToken}");
 
+                // Validate the Estate Record is a valid estate
+                var estate = await this.EstateClient.GetEstate(token.AccessToken, estateId, cancellationToken);
+
+                // TODO: Remove this once GetEstate returns correct response when estate not found
+                if (estate.EstateName == null)
+                {
+
+
+
+
+
+
+                    throw new TransactionValidationException($"Estate Id [{estateId}] is not a valid estate", TransactionResponseCode.InvalidEstateId);
+                }
+
                 // get the merchant record and validate the device
                 // TODO: Token
                 MerchantResponse merchant = await this.EstateClient.GetMerchant(token.AccessToken, estateId, merchantId, cancellationToken);
@@ -187,10 +202,4 @@ await this.EstateClient.AddDeviceToMerchant(token.AccessToken,
 
         #endregion
     }
-
-    public enum TransactionResponseCode
-    {
-        Success = 0,
-        InvalidDeviceIdentifier = 1000
-    }
 }
diff --git a/TransactionProcessor.BusinessLogic/Services/TransactionResponseCode.cs b/TransactionProcessor.BusinessLogic/Services/TransactionResponseCode.cs
@@ -0,0 +1,10 @@
+namespace TransactionProcessor.BusinessLogic.Services
+{
+    public enum TransactionResponseCode
+    {
+        Success = 0,
+
+        InvalidDeviceIdentifier = 1000,
+        InvalidEstateId = 1001
+    }
+}
diff --git a/TransactionProcessor.IntegrationTests/Common/TestingContext.cs b/TransactionProcessor.IntegrationTests/Common/TestingContext.cs
@@ -56,14 +56,22 @@ public TestingContext()
         public EstateDetails GetEstateDetails(TableRow tableRow)
         {
             String estateName = SpecflowTableHelper.GetStringRowValue(tableRow, "EstateName");
+            EstateDetails estateDetails = null;
+
+            estateDetails = this.Estates.SingleOrDefault(e => e.EstateName == estateName);
 
-            EstateDetails estateDetails = this.Estates.SingleOrDefault(e => e.EstateName == estateName);
+            if (estateDetails == null && estateName == "InvalidEstate")
+            {
+                estateDetails = EstateDetails.Create(Guid.Parse("79902550-64DF-4491-B0C1-4E78943928A3"), estateName);
+                estateDetails.AddMerchant(Guid.Parse("36AA0109-E2E3-4049-9575-F507A887BB1F"), "Test Merchant 1");
+                this.Estates.Add(estateDetails);
+            }
 
             estateDetails.ShouldNotBeNull();
 
             return estateDetails;
         }
-        
+
         public EstateDetails GetEstateDetails(String estateName)
         {
             EstateDetails estateDetails = this.Estates.SingleOrDefault(e => e.EstateName == estateName);

diff --git a/TransactionProcessor.IntegrationTests/LogonTransaction/LogonTransaction.feature b/TransactionProcessor.IntegrationTests/LogonTransaction/LogonTransaction.feature
@@ -78,3 +78,18 @@ Scenario: Logon Transaction with Invalid Device
 	Then transaction response should contain the following information
 	| EstateName    | MerchantName    | TransactionNumber | ResponseCode | ResponseMessage                                                    |
 	| Test Estate 1 | Test Merchant 1 | 1                 | 1000         | Device Identifier 123456781 not valid for Merchant Test Merchant 1 |
+
+Scenario: Logon Transaction with Invalid Estate
+
+	Given I have assigned the following devices to the merchants
+	| DeviceIdentifier | MerchantName    | MerchantNumber | EstateName    |
+	| 123456780        | Test Merchant 1 | 00000001       | Test Estate 1 |
+
+	When I perform the following transactions
+	| DateTime | TransactionNumber | TransactionType | MerchantName    | DeviceIdentifier | EstateName    |
+	| Today    | 1                 | Logon           | Test Merchant 1 | 123456781        | InvalidEstate |
+
+	Then transaction response should contain the following information
+	| EstateName    | MerchantName    | TransactionNumber | ResponseCode | ResponseMessage                                                        |
+	| InvalidEstate | Test Merchant 1 | 1                 | 1001         | Estate Id [79902550-64df-4491-b0c1-4e78943928a3] is not a valid estate |
+
diff --git a/TransactionProcessor.IntegrationTests/LogonTransaction/LogonTransaction.feature.cs b/TransactionProcessor.IntegrationTests/LogonTransaction/LogonTransaction.feature.cs
diff --git a/TransactionProcessor.Testing/TestData.cs b/TransactionProcessor.Testing/TestData.cs
@@ -126,5 +126,19 @@ public static TokenResponse TokenResponse()
                                                                                 MerchantId = TestData.MerchantId,
                                                                                 Devices = new Dictionary<Guid, String>()
                                                                             };
+
+        public static EstateResponse GetEmptyEstateResponse = new EstateResponse
+                                                              {
+                                                                  EstateName = null,
+                                                                  EstateId = TestData.EstateId
+                                                              };
+        public static String EstateName = "Test Estate 1";
+        public static EstateResponse GetEstateResponse = new EstateResponse
+                                                         {
+                                                             EstateName = TestData.EstateName,
+                                                             EstateId = TestData.EstateId
+                                                         };
+
+
     }
 }