// app/application/usecase/user/register_usecase.go
package user

import (
	"context"

	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/domain/user"
)

type RegisterUsecase struct {
	userRepository    user.UserRepository
	userDomainService user.UserDomainService
}

func NewRegisterUsecase(
	userRepository user.UserRepository,
	userDomainService user.UserDomainService,
) *RegisterUsecase {
	return &RegisterUsecase{
		userRepository:    userRepository,
		userDomainService: userDomainService,
	}
}

func (ru *RegisterUsecase) Run(ctx context.Context, input RegisterUsecaseInputDTO) (*RegisterUsecaseOutputDTO, error) {
	// userインスタンスを生成
	u, err := user.NewUser(
		input.Email,
		input.Name,
		input.Password,
	)
	if err != nil {
		return nil, err
	}
	//userがすでに登録済みでないか？
	ok, err := ru.userDomainService.IsExists(ctx, u.GetEmail())
	if err != nil {
		return nil, err
	}
	// emailがすでに存在していた場合
	if ok {
		return nil, errors.ErrAlreadyRegisterd
	}
	if err := ru.userRepository.Save(ctx, u); err != nil {
		return nil, err
	}
	// DTOに詰め替えて返す
	return &RegisterUsecaseOutputDTO{
		ID:    u.GetID(),
		Name:  u.GetName(),
		Email: u.GetEmail().Value(),
	}, nil
}

DTOを用意

// app/application/usecase/user/register_usecase_dto.go
package user

type RegisterUsecaseInputDTO struct {
	Name     string
	Email    string
	Password string
}

type RegisterUsecaseOutputDTO struct {
	ID    string
	Name  string
	Email string
}

テストコード

// app/application/usecase/user/register_usecase_test.go
package user

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/domain/user"
	"go.uber.org/mock/gomock"
)

func TestUser_RegisterUsecase_Run(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name    string
		mockFn  func(mr *user.MockUserRepository, mds *user.MockUserDomainService)
		input   RegisterUsecaseInputDTO
		errType error
		want    *RegisterUsecaseOutputDTO
		wantErr bool
	}{
		{
			name: "正常系：ユーザーを登録できる",
			mockFn: func(mr *user.MockUserRepository, mds *user.MockUserDomainService) {
				mds.EXPECT().IsExists(gomock.Any(), gomock.Any()).Return(false, nil)
				mr.EXPECT().Save(gomock.Any(), gomock.Any()).Return(nil)
			},
			input: RegisterUsecaseInputDTO{
				Name:     "user",
				Email:    "[email protected]",
				Password: "password",
			},
			want: &RegisterUsecaseOutputDTO{
				Name:  "user",
				Email: "[email protected]",
			},
			wantErr: false,
		},
		{
			name: "準正常系：重複した登録は阻止する",
			mockFn: func(mr *user.MockUserRepository, mds *user.MockUserDomainService) {
				// emailで検索すると、DBに存在していたケース
				mds.EXPECT().IsExists(gomock.Any(), gomock.Any()).Return(true, nil)
			},
			input: RegisterUsecaseInputDTO{
				Name:     "user",
				Email:    "[email protected]",
				Password: "password",
			},
			errType: errors.ErrAlreadyRegisterd,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			// モックを設定
			ctrl := gomock.NewController(t)
			mockUserRepository := user.NewMockUserRepository(ctrl)
			mockUserDomainService := user.NewMockUserDomainService(ctrl)
			tt.mockFn(mockUserRepository, mockUserDomainService)
			// ユースケースオブジェクト
			registerUsecase := NewRegisterUsecase(mockUserRepository, mockUserDomainService)
			ctx := context.Background()
			got, err := registerUsecase.Run(ctx, tt.input)
			// 期待するエラー型を設定していた場合はエラー型を比較して検証する
			if tt.errType != nil && !errors.Is(err, tt.errType) {
				t.Errorf("registerUsecase.Run = error:%v,want errYType:%v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("registerUsecase.Run = error:%v,wantErr:%v", err, tt.wantErr)
				return
			}
			if diff := cmp.Diff(got, tt.want, cmpopts.IgnoreFields(RegisterUsecaseOutputDTO{}, "ID")); diff != "" {
				t.Errorf("registerUsecase.Run() -got,+want :%v ", diff)
			}
		})
	}
}

