// app/adapter/repository/interface_querier.go
package repository

import "context"

// ORMはこのインターフェースを満たすように設計する
type Querier interface {
	DeleteTask(ctx context.Context, id string) error
	DeleteUser(ctx context.Context, id string) error
	FetchAllUser(ctx context.Context) ([]FetchAllUsersRow, error)
	FindTaskById(ctx context.Context, id string) (FindTaskByIdRow, error)
	FindUserByEmail(ctx context.Context, email string) (FindUserByEmailRow, error)
	FindUserById(ctx context.Context, id string) (FindUserByIdRow, error)
	InsertTask(ctx context.Context, arg InsertTaskParams) error
	InsertUser(ctx context.Context, arg InsertUserParams) error
	UpdateTask(ctx context.Context, arg UpdateTaskParams) error
	UpdateUser(ctx context.Context, arg UpdateUserParams) error
}

type FetchAllUsersRow struct {
	ID             string
	Email          string
	Name           string
	HashedPassword string
}

type FindUserByEmailRow struct {
	ID             string
	Email          string
	Name           string
	HashedPassword string
}

type FindUserByIdRow struct {
	ID             string
	Email          string
	Name           string
	HashedPassword string
}

type InsertUserParams struct {
	ID             string
	Name           string
	Email          string
	HashedPassword string
}

type UpdateUserParams struct {
	Name  string
	Email string
	ID    string
}

type FindTaskByIdRow struct {
	ID      string
	UserID  string
	Content string
	State   int32
}

type InsertTaskParams struct {
	ID      string
	UserID  string
	Content string
	State   int32
}

type UpdateTaskParams struct {
	State int32
	ID    string
}

// app/adapter/repository/user_repository.go
package repository

import (
	"context"
	"database/sql"

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

type userRepository struct {
	querier Querier
}

func NewUserRepository(querier Querier) user.UserRepository {
	return &userRepository{
		querier: querier,
	}
}

func (ur *userRepository) Save(ctx context.Context, user *user.User) error {
	arg := InsertUserParams{
		ID:             user.GetID(),
		Name:           user.GetName(),
		Email:          user.GetEmail().Value(),
		HashedPassword: user.GetHashedPassword().Value(),
	}
	if err := ur.querier.InsertUser(ctx, arg); err != nil {
		return err
	}
	return nil
}

func (ur *userRepository) FindByEmail(ctx context.Context, email user.Email) (*user.User, error) {
	u, err := ur.querier.FindUserByEmail(ctx, email.Value())
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return nil, errors.ErrNotFoundUser
	}
	if err != nil {
		return nil, err
	}
	user := user.ReconstructUser(
		u.ID,
		u.Email,
		u.Name,
		u.HashedPassword,
	)
	return user, nil
}

func (ur *userRepository) FindById(ctx context.Context, id string) (*user.User, error) {
	u, err := ur.querier.FindUserById(ctx, id)
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return nil, errors.ErrNotFoundUser
	}
	if err != nil {
		return nil, err
	}
	user := user.ReconstructUser(
		u.ID,
		u.Email,
		u.Name,
		u.HashedPassword,
	)
	return user, nil
}

func (ur *userRepository) FetchAllUsers(ctx context.Context) (user.Users, error) {
	us, err := ur.querier.FetchAllUser(ctx)
	if err != nil {
		return nil, err
	}
	// あらかじめ配列のキャパを確保しておく
	users := make(user.Users, 0, len(us))
	for _, u := range us {
		user := user.ReconstructUser(
			u.ID,
			u.Email,
			u.Name,
			u.HashedPassword,
		)
		users = append(users, user)
	}
	return users, nil
}

func (ur *userRepository) Update(ctx context.Context, user *user.User) error {
	params := UpdateUserParams{
		Name:  user.GetName(),
		Email: user.GetEmail().Value(),
		ID:    user.GetID(),
	}
	if err := ur.querier.UpdateUser(ctx, params); err != nil {
		return err
	}
	return nil
}

func (ur *userRepository) Delete(ctx context.Context, user *user.User) error {
	if err := ur.querier.DeleteUser(ctx, user.GetID()); err != nil {
		return err
	}
	return nil
}

// app/adapter/repository/task_repository.go
package repository

