Merge pull request #134 from dogmatiq/dogma-v0.9.0

Update to Dogma v0.9.0
dogmatiq · Nov 5, 2020 · 067f2d7 · 067f2d7
2 parents fecbfdd + 04461dd
commit 067f2d7
Show file tree

Hide file tree

Showing 11 changed files with 160 additions and 75 deletions.
diff --git a/assert/common_test.go b/assert/common_test.go
@@ -28,6 +28,7 @@ func newTestApp() (
 			return "<aggregate-instance>"
 		},
 		HandleCommandFunc: func(
+			_ dogma.AggregateRoot,
 			s dogma.AggregateCommandScope,
 			m dogma.Message,
 		) {

diff --git a/compare/comparator_test.go b/compare/comparator_test.go
@@ -1,6 +1,7 @@
 package compare_test
 
 import (
+	"github.com/dogmatiq/dogma"
 	. "github.com/dogmatiq/dogma/fixtures"
 	. "github.com/dogmatiq/testkit/compare"
 	. "github.com/onsi/ginkgo"
@@ -36,30 +37,50 @@ var _ = Describe("type DefaultComparator", func() {
 	})
 
 	Describe("func AggregateRootIsEqual()", func() {
-		It("returns true if tlues have the same type and value", func() {
+		It("returns true if the values have the same type and value", func() {
 			Expect(comparator.AggregateRootIsEqual(
-				&AggregateRoot{Value: "<foo>"},
-				&AggregateRoot{Value: "<foo>"},
+				&AggregateRoot{
+					AppliedEvents: []dogma.Message{
+						MessageA1,
+					},
+				},
+				&AggregateRoot{
+					AppliedEvents: []dogma.Message{
+						MessageA1,
+					},
+				},
 			)).To(BeTrue())
 		})
 
 		It("returns false if the values have the same type with different values", func() {
 			Expect(comparator.AggregateRootIsEqual(
-				&AggregateRoot{Value: "<foo>"},
-				&AggregateRoot{Value: "<bar>"},
+				&AggregateRoot{
+					AppliedEvents: []dogma.Message{
+						MessageA1,
+					},
+				},
+				&AggregateRoot{
+					AppliedEvents: []dogma.Message{
+						MessageA2,
+					},
+				},
 			)).To(BeFalse())
 		})
 
 		It("returns false if the values are different types", func() {
 			Expect(comparator.AggregateRootIsEqual(
-				&AggregateRoot{Value: "<foo>"},
+				&AggregateRoot{
+					AppliedEvents: []dogma.Message{
+						"<foo>",
+					},
+				},
 				&struct{ AggregateRoot }{},
 			)).To(BeFalse())
 		})
 	})
 
 	Describe("func ProcessRootIsEqual()", func() {
-		It("returns true if tlues have the same type and value", func() {
+		It("returns true if the values have the same type and value", func() {
 			Expect(comparator.ProcessRootIsEqual(
 				&ProcessRoot{Value: "<foo>"},
 				&ProcessRoot{Value: "<foo>"},

diff --git a/engine/controller/aggregate/controller.go b/engine/controller/aggregate/controller.go
@@ -144,7 +144,7 @@ func (c *Controller) Handle(
 		"HandleCommand",
 		env.Message,
 		func() {
-			handler.HandleCommand(s, env.Message)
+			handler.HandleCommand(r, s, env.Message)
 		},
 	)
 

diff --git a/engine/controller/aggregate/controller_test.go b/engine/controller/aggregate/controller_test.go
@@ -112,6 +112,7 @@ var _ = Describe("type Controller", func() {
 		It("forwards the message to the handler", func() {
 			called := false
 			handler.HandleCommandFunc = func(
+				_ dogma.AggregateRoot,
 				_ dogma.AggregateCommandScope,
 				m dogma.Message,
 			) {
@@ -132,6 +133,7 @@ var _ = Describe("type Controller", func() {
 
 		It("returns the recorded events", func() {
 			handler.HandleCommandFunc = func(
+				_ dogma.AggregateRoot,
 				s dogma.AggregateCommandScope,
 				_ dogma.Message,
 			) {
@@ -208,6 +210,25 @@ var _ = Describe("type Controller", func() {
 				))
 			})
 
+			It("passes a new aggregate root", func() {
+				handler.HandleCommandFunc = func(
+					r dogma.AggregateRoot,
+					s dogma.AggregateCommandScope,
+					_ dogma.Message,
+				) {
+					Expect(r).To(Equal(&AggregateRoot{}))
+				}
+
+				_, err := ctrl.Handle(
+					context.Background(),
+					fact.Ignore,
+					time.Now(),
+					command,
+				)
+
+				Expect(err).ShouldNot(HaveOccurred())
+			})
+
 			It("panics if New() returns nil", func() {
 				handler.NewFunc = func() dogma.AggregateRoot {
 					return nil
@@ -227,6 +248,7 @@ var _ = Describe("type Controller", func() {
 		When("the instance exists", func() {
 			BeforeEach(func() {
 				handler.HandleCommandFunc = func(
+					_ dogma.AggregateRoot,
 					s dogma.AggregateCommandScope,
 					_ dogma.Message,
 				) {
@@ -241,6 +263,8 @@ var _ = Describe("type Controller", func() {
 				)
 
 				Expect(err).ShouldNot(HaveOccurred())
+
+				handler.HandleCommandFunc = nil
 			})
 
 			It("records a fact", func() {
@@ -258,11 +282,40 @@ var _ = Describe("type Controller", func() {
 						HandlerName: "<name>",
 						Handler:     handler,
 						InstanceID:  "<instance-C1>",
-						Root:        &AggregateRoot{},
-						Envelope:    command,
+						Root: &AggregateRoot{
+							AppliedEvents: []dogma.Message{
+								MessageE1,
+							},
+						},
+						Envelope: command,
 					},
 				))
 			})
+
+			It("passes an aggregate root with historical events applied", func() {
+				handler.HandleCommandFunc = func(
+					r dogma.AggregateRoot,
+					s dogma.AggregateCommandScope,
+					_ dogma.Message,
+				) {
+					Expect(r).To(Equal(
+						&AggregateRoot{
+							AppliedEvents: []dogma.Message{
+								MessageE1,
+							},
+						},
+					))
+				}
+
+				_, err := ctrl.Handle(
+					context.Background(),
+					fact.Ignore,
+					time.Now(),
+					command,
+				)
+
+				Expect(err).ShouldNot(HaveOccurred())
+			})
 		})
 
 		It("provides more context to UnexpectedMessage panics from RouteCommandToInstance()", func() {
@@ -292,6 +345,7 @@ var _ = Describe("type Controller", func() {
 
 		It("provides more context to UnexpectedMessage panics from HandleCommand()", func() {
 			handler.HandleCommandFunc = func(
+				dogma.AggregateRoot,
 				dogma.AggregateCommandScope,
 				dogma.Message,
 			) {
@@ -320,6 +374,7 @@ var _ = Describe("type Controller", func() {
 
 		It("provides more context to UnexpectedMessage panics from ApplyEvent() when called with new events", func() {
 			handler.HandleCommandFunc = func(
+				_ dogma.AggregateRoot,
 				s dogma.AggregateCommandScope,
 				_ dogma.Message,
 			) {
@@ -328,7 +383,7 @@ var _ = Describe("type Controller", func() {
 
 			handler.NewFunc = func() dogma.AggregateRoot {
 				return &AggregateRoot{
-					ApplyEventFunc: func(dogma.Message, interface{}) {
+					ApplyEventFunc: func(dogma.Message) {
 						panic(dogma.UnexpectedMessage)
 					},
 				}
@@ -356,6 +411,7 @@ var _ = Describe("type Controller", func() {
 
 		It("provides more context to UnexpectedMessage panics from ApplyEvent() when called with historical events", func() {
 			handler.HandleCommandFunc = func(
+				_ dogma.AggregateRoot,
 				s dogma.AggregateCommandScope,
 				_ dogma.Message,
 			) {
@@ -372,7 +428,7 @@ var _ = Describe("type Controller", func() {
 			handler.HandleCommandFunc = nil
 			handler.NewFunc = func() dogma.AggregateRoot {
 				return &AggregateRoot{
-					ApplyEventFunc: func(dogma.Message, interface{}) {
+					ApplyEventFunc: func(dogma.Message) {
 						panic(dogma.UnexpectedMessage)
 					},
 				}
@@ -402,8 +458,9 @@ var _ = Describe("type Controller", func() {
 	Describe("func Reset()", func() {
 		BeforeEach(func() {
 			handler.HandleCommandFunc = func(
+				_ dogma.AggregateRoot,
 				s dogma.AggregateCommandScope,
-				m dogma.Message,
+				_ dogma.Message,
 			) {
 				s.RecordEvent(MessageE1) // record event to create the instance
 			}

diff --git a/engine/controller/aggregate/scope.go b/engine/controller/aggregate/scope.go
@@ -47,10 +47,6 @@ func (s *scope) Destroy() {
 	})
 }
 
-func (s *scope) Root() dogma.AggregateRoot {
-	return s.root
-}
-
 func (s *scope) RecordEvent(m dogma.Message) {
 	if !s.exists {
 		s.observer.Notify(fact.AggregateInstanceCreated{