// app/application/usecase/user/unregister_usecase.go
package user

import (
	"context"

	"github.com/kakkky/app/domain/user"
)

type UnregisterUsecase struct {
	userRepository user.UserRepository
}

func NewUnregisterUsecase(
	userRepository user.UserRepository,
) *UnregisterUsecase {
	return &UnregisterUsecase{
		userRepository: userRepository,
	}
}

func (uu *UnregisterUsecase) Run(ctx context.Context, input UnregisterUsecaseInputDTO) error {
	// 存在しているユーザーしか削除できない
	u, err := uu.userRepository.FindById(ctx, input.ID)
	// エラーかユーザーがnilの場合はエラー
	if err != nil || u == nil {
		return err
	}
	if err := uu.userRepository.Delete(ctx, u); err != nil {
		return err
	}
	return nil
}

DTOを用意

// app/application/usecase/user/unregister_usecase_dto.go
package user

type UnregisterUsecaseInputDTO struct {
	ID string
}

テストコード

// app/application/usecase/user/unregister_usecase_test.go
package user

import (
	"context"
	"testing"

	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/domain/user"
	"go.uber.org/mock/gomock"
)

func TestUser_UnregisterUsease_Run(t *testing.T) {
	tests := []struct {
		name    string
		mockFn  func(mr *user.MockUserRepository)
		input   UnregisterUsecaseInputDTO
		wantErr bool
	}{
		{
			name: "正常系: ユーザーを削除できる",
			mockFn: func(mr *user.MockUserRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(user.ReconstructUser("1", "", "", ""), nil)
				mr.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil)
			},
			input: UnregisterUsecaseInputDTO{
				ID: "1",
			},
			wantErr: false,
		},
		{
			name: "準正常系: ユーザーが見つからない場合はエラーを返す",
			mockFn: func(mr *user.MockUserRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(nil, errors.ErrNotFoundUser)
			},
			input: UnregisterUsecaseInputDTO{
				ID: "0",
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			// モックを設定
			ctrl := gomock.NewController(t)
			mockUserRepository := user.NewMockUserRepository(ctrl)
			tt.mockFn(mockUserRepository)
			// ユースケースオブジェクト
			unregisterUsecase := NewUnregisterUsecase(mockUserRepository)
			ctx := context.Background()
			err := unregisterUsecase.Run(ctx, tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("unregisterUsecase.Run = error:%v,wantErr:%v", err, tt.wantErr)
			}
		})
	}
}

// app/application/usecase/user/update_profile_usecase.go
package user

import (
	"context"

	"github.com/kakkky/app/domain/user"
)

type UpdateProfileUsecase struct {
	userRepository user.UserRepository
}

func NewUpdateProfileUsecase(
	userRepository user.UserRepository,
) *UpdateProfileUsecase {
	return &UpdateProfileUsecase{
		userRepository: userRepository,
	}
}

func (epu *UpdateProfileUsecase) Run(ctx context.Context, input UpdateProfileUsecaseInputDTO) (
	*UpdateProfileUsecaseOutputDTO, error,
) {
	// 存在しているユーザーしか編集できない
	u, err := epu.userRepository.FindById(ctx, input.ID)
	// エラーかユーザーがnilの場合はエラー
	if err != nil || u == nil {
		return nil, err
	}
	// 値が空の場合は既存情報を入れる
	if input.Name == "" {
		input.Name = u.GetName()
	}
	if input.Email == "" {
		input.Email = u.GetEmail().Value()
	}
	// input情報をもとに、更新情報を反映したインスタンスを作成
	updatedUser, err := u.UpdateUser(
		input.Email,
		input.Name,
	)
	if err != nil {
		return nil, err
	}
	if err := epu.userRepository.Update(ctx, updatedUser); err != nil {
		return nil, err
	}
	// 更新したオブジェクトをDTOに詰め替える
	return &UpdateProfileUsecaseOutputDTO{
		ID:    updatedUser.GetID(),
		Email: updatedUser.GetEmail().Value(),
		Name:  updatedUser.GetName(),
	}, nil
}

