Merge pull request #5 from TransactionProcessing/task/#1_testbankdepositcallbacks

StuartFerguson · web-flow · commit dfe4496cfec5 · 2021-10-22T15:01:26.000+01:00
Misssing reference in callback message event
diff --git a/CallbackHander.Testing/TestData.cs b/CallbackHander.Testing/TestData.cs
@@ -18,9 +18,11 @@ public class TestData
 
         public static String[] Destinations = new[] {"A", "B"};
 
+        public static String Reference = "TestRef";
+
         public static RecordCallbackRequest RecordCallbackRequest =>
             RecordCallbackRequest.Create(TestData.CallbackId, TestData.MessageFormat, TestData.TypeString,
-                                         TestData.CallbackMessage, TestData.Destinations);
+                                         TestData.CallbackMessage, TestData.Reference, TestData.Destinations);
 
         public static CallbackMessageAggregate EmptyCallbackMessageAggregate()
         {
diff --git a/CallbackHandler.BusinessLogic.Tests/Requests/RequestTests.cs b/CallbackHandler.BusinessLogic.Tests/Requests/RequestTests.cs
@@ -12,14 +12,16 @@ public class RequestTests
         public void RecordCallbackRequest_CanBeCreated_IsCreated()
         {
             RecordCallbackRequest recordCallbackRequest = RecordCallbackRequest.Create(TestData.CallbackId, TestData.MessageFormat, TestData.TypeString,
-                                                                                       TestData.CallbackMessage, TestData.Destinations);
+                                                                                       TestData.CallbackMessage, TestData.Reference,
+                                                                                       TestData.Destinations);
 
             recordCallbackRequest.ShouldNotBeNull();
             recordCallbackRequest.ShouldSatisfyAllConditions(
                                                              () => recordCallbackRequest.CallbackId.ShouldBe(TestData.CallbackId),
                                                              () => recordCallbackRequest.MessageFormat.ShouldBe((MessageFormat)TestData.MessageFormat),
                                                              () => recordCallbackRequest.TypeString.ShouldBe(TestData.TypeString),
                                                              () => recordCallbackRequest.CallbackMessage.ShouldBe(TestData.CallbackMessage),
+                                                             () => recordCallbackRequest.Reference.ShouldBe(TestData.Reference),
                                                              () => recordCallbackRequest.Destinations.ShouldBe(TestData.Destinations)
                                                             );
         }
diff --git a/CallbackHandler.BusinessLogic/RequestHandler/CallbackHandlerRequestHandler.cs b/CallbackHandler.BusinessLogic/RequestHandler/CallbackHandlerRequestHandler.cs
@@ -23,7 +23,7 @@ public async Task<Unit> Handle(RecordCallbackRequest request,
 
             CallbackMessageAggregate aggregate = await this.AggregateRepository.GetLatestVersion(request.CallbackId, cancellationToken);
 
-            aggregate.RecordCallback(request.TypeString, request.MessageFormat, request.CallbackMessage, request.Destinations);
+            aggregate.RecordCallback(request.TypeString, request.MessageFormat, request.CallbackMessage, request.Reference, request.Destinations);
 
             await this.AggregateRepository.SaveChanges(aggregate,cancellationToken);
             
diff --git a/CallbackHandler.BusinessLogic/Requests/RecordCallbackRequest.cs b/CallbackHandler.BusinessLogic/Requests/RecordCallbackRequest.cs
@@ -12,13 +12,15 @@ private RecordCallbackRequest(Guid callbackId,
                                       Int32 messageFormat,
                                       String typeString,
                                       String callbackMessage,
+                                      String reference,
                                       String[] destinations)
         {
             this.CallbackId = callbackId;
             this.MessageFormat = (MessageFormat)messageFormat;
             this.TypeString = typeString;
             this.CallbackMessage = callbackMessage;
             this.Destinations = destinations;
+            this.Reference = reference;
         }
 
         #endregion
@@ -35,6 +37,8 @@ private RecordCallbackRequest(Guid callbackId,
 
         public String TypeString { get; }
 
+        public String Reference { get; }
+
         #endregion
 
         #region Methods
@@ -43,9 +47,10 @@ public static RecordCallbackRequest Create(Guid callbackId,
                                                    Int32 messageFormat,
                                                    String typeString,
                                                    String callbackMessage,
+                                                   String reference,
                                                    String[] destinations)
         {
-            return new RecordCallbackRequest(callbackId, messageFormat, typeString, callbackMessage, destinations);
+            return new RecordCallbackRequest(callbackId, messageFormat, typeString, callbackMessage, reference, destinations);
         }
 
         #endregion
diff --git a/CallbackHandler.CallbackMessage.DomainEvents/CallbackReceivedEvent.cs b/CallbackHandler.CallbackMessage.DomainEvents/CallbackReceivedEvent.cs
@@ -8,18 +8,22 @@ public record CallbackReceivedEvent : DomainEventRecord.DomainEvent
         public CallbackReceivedEvent(Guid aggregateId, String typeString,
                                      Int32 messageFormat,
                                      String callbackMessage,
+                                     String reference,
                                      String destination) : base(aggregateId, Guid.NewGuid())
         {
             this.TypeString = typeString;
             this.MessageFormat = messageFormat;
             this.CallbackMessage = callbackMessage;
             this.Destination = destination;
+            this.Reference = reference;
         }
 
         public String TypeString { get; init; }
         public Int32 MessageFormat { get; init; }
         public String CallbackMessage { get; init; }
 
+        public String Reference { get; init; }
+
         public String Destination { get; init; }
     }
 }