import (
	"context"
	"database/sql"

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

type taskRepository struct {
	querier Querier
}

func NewTaskRepository(querier Querier) task.TaskRepository {
	return &taskRepository{
		querier: querier,
	}
}

func (tr *taskRepository) FindById(ctx context.Context, id string) (*task.Task, error) {
	t, err := tr.querier.FindTaskById(ctx, id)
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return nil, errors.ErrNotFoundTask
	}
	if err != nil {
		return nil, err
	}
	task := task.ReconstructTask(
		t.ID,
		t.UserID,
		t.Content,
		int(t.State),
	)
	return task, nil
}

func (tr *taskRepository) Save(ctx context.Context, task *task.Task) error {
	arg := InsertTaskParams{
		ID:      task.GetID(),
		UserID:  task.GetUserId(),
		Content: task.GetContent().Value(),
		State:   int32(task.GetState().IntValue()),
	}
	if err := tr.querier.InsertTask(ctx, arg); err != nil {
		return err
	}
	return nil
}

func (tr *taskRepository) Update(ctx context.Context, task *task.Task) error {
	arg := UpdateTaskParams{
		ID:    task.GetID(),
		State: int32(task.GetState().IntValue()),
	}
	if err := tr.querier.UpdateTask(ctx, arg); err != nil {
		return err
	}
	return nil
}

func (tr *taskRepository) Delete(ctx context.Context, task *task.Task) error {
	if err := tr.querier.DeleteTask(ctx, task.GetID()); err != nil {
		return err
	}
	return nil
}

usersテーブルの操作

-- app/infrastructure/db/sqlc/queries/users.sql
-- name: FindUserByEmail :one
select id,email,name,hashed_password
from users
where email = sqlc.arg(email);

-- name: FindUserById :one
select id,email,name,hashed_password
from users
where id = sqlc.arg(id);

-- name: FetchAllUsers :many
select id,email,name,hashed_password
from users;

-- name: InsertUser :exec
insert into users (
    id,
    name,
    email,
    hashed_password
) values (
    sqlc.arg(id),
    sqlc.arg(name),
    sqlc.arg(email),
    sqlc.arg(hashed_password)
);

-- name: UpdateUser :exec
update users
set name=sqlc.arg(name),email=sqlc.arg(email)
where id=sqlc.arg(id);

-- name: DeleteUser :exec
delete from users
where id=sqlc.arg(id);

tasksテーブルの操作

-- app/infrastructure/db/sqlc/queries/tasks.sql
-- name: FindTaskById :one
select id,user_id,content,state
from tasks
where id = sqlc.arg(id);

-- name: FetchTaskById :one
select t.id,u.name,t.user_id,t.content,t.state
from tasks as t inner join users as u
on t.user_id = u.id
where t.id = sqlc.arg(id);

-- name: FetchUserTasks :many
select t.id,u.name,t.user_id,t.content,t.state
from tasks as t inner join users as u
on t.user_id = u.id
where t.user_id = sqlc.arg(user_id);

-- name: FetchAllTasks :many
select t.id,u.name,t.user_id,t.content,t.state
from tasks as t inner join users as u
on t.user_id = u.id;

-- name: InsertTask :exec
insert into tasks(
    id,
    user_id,
    content,
    state
)values(
    sqlc.arg(id),
    sqlc.arg(user_id),
    sqlc.arg(content),
    sqlc.arg(state)
);

-- name: UpdateTask :exec
update tasks
set state=sqlc.arg(state)
where id = sqlc.arg(id);

-- name: DeleteTask :exec
delete from tasks
where id=sqlc.arg(id);

// app/infrastructure/db/sqlc/sqlc_querier.go
package sqlc

import (
	"context"

	"github.com/kakkky/app/adapter/repository"
	"github.com/kakkky/app/infrastructure/db"
)

// Querierインターフェースを満たす
// sqlcはここから利用する
type SqlcQuerier struct {
	queries *Queries
}

func NewSqlcQuerier() *SqlcQuerier {
	return &SqlcQuerier{
		queries: New(db.GetDB()),
	}
}

func (sq *SqlcQuerier) DeleteTask(ctx context.Context, id string) error {
	return sq.queries.DeleteTask(ctx, id)
}