DTOを用意

// app/application/usecase/user/update_profile_usecase_dto.go
package user

type UpdateProfileUsecaseInputDTO struct {
	ID    string
	Name  string
	Email string
}
type UpdateProfileUsecaseOutputDTO struct {
	ID    string
	Name  string
	Email string
}

テストコード

// app/application/usecase/user/update_profile_usecase_test.go
package user

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/domain/user"
	"go.uber.org/mock/gomock"
)

func TestUser_UpdateProfileUsecase_Run(t *testing.T) {
	tests := []struct {
		name    string
		mockFn  func(mr *user.MockUserRepository)
		input   UpdateProfileUsecaseInputDTO
		want    *UpdateProfileUsecaseOutputDTO
		wantErr bool
	}{
		{
			name: "正常形:プロフィールを編集できる",
			mockFn: func(mr *user.MockUserRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(user.ReconstructUser("1", "[email protected]", "testuser", ""), nil)
				mr.EXPECT().Update(gomock.Any(), gomock.Any()).Return(nil)

			},
			input: UpdateProfileUsecaseInputDTO{
				ID:    "1",
				Email: "[email protected]",
				Name:  "updatedUser",
			},
			want: &UpdateProfileUsecaseOutputDTO{
				ID:    "1",
				Email: "[email protected]",
				Name:  "updatedUser",
			},
			wantErr: false,
		},
		{
			name: "正常形:空のフィールドは更新されない",
			mockFn: func(mr *user.MockUserRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(user.ReconstructUser("1", "[email protected]", "testuser", ""), nil)
				mr.EXPECT().Update(gomock.Any(), gomock.Any()).Return(nil)

			},
			input: UpdateProfileUsecaseInputDTO{
				ID:   "1",
				Name: "updatedUser",
			},
			want: &UpdateProfileUsecaseOutputDTO{
				ID:    "1",
				Email: "[email protected]",
				Name:  "updatedUser",
			},
			wantErr: false,
		},
		{
			name: "準正常形:存在しないユーザーは編集できない",
			mockFn: func(mr *user.MockUserRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(nil, errors.ErrNotFoundUser)
			},
			input: UpdateProfileUsecaseInputDTO{
				ID:    "0",
				Email: "[email protected]",
				Name:  "noexitstent",
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			// モックを設定
			ctrl := gomock.NewController(t)
			mockUserRepository := user.NewMockUserRepository(ctrl)
			tt.mockFn(mockUserRepository)
			// ユースケースオブジェクト
			UpdateProfileUsecase := NewUpdateProfileUsecase(mockUserRepository)
			ctx := context.Background()
			got, err := UpdateProfileUsecase.Run(ctx, tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("UpdateProfileUsecase.Run = error:%v,wantErr:%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("UpdateProfileUsecase.Run() -got,+want :%v ", diff)
			}
		})
	}
}

// app/application/usecase/user/fetch_users_usecase.go
package user

import (
	"context"

	"github.com/kakkky/app/domain/user"
)

type FetchUsersUsecase struct {
	userRepository user.UserRepository
}

func NewFetchUsersUsecase(
	userRepository user.UserRepository,
) *FetchUsersUsecase {
	return &FetchUsersUsecase{
		userRepository: userRepository,
	}
}

func (fuu *FetchUsersUsecase) Run(ctx context.Context) ([]*FetchUsersUsecaseOutputDTO, error) {
	us, err := fuu.userRepository.FetchAllUsers(ctx)
	if err != nil {
		return nil, err
	}
	outputs := make([]*FetchUserUsecaseOutputDTO, 0, len(us))
	for _, u := range us {
		outputs = append(outputs, &FetchUserUsecaseOutputDTO{ID: u.GetID(), Name: u.GetName()})
	}
	return outputs, nil
}

DTOを用意

// app/application/usecase/user/fetch_user_usecase_dto.go
package user

type FetchUserUsecaseOutputDTO struct {
	ID   string
	Name string
}

テストコード

// app/application/usecase/user/fetch_users_usecase_test.go
package user

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/kakkky/app/domain/user"
	"go.uber.org/mock/gomock"
)

