343 lines
10 KiB
Go
343 lines
10 KiB
Go
package domain
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/mock"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type fakeTransactor struct {
|
|
calls int
|
|
err error
|
|
}
|
|
|
|
func (f *fakeTransactor) WithinTx(ctx context.Context, fn func(ctx context.Context) error) error {
|
|
f.calls++
|
|
if f.err != nil {
|
|
return f.err
|
|
}
|
|
return fn(ctx)
|
|
}
|
|
|
|
type mockListRepository struct {
|
|
mock.Mock
|
|
}
|
|
|
|
func (m *mockListRepository) CreateList(ctx context.Context, name string) (*List, error) {
|
|
args := m.Called(ctx, name)
|
|
list, _ := args.Get(0).(*List)
|
|
return list, args.Error(1)
|
|
}
|
|
|
|
func (m *mockListRepository) DeleteList(ctx context.Context, listID string) error {
|
|
args := m.Called(ctx, listID)
|
|
return args.Error(0)
|
|
}
|
|
|
|
func (m *mockListRepository) GetLists(ctx context.Context, userID string) ([]List, error) {
|
|
args := m.Called(ctx, userID)
|
|
lists, _ := args.Get(0).([]List)
|
|
return lists, args.Error(1)
|
|
}
|
|
|
|
func (m *mockListRepository) AddUserToList(ctx context.Context, listID string, userID string) error {
|
|
args := m.Called(ctx, listID, userID)
|
|
return args.Error(0)
|
|
}
|
|
|
|
func (m *mockListRepository) RemoveUserFromList(ctx context.Context, listID string, userID string) error {
|
|
args := m.Called(ctx, listID, userID)
|
|
return args.Error(0)
|
|
}
|
|
|
|
func (m *mockListRepository) IsUserInList(ctx context.Context, listID string, userID string) (bool, error) {
|
|
args := m.Called(ctx, listID, userID)
|
|
return args.Bool(0), args.Error(1)
|
|
}
|
|
|
|
func (m *mockListRepository) IsUserInListByItemID(ctx context.Context, listItemID string, userID string) (bool, error) {
|
|
args := m.Called(ctx, listItemID, userID)
|
|
return args.Bool(0), args.Error(1)
|
|
}
|
|
|
|
func (m *mockListRepository) CreateListItem(ctx context.Context, listID string, title string) (*ListItem, error) {
|
|
args := m.Called(ctx, listID, title)
|
|
item, _ := args.Get(0).(*ListItem)
|
|
return item, args.Error(1)
|
|
}
|
|
|
|
func (m *mockListRepository) DeleteListItem(ctx context.Context, listItemID string) error {
|
|
args := m.Called(ctx, listItemID)
|
|
return args.Error(0)
|
|
}
|
|
|
|
func (m *mockListRepository) UpdateListItem(ctx context.Context, listItemID string, title string, isCompleted bool) error {
|
|
args := m.Called(ctx, listItemID, title, isCompleted)
|
|
return args.Error(0)
|
|
}
|
|
|
|
func (m *mockListRepository) SetListItemTitle(ctx context.Context, listItemID string, title string) error {
|
|
args := m.Called(ctx, listItemID, title)
|
|
return args.Error(0)
|
|
}
|
|
|
|
func (m *mockListRepository) SetListItemCompleted(ctx context.Context, listItemID string, isCompleted bool) error {
|
|
args := m.Called(ctx, listItemID, isCompleted)
|
|
return args.Error(0)
|
|
}
|
|
|
|
func (m *mockListRepository) GetListItems(ctx context.Context, listID string) ([]ListItem, error) {
|
|
args := m.Called(ctx, listID)
|
|
items, _ := args.Get(0).([]ListItem)
|
|
return items, args.Error(1)
|
|
}
|
|
|
|
func newListService(t *testing.T) (*ListService, *mockListRepository, *fakeTransactor) {
|
|
t.Helper()
|
|
|
|
repo := &mockListRepository{}
|
|
t.Cleanup(func() { repo.AssertExpectations(t) })
|
|
|
|
tx := &fakeTransactor{}
|
|
|
|
return NewListService(tx, repo), repo, tx
|
|
}
|
|
|
|
func TestListService_CreateList(t *testing.T) {
|
|
t.Run("creates the list and adds the owner", func(t *testing.T) {
|
|
svc, repo, tx := newListService(t)
|
|
|
|
created := &List{ID: "list-1", Name: "Groceries", CreatedAt: time.Now()}
|
|
repo.On("CreateList", mock.Anything, "Groceries").Return(created, nil)
|
|
repo.On("AddUserToList", mock.Anything, "list-1", "user-1").Return(nil)
|
|
|
|
list, err := svc.CreateList(context.Background(), "user-1", "Groceries")
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, created, list)
|
|
assert.Equal(t, 1, tx.calls)
|
|
})
|
|
|
|
t.Run("empty name is rejected before any repo call", func(t *testing.T) {
|
|
svc, _, tx := newListService(t)
|
|
|
|
list, err := svc.CreateList(context.Background(), "user-1", "")
|
|
|
|
assert.Nil(t, list)
|
|
assert.ErrorIs(t, err, ErrListNameMissing)
|
|
assert.Zero(t, tx.calls)
|
|
})
|
|
|
|
t.Run("insert error aborts before adding the user", func(t *testing.T) {
|
|
svc, repo, _ := newListService(t)
|
|
|
|
repoErr := errors.New("insert failed")
|
|
repo.On("CreateList", mock.Anything, "Groceries").Return(nil, repoErr)
|
|
|
|
list, err := svc.CreateList(context.Background(), "user-1", "Groceries")
|
|
|
|
assert.Nil(t, list)
|
|
assert.ErrorIs(t, err, repoErr)
|
|
repo.AssertNotCalled(t, "AddUserToList", mock.Anything, mock.Anything, mock.Anything)
|
|
})
|
|
|
|
t.Run("transaction error is returned", func(t *testing.T) {
|
|
svc, _, tx := newListService(t)
|
|
|
|
tx.err = errors.New("could not begin transaction")
|
|
|
|
list, err := svc.CreateList(context.Background(), "user-1", "Groceries")
|
|
|
|
assert.Nil(t, list)
|
|
assert.ErrorIs(t, err, tx.err)
|
|
})
|
|
}
|
|
|
|
func TestListService_DeleteList(t *testing.T) {
|
|
t.Run("deletes when the user is a member", func(t *testing.T) {
|
|
svc, repo, _ := newListService(t)
|
|
|
|
repo.On("IsUserInList", mock.Anything, "list-1", "user-1").Return(true, nil)
|
|
repo.On("DeleteList", mock.Anything, "list-1").Return(nil)
|
|
|
|
assert.NoError(t, svc.DeleteList(context.Background(), "user-1", "list-1"))
|
|
})
|
|
|
|
t.Run("refuses when the user is not a member", func(t *testing.T) {
|
|
svc, repo, _ := newListService(t)
|
|
|
|
repo.On("IsUserInList", mock.Anything, "list-1", "intruder").Return(false, nil)
|
|
|
|
err := svc.DeleteList(context.Background(), "intruder", "list-1")
|
|
|
|
assert.ErrorIs(t, err, ErrUserNotInList)
|
|
repo.AssertNotCalled(t, "DeleteList", mock.Anything, mock.Anything)
|
|
})
|
|
|
|
t.Run("membership check error is propagated", func(t *testing.T) {
|
|
svc, repo, _ := newListService(t)
|
|
|
|
repoErr := errors.New("connection reset")
|
|
repo.On("IsUserInList", mock.Anything, "list-1", "user-1").Return(false, repoErr)
|
|
|
|
err := svc.DeleteList(context.Background(), "user-1", "list-1")
|
|
|
|
assert.ErrorIs(t, err, repoErr)
|
|
assert.NotErrorIs(t, err, ErrUserNotInList)
|
|
repo.AssertNotCalled(t, "DeleteList", mock.Anything, mock.Anything)
|
|
})
|
|
}
|
|
|
|
func TestListService_GetLists(t *testing.T) {
|
|
svc, repo, _ := newListService(t)
|
|
|
|
want := []List{{ID: "list-1", Name: "Groceries"}, {ID: "list-2", Name: "Reading"}}
|
|
repo.On("GetLists", mock.Anything, "user-1").Return(want, nil)
|
|
|
|
lists, err := svc.GetLists(context.Background(), "user-1")
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, want, lists)
|
|
}
|
|
|
|
func TestListService_CreateListItem(t *testing.T) {
|
|
t.Run("creates the item for a member", func(t *testing.T) {
|
|
svc, repo, _ := newListService(t)
|
|
|
|
created := &ListItem{ID: "item-1", ListID: "list-1", Title: "Milk"}
|
|
repo.On("IsUserInList", mock.Anything, "list-1", "user-1").Return(true, nil)
|
|
repo.On("CreateListItem", mock.Anything, "list-1", "Milk").Return(created, nil)
|
|
|
|
item, err := svc.CreateListItem(context.Background(), "user-1", "list-1", "Milk")
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, created, item)
|
|
})
|
|
|
|
t.Run("refuses for a non-member", func(t *testing.T) {
|
|
svc, repo, _ := newListService(t)
|
|
|
|
repo.On("IsUserInList", mock.Anything, "list-1", "intruder").Return(false, nil)
|
|
|
|
item, err := svc.CreateListItem(context.Background(), "intruder", "list-1", "Milk")
|
|
|
|
assert.Nil(t, item)
|
|
assert.ErrorIs(t, err, ErrUserNotInList)
|
|
repo.AssertNotCalled(t, "CreateListItem", mock.Anything, mock.Anything, mock.Anything)
|
|
})
|
|
}
|
|
|
|
func TestListService_SetListItemCompleted(t *testing.T) {
|
|
t.Run("checks membership through the item id", func(t *testing.T) {
|
|
svc, repo, _ := newListService(t)
|
|
|
|
repo.On("IsUserInListByItemID", mock.Anything, "item-1", "user-1").Return(true, nil)
|
|
repo.On("SetListItemCompleted", mock.Anything, "item-1", true).Return(nil)
|
|
|
|
assert.NoError(t, svc.SetListItemCompleted(context.Background(), "user-1", "item-1", true))
|
|
})
|
|
|
|
t.Run("refuses for a non-member", func(t *testing.T) {
|
|
svc, repo, _ := newListService(t)
|
|
|
|
repo.On("IsUserInListByItemID", mock.Anything, "item-1", "intruder").Return(false, nil)
|
|
|
|
err := svc.SetListItemCompleted(context.Background(), "intruder", "item-1", false)
|
|
|
|
assert.ErrorIs(t, err, ErrUserNotInList)
|
|
repo.AssertNotCalled(t, "SetListItemCompleted", mock.Anything, mock.Anything, mock.Anything)
|
|
})
|
|
}
|
|
|
|
func TestListService_ValidationErrors(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
call func(svc *ListService) error
|
|
wantErr error
|
|
}{
|
|
{
|
|
name: "DeleteList without list id",
|
|
call: func(svc *ListService) error { return svc.DeleteList(context.Background(), "user-1", "") },
|
|
wantErr: ErrListIDMissing,
|
|
},
|
|
{
|
|
name: "AddUserToList without list id",
|
|
call: func(svc *ListService) error {
|
|
return svc.AddUserToList(context.Background(), "user-1", "", "user-2")
|
|
},
|
|
wantErr: ErrListIDMissing,
|
|
},
|
|
{
|
|
name: "AddUserToList without user id",
|
|
call: func(svc *ListService) error {
|
|
return svc.AddUserToList(context.Background(), "user-1", "list-1", "")
|
|
},
|
|
wantErr: ErrUserIDMissing,
|
|
},
|
|
{
|
|
name: "RemoveUserFromList without user id",
|
|
call: func(svc *ListService) error {
|
|
return svc.RemoveUserFromList(context.Background(), "user-1", "list-1", "")
|
|
},
|
|
wantErr: ErrUserIDMissing,
|
|
},
|
|
{
|
|
name: "CreateListItem without title",
|
|
call: func(svc *ListService) error {
|
|
_, err := svc.CreateListItem(context.Background(), "user-1", "list-1", "")
|
|
return err
|
|
},
|
|
wantErr: ErrListItemTitleMissing,
|
|
},
|
|
{
|
|
name: "DeleteListItem without item id",
|
|
call: func(svc *ListService) error {
|
|
return svc.DeleteListItem(context.Background(), "user-1", "")
|
|
},
|
|
wantErr: ErrListItemIDMissing,
|
|
},
|
|
{
|
|
name: "UpdateListItem without title",
|
|
call: func(svc *ListService) error {
|
|
return svc.UpdateListItem(context.Background(), "user-1", "item-1", "", false)
|
|
},
|
|
wantErr: ErrListItemTitleMissing,
|
|
},
|
|
{
|
|
name: "SetListItemTitle without item id",
|
|
call: func(svc *ListService) error {
|
|
return svc.SetListItemTitle(context.Background(), "user-1", "", "Milk")
|
|
},
|
|
wantErr: ErrListItemIDMissing,
|
|
},
|
|
{
|
|
name: "SetListItemCompleted without item id",
|
|
call: func(svc *ListService) error {
|
|
return svc.SetListItemCompleted(context.Background(), "user-1", "", true)
|
|
},
|
|
wantErr: ErrListItemIDMissing,
|
|
},
|
|
{
|
|
name: "GetListItems without list id",
|
|
call: func(svc *ListService) error {
|
|
_, err := svc.GetListItems(context.Background(), "user-1", "")
|
|
return err
|
|
},
|
|
wantErr: ErrListIDMissing,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
svc, _, _ := newListService(t)
|
|
|
|
assert.ErrorIs(t, tt.call(svc), tt.wantErr)
|
|
})
|
|
}
|
|
}
|