func (sq *SqlcQuerier) DeleteUser(ctx context.Context, id string) error {
	return sq.queries.DeleteUser(ctx, id)
}

func (sq *SqlcQuerier) FetchAllUser(ctx context.Context) ([]repository.FetchAllUsersRow, error) {
	rows, err := sq.queries.FetchAllUsers(ctx)
	var r []repository.FetchAllUsersRow
	for _, row := range rows {
		r = append(r, repository.FetchAllUsersRow(row))
	}
	return r, err
}

func (sq *SqlcQuerier) FindTaskById(ctx context.Context, id string) (repository.FindTaskByIdRow, error) {
	row, err := sq.queries.FindTaskById(ctx, id)
	return repository.FindTaskByIdRow(row), err
}

func (sq *SqlcQuerier) FindUserByEmail(ctx context.Context, email string) (repository.FindUserByEmailRow, error) {
	row, err := sq.queries.FindUserByEmail(ctx, email)
	return repository.FindUserByEmailRow(row), err
}

func (sq *SqlcQuerier) FindUserById(ctx context.Context, id string) (repository.FindUserByIdRow, error) {
	row, err := sq.queries.FindUserById(ctx, id)
	return repository.FindUserByIdRow(row), err
}

func (sq *SqlcQuerier) InsertTask(ctx context.Context, arg repository.InsertTaskParams) error {
	return sq.queries.InsertTask(ctx, InsertTaskParams(arg))
}

func (sq *SqlcQuerier) InsertUser(ctx context.Context, arg repository.InsertUserParams) error {
	return sq.queries.InsertUser(ctx, InsertUserParams(arg))
}

func (sq *SqlcQuerier) UpdateTask(ctx context.Context, arg repository.UpdateTaskParams) error {
	return sq.queries.UpdateTask(ctx, UpdateTaskParams(arg))
}

func (sq *SqlcQuerier) UpdateUser(ctx context.Context, arg repository.UpdateUserParams) error {
	return sq.queries.UpdateUser(ctx, UpdateUserParams(arg))
}

// app/infrastructure/db/container/dockertest.go
package container

import (
	"log"

	"github.com/ory/dockertest/v3"
	"github.com/ory/dockertest/v3/docker"
)

var (
	userName = "root"
	password = "secret"
	hostname = "localhost"
	dbName   = "test-db"
	port     int //ポート番号は起動したコンテナから取得する（ランダム）
)

// DockerTestのコンテナを起動
func NewDockertestContainer() (*dockertest.Pool, *dockertest.Resource) {
	// デフォルトでUnixソケットを使用する
	pool, err := dockertest.NewPool("")
	if err != nil {
		log.Fatalf("failled to construct pool:%v", err)
	}
	// Dockerに接続確認
	if err := pool.Client.Ping(); err != nil {
		log.Fatalf("failed to connect to Docker: %v", err)
	}
	// コンテナの起動設定を指定
	runOptions := &dockertest.RunOptions{
		Repository: "mysql",
		Tag:        "8",
		Env: []string{
			"MYSQL_ROOT_PASSWORD=" + password,
			"MYSQL_DATABASE=" + dbName,
		},
		// 開発環境の設定に揃える
		Cmd: []string{
			"mysqld",
			"--character-set-server=utf8mb4",
			"--collation-server=utf8mb4_unicode_ci",
		},
	}
	resource, err := pool.RunWithOptions(runOptions, func(hc *docker.HostConfig) {
		// コンテナは停止後に自動削除される
		hc.AutoRemove = true
		// コンテナが異常終了しても再起動しない
		hc.RestartPolicy = docker.RestartPolicy{
			Name: "no",
		}
	})
	if err != nil {
		log.Fatalf("failed to start resource: %v", err)
	}
	return pool, resource
}

// コンテナを削除する
func RemoveDockertestContainer(pool *dockertest.Pool, resource *dockertest.Resource) {
	if err := pool.Purge(resource); err != nil {
		log.Fatalf("failed to  purge resource: %s", err)
	}
}

// app/infrastructure/db/container/db.go
package container