func TestUser_FetchUsersUsecase_Run(t *testing.T) {
	tests := []struct {
		name    string
		mockFn  func(mr *user.MockUserRepository)
		want    []*FetchUserUsecaseOutputDTO
		wantErr bool
	}{
		{
			name: "正常形: 登録されている全てのユーザーを取得する",
			mockFn: func(mr *user.MockUserRepository) {
				mr.EXPECT().FetchAllUsers(gomock.Any()).Return(
					user.Users{
						user.ReconstructUser("1", "", "user1", ""),
						user.ReconstructUser("2", "", "user2", ""),
						user.ReconstructUser("3", "", "user3", ""),
					}, nil,
				)
			},
			want: []*FetchUserUsecaseOutputDTO{
				{
					ID:   "1",
					Name: "user1",
				},
				{
					ID:   "2",
					Name: "user2",
				},
				{
					ID:   "3",
					Name: "user3",
				},
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			// モックを設定
			ctrl := gomock.NewController(t)
			mockUserRepository := user.NewMockUserRepository(ctrl)
			tt.mockFn(mockUserRepository)
			FetchUsersUsecase := NewFetchUsersUsecase(mockUserRepository)
			ctx := context.Background()
			got, err := FetchUsersUsecase.Run(ctx)
			if (err != nil) != tt.wantErr {
				t.Errorf("FetchUsersUsecase.Run = error:%v,wantErr:%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("FetchUsersUsecase.Run() -got,+want :%v ", diff)
			}

		})
	}
}

// app/application/usecase/task/create_task_usecase.go
package task

import (
	"context"

	"github.com/kakkky/app/domain/task"
)

type CreateTaskUsecase struct {
	taskRepository task.TaskRepository
}

func NewCreateTaskUsecase(taskRepository task.TaskRepository) *CreateTaskUsecase {
	return &CreateTaskUsecase{
		taskRepository: taskRepository,
	}
}

func (ctu *CreateTaskUsecase) Run(ctx context.Context, input CreateTaskUsecaseInputDTO) (
	*CreateTaskUsecaseOutputDTO, error) {
	t, err := task.NewTask(input.UserId, input.Content, input.State)
	if err != nil {
		return nil, err
	}
	if err := ctu.taskRepository.Save(ctx, t); err != nil {
		return nil, err
	}
	return &CreateTaskUsecaseOutputDTO{
		ID:      t.GetID(),
		UserId:  t.GetUserId(),
		Content: t.GetContent().Value(),
		State:   t.GetState().StrValue(),
	}, nil
}

// app/application/usecase/task/create_task_usecase_dto.go
package task

type CreateTaskUsecaseInputDTO struct {
	UserId  string
	Content string
	State   string
}

type CreateTaskUsecaseOutputDTO struct {
	ID      string
	UserId  string
	Content string
	State   string
}

// app/application/usecase/task/create_task_usecase_test.go
package task

import (
	"context"

	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/domain/task"
	"go.uber.org/mock/gomock"
)

func TestTask_CreateTaskUsecase_Run(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name    string
		mockFn  func(mr *task.MockTaskRepository)
		input   CreateTaskUsecaseInputDTO
		errType error
		want    *CreateTaskUsecaseOutputDTO
		wantErr bool
	}{
		{
			name: "正常系",
			mockFn: func(mr *task.MockTaskRepository) {
				mr.EXPECT().Save(gomock.Any(), gomock.Any()).Return(nil)
			},
			input: CreateTaskUsecaseInputDTO{
				UserId:  "user_id",
				Content: "this is content",
				State:   "todo",
			},
			want: &CreateTaskUsecaseOutputDTO{
				UserId:  "user_id",
				Content: "this is content",
				State:   "todo",
			},
			wantErr: false,
		},
		{
			name: "準正常系：タスク内容が空っぽ",
			mockFn: func(mr *task.MockTaskRepository) {
				// Saveメソッドは呼ばれない
			},
			input: CreateTaskUsecaseInputDTO{
				UserId:  "user_id",
				Content: "",
				State:   "todo",
			},
			errType: errors.ErrContentEmpty,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			// モックを設定
			ctrl := gomock.NewController(t)
			mockTaskRepository := task.NewMockTaskRepository(ctrl)
			tt.mockFn(mockTaskRepository)
			// ユースケースオブジェクト
			sut := NewCreateTaskUsecase(mockTaskRepository)
			ctx := context.Background()
			got, err := sut.Run(ctx, tt.input)
			// 期待するエラー型を設定していた場合はエラー型を比較して検証する
			if tt.errType != nil && !errors.Is(err, tt.errType) {
				t.Errorf("createTaskUsecase.Run = error:%v,want errYType:%v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("createTaskUsecase.Run = error:%v,wantErr:%v", err, tt.wantErr)
				return
			}
			if diff := cmp.Diff(got, tt.want, cmpopts.IgnoreFields(CreateTaskUsecaseOutputDTO{}, "ID")); diff != "" {
				t.Errorf("createTaskUsecase.Run() -got,+want :%v ", diff)
			}
		})
	}
}

