JSONのフォーマットを整形するヘルパー関数

// app/infrastructure/api_test/testhelper/format_json.go
package testhelper

import (
	"bytes"
	"encoding/json"
	"testing"
)

func FormatJSON(t *testing.T, b []byte) []byte {
	t.Helper()

	var out bytes.Buffer
	// bodyをインデント整形し、バッファoutに書き込む
	err := json.Indent(&out, b, "", "  ")
	if err != nil {
		t.Fatal(err)
	}

	return out.Bytes()
}

ランダムに生成されるULIDの値を固定化するヘルパー関数

// app/infrastructure/api_test/testhelper/normalize_ulid.go
package testhelper

import (
	"regexp"
	"testing"
)

func NormalizeULID(t *testing.T, b []byte) []byte {
	t.Helper()

	regexp := regexp.MustCompile(`"id":\s?"[0-9A-HJKMNP-TV-Z]{26}"`)
	s := regexp.ReplaceAllString(string(b), `"id": "ulid"`)
	return []byte(s)
}

レスポンスとして返るJSONが含むjwt_tokenフィールドの中身を固定化する

// app/infrastructure/api_test/testhelper/normalize_jwt.go
package testhelper

import (
	"regexp"
	"testing"
)

func NormalizeJWT(t *testing.T, b []byte) []byte {
	t.Helper()

	// 正規表現でJWT全体を "jwt" に置き換える
	regexp := regexp.MustCompile(`"jwt_token":\s?"[^"]+"`)
	s := regexp.ReplaceAllString(string(b), `"jwt_token": "jwt"`)
	return []byte(s)
}

認証状態を操作するヘルパー関数

// app/infrastructure/api_test/testhelper/setup_auth.go
package testhelper

import (
	"context"
	"testing"
	"time"

	"github.com/kakkky/app/adapter/repository"
	"github.com/kakkky/app/infrastructure/auth"
	"github.com/kakkky/app/infrastructure/kvs"
)

// ログイン状態をセットアップする
// userID：JTIのペアを、KVSに保存する
// 生成したJWTトークンを返す
func LoginForTest(t *testing.T, userID string) string {
	t.Helper()

	jwtAuthenticator := auth.NewJwtAuthenticator()
	// トークン生成
	jwtToken, err := jwtAuthenticator.GenerateJwtToken(userID, "jti")
	if err != nil {
		t.Fatalf("error occuerd in jwtAuthenticator.GenerateJwtToken() :%v", err)
	}
	jwtAuthenticatorRepository := repository.NewJwtAuthenticatorRepository(kvs.NewRedisCommander())
	// Redisに保存
	jwtAuthenticatorRepository.Save(context.Background(), time.Duration(2*time.Hour), userID, "jti")
	return jwtToken
}

func LogoutForTest(t *testing.T, userID string) {
	t.Helper()

	jwtAuthenticatorRepository := repository.NewJwtAuthenticatorRepository(kvs.NewRedisCommander())
	if err := jwtAuthenticatorRepository.Delete(context.Background(), userID); err != nil {
		t.Fatalf("error occured in jwtAuthenticatorRepository.Delete() :%v", err)
	}
}

ユーザー

# app/infrastructure/api_test/testdata/fixtures/users.yml
- id: 1
  name: user1
  email: [email protected]
  # passwordという文字列をハッシュ化した値
  hashed_password: $2a$10$GJ6IGQeueUpFmo/kGXQEiOaVjD/Mma.3OlWwcr9P82L32gkUm6UqG%

- id: 2
  name: user2
  email: [email protected]
  hashed_password: $2a$10$GJ6IGQeueUpFmo/kGXQEiOaVjD/Mma.3OlWwcr9P82L32gkUm6UqG%

- id: 3
  name: user3
  email: [email protected]
  hashed_password: $2a$10$GJ6IGQeueUpFmo/kGXQEiOaVjD/Mma.3OlWwcr9P82L32gkUm6UqG%

- id: 4
  name: user4
  email: [email protected]
  hashed_password: $2a$10$GJ6IGQeueUpFmo/kGXQEiOaVjD/Mma.3OlWwcr9P82L32gkUm6UqG%

- id: 5
  name: user5
  email: [email protected]
  hashed_password: $2a$10$GJ6IGQeueUpFmo/kGXQEiOaVjD/Mma.3OlWwcr9P82L32gkUm6UqG%