import (
	"database/sql"
	"fmt"
	"log"
	"path/filepath"
	"runtime"
	"strconv"

	"github.com/golang-migrate/migrate/v4"
	_ "github.com/golang-migrate/migrate/v4/database/mysql"
	_ "github.com/golang-migrate/migrate/v4/source/file"
	"github.com/kakkky/app/domain/errors"
	"github.com/ory/dockertest/v3"
)

// DBに接続する
func NewDB(pool *dockertest.Pool, resource *dockertest.Resource) *sql.DB {
	var db *sql.DB
	// エラーだと再実行を繰り返す
	if err := pool.Retry(func() error {
		var err error
		// 公開ポート番号を取得
		port, err = strconv.Atoi(resource.GetPort("3306/tcp")) //コンテナ内のポート番号は3306
		if err != nil {
			return err
		}
		// DBに接続
		db, err = sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?parseTime=true", userName, password, hostname, port, dbName))
		if err != nil {
			return err
		}
		// 接続確認
		return db.Ping()
	}); err != nil {
		log.Fatalf("failed to connect to database: %v", err)
	}
	return db
}

func SetupDB() {
	migrationsPath := getMigrationsPath()
	m, err := migrate.New(migrationsPath, fmt.Sprintf("mysql://%s:%s@tcp(%s:%d)/%s?parseTime=true", userName, password, hostname, port, dbName))
	if err != nil {
		log.Fatalf("failed to create migrate instance:%v", err)
	}
	// マイグレーションをテストDBに適用させる
	if err := m.Up(); err != nil {
		if errors.Is(err, migrate.ErrNoChange) {
			log.Println("migrations have already been applied")
		} else {
			log.Fatalf("failed to up migrations:%v", err)
		}
	}
}

const migrationsRelativePath = "../migrations"

// どこからSetupDBを呼び出しても/migrationsへのパスを取得できるようにする
func getMigrationsPath() string {
	// Callerを呼んだファイル名（ファイルパス）を取得する
	_, callerFile, _, ok := runtime.Caller(0)
	print(callerFile)
	if !ok {
		log.Fatal("failed to get caller directory")
	}
	// ファイルパスからディレクトリ部分を取り出す
	callerDir := filepath.Dir(callerFile)
	// /migrationsへの絶対パスを作成
	migrationsAbsPath := "file://" + filepath.Join(callerDir, migrationsRelativePath)
	return migrationsAbsPath
}

// app/infrastructure/db/repository_test/repository_test.go
package repository_test

import (
	"log"
	"testing"

	"github.com/kakkky/app/infrastructure/db"
	"github.com/kakkky/app/infrastructure/db/container"
)

func TestMain(m *testing.M) {
	//dockertestコンテナを起動
	pool, resource := container.NewDockertestContainer()
	log.Println("success to start dockertest container")
	defer func() {
		container.RemoveDockertestContainer(pool, resource)
		log.Println("success to remove dockertest container")
	}()
	// DBに接続
	testDB := container.NewDB(pool, resource)
	log.Println("success to connect test-db")
	defer testDB.Close()
	// マイグレーションを適用させる
	container.SetupDB()
	log.Println("success to apply migrations")
	// dbパッケージ変数にテスト用DBをセット
	db.SetDB(testDB)
	log.Println("dockertest & test-db settings complete")

    // (第10章ではRedisのテスト用クライアントの処理を呼び出します)

	m.Run()
}

// app/infrastructure/repository_test/user_repository_test.go
package repository_test

import (
	"context"
	"fmt"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/kakkky/app/adapter/repository"
	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/domain/user"
	"github.com/kakkky/app/infrastructure/db/sqlc"
	testhelper "github.com/kakkky/app/infrastructure/db/testhelper"
)