// app/application/usecase/task/delete_task_usecase.go
package task

import (
	"context"

	"github.com/kakkky/app/domain/task"
)

type DeleteTaskUsecase struct {
	taskRepository task.TaskRepository
}

func NewDeleteTaskUsecase(taskRepository task.TaskRepository) *DeleteTaskUsecase {
	return &DeleteTaskUsecase{
		taskRepository: taskRepository,
	}
}

func (dtu *DeleteTaskUsecase) Run(ctx context.Context, input DeleteTaskUsecaseInputDTO) error {
	t, err := dtu.taskRepository.FindById(ctx, input.ID)
	if err != nil || t == nil {
		return err
	}
	// ログインしているユーザーIDと一致したら
	if err := t.IsOperableBy(input.UserId); err != nil {
		return err
	}
	if err := dtu.taskRepository.Delete(ctx, t); err != nil {
		return err
	}
	return nil
}

// app/application/usecase/task/delete_task_usecase_dto.go
package task

type DeleteTaskUsecaseInputDTO struct {
	ID     string
	UserId string
}

// app/application/usecase/task/delete_task_usecase_test.go
package task

import (
	"context"
	"testing"

	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/domain/task"
	"go.uber.org/mock/gomock"
)

func TestTask_DeleteTaskUsecase_Run(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name    string
		mockFn  func(mr *task.MockTaskRepository)
		input   DeleteTaskUsecaseInputDTO
		errType error
		wantErr bool
	}{
		{
			name: "正常系",
			mockFn: func(mr *task.MockTaskRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(
					task.ReconstructTask("id", "user_id", "this is content", 0),
					nil,
				)
				mr.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil)
			},
			input: DeleteTaskUsecaseInputDTO{
				UserId: "user_id",
				ID:     "id",
			},
			wantErr: false,
		},
		{
			name: "準正常系:指定したidを持つタスクが存在しない",
			mockFn: func(mr *task.MockTaskRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(
					nil,
					errors.ErrNotFoundTask,
				)
			},
			input: DeleteTaskUsecaseInputDTO{
				UserId: "user_id",
				ID:     "id",
			},
			wantErr: true,
		},
		{
			name: "準正常系:異なるuser_idで操作するとエラーが返る",
			mockFn: func(mr *task.MockTaskRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(
					task.ReconstructTask("id", "user_id", "this is content", 0),
					nil,
				)
			},
			input: DeleteTaskUsecaseInputDTO{
				UserId: "orther_user_id",
				ID:     "id",
			},
			wantErr: true,
			errType: errors.ErrForbiddenTaskOperation,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			// モックを設定
			ctrl := gomock.NewController(t)
			mockTaskRepository := task.NewMockTaskRepository(ctrl)
			tt.mockFn(mockTaskRepository)
			// ユースケースオブジェクト
			sut := NewDeleteTaskUsecase(mockTaskRepository)
			ctx := context.Background()
			err := sut.Run(ctx, tt.input)
			// 期待するエラー型を設定していた場合はエラー型を比較して検証する
			if tt.errType != nil && !errors.Is(err, tt.errType) {
				t.Errorf("deleteTaskUsecase.Run = error:%v,want errYType:%v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("deleteTaskUsecase.Run = error:%v,wantErr:%v", err, tt.wantErr)
				return
			}
		})
	}
}

