feat(account): add FindAll(user) (#44)

* add FindAll(user)

* add FindAll(user)

* add FindAll(user)

* memoy

* add test

account/accountinfrastructure/accountmemory/user.go

@@ -29,6 +29,18 @@ func NewUserWith(users ...*user.User) *User {
 	return r
 }
 
+func (r *User) FindAll(ctx context.Context) (user.List, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+
+	res := r.data.FindAll(func(key user.ID, value *user.User) bool {
+		return true
+	})
+
+	return res, nil
+}
+
 func (r *User) FindByIDs(_ context.Context, ids user.IDList) (user.List, error) {
 	if r.err != nil {
 		return nil, r.err

account/accountinfrastructure/accountmemory/user_test.go

@@ -33,6 +33,31 @@ func TestNewUserWith(t *testing.T) {
 	assert.Equal(t, u, got)
 }
 
+func TestUser_FindAll(t *testing.T) {
+	ctx := context.Background()
+	u1 := user.New().NewID().Name("hoge").Email("[email protected]").MustBuild()
+	u2 := user.New().NewID().Name("foo").Email("[email protected]").MustBuild()
+	r := &User{
+		data: &util.SyncMap[accountdomain.UserID, *user.User]{},
+	}
+
+	out, err := r.FindAll(ctx)
+	assert.NoError(t, err)
+	assert.Equal(t, 0, len(out))
+
+	r.data.Store(u1.ID(), u1)
+	r.data.Store(u2.ID(), u2)
+
+	out, err = r.FindAll(ctx)
+	assert.NoError(t, err)
+	assert.Equal(t, 2, len(out))
+
+	wantErr := errors.New("test")
+	SetUserError(r, wantErr)
+	_, err = r.FindAll(ctx)
+	assert.Same(t, wantErr, err)
+}
+
 func TestUser_FindBySub(t *testing.T) {
 	ctx := context.Background()
 	u := user.New().NewID().Name("hoge").Email("[email protected]").Auths([]user.Auth{{

account/accountinfrastructure/accountmongo/user.go

@@ -38,6 +38,14 @@ func (r *User) Init() error {
 	return createIndexes(context.Background(), r.client, userIndexes, userUniqueIndexes)
 }
 
+func (r *User) FindAll(ctx context.Context) (user.List, error) {
+	res, err := r.find(ctx, bson.M{})
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
 func (r *User) FindByID(ctx context.Context, id2 user.ID) (*user.User, error) {
 	return r.findOne(ctx, bson.M{"id": id2.String()})
 }

account/accountinfrastructure/accountmongo/user_test.go

@@ -13,6 +13,67 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestUserRepo_FindAll(t *testing.T) {
+	wsid := user.NewWorkspaceID()
+	user1 := user.New().
+		NewID().
+		Email("[email protected]").
+		Workspace(wsid).
+		Name("foo").
+		MustBuild()
+	user2 := user.New().
+		NewID().
+		Email("[email protected]").
+		Workspace(wsid).
+		Name("hoge").
+		MustBuild()
+
+	tests := []struct {
+		Name               string
+		RepoData, Expected []*user.User
+	}{
+		{
+			Name:     "must find users",
+			RepoData: []*user.User{user1, user2},
+			Expected: []*user.User{user1, user2},
+		},
+		{
+			Name:     "must not find any user",
+			RepoData: []*user.User{},
+		},
+	}
+
+	init := mongotest.Connect(t)
+
+	for _, tc := range tests {
+		tc := tc
+
+		t.Run(tc.Name, func(tt *testing.T) {
+			tt.Parallel()
+
+			client := mongox.NewClientWithDatabase(init(t))
+
+			repo := NewUser(client)
+			ctx := context.Background()
+			for _, u := range tc.RepoData {
+				err := repo.Save(ctx, u)
+				assert.NoError(tt, err)
+			}
+
+			got, err := repo.FindAll(ctx)
+			assert.NoError(tt, err)
+			for k, u := range got {
+				if u != nil {
+					assert.Equal(tt, tc.Expected[k].ID(), u.ID())
+					assert.Equal(tt, tc.Expected[k].Email(), u.Email())
+					assert.Equal(tt, tc.Expected[k].Name(), u.Name())
+					assert.Equal(tt, tc.Expected[k].Workspace(), u.Workspace())
+				}
+			}
+		})
+	}
+}
+
 func TestUserRepo_FindByID(t *testing.T) {
 	wsid := user.NewWorkspaceID()
 	user1 := user.New().

account/accountusecase/accountrepo/multiuser.go

@@ -16,6 +16,18 @@ func NewMultiUser(users ...User) MultiUser {
 
 var _ User = MultiUser{}
 
+func (u MultiUser) FindAll(ctx context.Context) (user.List, error) {
+	res := user.List{}
+	for _, r := range u {
+		if r, err := r.FindAll(ctx); err != nil {
+			return nil, err
+		} else {
+			res = append(res, r...)
+		}
+	}
+	return res, nil
+}
+
 func (u MultiUser) FindByID(ctx context.Context, id user.ID) (*user.User, error) {
 	return u.findOne(func(r User) (*user.User, error) {
 		return r.FindByID(ctx, id)

account/accountusecase/accountrepo/user.go

@@ -21,6 +21,7 @@ type User interface {
 }
 
 type UserQuery interface {
+	FindAll(context.Context) (user.List, error)
 	FindByID(context.Context, user.ID) (*user.User, error)
 	FindByIDs(context.Context, user.IDList) (user.List, error)
 	FindBySub(context.Context, string) (*user.User, error)