func TestUserRepository_Save(t *testing.T) {
	userRepository := repository.NewUserRepository(sqlc.NewSqlcQuerier())
	// ユーザーインスタンスを用意
	user0, _ := user.NewUser(
		"[email protected]",
		"user0",
		"password",
	)
	type args struct {
		user  *user.User
		email user.Email
	}
	// テストテーブル
	tests := []struct {
		name    string
		args    args
		want    *user.User
		wantErr bool
	}{
		{
			name: "正常系: 1人ユーザーが追加され、emailで検索できる",
			args: args{
				user:  user0,
				email: user0.GetEmail(),
			},
			want:    user0,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			ctx := context.Background()
			// ユーザーを保存
			if err := userRepository.Save(ctx, tt.args.user); (err != nil) != tt.wantErr {
				t.Errorf("userRepository.Save()=error %v ,but wantErr:%v", err, tt.wantErr)
			}
			// ユーザーをemailで検索
			got, err := userRepository.FindByEmail(ctx, tt.args.email)
			// 返すエラーはErrNotFoundUserのみであるべき
			if (err != nil) != tt.wantErr {
				t.Errorf("userRepository.FindByEmail() =　error %v,but wantErr :%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(user.User{}, user.Email{}, user.HashedPassword{}), cmpopts.IgnoreFields(user.User{}, "id", "hashedPassword")); diff != "" {
				t.Errorf("userRepository.FindByEmail() -got,+want :%v ", diff)
			}
		})
	}
}

func TestUserRepository_FindByEmail(t *testing.T) {
	userRepository := repository.NewUserRepository(sqlc.NewSqlcQuerier())
	user1, _ := user.NewUser(
		"[email protected]",
		"user1",
		"password",
	)
	noExistentUser, _ := user.NewUser(
		"[email protected]",
		"noexistent",
		"password",
	)
	type args struct {
		email user.Email
	}
	tests := []struct {
		name    string
		args    args
		want    *user.User
		errType error
		wantErr bool
	}{
		{
			name: "正常系：ユーザーを検索できる",
			args: args{
				email: user1.GetEmail(),
			},
			want:    user1,
			wantErr: false,
		},
		{
			name: "準正常系：ユーザーが見つからなければErrNotFoundUserが返ってくる",
			args: args{
				// 存在しないuser2のemailで検索
				email: noExistentUser.GetEmail(),
			},
			errType: errors.ErrNotFoundUser,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			// user1のみがDBに保存されている
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml")
			ctx := context.Background()
			got, err := userRepository.FindByEmail(ctx, tt.args.email)
			// 期待されるエラータイプが設定されている場合はそれも検証
			if (err != nil) != tt.wantErr && tt.errType != nil {
				t.Errorf("userRepository.FindByEmail() =error:%v, want errType:%v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("userRepository.FindByEmail() =error:%v, wantErr:%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(user.User{}, user.Email{}, user.HashedPassword{}), cmpopts.IgnoreFields(user.User{}, "id", "hashedPassword")); diff != "" {
				t.Errorf("userRepository.FindByEmail() -got,+want :%v ", diff)
			}
		})
	}
}
func TestUserRepository_FindById(t *testing.T) {
	userRepository := repository.NewUserRepository(sqlc.NewSqlcQuerier())
	user1 := user.ReconstructUser(
		"1",
		"[email protected]",
		"user1",
		"password",
	)
	noExistentUser := user.ReconstructUser(
		"noExistent",
		"",
		"",
		"",
	)
	type args struct {
		id string
	}
	tests := []struct {
		name    string
		args    args
		want    *user.User
		errType error
		wantErr bool
	}{
		{
			name: "正常系：ユーザーを検索できる",
			args: args{
				id: user1.GetID(),
			},
			want:    user1,
			wantErr: false,
		},
		{
			name: "準正常系：ユーザーが見つからなければErrNotFoundUserが返ってくる",
			args: args{
				id: noExistentUser.GetID(),
			},
			errType: errors.ErrNotFoundUser,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			// user1のみがDBに保存されている
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml")
			ctx := context.Background()
			got, err := userRepository.FindById(ctx, tt.args.id)
			// 期待されるエラータイプが設定されている場合はそれも検証
			if (err != nil) != tt.wantErr && tt.errType != nil && errors.Is(err, tt.errType) {
				t.Errorf("userRepository.FindById() =error:%v, want errType:%v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("userRepository.FindById() =error:%v, wantErr:%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(user.User{}, user.Email{}, user.HashedPassword{}), cmpopts.IgnoreFields(user.User{}, "id", "hashedPassword")); diff != "" {
				t.Errorf("userRepository.FindById() -got,+want :%v ", diff)
			}
		})
	}
}