// app/application/usecase/task/update_task_state_usecase.go
package task

import (
	"context"

	"github.com/kakkky/app/domain/task"
)

type UpdateTaskStateUsecase struct {
	taskRepository task.TaskRepository
}

func NewUpdateTaskStateUsecase(taskRepository task.TaskRepository) *UpdateTaskStateUsecase {
	return &UpdateTaskStateUsecase{
		taskRepository: taskRepository,
	}
}

func (utu *UpdateTaskStateUsecase) Run(ctx context.Context, input UpdateTaskStateUsecaseInputDTO) (
	*UpdateTaskStateUsecaseOutputDTO, error,
) {
	t, err := utu.taskRepository.FindById(ctx, input.ID)
	if err != nil || t == nil {
		return nil, err
	}
	// ログインしているユーザーIDと一致したら
	if err := t.IsOperableBy(input.UserId); err != nil {
		return nil, err
	}
	updatedTask, err := t.UpdateState(input.State)
	if err != nil {
		return nil, err
	}
	if err := utu.taskRepository.Update(ctx, updatedTask); err != nil {
		return nil, err
	}
	return &UpdateTaskStateUsecaseOutputDTO{
		ID:      updatedTask.GetID(),
		UserId:  updatedTask.GetUserId(),
		Content: updatedTask.GetContent().Value(),
		State:   updatedTask.GetState().StrValue(),
	}, nil
}

// app/application/usecase/task/update_task_state_usecase_dto.go
package task

type UpdateTaskStateUsecaseInputDTO struct {
	ID     string
	UserId string
	State  string
}

type UpdateTaskStateUsecaseOutputDTO struct {
	ID      string
	UserId  string
	Content string
	State   string
}

// app/application/usecase/task/update_task_state_usecase_test.go
package task

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/domain/task"
	"go.uber.org/mock/gomock"
)

func TestTask_UpdateTaskStateUsecase_Run(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name    string
		mockFn  func(mr *task.MockTaskRepository)
		input   UpdateTaskStateUsecaseInputDTO
		errType error
		want    *UpdateTaskStateUsecaseOutputDTO
		wantErr bool
	}{
		{
			name: "正常系",
			mockFn: func(mr *task.MockTaskRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(
					task.ReconstructTask("id", "user_id", "this is content", 0),
					nil,
				)
				mr.EXPECT().Update(gomock.Any(), gomock.Any()).Return(nil)
			},
			input: UpdateTaskStateUsecaseInputDTO{
				ID:     "id",
				UserId: "user_id",
				State:  "done",
			},
			want: &UpdateTaskStateUsecaseOutputDTO{
				ID:      "id",
				UserId:  "user_id",
				Content: "this is content",
				State:   "done",
			},
			wantErr: false,
		},
		{
			name: "準正常系:指定したstateが不正",
			mockFn: func(mr *task.MockTaskRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(
					task.ReconstructTask("id", "user_id", "this is content", 0),
					nil,
				)
			},
			errType: errors.ErrInvalidTaskState,
			input: UpdateTaskStateUsecaseInputDTO{
				ID:     "id",
				UserId: "user_id",
				State:  "invalid",
			},
			wantErr: true,
		},
		{
			name: "準正常系:指定したidを持つタスクが存在しない",
			mockFn: func(mr *task.MockTaskRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(
					nil,
					errors.ErrNotFoundTask,
				)
			},
			errType: errors.ErrNotFoundTask,
			input: UpdateTaskStateUsecaseInputDTO{
				ID:     "id",
				UserId: "user_id",
				State:  "doing",
			},
			wantErr: true,
		},
		{
			name: "準正常系:異なるuser_idで操作するとエラーが返る",
			mockFn: func(mr *task.MockTaskRepository) {
				mr.EXPECT().FindById(gomock.Any(), gomock.Any()).Return(
					task.ReconstructTask("id", "user_id", "this is content", 0),
					nil,
				)
			},
			errType: errors.ErrForbiddenTaskOperation,
			input: UpdateTaskStateUsecaseInputDTO{
				ID:     "id",
				UserId: "other_user_id",
				State:  "doing",
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			// モックを設定
			ctrl := gomock.NewController(t)
			mockTaskRepository := task.NewMockTaskRepository(ctrl)
			tt.mockFn(mockTaskRepository)
			// ユースケースオブジェクト
			sut := NewUpdateTaskStateUsecase(mockTaskRepository)
			ctx := context.Background()
			got, err := sut.Run(ctx, tt.input)
			// 期待するエラー型を設定していた場合はエラー型を比較して検証する
			if tt.errType != nil && !errors.Is(err, tt.errType) {
				t.Errorf("updateTaskState.Run = error:%v,want errYType:%v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("updateTaskState.Run = error:%v,wantErr:%v", err, tt.wantErr)
				return
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("updateTaskState.Run() -got,+want :%v ", diff)
			}
		})
	}
}

