Improve error handling

Do not ignore errors

Author: boekkooi-fresh

driver/inmemory/eventstore_test.go

@@ -61,7 +61,8 @@ func TestEventStore_HasStream(t *testing.T) {
 	asserts.False(store.HasStream(ctx, createThisStream))
 	asserts.False(store.HasStream(ctx, unkownStream))
 
-	store.Create(ctx, createThisStream)
+	err := store.Create(ctx, createThisStream)
+	asserts.NoError(err)
 	asserts.True(store.HasStream(ctx, createThisStream))
 	asserts.False(store.HasStream(ctx, unkownStream))
 

driver/inmemory/eventstream_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/hellofresh/goengine/driver/inmemory"
 	"github.com/hellofresh/goengine/mocks"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestEventStream(t *testing.T) {
@@ -44,15 +45,12 @@ func TestEventStream(t *testing.T) {
 			asserts := assert.New(t)
 
 			stream, err := inmemory.NewEventStream(testCase.messages, testCase.messageNumbers)
-			if !asserts.NoError(err) {
-				return
-			}
+			require.NoError(t, err)
 			asserts.NotNil(stream)
 
 			messages, messageNumbers, err := goengine.ReadEventStream(stream)
-			if !asserts.NoError(stream.Err()) {
-				asserts.FailNow("no exception was expected while reading the stream")
-			}
+			require.NoError(t, err)
+			require.NoError(t, stream.Err(), "no exception was expected while reading the stream")
 
 			asserts.Equal(testCase.messages, messages)
 			asserts.Equal(testCase.messageNumbers, messageNumbers)

driver/sql/postgres/eventstore_test.go

@@ -21,6 +21,7 @@ import (
 	strategyPostgres "github.com/hellofresh/goengine/strategy/json/sql/postgres"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewEventStore(t *testing.T) {
@@ -301,6 +302,7 @@ func TestEventStore_Load(t *testing.T) {
 				strategy.On("GenerateTableName", goengine.StreamName("event_stream")).Return("event_stream", nil)
 
 				store, err := postgres.NewEventStore(strategy, db, factory, nil)
+				require.NoError(t, err)
 
 				stream, err := store.Load(
 					context.Background(),
@@ -309,10 +311,9 @@ func TestEventStore_Load(t *testing.T) {
 					testCase.count,
 					testCase.matcher(),
 				)
+				require.NoError(t, err)
+				assert.Equal(t, expectedStream, stream)
 
-				if assert.NoError(t, err) {
-					assert.Equal(t, expectedStream, stream)
-				}
 				factory.AssertExpectations(t)
 				strategy.AssertExpectations(t)
 			})
@@ -355,6 +356,7 @@ func TestEventStore_Load(t *testing.T) {
 			test.RunWithMockDB(t, testCase.title, func(t *testing.T, db *sql.DB, dbMock sqlmock.Sqlmock) {
 				strategy := testCase.strategy()
 				store, err := postgres.NewEventStore(strategy, db, &mockSQL.MessageFactory{}, nil)
+				require.NoError(t, err)
 
 				stream, err := store.Load(context.Background(), "event_stream", 1, nil, nil)
 				if assert.Error(t, err) {

example/aggregate/main.go

@@ -44,9 +44,16 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	account.Deposit(100)
-	account.Withdraw(10)
-	account.Withdraw(20)
+
+	if err := account.Deposit(100); err != nil {
+		panic(err)
+	}
+	if err := account.Withdraw(10); err != nil {
+		panic(err)
+	}
+	if err := account.Withdraw(20); err != nil {
+		panic(err)
+	}
 
 	fmt.Printf("BankAccount %s has a balance of %d\n", account.AggregateID(), account.Balance())
 }

example/repository/bank_account.go

@@ -39,16 +39,18 @@ type (
 )
 
 // OpenBankAccount opens a new bank account
-func OpenBankAccount() *BankAccount {
+func OpenBankAccount() (*BankAccount, error) {
 	accountID := aggregate.GenerateID()
 
 	account := &BankAccount{
 		accountID: accountID,
 	}
 
-	aggregate.RecordChange(account, AccountOpened{AccountID: accountID})
+	if err := aggregate.RecordChange(account, AccountOpened{AccountID: accountID}); err != nil {
+		return nil, err
+	}
 
-	return account
+	return account, nil
 }
 
 // AggregateID returns the bank accounts aggregate.ID need to implement aggregate.Root
@@ -61,23 +63,20 @@ func (b *BankAccount) Apply(change *aggregate.Changed) {
 	switch event := change.Payload().(type) {
 	case AccountOpened:
 		b.accountID = event.AccountID
-		break
 	case AccountCredited:
 		b.balance += event.Amount
-		break
 	case AccountDebited:
 		b.balance -= event.Amount
-		break
 	}
 }
 
 // Deposit adds an amount of money to the bank account
-func (b *BankAccount) Deposit(amount uint) {
+func (b *BankAccount) Deposit(amount uint) error {
 	if amount == 0 {
-		return
+		return nil
 	}
 
-	aggregate.RecordChange(b, AccountCredited{Amount: amount})
+	return aggregate.RecordChange(b, AccountCredited{Amount: amount})
 }
 
 // Withdraw removes an amount of money to the bank account
@@ -86,8 +85,7 @@ func (b *BankAccount) Withdraw(amount uint) error {
 		return ErrInsufficientMoney
 	}
 
-	aggregate.RecordChange(b, AccountDebited{Amount: amount})
-	return nil
+	return aggregate.RecordChange(b, AccountDebited{Amount: amount})
 }
 
 // Balance returns the current amount of money that is contained in bank account

example/repository/main.go

@@ -16,22 +16,28 @@ func main() {
 	store := inmemory.NewEventStore(logger)
 
 	eventStream := goengine.StreamName("event_stream")
-	store.Create(ctx, eventStream)
+	failOnErr(
+		store.Create(ctx, eventStream),
+	)
 
 	repository, err := NewBankAccountRepository(store, eventStream)
 	failOnErr(err)
 
 	fmt.Print("Opening an account\n")
-	account := OpenBankAccount()
-	accountID := account.AggregateID()
+	account, err := OpenBankAccount()
+	failOnErr(err)
 	failOnErr(
 		repository.Save(ctx, account),
 	)
+	accountID := account.AggregateID()
 	fmt.Printf("Opened account %s balance %d\n\n", account.AggregateID(), account.Balance())
 
 	fmt.Print("Opening an account with 100\n")
-	secondAccount := OpenBankAccount()
-	secondAccount.Deposit(100)
+	secondAccount, err := OpenBankAccount()
+	failOnErr(err)
+	failOnErr(
+		secondAccount.Deposit(100),
+	)
 	failOnErr(
 		repository.Save(ctx, secondAccount),
 	)
@@ -41,7 +47,9 @@ func main() {
 	loadedAccount, err := repository.Get(ctx, accountID)
 	failOnErr(err)
 
-	loadedAccount.Deposit(100)
+	failOnErr(
+		loadedAccount.Deposit(100),
+	)
 	failOnErr(
 		repository.Save(ctx, loadedAccount),
 	)
@@ -52,7 +60,9 @@ func main() {
 	loadedAccount, err = repository.Get(ctx, accountID)
 	failOnErr(err)
 
-	loadedAccount.Withdraw(50)
+	failOnErr(
+		loadedAccount.Withdraw(50),
+	)
 	failOnErr(
 		repository.Save(ctx, loadedAccount),
 	)

strategy/json/payload_transformer_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/hellofresh/goengine/internal/mocks/payload"
 	strategyJSON "github.com/hellofresh/goengine/strategy/json"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type simpleType struct {
@@ -22,9 +23,11 @@ func TestPayloadTransformer(t *testing.T) {
 		asserts := assert.New(t)
 
 		transformer := strategyJSON.NewPayloadTransformer()
-		transformer.RegisterPayload("payload", func() interface{} {
-			return payload.Payload{}
-		})
+		require.NoError(t,
+			transformer.RegisterPayload("payload", func() interface{} {
+				return payload.Payload{}
+			}),
+		)
 
 		name, data, err := transformer.ConvertPayload(anotherpayload.Payload{})
 		asserts.Equal(err, strategyJSON.ErrPayloadNotRegistered)
@@ -60,7 +63,9 @@ func TestPayloadTransformer_ConvertPayload(t *testing.T) {
 			t.Run(tc.title, func(t *testing.T) {
 				asserts := assert.New(t)
 				transformer := strategyJSON.NewPayloadTransformer()
-				transformer.RegisterPayload(tc.payloadType, tc.payloadInitiator)
+				require.NoError(t,
+					transformer.RegisterPayload(tc.payloadType, tc.payloadInitiator),
+				)
 
 				name, data, err := transformer.ConvertPayload(tc.payloadData)
 				asserts.NoError(err)
@@ -81,10 +86,7 @@ func TestPayloadTransformer_ConvertPayload(t *testing.T) {
 		testCases := []testCase{
 			{
 				"not registered convert payload",
-				func() interface{} {
-					// not necessary for this test case
-					return nil
-				},
+				nil,
 				&simpleType{Test: "test", Order: 1},
 				strategyJSON.ErrPayloadNotRegistered,
 			},
@@ -103,8 +105,11 @@ func TestPayloadTransformer_ConvertPayload(t *testing.T) {
 			t.Run(tc.title, func(t *testing.T) {
 				asserts := assert.New(t)
 				transformer := strategyJSON.NewPayloadTransformer()
-
-				transformer.RegisterPayload("tests", tc.payloadInitiator)
+				if tc.payloadInitiator != nil {
+					require.NoError(t,
+						transformer.RegisterPayload("tests", tc.payloadInitiator),
+					)
+				}
 
 				name, data, err := transformer.ConvertPayload(tc.payloadData)
 				asserts.Equal(tc.expectedError, err)
@@ -235,13 +240,15 @@ func TestJSONPayloadTransformer_CreatePayload(t *testing.T) {
 		for _, testCase := range testCases {
 			t.Run(testCase.title, func(t *testing.T) {
 				factory := strategyJSON.NewPayloadTransformer()
-				factory.RegisterPayload("tests", testCase.payloadInitiator)
+				require.NoError(t,
+					factory.RegisterPayload("tests", testCase.payloadInitiator),
+				)
 
-				payload, err := factory.CreatePayload("tests", testCase.payloadData)
+				res, err := factory.CreatePayload("tests", testCase.payloadData)
 
 				asserts := assert.New(t)
 				asserts.IsType((*json.SyntaxError)(nil), err)
-				asserts.Nil(payload)
+				asserts.Nil(res)
 			})
 		}
 	})

strategy/json/sql/message_factory_aggregate_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/hellofresh/goengine/mocks"
 	"github.com/hellofresh/goengine/strategy/json/sql"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type nameChanged struct {
@@ -119,9 +120,8 @@ func TestAggregateChangedFactory_CreateFromRows(t *testing.T) {
 				defer stream.Close()
 
 				messages, messageNumbers, err := goengine.ReadEventStream(stream)
-				if !asserts.NoError(stream.Err()) {
-					asserts.FailNow("no exception was expected while reading the stream")
-				}
+				require.NoError(t, err)
+				require.NoError(t, stream.Err(), "no exception was expected while reading the stream")
 
 				assertEqualMessages(t, expectedMessages, messages)
 				asserts.Equal(expectedMessageNumbers, messageNumbers)