func TestUserRepository_FetchAllUsers(t *testing.T) {
	userRepository := repository.NewUserRepository(sqlc.NewSqlcQuerier())
	var users user.Users
	for i := 0; i < 3; i++ {
		u, _ := user.NewUser(
			fmt.Sprintf("user%[email protected]", i+1),
			fmt.Sprintf("user%d", i+1),
			"password",
		)
		users = append(users, u)
	}
	tests := []struct {
		name    string
		want    user.Users
		wantErr bool
	}{
		{
			name:    "正常系：全てのユーザーを取得できる",
			want:    users,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml")
			ctx := context.Background()
			got, err := userRepository.FetchAllUsers(ctx)
			if (err != nil) != tt.wantErr {
				t.Errorf("userRepository.FetchAllUsers() =error:%v, wantErr:%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(user.User{}, user.Email{}, user.HashedPassword{}), cmpopts.IgnoreFields(user.User{}, "id", "hashedPassword")); diff != "" {
				t.Errorf("userRepository.FetchAllUsers() -got,+want :%v ", diff)
			}
		})
	}
}

func TestUserRepository_Update(t *testing.T) {
	userRepository := repository.NewUserRepository(sqlc.NewSqlcQuerier())
	// 更新情報を詰め替えて再構成したユーザー
	updatingUser := user.ReconstructUser(
		"1",
		"[email protected]", // 更新
		"updatedUser",      // 更新
		"password",
	)
	updatingNameUser := user.ReconstructUser(
		"1",
		"[email protected]",
		"nameUpdatedUser", //更新
		"password",
	)
	type args struct {
		user *user.User
	}
	tests := []struct {
		name    string
		args    args
		want    *user.User
		wantErr bool
	}{
		{
			name: "正常系: emailとnameの両方を更新する",
			args: args{
				user: updatingUser,
			},
			want:    updatingUser,
			wantErr: false,
		},
		{
			name: "正常系: nameのみを更新する",
			args: args{
				user: updatingNameUser,
			},
			want:    updatingNameUser,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml")
			ctx := context.Background()
			if err := userRepository.Update(ctx, tt.args.user); (err != nil) != tt.wantErr {
				t.Errorf("userRepository.Update()=error:%v, wantErr:%v", err, tt.wantErr)
			}
			got, err := userRepository.FindByEmail(ctx, tt.args.user.GetEmail())
			if (err != nil) != tt.wantErr {
				t.Errorf("userRepository.FindByEmail()=error:%v, wantErr:%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(user.User{}, user.Email{}, user.HashedPassword{}), cmpopts.IgnoreFields(user.User{}, "id", "hashedPassword")); diff != "" {
				t.Errorf("userRepository.FindByEmail() -got,+want :%v ", diff)
			}
		})
	}
}
func TestUserRepository_Delete(t *testing.T) {
	userRepository := repository.NewUserRepository(sqlc.NewSqlcQuerier())
	deletingUser := user.ReconstructUser(
		"1",
		"[email protected]",
		"user1",
		"password",
	)
	type args struct {
		user *user.User
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "正常系: 指定のユーザーを削除できる",
			args: args{
				user: deletingUser,
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml")
			ctx := context.Background()
			if err := userRepository.Delete(ctx, tt.args.user); (err != nil) != tt.wantErr {
				t.Errorf("userRepository.Delete()=error:%v, wantErr:%v", err, tt.wantErr)
			}
			_, err := userRepository.FindByEmail(ctx, deletingUser.GetEmail())
			// エラーがあればそれはErrNotFoundUserであるべき
			if (err != nil) != tt.wantErr && !errors.Is(err, errors.ErrNotFoundUser) {
				t.Errorf("userRepository.FindByEmail()=error:%v, wantErr:%v", err, tt.wantErr)
			}
		})
	}
}

// app/infrastructure/repository_test/task_repository_test.go
package repository_test

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/kakkky/app/adapter/repository"
	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/domain/task"
	"github.com/kakkky/app/infrastructure/db/sqlc"
	testhelper "github.com/kakkky/app/infrastructure/db/testhelper"
)