diff --git a/CallbackHandler.CallbackMessageAggregate.Tests/CallbackMessageAggregateTests.cs b/CallbackHandler.CallbackMessageAggregate.Tests/CallbackMessageAggregateTests.cs
@@ -20,11 +20,12 @@ public void CallbackMessageAggregate_RecordCallback_CallbackIsRecorded()
         {
             CallbackMessageAggregate aggregate = CallbackMessageAggregate.Create(TestData.CallbackId);
 
-            aggregate.RecordCallback(TestData.TypeString, MessageFormat.JSON, TestData.CallbackMessage, TestData.Destinations);
+            aggregate.RecordCallback(TestData.TypeString, MessageFormat.JSON, TestData.CallbackMessage, TestData.Reference, TestData.Destinations);
 
             aggregate.ShouldSatisfyAllConditions(() => aggregate.CallbackMessage.ShouldBe(TestData.CallbackMessage),
                                                  () => aggregate.TypeString.ShouldBe(TestData.TypeString),
                                                  () => aggregate.MessageFormat.ShouldBe(MessageFormat.JSON),
+                                                 () => aggregate.Reference.ShouldBe(TestData.Reference),
                                                  () => aggregate.GetDestinations().ShouldNotBeEmpty(),
                                                  () => aggregate.GetDestinations().Length.ShouldBe(TestData.Destinations.Length));
         }
diff --git a/CallbackHandler.CallbackMessageAggregate.Tests/DomainEventTests.cs b/CallbackHandler.CallbackMessageAggregate.Tests/DomainEventTests.cs
@@ -11,12 +11,14 @@ public class DomainEventTests
         public void CallbackReceivedEvent_CanbeCreated_IsCreated()
         {
             CallbackReceivedEvent callbackReceivedEvent =
-                new CallbackReceivedEvent(TestData.CallbackId, TestData.TypeString, TestData.MessageFormat, TestData.CallbackMessage, TestData.Destinations[0]);
+                new CallbackReceivedEvent(TestData.CallbackId, TestData.TypeString, TestData.MessageFormat, 
+                                          TestData.CallbackMessage, TestData.Reference, TestData.Destinations[0]);
 
             callbackReceivedEvent.ShouldNotBeNull();
             callbackReceivedEvent.ShouldSatisfyAllConditions(() => callbackReceivedEvent.CallbackMessage.ShouldBe(TestData.CallbackMessage),
                                                              () => callbackReceivedEvent.TypeString.ShouldBe(TestData.TypeString),
                                                              () => callbackReceivedEvent.MessageFormat.ShouldBe(TestData.MessageFormat),
+                                                             () => callbackReceivedEvent.Reference.ShouldBe(TestData.Reference),
                                                              () => callbackReceivedEvent.Destination.ShouldBe(TestData.Destinations[0]));
         }
     }
