Skip to content

Commit 8ca50cd

Browse files
boekkooi-freshboekkooi-fresh
authored
Merge pull request #22 from hellofresh/patch/require-vs-assert
 Use assert for the test and require for requirements
2 parents 59b79e1 + 9a5a55e commit 8ca50cd

16 files changed

+164
-297
lines changed

‎.golangci.yml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
run:
22
build-tags:
33
- unit
4+
- integration
45
skip-files:
56
- driver/inmemory/matcher_gen.go
67

‎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)