func TestTaskRepository_Save(t *testing.T) {
	taskRepository := repository.NewTaskRepository(sqlc.NewSqlcQuerier())
	ta, _ := task.NewTask(
		"1",
		"content",
		"todo",
	)
	type args struct {
		task *task.Task
	}
	tests := []struct {
		name    string
		args    args
		want    *task.Task
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				task: ta,
			},
			want:    ta,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml")

			ctx := context.Background()
			// タスクを保存
			if err := taskRepository.Save(ctx, tt.args.task); (err != nil) != tt.wantErr {
				t.Errorf("taskRepository.Save() = error %v, wantErr %v", err, tt.wantErr)
			}
			// FindByIdで検索して確かめる
			got, err := taskRepository.FindById(ctx, ta.GetID())
			if (err != nil) != tt.wantErr {
				t.Errorf("taskRepository.FindById() =　error %v,but wantErr :%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(task.Task{}, task.Content{}), cmpopts.IgnoreFields(task.Task{}, "id")); diff != "" {
				t.Errorf("userRepository.FindByEmail() -got,+want :%v ", diff)
			}
		})
	}
}

func TestTaskRepository_FindById(t *testing.T) {
	taskRepository := repository.NewTaskRepository(sqlc.NewSqlcQuerier())
	task1 := task.ReconstructTask(
		"1",
		"1",
		"content",
		0,
	)

	type args struct {
		id string
	}
	tests := []struct {
		name    string
		args    args
		want    *task.Task
		errType error
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				id: "1",
			},
			want:    task1,
			wantErr: false,
		},
		{
			name: "準正常系: 存在しないタスクIDではErrNotFoundTaskが返る",
			args: args{
				id: "invalid",
			},
			errType: errors.ErrNotFoundTask,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			// task1のみがDBに保存されている
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml", "testdata/fixtures/tasks.yml")
			ctx := context.Background()
			got, err := taskRepository.FindById(ctx, tt.args.id)
			if (err != nil) != tt.wantErr && tt.errType != nil && errors.Is(err, tt.errType) {
				t.Errorf("taskRepository.FindById() = error %v, want errType %v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("taskRepository.FindById() = error %v, wantErr %v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(task.Task{}, task.Content{})); diff != "" {
				t.Errorf("taskRepository.FindById() -got,+want : %v", diff)
			}
		})
	}
}

func TestTaskRepository_Update(t *testing.T) {
	taskRepository := repository.NewTaskRepository(sqlc.NewSqlcQuerier())
	// 更新するタスク
	updatingTask := task.ReconstructTask(
		"1",
		"1",
		"content",
		1,
	)

	type args struct {
		task *task.Task
	}
	tests := []struct {
		name    string
		args    args
		want    *task.Task
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				task: updatingTask,
			},
			want:    updatingTask,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			// 既存のタスクを更新
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml", "testdata/fixtures/tasks.yml")

			ctx := context.Background()
			if err := taskRepository.Update(ctx, tt.args.task); (err != nil) != tt.wantErr {
				t.Errorf("taskRepository.Update() = error %v, wantErr %v", err, tt.wantErr)
			}
			// FindByIdで検索して確かめる
			got, err := taskRepository.FindById(ctx, tt.args.task.GetID())
			if (err != nil) != tt.wantErr {
				t.Errorf("taskRepository.FindById() = error %v, wantErr %v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(task.Task{}, task.Content{})); diff != "" {
				t.Errorf("taskRepository.FindById() -got,+want : %v", diff)
			}
		})
	}
}

func TestTaskRepository_Delete(t *testing.T) {
	taskRepository := repository.NewTaskRepository(sqlc.NewSqlcQuerier())
	// 更新するタスク
	deletingTask := task.ReconstructTask(
		"1",
		"1",
		"content",
		1,
	)
	type args struct {
		task *task.Task
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				deletingTask,
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			// 既存のタスクを更新
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml", "testdata/fixtures/tasks.yml")

			ctx := context.Background()
			if err := taskRepository.Delete(ctx, tt.args.task); (err != nil) != tt.wantErr {
				t.Errorf("taskRepository.Delete() = error %v, wantErr %v", err, tt.wantErr)
			}
			// FindByIdで検索して確かめる
			_, err := taskRepository.FindById(ctx, tt.args.task.GetID())
			if (err != nil) != tt.wantErr && !errors.Is(err, errors.ErrNotFoundTask) {
				t.Errorf("taskRepository.FindById()=error:%v, wantErr:%v", err, tt.wantErr)
			}
		})
	}
}