diff --git a/CallbackHandler.CallbackMessageAggregate/CallbackMessageAggregate.cs b/CallbackHandler.CallbackMessageAggregate/CallbackMessageAggregate.cs
@@ -47,6 +47,8 @@ private CallbackMessageAggregate(Guid aggregateId)
 
         public String TypeString { get; private set; }
 
+        public String Reference { get; private set; }
+
         #endregion
 
         #region Methods
@@ -74,11 +76,12 @@ public override void PlayEvent(IDomainEvent domainEvent)
         public void RecordCallback(String typeString,
                                    MessageFormat messageFormat,
                                    String callbackMessage,
+                                   String reference,
                                    String[] destinations)
         {
             foreach (String destination in destinations)
             {
-                CallbackReceivedEvent callbackReceivedEvent = new CallbackReceivedEvent(this.AggregateId, typeString, (Int32)messageFormat, callbackMessage, destination);
+                CallbackReceivedEvent callbackReceivedEvent = new CallbackReceivedEvent(this.AggregateId, typeString, (Int32)messageFormat, callbackMessage, reference, destination);
                 this.ApplyAndAppend(callbackReceivedEvent);
             }
         }
@@ -95,6 +98,7 @@ private void PlayEvent(CallbackReceivedEvent domainEvent)
             this.MessageFormat = (MessageFormat)domainEvent.MessageFormat;
             this.TypeString = domainEvent.TypeString;
             this.Destinations.Add(domainEvent.Destination);
+            this.Reference = domainEvent.Reference;
         }
 
         #endregion
diff --git a/CallbackHandler/Controllers/CallbackController.cs b/CallbackHandler/Controllers/CallbackController.cs
@@ -41,6 +41,7 @@ public async Task<IActionResult> RecordCallback(Deposit depositCallback,
                                                                          1, // JSON
                                                                          depositCallback.GetType().ToString(),
                                                                          JsonConvert.SerializeObject(depositCallback),
+                                                                         depositCallback.Reference,
                                                                          new[] {"EstateManagement"});
 
             await this.Mediator.Send(request, cancellationToken);

Original file line number	Diff line number	Diff line change
`@@ -8,18 +8,22 @@ public record CallbackReceivedEvent : DomainEventRecord.DomainEvent`
`8`	`8`	`public CallbackReceivedEvent(Guid aggregateId, String typeString,`
`9`	`9`	`Int32 messageFormat,`
`10`	`10`	`String callbackMessage,`
	`11`	`+ String reference,`
`11`	`12`	`String destination) : base(aggregateId, Guid.NewGuid())`
`12`	`13`	`{`
`13`	`14`	`this.TypeString = typeString;`
`14`	`15`	`this.MessageFormat = messageFormat;`
`15`	`16`	`this.CallbackMessage = callbackMessage;`
`16`	`17`	`this.Destination = destination;`
	`18`	`+ this.Reference = reference;`
`17`	`19`	`}`
`18`	`20`
`19`	`21`	`public String TypeString { get; init; }`
`20`	`22`	`public Int32 MessageFormat { get; init; }`
`21`	`23`	`public String CallbackMessage { get; init; }`
`22`	`24`
	`25`	`+ public String Reference { get; init; }`
	`26`	`+`
