Skip to content

Commit 1c94b4d

Browse files
boekkooi-freshboekkooi-fresh
committed
Use assert for the test and require for requirements
In order to remove some code and add some consistency we now use assert to assert the results of the actual tests. require is no used for any required parts of the tests.
1 parent a6890b3 commit 1c94b4d

15 files changed

+163
-297
lines changed

‎aggregate/aggregate_test.go‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -49,9 +49,8 @@ func TestIDFromString(t *testing.T) {
4949
t.Run(testCase.title, func(t *testing.T) {
5050
id, err := aggregate.IDFromString(testCase.input)
5151

52-
asserts := assert.New(t)
53-
asserts.Nil(err)
54-
asserts.Equal(testCase.output, id)
52+
assert.NoError(t, err)
53+
assert.Equal(t, testCase.output, id)
5554
})
5655
}
5756
})
@@ -106,7 +105,7 @@ func TestRecordChange(t *testing.T) {
106105
err := aggregate.RecordChange(root, domainEvent)
107106

108107
// Check that the change was recorded
109-
asserts.Empty(err, "No error should be returned")
108+
asserts.NoError(err)
110109
})
111110

112111
t.Run("Check required arguments", func(t *testing.T) {

‎aggregate/aggregate_type_test.go‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ func TestType(t *testing.T) {
2020
aggregateType, err := aggregate.NewType("mock", mockInitiator)
2121

2222
asserts := assert.New(t)
23-
if !asserts.Empty(err, "No error should be returned") {
23+
if !asserts.NoError(err, "No error should be returned") {
2424
return
2525
}
2626
asserts.NotEmpty(aggregateType, "A aggregate.Type should be returned")
@@ -61,9 +61,9 @@ func TestType(t *testing.T) {
6161
t.Run("CreateInstance", func(t *testing.T) {
6262
newInstance := aggregateType.CreateInstance()
6363

64-
asserts := assert.New(t)
65-
asserts.NotNil(newInstance, "Expect the instance to not be empty")
66-
asserts.True(
64+
assert.NotNil(t, newInstance, "Expect the instance to not be empty")
65+
assert.True(
66+
t,
6767
aggregateType.IsImplementedBy(newInstance),
6868
"Expected new instance of it's type",
6969
)

‎aggregate/repository_test.go‎

Lines changed: 11 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -9,15 +9,14 @@ import (
99
"time"
1010

1111
"github.com/golang/mock/gomock"
12-
"github.com/stretchr/testify/require"
13-
1412
"github.com/hellofresh/goengine"
1513
"github.com/hellofresh/goengine/aggregate"
1614
"github.com/hellofresh/goengine/driver/inmemory"
1715
"github.com/hellofresh/goengine/metadata"
1816
"github.com/hellofresh/goengine/mocks"
1917
aggregateMocks "github.com/hellofresh/goengine/mocks/aggregate"
2018
"github.com/stretchr/testify/assert"
19+
"github.com/stretchr/testify/require"
2120
)
2221

2322
func TestNewRepository(t *testing.T) {
@@ -32,9 +31,8 @@ func TestNewRepository(t *testing.T) {
3231
aggregateType,
3332
)
3433

35-
asserts := assert.New(t)
36-
asserts.NotNil(repo, "Expected a repository to be returned")
37-
asserts.Nil(err, "Expected no error")
34+
assert.NotNil(t, repo, "Expected a repository to be returned")
35+
assert.NoError(t, err)
3836
})
3937

4038
t.Run("invalid arguments", func(t *testing.T) {
@@ -123,7 +121,7 @@ func TestRepository_SaveAggregateRoot(t *testing.T) {
123121
}
124122
err := repo.SaveAggregateRoot(context.Background(), root)
125123

126-
asserts.Nil(err, "Expect no error")
124+
asserts.NoError(err)
127125
})
128126

129127
t.Run("store nothing when there are no pending events", func(t *testing.T) {
@@ -151,7 +149,6 @@ func TestRepository_SaveAggregateRoot(t *testing.T) {
151149

152150
func TestRepository_GetAggregateRoot(t *testing.T) {
153151
t.Run("load and reconstitute a AggregateRoot", func(t *testing.T) {
154-
asserts := assert.New(t)
155152
ctrl := gomock.NewController(t)
156153
defer ctrl.Finish()
157154

@@ -175,9 +172,7 @@ func TestRepository_GetAggregateRoot(t *testing.T) {
175172
2,
176173
)
177174
messageStream, err := inmemory.NewEventStream([]goengine.Message{firstEvent, secondEvent}, []int64{1, 2})
178-
if !asserts.NoError(err) {
179-
return
180-
}
175+
require.NoError(t, err)
181176

182177
store := mocks.NewEventStore(ctrl)
183178
aggregateTypeCalls := 0
@@ -192,7 +187,7 @@ func TestRepository_GetAggregateRoot(t *testing.T) {
192187
root.EXPECT().Apply(secondEvent),
193188
)
194189
default:
195-
asserts.Fail("unexpected type creation")
190+
t.Error("unexpected type creation")
196191
}
197192
aggregateTypeCalls++
198193
return root
@@ -225,8 +220,8 @@ func TestRepository_GetAggregateRoot(t *testing.T) {
225220
// Get/Load the aggregate
226221
root, err := repo.GetAggregateRoot(ctx, rootID)
227222

228-
asserts.NoError(err)
229-
asserts.NotNil(root, "Expected a aggregate root")
223+
assert.NoError(t, err)
224+
assert.NotNil(t, root, "Expected a aggregate root")
230225
})
231226

232227
t.Run("load failures", func(t *testing.T) {
@@ -260,17 +255,14 @@ func TestRepository_GetAggregateRoot(t *testing.T) {
260255

261256
for _, testCase := range badTestCases {
262257
t.Run(testCase.title, func(t *testing.T) {
263-
asserts := assert.New(t)
264258
ctrl := gomock.NewController(t)
265259
defer ctrl.Finish()
266260

267261
ctx := context.Background()
268262
rootID := aggregate.GenerateID()
269263

270264
stream, err := inmemory.NewEventStream(testCase.storeMessages, make([]int64, len(testCase.storeMessages)))
271-
if !asserts.NoError(err) {
272-
return
273-
}
265+
require.NoError(t, err)
274266

275267
repo, store := mockRepository(ctrl)
276268
store.EXPECT().Load(
@@ -284,8 +276,8 @@ func TestRepository_GetAggregateRoot(t *testing.T) {
284276
// Get/Load the aggregate
285277
root, err := repo.GetAggregateRoot(ctx, rootID)
286278

287-
asserts.Equal(testCase.expectedError, err, "Expected error")
288-
asserts.Nil(root, "Expected no aggregate root")
279+
assert.Equal(t, testCase.expectedError, err, "Expected error")
280+
assert.Nil(t, root, "Expected no aggregate root")
289281
})
290282
}
291283
})

‎driver/generic/query_executor_test.go‎

Lines changed: 8 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -8,13 +8,13 @@ import (
88
"time"
99

1010
"github.com/golang/mock/gomock"
11-
1211
"github.com/hellofresh/goengine"
1312
"github.com/hellofresh/goengine/driver/generic"
1413
"github.com/hellofresh/goengine/driver/inmemory"
1514
"github.com/hellofresh/goengine/metadata"
1615
"github.com/hellofresh/goengine/mocks"
1716
"github.com/stretchr/testify/assert"
17+
"github.com/stretchr/testify/require"
1818
)
1919

2020
func TestNewQueryExecutor(t *testing.T) {
@@ -34,9 +34,8 @@ func TestNewQueryExecutor(t *testing.T) {
3434

3535
executor, err := generic.NewQueryExecutor(store, "test", registry, query, 100)
3636

37-
asserts := assert.New(t)
38-
asserts.NotNil(executor)
39-
asserts.NoError(err)
37+
assert.NotNil(t, executor)
38+
assert.NoError(t, err)
4039
})
4140

4241
t.Run("invalid arguments", func(t *testing.T) {
@@ -118,27 +117,22 @@ func TestQueryExecutor_Run(t *testing.T) {
118117
numbers: []int{1, 2, 3},
119118
}
120119

121-
asserts := assert.New(t)
122120
eventBatch1, err := inmemory.NewEventStream(
123121
[]goengine.Message{
124122
mockMessageWithPayload(myEvent{1}, map[string]interface{}{}),
125123
mockMessageWithPayload(mySecondEvent{2}, map[string]interface{}{}),
126124
},
127125
[]int64{1, 2},
128126
)
129-
if !asserts.NoError(err) {
130-
return
131-
}
127+
require.NoError(t, err)
132128

133129
eventBatch2, err := inmemory.NewEventStream(
134130
[]goengine.Message{
135131
mockMessageWithPayload(myEvent{3}, map[string]interface{}{}),
136132
},
137133
[]int64{3},
138134
)
139-
if !asserts.NoError(err) {
140-
return
141-
}
135+
require.NoError(t, err)
142136

143137
var streamName goengine.StreamName = "event_stream"
144138

@@ -181,14 +175,12 @@ func TestQueryExecutor_Run(t *testing.T) {
181175
}).MinTimes(1)
182176

183177
executor, err := generic.NewQueryExecutor(store, streamName, registry, query, queryBatchSize)
184-
if !asserts.NoError(err) {
185-
asserts.FailNow("failed to create executor")
186-
}
178+
require.NoError(t, err)
187179

188180
finalState, err := executor.Run(ctx)
189181

190-
asserts.Equal(expectedState, finalState)
191-
asserts.NoError(err)
182+
assert.Equal(t, expectedState, finalState)
183+
assert.NoError(t, err)
192184
})
193185
}
194186

‎driver/inmemory/eventstore_test.go‎

Lines changed: 21 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@ import (
1414
"github.com/hellofresh/goengine/mocks"
1515
"github.com/sirupsen/logrus/hooks/test"
1616
"github.com/stretchr/testify/assert"
17+
"github.com/stretchr/testify/require"
1718
)
1819

1920
func TestNewEventStore(t *testing.T) {
@@ -31,41 +32,39 @@ func TestNewEventStore(t *testing.T) {
3132
}
3233

3334
func TestEventStore_Create(t *testing.T) {
35+
ctx := context.Background()
3436
logger, loggerHooks := test.NewNullLogger()
3537
store := inmemory.NewEventStore(logrus.Wrap(logger))
3638

37-
ctx := context.Background()
3839
err := store.Create(ctx, "event_stream")
3940

40-
asserts := assert.New(t)
41-
asserts.Nil(err)
42-
asserts.Len(loggerHooks.Entries, 0)
41+
assert.Nil(t, err)
42+
assert.Len(t, loggerHooks.Entries, 0)
4343

4444
t.Run("Cannot create a stream twice", func(t *testing.T) {
4545
err := store.Create(ctx, "event_stream")
4646

47-
asserts := assert.New(t)
48-
asserts.Equal(inmemory.ErrStreamExistsAlready, err)
49-
asserts.Len(loggerHooks.Entries, 0)
47+
assert.Equal(t, inmemory.ErrStreamExistsAlready, err)
48+
assert.Len(t, loggerHooks.Entries, 0)
5049
})
5150
}
5251

5352
func TestEventStore_HasStream(t *testing.T) {
5453
createThisStream := goengine.StreamName("my_stream")
55-
unkownStream := goengine.StreamName("never_stream")
54+
unknownStream := goengine.StreamName("never_stream")
5655

5756
logger, loggerHooks := test.NewNullLogger()
5857
store := inmemory.NewEventStore(logrus.Wrap(logger))
5958
ctx := context.Background()
6059

6160
asserts := assert.New(t)
6261
asserts.False(store.HasStream(ctx, createThisStream))
63-
asserts.False(store.HasStream(ctx, unkownStream))
62+
asserts.False(store.HasStream(ctx, unknownStream))
6463

6564
err := store.Create(ctx, createThisStream)
6665
asserts.NoError(err)
6766
asserts.True(store.HasStream(ctx, createThisStream))
68-
asserts.False(store.HasStream(ctx, unkownStream))
67+
asserts.False(store.HasStream(ctx, unknownStream))
6968

7069
asserts.Len(loggerHooks.Entries, 0)
7170
}
@@ -156,27 +155,18 @@ func TestEventStore_Load(t *testing.T) {
156155
store := inmemory.NewEventStore(logrus.Wrap(logger))
157156

158157
for stream, events := range testStreams {
159-
if err := store.Create(ctx, stream); !assert.Nil(t, err) {
160-
t.FailNow()
161-
}
162-
163-
if err := store.AppendTo(ctx, stream, events); !assert.Nil(t, err) {
164-
t.FailNow()
165-
}
158+
require.NoError(t, store.Create(ctx, stream))
159+
require.NoError(t, store.AppendTo(ctx, stream, events))
166160
}
167161

168162
stream, err := store.Load(ctx, testCase.loadFrom, 1, testCase.loadCount, testCase.matcher)
169-
asserts := assert.New(t)
170-
if !asserts.Nil(err) {
171-
return
172-
}
163+
require.NoError(t, err)
173164
defer stream.Close()
174165

175166
messages, messageNumbers, err := goengine.ReadEventStream(stream)
176-
if !asserts.NoError(err) {
177-
asserts.FailNow("no exception was expected while reading the stream")
178-
}
179167

168+
asserts := assert.New(t)
169+
asserts.NoError(err)
180170
asserts.Equal(testCase.expectedEvents, messages)
181171
asserts.Equal(testCase.expectedNumbers, messageNumbers)
182172
asserts.Len(loggerHooks.Entries, 0)
@@ -232,9 +222,8 @@ func TestEventStore_AppendTo(t *testing.T) {
232222

233223
err := store.AppendTo(ctx, stream, nil)
234224

235-
asserts := assert.New(t)
236-
asserts.Equal(inmemory.ErrStreamNotFound, err)
237-
asserts.Len(loggerHooks.Entries, 0)
225+
assert.Equal(t, inmemory.ErrStreamNotFound, err)
226+
assert.Len(t, loggerHooks.Entries, 0)
238227
})
239228

240229
t.Run("Nil message", func(t *testing.T) {
@@ -245,9 +234,8 @@ func TestEventStore_AppendTo(t *testing.T) {
245234

246235
err := store.AppendTo(ctx, stream, []goengine.Message{nil})
247236

248-
asserts := assert.New(t)
249-
asserts.Equal(inmemory.ErrNilMessage, err)
250-
asserts.Len(loggerHooks.Entries, 0)
237+
assert.Equal(t, inmemory.ErrNilMessage, err)
238+
assert.Len(t, loggerHooks.Entries, 0)
251239
})
252240

253241
t.Run("Nil message reference", func(t *testing.T) {
@@ -260,9 +248,8 @@ func TestEventStore_AppendTo(t *testing.T) {
260248
(*mocks.Message)(nil),
261249
})
262250

263-
asserts := assert.New(t)
264-
asserts.Equal(inmemory.ErrNilMessage, err)
265-
asserts.Len(loggerHooks.Entries, 0)
251+
assert.Equal(t, inmemory.ErrNilMessage, err)
252+
assert.Len(t, loggerHooks.Entries, 0)
266253
})
267254
})
268255
}
@@ -273,9 +260,7 @@ func createEventStoreWithStream(t *testing.T, name goengine.StreamName) (*inmemo
273260
store := inmemory.NewEventStore(logrus.Wrap(logger))
274261

275262
err := store.Create(ctx, name)
276-
if !assert.Nil(t, err) {
277-
t.FailNow()
278-
}
263+
require.NoError(t, err)
279264

280265
return store, loggerHooks
281266
}

0 commit comments

Comments
 (0)