// app/application/usecase/task/fetch_task_usecase.go
package task

import "context"

type FetchTaskUsease struct {
	taskQueryService TaskQueryService
}

func NewFetchTaskUsease(taskQueryService TaskQueryService) *FetchTaskUsease {
	return &FetchTaskUsease{
		taskQueryService: taskQueryService,
	}
}

func (ftu *FetchTaskUsease) Run(ctx context.Context, input FetchTaskUsecaseInputDTO) (
	*FetchTaskUsecaseOutputDTO, error,
) {
	dto, err := ftu.taskQueryService.FetchTaskById(ctx, input.ID)
	if err != nil {
		return nil, err
	}
	// クエリサービスから得たdtoを詰め替える
	return &FetchTaskUsecaseOutputDTO{
		ID:       dto.ID,
		UserId:   dto.UserId,
		UserName: dto.UserName,
		Content:  dto.Content,
		State:    dto.State,
	}, nil
}

// app/application/usecase/task/fetch_task_usecase_dto.go
package task

type FetchTaskUsecaseInputDTO struct {
	ID string
}

type FetchTaskUsecaseOutputDTO struct {
	ID       string
	UserName string
	UserId   string
	Content  string
	State    string
}

// app/application/usecase/task/fetch_task_usecase_test.go
package task

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/kakkky/app/domain/errors"
	"go.uber.org/mock/gomock"
)

func TestTask_FetchTaskUsecase_Run(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name    string
		mockFn  func(mq *MockTaskQueryService)
		input   FetchTaskUsecaseInputDTO
		errType error
		want    *FetchTaskUsecaseOutputDTO
		wantErr bool
	}{
		{
			name: "正常系",
			mockFn: func(mq *MockTaskQueryService) {
				mq.EXPECT().FetchTaskById(gomock.Any(), gomock.Any()).Return(
					&FetchTaskDTO{
						ID:       "id",
						UserName: "user",
						UserId:   "user_id",
						Content:  "content",
						State:    "todo",
					}, nil,
				)
			},
			input: FetchTaskUsecaseInputDTO{
				ID: "id",
			},
			want: &FetchTaskUsecaseOutputDTO{
				ID:       "id",
				UserName: "user",
				UserId:   "user_id",
				Content:  "content",
				State:    "todo",
			},
			wantErr: false,
		},
		{
			name: "準正常系：指定のidを持つtaskが見つからない",
			mockFn: func(mq *MockTaskQueryService) {
				mq.EXPECT().FetchTaskById(gomock.Any(), gomock.Any()).Return(
					nil, errors.ErrNotFoundTask,
				)
			},
			input: FetchTaskUsecaseInputDTO{
				ID: "id",
			},
			errType: errors.ErrNotFoundTask,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			ctrl := gomock.NewController(t)
			mockTaskQueryService := NewMockTaskQueryService(ctrl)
			tt.mockFn(mockTaskQueryService)
			// ユースケースオブジェクト
			sut := NewFetchTaskUsease(mockTaskQueryService)
			ctx := context.Background()
			got, err := sut.Run(ctx, tt.input)
			// 期待するエラー型を設定していた場合はエラー型を比較して検証する
			if tt.errType != nil && !errors.Is(err, tt.errType) {
				t.Errorf("fetchTaskUsecase.Run = error:%v,want errYType:%v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("fetchTaskUsecase.Run = error:%v,wantErr:%v", err, tt.wantErr)
				return
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("fetchTaskUsecase.Run() -got,+want :%v ", diff)
			}
		})
	}
}