- id: 6
  name: user6
  email: [email protected]
  hashed_password: $2a$10$GJ6IGQeueUpFmo/kGXQEiOaVjD/Mma.3OlWwcr9P82L32gkUm6UqG%

タスク

# app/infrastructure/api_test/testdata/fixtures/tasks.yml
- id: 1
  user_id: 1
  content: content
  state: 0

- id: 2
  user_id: 1
  content: content
  state: 0

- id: 3
  user_id: 2
  content: content
  state: 1

- id: 4
  user_id: 2
  content: content
  state: 1

// app/infrastructure/api_test/integration/api_test.go
package integration

import (
	"log"
	"net/http"
	"testing"

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

var mux http.Handler

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")

	// テスト用のredisサーバーを起動
	cli := kvs.NewRedisTestClient()
	defer cli.Close()

	// ルーティングを初期化
	mux = router.NewMux()

	m.Run()
}

// app/infrastructure/api_test/integration/user_api_test.go
//go:build integration

package integration

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/kakkky/app/adapter/presentation/handler/user"
	"github.com/kakkky/app/infrastructure/api_test/testhelper"
	dbTesthelper "github.com/kakkky/app/infrastructure/db/testhelper"
	"github.com/sebdah/goldie/v2"
)

func TestUser_GetUsers(t *testing.T) {
	tests := []struct {
		name     string
		wantCode int
		gfName   string
		isLogin  bool //ログインさせるか
	}{
		{
			name:     "正常系",
			wantCode: http.StatusOK,
			gfName:   "get_users_nomal",
			isLogin:  true,
		},
		{
			name:     "準正常系：未ログイン",
			wantCode: http.StatusUnauthorized,
			gfName:   "get_users_seminomal_not_loggedin",
			isLogin:  false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml")

			// リクエストボディをマーシャル（→json）
			r := httptest.NewRequest(http.MethodGet, "/users", nil)
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				defer testhelper.LogoutForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			// リクエストを送信
			mux.ServeHTTP(rw, r)
			// ステータスコードを検証
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			resp := testhelper.FormatJSON(
				t,
				rw.Body.Bytes(),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/user"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

func TestUser_PostUser(t *testing.T) {
	tests := []struct {
		name     string
		wantCode int
		req      user.PostUserRequest
		gfName   string
	}{
		{
			name:     "正常系",
			wantCode: http.StatusCreated,
			req: user.PostUserRequest{
				Email:    "[email protected]",
				Name:     "user0",
				Password: "password",
			},
			gfName: "post_user_nomal",
		},
		{
			name:     "準正常系:すでに登録しているメールアドレス",
			wantCode: http.StatusBadRequest,
			req: user.PostUserRequest{
				Email:    "[email protected]",
				Name:     "user1",
				Password: "password",
			},
			gfName: "post_user_seminomal_dup_email",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml")

			// リクエストボディをマーシャル（→json）
			b, _ := json.Marshal(tt.req)
			r := httptest.NewRequest(http.MethodPost, "/users", bytes.NewBuffer(b))
			rw := httptest.NewRecorder()
			mux.ServeHTTP(rw, r)
			// ステータスコードを検証
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			resp := testhelper.FormatJSON(
				t,
				testhelper.NormalizeULID(t, rw.Body.Bytes()),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/user"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

func TestUser_UpdateUser(t *testing.T) {
	tests := []struct {
		name     string
		wantCode int
		req      user.UpdateUserRequest
		gfName   string
		isLogin  bool //ログインさせるか
	}{
		{
			name:     "正常系 : id=1のユーザーを更新する",
			wantCode: http.StatusOK,
			req: user.UpdateUserRequest{
				Email: "[email protected]",
				Name:  "updated",
			},
			gfName:  "update_user_nomal",
			isLogin: true,
		},
		{
			name:     "準正常系 : 未ログイン",
			wantCode: http.StatusUnauthorized,
			req: user.UpdateUserRequest{
				Email: "[email protected]",
				Name:  "updated",
			},
			gfName:  "update_user_seminormal_not_loggedin",
			isLogin: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml")

			// リクエストボディをマーシャル（→json）
			b, _ := json.Marshal(tt.req)
			r := httptest.NewRequest(http.MethodPatch, "/users/me", bytes.NewBuffer(b))
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				defer testhelper.LogoutForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			// リクエストを送信
			mux.ServeHTTP(rw, r)
			// ステータスコードを検証
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			resp := testhelper.FormatJSON(
				t,
				rw.Body.Bytes(),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/user"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

func TestUser_DeleteUser(t *testing.T) {
	tests := []struct {
		name     string
		gfName   string
		wantCode int
		isLogin  bool
	}{
		{
			name:     "正常系:id=1のユーザーを削除",
			wantCode: http.StatusNoContent,
			gfName:   "delete_user_nomal",
			isLogin:  true,
		},
		{
			name:     "準正常系:未ログイン",
			wantCode: http.StatusUnauthorized,
			gfName:   "delete_user_seminomal_not_loggedin",
			isLogin:  false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml")

			r := httptest.NewRequest(http.MethodDelete, "/users/me", nil)
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				defer testhelper.LogoutForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			mux.ServeHTTP(rw, r)
			// ステータスコードを検証
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			// 204ステータスコードなら、JSONは返らないのでここで終了
			if rw.Code == http.StatusNoContent {
				return
			}
			resp := testhelper.FormatJSON(
				t,
				rw.Body.Bytes(),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/user"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

// app/infrastructure/api_test/integration/task_api_test.go
//go:build integration

package integration

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/kakkky/app/adapter/presentation/handler/task"
	"github.com/kakkky/app/infrastructure/api_test/testhelper"
	dbTesthelper "github.com/kakkky/app/infrastructure/db/testhelper"
	"github.com/sebdah/goldie/v2"
)

func TestTask_GetTask(t *testing.T) {
	tests := []struct {
		name      string
		pathParam string
		wantCode  int
		gfName    string
		isLogin   bool //ログインさせるか
	}{
		{
			name:      "正常系",
			wantCode:  http.StatusOK,
			pathParam: "1",
			gfName:    "get_task_nomal",
			isLogin:   true,
		},
		{
			name:      "準正常系：未ログイン",
			wantCode:  http.StatusUnauthorized,
			pathParam: "1",
			gfName:    "get_task_seminomal_not_loggedin",
			isLogin:   false,
		},
		{
			name:      "準正常系：存在しないタスク",
			pathParam: "0", //存在しないタスクのid
			wantCode:  http.StatusBadRequest,
			gfName:    "get_task_seminomal_not_found",
			isLogin:   true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml", "../testdata/fixtures/tasks.yml")
			// リクエストボディをマーシャル（→json）
			r := httptest.NewRequest(http.MethodGet, "/tasks/"+tt.pathParam, nil)
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				defer testhelper.LogoutForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			// リクエストを送信
			mux.ServeHTTP(rw, r)
			// ステータスコードを検証
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			resp := testhelper.FormatJSON(
				t,
				rw.Body.Bytes(),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/task"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

func TestTask_GetTasks(t *testing.T) {
	tests := []struct {
		name     string
		wantCode int
		gfName   string
		isLogin  bool //ログインさせるか
	}{
		{
			name:     "正常系",
			wantCode: http.StatusOK,
			gfName:   "get_tasks_nomal",
			isLogin:  true,
		},
		{
			name:     "準正常系：未ログイン",
			wantCode: http.StatusUnauthorized,
			gfName:   "get_tasks_seminomal_not_loggedin",
			isLogin:  false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml", "../testdata/fixtures/tasks.yml")
			r := httptest.NewRequest(http.MethodGet, "/tasks", nil)
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				defer testhelper.LogoutForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			mux.ServeHTTP(rw, r)
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			resp := testhelper.FormatJSON(
				t,
				rw.Body.Bytes(),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/task"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})

	}
}

func TestTask_GetUserTasks(t *testing.T) {
	tests := []struct {
		name     string
		wantCode int
		gfName   string
		isLogin  bool //ログインさせるか
	}{
		{
			name:     "正常系",
			wantCode: http.StatusOK,
			gfName:   "get_user_tasks_nomal",
			isLogin:  true,
		},
		{
			name:     "準正常系：未ログイン",
			wantCode: http.StatusUnauthorized,
			gfName:   "get_user_tasks_seminomal_not_loggedin",
			isLogin:  false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml", "../testdata/fixtures/tasks.yml")
			r := httptest.NewRequest(http.MethodGet, "/users/me/tasks", nil)
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				defer testhelper.LogoutForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			mux.ServeHTTP(rw, r)
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			resp := testhelper.FormatJSON(
				t,
				rw.Body.Bytes(),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/task"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

func TestTask_PostTask(t *testing.T) {
	tests := []struct {
		name     string
		req      task.PostTaskRequest
		wantCode int
		gfName   string
		isLogin  bool //ログインさせるか
	}{
		{
			name:     "正常系",
			wantCode: http.StatusCreated,
			req: task.PostTaskRequest{
				Content: "content",
				State:   "todo",
			},
			gfName:  "post_task_nomal",
			isLogin: true,
		},
		{
			name:     "準正常系：未ログイン",
			wantCode: http.StatusUnauthorized,
			req: task.PostTaskRequest{
				Content: "content",
				State:   "todo",
			},
			gfName:  "post_task_seminomal_not_loggedin",
			isLogin: false,
		},
		{
			name:     "準正常系：タスクの内容が空",
			wantCode: http.StatusBadRequest,
			req: task.PostTaskRequest{
				Content: "",
				State:   "todo",
			},
			gfName:  "post_task_seminomal_content_empty",
			isLogin: true,
		},
		{
			name:     "準正常系：タスク状態の値が不正",
			wantCode: http.StatusBadRequest,
			req: task.PostTaskRequest{
				Content: "content",
				State:   "invalid",
			},
			gfName:  "post_task_seminomal_invalid_state",
			isLogin: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml", "../testdata/fixtures/tasks.yml")
			// リクエストボディをマーシャル（→json）
			b, _ := json.Marshal(tt.req)
			r := httptest.NewRequest(http.MethodPost, "/tasks", bytes.NewBuffer(b))
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				defer testhelper.LogoutForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			mux.ServeHTTP(rw, r)
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			resp := testhelper.FormatJSON(
				t,
				testhelper.NormalizeULID(t, rw.Body.Bytes()),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/task"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

func TestTask_UpdateTaskState(t *testing.T) {
	tests := []struct {
		name      string
		req       task.UpdateTaskStateRequest
		pathParam string
		wantCode  int
		gfName    string
		isLogin   bool //ログインさせるか
	}{
		{
			name:      "正常系",
			wantCode:  http.StatusOK,
			pathParam: "1",
			req: task.UpdateTaskStateRequest{
				State: "doing",
			},
			gfName:  "update_task_nomal",
			isLogin: true,
		},
		{
			name:      "準正常系：未ログイン",
			wantCode:  http.StatusUnauthorized,
			pathParam: "1",
			req: task.UpdateTaskStateRequest{
				State: "done",
			},
			gfName:  "update_task_seminomal_not_loggedin",
			isLogin: false,
		},
		{
			name:      "準正常系：タスク状態の値が不正",
			wantCode:  http.StatusBadRequest,
			pathParam: "1",
			req: task.UpdateTaskStateRequest{
				State: "invalid",
			},
			gfName:  "update_task_seminomal_invalid_state",
			isLogin: true,
		},
		{
			name:      "準正常系：他ユーザーのタスクは操作できない",
			wantCode:  http.StatusForbidden,
			pathParam: "3", //user2のタスク
			req: task.UpdateTaskStateRequest{
				State: "done",
			},
			gfName:  "update_task_seminomal_forbidden_operate_others_task",
			isLogin: true,
		},
		{
			name:      "準正常系：存在しないタスクはエラーが返る",
			wantCode:  http.StatusBadRequest,
			pathParam: "0", //存在しない
			req: task.UpdateTaskStateRequest{
				State: "done",
			},
			gfName:  "update_task_seminomal_not_found",
			isLogin: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml", "../testdata/fixtures/tasks.yml")
			// リクエストボディをマーシャル（→json）
			b, _ := json.Marshal(tt.req)
			r := httptest.NewRequest(http.MethodPatch, "/tasks/"+tt.pathParam+"/state", bytes.NewBuffer(b))
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				defer testhelper.LogoutForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			mux.ServeHTTP(rw, r)
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			resp := testhelper.FormatJSON(
				t,
				rw.Body.Bytes(),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/task"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

func TestTask_DeleteTask(t *testing.T) {
	tests := []struct {
		name      string
		pathParam string
		wantCode  int
		gfName    string
		isLogin   bool //ログインさせるか
	}{
		{
			name:      "正常系",
			wantCode:  http.StatusNoContent,
			pathParam: "1",
			gfName:    "delete_task_nomal",
			isLogin:   true,
		},
		{
			name:      "準正常系：未ログイン",
			wantCode:  http.StatusUnauthorized,
			pathParam: "1",
			gfName:    "delete_task_seminomal_not_loggedin",
			isLogin:   false,
		},
		{
			name:      "準正常系：他ユーザーのタスクは操作できない",
			wantCode:  http.StatusForbidden,
			pathParam: "3",
			gfName:    "delete_task_seminomal_forbidden_operate_others_task",
			isLogin:   true,
		},
		{
			name:      "準正常系：存在しないタスクはエラーが返る",
			wantCode:  http.StatusBadRequest,
			pathParam: "0",
			gfName:    "delete_task_seminomal_not_found",
			isLogin:   true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml", "../testdata/fixtures/tasks.yml")

			r := httptest.NewRequest(http.MethodDelete, "/tasks/"+tt.pathParam, nil)
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				defer testhelper.LogoutForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			mux.ServeHTTP(rw, r)
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			// 204ステータスコードなら、JSONは返らないのでここで終了
			if rw.Code == http.StatusNoContent {
				return
			}
			resp := testhelper.FormatJSON(
				t,
				rw.Body.Bytes(),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/task"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

// app/infrastructure/api_test/integration/auth_api_test.go
//go:build integration

package integration

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/kakkky/app/adapter/presentation/handler/auth"
	"github.com/kakkky/app/infrastructure/api_test/testhelper"
	dbTesthelper "github.com/kakkky/app/infrastructure/db/testhelper"
	"github.com/sebdah/goldie/v2"
)

func TestAuth_Login(t *testing.T) {
	tests := []struct {
		name     string
		wantCode int
		req      auth.LoginRequest
		gfName   string
	}{
		{
			name:     "正常系",
			wantCode: http.StatusOK,
			req: auth.LoginRequest{
				Email:    "[email protected]",
				Password: "password",
			},
			gfName: "login_nomal",
		},
		{
			name:     "準正常系:パスワードが異なる",
			wantCode: http.StatusUnauthorized,
			req: auth.LoginRequest{
				Email:    "[email protected]",
				Password: "invalid",
			},
			gfName: "login_seminomal_password_mismatch",
		},
		{
			name:     "準正常系:指定のemailは存在しない",
			wantCode: http.StatusUnauthorized,
			req: auth.LoginRequest{
				Email:    "[email protected]",
				Password: "notfound",
			},
			gfName: "login_seminomal_email_notfound",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// テストデータを投入
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml")
			// リクエストボディをマーシャル（→json）
			b, _ := json.Marshal(tt.req)
			r := httptest.NewRequest(http.MethodPost, "/login", bytes.NewBuffer(b))
			rw := httptest.NewRecorder()
			mux.ServeHTTP(rw, r)
			// ステータスコードを検証
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			resp := testhelper.FormatJSON(
				t,
				testhelper.NormalizeJWT(t, rw.Body.Bytes()),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/auth"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}

func TestAuth_Logout(t *testing.T) {
	tests := []struct {
		name     string
		wantCode int
		gfName   string
		isLogin  bool
	}{
		{
			name:     "正常系",
			wantCode: http.StatusNoContent,
			gfName:   "logout_nomal",
			isLogin:  true,
		},
		{
			name:     "準正常系:ログインしていないとログアウトできない",
			wantCode: http.StatusUnauthorized,
			gfName:   "logout_seminomal_not_loggedin",
			isLogin:  false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dbTesthelper.SetupFixtures(t, "../testdata/fixtures/users.yml")
			r := httptest.NewRequest(http.MethodDelete, "/logout", nil)
			rw := httptest.NewRecorder()
			// ログイン状態をセットアップ
			// Authorizationヘッダーを付加する
			if tt.isLogin {
				jwtToken := testhelper.LoginForTest(t, "1")
				r.Header.Set("Authorization", "Bearer "+jwtToken)
			}
			// リクエストを送信
			mux.ServeHTTP(rw, r)
			// ステータスコードを検証
			if rw.Code != tt.wantCode {
				t.Errorf("got %d , but want Code %d", rw.Code, tt.wantCode)
			}
			// 204ステータスコードなら、JSONは返らないのでここで終了
			if rw.Code == http.StatusNoContent {
				return
			}
			resp := testhelper.FormatJSON(
				t,
				rw.Body.Bytes(),
			)
			g := goldie.New(
				t,
				goldie.WithFixtureDir("../testdata/golden/auth"),
				goldie.WithNameSuffix(".golden.json"))
			g.Assert(t, tt.gfName, resp)
		})
	}
}