`23`	`27`	`public String Destination { get; init; }`
`24`	`28`	`}`
`25`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,12 @@ public void CallbackMessageAggregate_RecordCallback_CallbackIsRecorded()`
`20`	`20`	`{`
`21`	`21`	`CallbackMessageAggregate aggregate = CallbackMessageAggregate.Create(TestData.CallbackId);`
`22`	`22`
`23`		`- aggregate.RecordCallback(TestData.TypeString, MessageFormat.JSON, TestData.CallbackMessage, TestData.Destinations);`
	`23`	`+ aggregate.RecordCallback(TestData.TypeString, MessageFormat.JSON, TestData.CallbackMessage, TestData.Reference, TestData.Destinations);`
`24`	`24`
`25`	`25`	`aggregate.ShouldSatisfyAllConditions(() => aggregate.CallbackMessage.ShouldBe(TestData.CallbackMessage),`
`26`	`26`	`() => aggregate.TypeString.ShouldBe(TestData.TypeString),`
`27`	`27`	`() => aggregate.MessageFormat.ShouldBe(MessageFormat.JSON),`
	`28`	`+ () => aggregate.Reference.ShouldBe(TestData.Reference),`
`28`	`29`	`() => aggregate.GetDestinations().ShouldNotBeEmpty(),`
`29`	`30`	`() => aggregate.GetDestinations().Length.ShouldBe(TestData.Destinations.Length));`
`30`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,14 @@ public class DomainEventTests`
`11`	`11`	`public void CallbackReceivedEvent_CanbeCreated_IsCreated()`
`12`	`12`	`{`
`13`	`13`	`CallbackReceivedEvent callbackReceivedEvent =`
`14`		`- new CallbackReceivedEvent(TestData.CallbackId, TestData.TypeString, TestData.MessageFormat, TestData.CallbackMessage, TestData.Destinations[0]);`
	`14`	`+ new CallbackReceivedEvent(TestData.CallbackId, TestData.TypeString, TestData.MessageFormat,`
	`15`	`+ TestData.CallbackMessage, TestData.Reference, TestData.Destinations[0]);`
`15`	`16`
`16`	`17`	`callbackReceivedEvent.ShouldNotBeNull();`
`17`	`18`	`callbackReceivedEvent.ShouldSatisfyAllConditions(() => callbackReceivedEvent.CallbackMessage.ShouldBe(TestData.CallbackMessage),`
`18`	`19`	`() => callbackReceivedEvent.TypeString.ShouldBe(TestData.TypeString),`
`19`	`20`	`() => callbackReceivedEvent.MessageFormat.ShouldBe(TestData.MessageFormat),`
	`21`	`+ () => callbackReceivedEvent.Reference.ShouldBe(TestData.Reference),`
`20`	`22`	`() => callbackReceivedEvent.Destination.ShouldBe(TestData.Destinations[0]));`
`21`	`23`	`}`
`22`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,8 @@ private CallbackMessageAggregate(Guid aggregateId)`
`47`	`47`
`48`	`48`	`public String TypeString { get; private set; }`
`49`	`49`
	`50`	`+ public String Reference { get; private set; }`
	`51`	`+`
`50`	`52`	`#endregion`
`51`	`53`
`52`	`54`	`#region Methods`
`@@ -74,11 +76,12 @@ public override void PlayEvent(IDomainEvent domainEvent)`
`74`	`76`	`public void RecordCallback(String typeString,`
`75`	`77`	`MessageFormat messageFormat,`
`76`	`78`	`String callbackMessage,`
	`79`	`+ String reference,`
`77`	`80`	`String[] destinations)`
`78`	`81`	`{`
`79`	`82`	`foreach (String destination in destinations)`
`80`	`83`	`{`
`81`		`- CallbackReceivedEvent callbackReceivedEvent = new CallbackReceivedEvent(this.AggregateId, typeString, (Int32)messageFormat, callbackMessage, destination);`
	`84`	`+ CallbackReceivedEvent callbackReceivedEvent = new CallbackReceivedEvent(this.AggregateId, typeString, (Int32)messageFormat, callbackMessage, reference, destination);`
`82`	`85`	`this.ApplyAndAppend(callbackReceivedEvent);`
`83`	`86`	`}`
`84`	`87`	`}`
`@@ -95,6 +98,7 @@ private void PlayEvent(CallbackReceivedEvent domainEvent)`
`95`	`98`	`this.MessageFormat = (MessageFormat)domainEvent.MessageFormat;`
`96`	`99`	`this.TypeString = domainEvent.TypeString;`
`97`	`100`	`this.Destinations.Add(domainEvent.Destination);`
	`101`	`+ this.Reference = domainEvent.Reference;`
`98`	`102`	`}`
`99`	`103`
`100`	`104`	`#endregion`