Merge pull request #21 from hellofresh/patch/golang-mock

 Replace Mockery with Mock

Author: boekkooi-fresh

Gopkg.lock

@@ -1,5 +1,5 @@
 required = [
-  "github.com/vektra/mockery/cmd/mockery"
+  "github.com/golang/mock/mockgen"
 ]
 
 [[override]]
@@ -14,6 +14,10 @@ required = [
   name = "github.com/stretchr/testify"
   version = "^1.2.2"
 
+[[constraint]]
+  name = "github.com/golang/mock"
+  version = "^1.2.0"
+
 [[constraint]]
   name = "github.com/sirupsen/logrus"
   version = "^1.0.6"

Gopkg.toml

@@ -5,10 +5,11 @@ package aggregate_test
 import (
 	"testing"
 
+	"github.com/golang/mock/gomock"
+
 	"github.com/hellofresh/goengine/aggregate"
-	"github.com/hellofresh/goengine/mocks"
+	mocks "github.com/hellofresh/goengine/mocks/aggregate"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 )
 
 func TestGenerateID(t *testing.T) {
@@ -86,28 +87,26 @@ func TestIDFromString(t *testing.T) {
 
 func TestRecordChange(t *testing.T) {
 	t.Run("A change is recorded", func(t *testing.T) {
+		asserts := assert.New(t)
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
 		rootID := aggregate.GenerateID()
 		domainEvent := struct{}{}
 
-		root := &mocks.AggregateRoot{}
-		root.On("AggregateID").Return(rootID)
-		root.On("Apply", mock.AnythingOfType("*aggregate.Changed"))
+		root := mocks.NewRoot(ctrl)
+		root.EXPECT().AggregateID().Return(rootID)
+		root.EXPECT().Apply(gomock.AssignableToTypeOf(&aggregate.Changed{})).Do(func(msg *aggregate.Changed) {
+			asserts.Equal(rootID, msg.AggregateID())
+			asserts.Equal(domainEvent, msg.Payload())
+			asserts.Equal(uint(1), msg.Version())
+		}).Times(1)
 
 		// Record the change
 		err := aggregate.RecordChange(root, domainEvent)
 
 		// Check that the change was recorded
-		asserts := assert.New(t)
 		asserts.Empty(err, "No error should be returned")
-
-		root.AssertExpectations(t)
-		calls := mocks.FetchFuncCalls(root.Calls, "Apply")
-		if asserts.Len(calls, 1) {
-			msg := calls[0].Arguments[0].(*aggregate.Changed)
-			asserts.Equal(rootID, msg.AggregateID())
-			asserts.Equal(domainEvent, msg.Payload())
-			asserts.Equal(uint(1), msg.Version())
-		}
 	})
 
 	t.Run("Check required arguments", func(t *testing.T) {
@@ -133,17 +132,17 @@ func TestRecordChange(t *testing.T) {
 
 		for _, testCase := range errorTestCases {
 			t.Run(testCase.title, func(t *testing.T) {
-				root := &mocks.AggregateRoot{}
-				root.On("AggregateID").Return(testCase.aggregateID)
-				root.On("Apply", mock.AnythingOfType("*aggregate.Changed"))
+				ctrl := gomock.NewController(t)
+				defer ctrl.Finish()
+
+				root := mocks.NewRoot(ctrl)
+				root.EXPECT().AggregateID().Return(testCase.aggregateID)
 
 				// Record the change
 				err := aggregate.RecordChange(root, testCase.domainEvent)
 
 				// Check error
-				asserts := assert.New(t)
-				asserts.Equal(testCase.expectedError, err)
-				root.AssertNotCalled(t, "Apply", mock.Anything)
+				assert.Equal(t, testCase.expectedError, err)
 			})
 		}
 	})

aggregate/aggregate_test.go

@@ -7,18 +7,16 @@ import (
 
 	"github.com/hellofresh/goengine"
 	"github.com/hellofresh/goengine/aggregate"
-	"github.com/hellofresh/goengine/mocks"
+	mocks "github.com/hellofresh/goengine/mocks/aggregate"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestType(t *testing.T) {
 	mockInitiator := func() aggregate.Root {
-		return &mocks.AggregateRoot{}
+		return &mocks.Root{}
 	}
 
 	t.Run("Create a new type", func(t *testing.T) {
-		t.Parallel()
-
 		aggregateType, err := aggregate.NewType("mock", mockInitiator)
 
 		asserts := assert.New(t)
@@ -28,7 +26,7 @@ func TestType(t *testing.T) {
 		asserts.NotEmpty(aggregateType, "A aggregate.Type should be returned")
 		asserts.Equal("mock", aggregateType.String(), "Expected name to be set")
 		asserts.True(
-			aggregateType.IsImplementedBy(&mocks.AggregateRoot{}),
+			aggregateType.IsImplementedBy(&mocks.Root{}),
 			"Expected the same aggregate type to be valid",
 		)
 
@@ -38,11 +36,11 @@ func TestType(t *testing.T) {
 		}{
 			{
 				title: "another aggregate is not of this type",
-				value: &mocks.AnotherAggregateRoot{},
+				value: &mocks.AnotherRoot{},
 			},
 			{
 				title: "not a reference is not of this type",
-				value: mocks.AggregateRoot{},
+				value: mocks.Root{},
 			},
 			{
 				title: "nil is not of this type",
@@ -98,7 +96,7 @@ func TestType(t *testing.T) {
 				expectedError: aggregate.ErrInitiatorMustReturnRoot,
 				name:          "init",
 				initiator: func() aggregate.Root {
-					return (*mocks.AggregateRoot)(nil)
+					return (*mocks.Root)(nil)
 				},
 			},
 		}