Unit testing with Go

// model.go
package unit

import "github.com/google/uuid"

// User is a domain representation of a User.
type User struct {
	ID    uuid.UUID `validate:"required"`
	Name  string    `validate:"required,gte=3,lte=50"`
	Email string    `validate:"required,email,lte=50"`
}

// controller.go
package unit

// ...

// StorageProvider provides the storage methods.
type StorageProvider interface {
	Insert(ctx context.Context, user User) (uuid.UUID, error)
}

// Controller is the communicator between
// the storage layer and domain.
type Controller struct {
	Storage   StorageProvider
	Validator *validator.Validate
}

// New initializes a new Controller.
func New(storage StorageProvider, validator *validator.Validate) Controller {
	return Controller{
		Storage:   storage,
		Validator: validator,
	}
}

// Create passes a new User to the storage layer.
func (c Controller) Create(ctx context.Context, user User) (uuid.UUID, error) {
	user.ID = uuid.New()

	if err := c.Validator.Struct(&user); err != nil {
		var validationErr validator.ValidationErrors
		if errors.As(err, &validationErr) {
			for _, err := range validationErr {
				return uuid.Nil, fmt.Errorf("%w: %v", ErrInvalidUser, err.Error())
			}
		}
	}

	id, err := c.Storage.Insert(ctx, user)
	if err != nil {
		if errors.Is(err, narrow.ErrUnableToExecuteQuery) {
			return uuid.Nil, ErrAlreadyExists
		}

		return uuid.Nil, ErrUnknown
	}

	return id, nil
}

// controller_test.go
package unit_test

// ...

type mockStorage struct {
	GivenID    uuid.UUID
	GivenError error
}

func (m mockStorage) Insert(_ context.Context, _ unit.User) (uuid.UUID, error) {
	return m.GivenID, m.GivenError
}

// controller_test.go
package unit_test

// ...

func TestController_Create(t *testing.T) {
	tests := []struct {
		name    string
		storage unit.StorageProvider
		user    unit.User
		want    uuid.UUID
		wantErr error
	}{
		{
			name: "expect success given a valid User",
			storage: mockStorage{
				GivenID: uuid.Must(uuid.Parse("a6acab82-2b2e-484c-8e2b-f3f7736a26ed")),
			},
			user: unit.User{
				Name:  "foo",
				Email: "foo@bar.com",
			},
			want:    uuid.Must(uuid.Parse("a6acab82-2b2e-484c-8e2b-f3f7736a26ed")),
			wantErr: nil,
		},
		{
			name: "expect validation error given name less than 3",
			storage: mockStorage{
				GivenError: narrow.ErrUnableToExecuteQuery,
			},
			user: unit.User{
				Name:  "fo",
				Email: "foo@bar.com",
			},
			want:    uuid.Nil,
			wantErr: unit.ErrInvalidUser,
		},
		{
			name: "expect validation error given name greater than 50",
			storage: mockStorage{
				GivenError: narrow.ErrUnableToExecuteQuery,
			},
			user: unit.User{
				Name:  "this is a very long name that should be caught by the validator",
				Email: "foo@bar.com",
			},
			want:    uuid.Nil,
			wantErr: unit.ErrInvalidUser,
		},
		{
			name: "expect validation error given invalid email",
			storage: mockStorage{
				GivenError: narrow.ErrUnableToExecuteQuery,
			},
			user: unit.User{
				Name:  "foo",
				Email: "notanemail@foo",
			},
			want:    uuid.Nil,
			wantErr: unit.ErrInvalidUser,
		},
		{
			name: "expect already exists given a storage insert error",
			storage: mockStorage{
				GivenError: narrow.ErrUnableToExecuteQuery,
			},
			user: unit.User{
				Name:  "foo",
				Email: "foo@bar.com",
			},
			want:    uuid.Nil,
			wantErr: unit.ErrAlreadyExists,
		},
		{
			name: "expect unknown error given an unhandled storage error",
			storage: mockStorage{
				GivenError: errors.New("foo"),
			},
			user: unit.User{
				Name:  "foo",
				Email: "foo@bar.com",
			},
			want:    uuid.Nil,
			wantErr: unit.ErrUnknown,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			c := unit.New(tt.storage, validator.New())

			got, err := c.Create(context.Background(), tt.user)

			if !cmp.Equal(err, tt.wantErr, cmpopts.EquateErrors()) {
				t.Error(cmp.Diff(err, tt.wantErr, cmpopts.EquateErrors()))
			}

			if !cmp.Equal(got, tt.want) {
				t.Error(cmp.Diff(got, tt.want))
			}
		})
	}
}