// app/application/usecase/task/fetch_tasks_usecase.go
package task

import "context"

type FetchTasksUsease struct {
	taskQueryService TaskQueryService
}

func NewFetchTasksUsease(taskQueryService TaskQueryService) *FetchTasksUsease {
	return &FetchTasksUsease{
		taskQueryService: taskQueryService,
	}
}

func (ftu *FetchTasksUsease) Run(ctx context.Context) (
	[]*FetchTaskUsecaseOutputDTO, error,
) {
	dtos, err := ftu.taskQueryService.FetchAllTasks(ctx)
	if err != nil {
		return nil, err
	}
	// クエリサービスから得たdtoを詰め替える
	outputs := make([]*FetchTaskUsecaseOutputDTO, 0, len(dtos))
	for _, dto := range dtos {
		outputs = append(outputs, &FetchTaskUsecaseOutputDTO{
			ID:       dto.ID,
			UserId:   dto.UserId,
			UserName: dto.UserName,
			Content:  dto.Content,
			State:    dto.State,
		})
	}
	return outputs, nil
}

// app/application/usecase/task/fetch_tasks_usecase_test.go
package task

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/kakkky/app/domain/errors"
	"go.uber.org/mock/gomock"
)

func TestTask_FetchTasksUsecase_Run(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name    string
		mockFn  func(mq *MockTaskQueryService)
		errType error
		want    []*FetchTaskUsecaseOutputDTO
		wantErr bool
	}{
		{
			name: "正常系",
			mockFn: func(mq *MockTaskQueryService) {
				mq.EXPECT().FetchAllTasks(gomock.Any()).Return(
					[]*FetchTaskDTO{
						{
							ID:       "id",
							UserName: "user",
							UserId:   "user_id",
							Content:  "content",
							State:    "todo",
						},
						{
							ID:       "id2",
							UserName: "user2",
							UserId:   "user_id2",
							Content:  "content",
							State:    "todo",
						},
					}, nil,
				)
			},
			want: []*FetchTaskUsecaseOutputDTO{
				{
					ID:       "id",
					UserName: "user",
					UserId:   "user_id",
					Content:  "content",
					State:    "todo",
				},
				{
					ID:       "id2",
					UserName: "user2",
					UserId:   "user_id2",
					Content:  "content",
					State:    "todo",
				},
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			ctrl := gomock.NewController(t)
			mockTaskQueryService := NewMockTaskQueryService(ctrl)
			tt.mockFn(mockTaskQueryService)
			// ユースケースオブジェクト
			sut := NewFetchTasksUsease(mockTaskQueryService)
			ctx := context.Background()
			got, err := sut.Run(ctx)
			// 期待するエラー型を設定していた場合はエラー型を比較して検証する
			if tt.errType != nil && !errors.Is(err, tt.errType) {
				t.Errorf("fetchTasksUsecase.Run = error:%v,want errYType:%v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("fetchTasksUsecase.Run = error:%v,wantErr:%v", err, tt.wantErr)
				return
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("fetchTasksUsecase.Run() -got,+want :%v ", diff)
			}
		})
	}
}