リポジトリで利用するKvsCommanderインターフェース

// app/adapter/repository/interface_kvs_commander.go
package repository

import (
	"context"
	"time"
)

// KVSに対するインターフェース
type KvsCommander interface {
	Save(ctx context.Context, duration time.Duration, userID, jwtID string) error
	Load(ctx context.Context, userID string) (string, error)
	Delete(ctx context.Context, userID string) error
}

具体実装はインフラストラクチャ層に配置します

// app/infrastructure/kvs/redis_commander.go
package kvs

import (
	"context"

	"time"

	"github.com/kakkky/app/domain/errors"
	"github.com/redis/go-redis/v9"
)

type RedisCommander struct {
	cli *redis.Client
}

func NewRedisCommander() *RedisCommander {
	return &RedisCommander{
		cli: GetRedisClient(),
	}
}

func (rc *RedisCommander) Save(ctx context.Context, duration time.Duration, userID, jwtID string) error {
	// Redis クライアントが nil の場合はエラーを返す
	if rc.cli == nil {
		return errors.New("failed to get Redis client")
	}
	status := rc.cli.Set(ctx, userID, jwtID, duration)
	if status.Err() != nil {
		return status.Err()
	}
	return nil
}

func (rc *RedisCommander) Load(ctx context.Context, userID string) (string, error) {
	// Redis クライアントが nil の場合はエラーを返す
	if rc.cli == nil {
		return "", errors.New("failed to get Redis client")
	}
	status := rc.cli.Get(ctx, userID)
	if status.Err() != nil {
		// nilだったら空文字を返す
		if status.Err() == redis.Nil {
			return "", nil
		}
		return "", status.Err()
	}
	return status.Val(), nil
}

func (rc *RedisCommander) Delete(ctx context.Context, userID string) error {
	// Redis クライアントが nil の場合はエラーを返す
	if rc.cli == nil {
		return errors.New("failed to get Redis client")
	}
	status := rc.cli.Del(ctx, userID)
	if status.Err() != nil {
		if status.Err() == redis.Nil {
			return nil
		}
		return status.Err()
	}
	return nil
}

リポジトリのインターフェース

// app/application/usecase/auth/interface_jwt_authenticator_repository.go
package auth

import (
	"context"
	"time"
)

// トークンをKVSで操作するリポジトリインターフェース

//go:generate mockgen -package=auth -source=./interface_jwt_authenticator_repository.go -destination=./mock_jwt_authenticator_repository.go
type JwtAuthenticatorRepository interface {
	Save(ctx context.Context, duration time.Duration, userID, jti string) error
	Load(ctx context.Context, userID string) (string, error)
	Delete(ctx context.Context, userID string) error
}

リポジトリの具体実装

// app/adapter/repository/jwt_authenticator_repository.go
package repository

import (
	"context"

	"time"
)

type jwtAuthenticatorRepository struct {
	kvsCommander KvsCommander
}

func NewJwtAuthenticatorRepository(kvsCommander KvsCommander) *jwtAuthenticatorRepository {
	return &jwtAuthenticatorRepository{
		kvsCommander: kvsCommander,
	}
}

func (tar *jwtAuthenticatorRepository) Save(ctx context.Context, duration time.Duration, userID, jti string) error {
	return tar.kvsCommander.Save(ctx, duration, userID, jti)
}

// 存在しないKEYを指定した場合は空文字を返す
func (tar *jwtAuthenticatorRepository) Load(ctx context.Context, userID string) (string, error) {
	return tar.kvsCommander.Load(ctx, userID)
}

func (tar *jwtAuthenticatorRepository) Delete(ctx context.Context, userID string) error {
	return tar.kvsCommander.Delete(ctx, userID)
}

// app/infrastructure/repository_test/jwt_authenticator_repository_test.go
package repository_test

import (
	"context"
	"testing"
	"time"

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

func TestJwtAuthenticatorRepository_Save_And_Load_And_Delete(t *testing.T) {
	jwtAuthenticatorRepository := repository.NewJwtAuthenticatorRepository(kvs.NewRedisCommander())
	type args struct {
		userID   string
		jti    string
		duration time.Duration
	}
	tests := []struct {
		name    string
		args    args
		want    string
		wantErr bool
	}{
		{
			name: "正常系: userID:jtiのペアでredisに保存できる",
			args: args{
				userID:   "1",
				jti:    "jti",
				duration: time.Duration(1 * time.Minute),
			},
			want:    "jti",
			wantErr: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			ctx := context.Background()
			if err := jwtAuthenticatorRepository.Save(ctx, tt.args.duration, tt.args.userID, tt.args.jti); (err != nil) != tt.wantErr {
				t.Errorf("jwtAuthenticatorRepository.Save() error=%v,wantErr %v", err, tt.wantErr)
			}
			got, err := jwtAuthenticatorRepository.Load(ctx, tt.args.userID)
			if (err != nil) != tt.wantErr {
				t.Errorf("jwtAuthenticatorRepository.Load() error=%v,wantErr %v", err, tt.wantErr)
			}
			if got != tt.want {
				t.Errorf("jwtAuthenticatorRepository.Load() got %v, want %v", got, tt.want)
			}
			if err := jwtAuthenticatorRepository.Delete(ctx, tt.args.userID); (err != nil) != tt.wantErr {
				t.Errorf("jwtAuthenticatorRepository.Delete() error=%v,wantErr %v", err, tt.wantErr)
			}
		})
	}
}

// app/application/usecase/auth/interface_jwt_authenticator.go
package auth

// トークンを生成する処理するインターフェース
//
//go:generate mockgen -package=auth -source=./interface_jwt_authenticator.go -destination=./mock_jwt_authenticator.go
type JwtAuthenticator interface {
	GenerateJwtToken(sub, jti string) (string, error)
	VerifyJwtToken(jwtToken string) (sub string, jti string, err error)
}

// app/application/usecase/auth/login_usecase.go
package auth

import (
	"context"
	"time"

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

type LoginUsecase struct {
	userRepository             user.UserRepository
	jwtAuthenticatorRepository JwtAuthenticatorRepository
	jwtAuthenticator           JwtAuthenticator
}

func NewLoginUsecase(
	userRepository user.UserRepository,
	jwtAuthenticatorRepository JwtAuthenticatorRepository,
	jwtAuthenticator JwtAuthenticator,
) *LoginUsecase {
	return &LoginUsecase{
		userRepository:             userRepository,
		jwtAuthenticatorRepository: jwtAuthenticatorRepository,
		jwtAuthenticator:           jwtAuthenticator,
	}
}

func (lu *LoginUsecase) Run(ctx context.Context, input LoginUsecaseInputDTO) (
	*LoginUsecaseOutputDTO, error,
) {
	// emailの検証
	email, err := user.NewEmail(input.Email)
	if err != nil {
		return nil, err
	}
	// ユーザー検索
	u, err := lu.userRepository.FindByEmail(ctx, email)
	if err != nil {
		return nil, err
	}
	// パスワードは正しいか
	if err := u.ComparePassword(input.Password); err != nil {
		return nil, err
	}
	// トークンを生成
	jti := ulid.NewUlid() //JWTトークンを識別するID
	jwtToken, err := lu.jwtAuthenticator.GenerateJwtToken(u.GetID(), jti)
	if err != nil {
		return nil, err
	}
	// トークンをkvsに保存
	if err := lu.jwtAuthenticatorRepository.Save(ctx, time.Duration(24*time.Hour), u.GetID(), jti); err != nil {
		return nil, err
	}
	return &LoginUsecaseOutputDTO{
		JwtToken: jwtToken,
	}, nil
}

入力・出力用のDTOを用意します。

// app/application/usecase/auth/login_usecase_dto.go
package auth

type LoginUsecaseInputDTO struct {
	Email    string
	Password string
}

type LoginUsecaseOutputDTO struct {
	JwtToken string
}

テストコード

// app/application/usecase/auth/login_usecase_test.go
package auth

import (
	"context"
	"testing"

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

func TestAuth_LoginUsecase_Run(t *testing.T) {
	t.Parallel()
	user1, _ := user.NewUser("[email protected]", "user1", "password")
	tests := []struct {
		name    string
		mockFn  func(mur *user.MockUserRepository, ma *MockJwtAuthenticator, mar *MockJwtAuthenticatorRepository)
		input   LoginUsecaseInputDTO
		want    *LoginUsecaseOutputDTO
		wantErr bool
	}{
		{
			name: "正常系:ユーザーにJWTトークンが返る",
			mockFn: func(mur *user.MockUserRepository, ma *MockJwtAuthenticator, mar *MockJwtAuthenticatorRepository) {
				mur.EXPECT().FindByEmail(gomock.Any(), gomock.Any()).Return(user1, nil)
				ma.EXPECT().GenerateJwtToken(gomock.Any(), gomock.Any()).Return("jwtToken", nil)
				mar.EXPECT().Save(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
			},
			input: LoginUsecaseInputDTO{
				Email:    "[email protected]",
				Password: "password",
			},
			want: &LoginUsecaseOutputDTO{
				JwtToken: "jwtToken",
			},
			wantErr: false,
		},
		{
			name: "準正常系:パスワードが異なる",
			mockFn: func(mur *user.MockUserRepository, ma *MockJwtAuthenticator, mar *MockJwtAuthenticatorRepository) {
				mur.EXPECT().FindByEmail(gomock.Any(), gomock.Any()).Return(user1, nil)
			},
			input: LoginUsecaseInputDTO{
				Email:    "[email protected]",
				Password: "invalid",
			},
			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)
			mockAuthenticator := NewMockJwtAuthenticator(ctrl)
			mockAuthenticatorRepository := NewMockJwtAuthenticatorRepository(ctrl)
			tt.mockFn(mockUserRepository, mockAuthenticator, mockAuthenticatorRepository)
			sut := NewLoginUsecase(mockUserRepository, mockAuthenticatorRepository, mockAuthenticator)
			ctx := context.Background()
			got, err := sut.Run(ctx, tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("LoginUsecase.Run error=%v,but wantErr%v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("LoginUsecase.Run -got,+want :%v", diff)
			}
		})
	}
}

// app/application/usecase/auth/logout_usecase.go
package auth

import "context"

type LogoutUsecase struct {
	jwtAuthenticator           JwtAuthenticator
	jwtAuthenticatorRepository JwtAuthenticatorRepository
}

func NewLogoutUsecase(
	jwtAuthenticator JwtAuthenticator,
	jwtAuthenticatorRepository JwtAuthenticatorRepository,
) *LogoutUsecase {
	return &LogoutUsecase{
		jwtAuthenticator:           jwtAuthenticator,
		jwtAuthenticatorRepository: jwtAuthenticatorRepository,
	}
}

func (lu *LogoutUsecase) Run(ctx context.Context, input LogoutUsecaseInputDTO) error {
	if err := lu.jwtAuthenticatorRepository.Delete(ctx, input.UserID); err != nil {
		return err
	}
	return nil
}

DTOを定義します

// app/application/usecase/auth/logout_usecase_dto.go
package auth

type LogoutUsecaseInputDTO struct {
	UserID string
}

テストコード

// app/application/usecase/auth/logout_usecase_test.go
package auth

import (
	"context"
	"fmt"
	"testing"

	"go.uber.org/mock/gomock"
)

func TestLogoutUsecase(t *testing.T) {
	tests := []struct {
		name    string
		mockFn  func(ma *MockJwtAuthenticator, mar *MockJwtAuthenticatorRepository)
		input   LogoutUsecaseInputDTO
		wantErr bool
	}{
		{
			name: "正常系:redisにあるレコードを削除してログアウトする",
			mockFn: func(ma *MockJwtAuthenticator, mar *MockJwtAuthenticatorRepository) {
				mar.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil)
			},
			input: LogoutUsecaseInputDTO{
				UserID: "1",
			},
			wantErr: false,
		},
		{
			name: "異常系:redis内でエラーが起きた場合、エラーを返す",
			mockFn: func(ma *MockJwtAuthenticator, mar *MockJwtAuthenticatorRepository) {
				mar.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(fmt.Errorf("err"))
			},
			input: LogoutUsecaseInputDTO{
				UserID: "1",
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			ctrl := gomock.NewController(t)
			mockAuthenticator := NewMockJwtAuthenticator(ctrl)
			mockAuthenticatorRepository := NewMockJwtAuthenticatorRepository(ctrl)
			tt.mockFn(mockAuthenticator, mockAuthenticatorRepository)
			sut := NewLogoutUsecase(mockAuthenticator, mockAuthenticatorRepository)
			ctx := context.Background()
			err := sut.Run(ctx, tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("LogoutUsecase.Run error=%v,but wantErr%v", err, tt.wantErr)
			}
		})
	}
}

// app/application/usecase/auth/authorization_usecase.go
package auth

import (
	"context"

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

type AuthorizationUsecase struct {
	jwtAuthenticator           JwtAuthenticator
	jwtAuthenticatorRepository JwtAuthenticatorRepository
}

func NewAuthorizationUsecase(
	jwtAuthenticator JwtAuthenticator,
	jwtAuthenticatorRepository JwtAuthenticatorRepository,
) *AuthorizationUsecase {
	return &AuthorizationUsecase{
		jwtAuthenticator:           jwtAuthenticator,
		jwtAuthenticatorRepository: jwtAuthenticatorRepository,
	}
}

func (au *AuthorizationUsecase) Run(ctx context.Context, input AuthorizationInputDTO) (
	*AuthorizationOutputDTO,
	error,
) {
	// 公開鍵で署名済みトークンを検証する
	userID, jti, err := au.jwtAuthenticator.VerifyJwtToken(input.JwtToken)
	if err != nil {
		return nil, err
	}
	// KVS から保存された jti を取得
	// ログアウトしていた場合は、nilが返る
	jtiFromKVS, err := au.jwtAuthenticatorRepository.Load(ctx, userID)
	if err != nil {
		return nil, err
	}
	// jti が一致しない場合はエラー
	// ログアウトしている場合は、ここでエラーとなる
	if jti != jtiFromKVS {
		return nil, errors.New("invalid JWT ID")
	}
	return &AuthorizationOutputDTO{
		UserID: userID,
	}, nil
}

入力・出力用のDTOを用意します。

// app/application/usecase/auth/authorization_usecase_dto.go
package auth

type AuthorizationInputDTO struct {
	JwtToken string
}

type AuthorizationOutputDTO struct {
	UserID string
}

テストコード

// app/application/usecase/auth/authorization_usecase_test.go
package auth

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"go.uber.org/mock/gomock"
)

func TestAuthorizationUsecase_Run(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name    string
		input   AuthorizationInputDTO
		mockFn  func(ma *MockJwtAuthenticator, mar *MockJwtAuthenticatorRepository)
		want    *AuthorizationOutputDTO
		wantErr bool
	}{
		{
			name: "正常系：トークンの認証に成功し、userIDを返す",
			input: AuthorizationInputDTO{
				JwtToken: "jwtToken",
			},
			mockFn: func(ma *MockJwtAuthenticator, mar *MockJwtAuthenticatorRepository) {
				ma.EXPECT().VerifyJwtToken(gomock.Any()).Return("userID", "jti", nil)
				mar.EXPECT().Load(gomock.Any(), "userID").Return("jti", nil)
			},
			want: &AuthorizationOutputDTO{
				UserID: "userID",
			},
			wantErr: false,
		},
		{
			name: "準正常系：kvsから得たjtiとトークンから得たjtiが一致しない",
			input: AuthorizationInputDTO{
				JwtToken: "jwtToken",
			},
			mockFn: func(ma *MockJwtAuthenticator, mar *MockJwtAuthenticatorRepository) {
				ma.EXPECT().VerifyJwtToken(gomock.Any()).Return("userID", "jti", nil)
				mar.EXPECT().Load(gomock.Any(), "userID").Return("", nil)
			},
			want: &AuthorizationOutputDTO{
				UserID: "userID",
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			ctrl := gomock.NewController(t)
			mockAuthenticator := NewMockJwtAuthenticator(ctrl)
			mockAuthenticatorRepository := NewMockJwtAuthenticatorRepository(ctrl)
			tt.mockFn(mockAuthenticator, mockAuthenticatorRepository)

			sut := NewAuthorizationUsecase(mockAuthenticator, mockAuthenticatorRepository)
			ctx := context.Background()
			got, err := sut.Run(ctx, tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("AuthorizationUsecase.Run error=%v,but wantErr%v", err, tt.wantErr)
			}
			// エラーが起きた場合はoutputを返さない
			if got == nil {
				return
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("AuthorizationUsecase.Run -got,+want :%v", diff)
			}
		})
	}
}

// app/infrastructure/auth/jwt_authenticator.go
package auth

import (
	"crypto/rsa"
	_ "embed"

	"fmt"
	"log"
	"time"

	"github.com/golang-jwt/jwt"
	"github.com/kakkky/app/domain/errors"
)

type jwtAuthenticator struct {
	privateKey *rsa.PrivateKey
	publicKey  *rsa.PublicKey
}

//go:embed certificate/private.pem
var rawPrivateKey []byte

//go:embed certificate/public.pem
var rawPublicKey []byte

func NewJwtAuthenticator() *jwtAuthenticator {
	// *rsa.PrivateKeyにパース
	privateKey, err := parsePrivateKey(rawPrivateKey)
	if err != nil {
		log.Fatalf("private key parse error :%v", err)
	}
	publicKey, err := parsePublicKey(rawPublicKey)
	if err != nil {
		log.Fatalf("public key parse error :%v", err)
	}
	return &jwtAuthenticator{
		privateKey: privateKey,
		publicKey:  publicKey,
	}
}

func (ja *jwtAuthenticator) GenerateJwtToken(sub, jti string) (string, error) {
	claims := jwt.StandardClaims{
		Id:        jti,
		ExpiresAt: time.Now().Add(24 * time.Hour).Unix(),
		IssuedAt:  time.Now().Unix(),
		Subject:   sub,
	}
	token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
	jwtToken, err := token.SignedString(ja.privateKey)
	if err != nil {
		return "", err
	}
	return jwtToken, nil
}

// 署名済みのトークンを公開鍵によって検証する
// クレームから取り出した値を返す
func (ja *jwtAuthenticator) VerifyJwtToken(jwtToken string) (sub string, jti string, err error) {
	token, err := jwt.Parse(jwtToken, func(t *jwt.Token) (interface{}, error) {
		// トークンの署名アルゴリズムをチェック
		if _, ok := t.Method.(*jwt.SigningMethodRSA); !ok {
			return nil, fmt.Errorf("unexpected signing method")
		}
		return ja.publicKey, nil
	})
	if err != nil {
		return "", "", err
	}
	//　トークンは有効か
	if !token.Valid {
		return "", "", fmt.Errorf("token is invalid")
	}
	// 有効期限は過ぎていないか
	if err := verifyExpiresAt(token); err != nil {
		return "", "", err
	}
	// subを取得
	sub, err = getSubFromClaim(token)
	if err != nil {
		return "", "", err
	}
	// jtiを取得
	jti, err = getJtiFromClaim(token)
	if err != nil {
		return "", "", err
	}
	return sub, jti, nil
}

func getJtiFromClaim(token *jwt.Token) (string, error) {
	claims, ok := token.Claims.(jwt.MapClaims)
	if !ok {
		return "", errors.New("invalid token claims")
	}
	return claims["jti"].(string), nil
}
func getSubFromClaim(token *jwt.Token) (string, error) {
	claims, ok := token.Claims.(jwt.MapClaims)
	if !ok {
		return "", errors.New("invalid token claims")
	}
	return claims["sub"].(string), nil
}
func verifyExpiresAt(token *jwt.Token) error {
	claims, ok := token.Claims.(jwt.MapClaims)
	if !ok {
		return errors.New("invalid token claims")
	}
	exp := claims["exp"].(float64)
	if time.Now().Unix() > int64(exp) {
		return errors.New("token has expired")
	}
	return nil
}

テストコード

// app/infrastructure/auth/jwt_authenticator_test.go
package auth

import "testing"

func TestJWTAuthenticator(t *testing.T) {
	type args struct {
		sub string
		jti string
	}
	tests := []struct {
		name string
		args args
	}{
		{
			name: "subとjtiを元に署名済みjwtトークンを生成し、解析してsubとjtiを取り出せる",
			args: args{
				sub: "userID",
				jti: "jti",
			},
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			sut := NewJwtAuthenticator()
			jwtToken, err := sut.GenerateJwtToken(tt.args.sub, tt.args.jti)
			if err != nil {
				t.Errorf("GenerateJwtToken() error=%v", err)
			}
			gotSub, gotJti, err := sut.VerifyJwtToken(jwtToken)
			if err != nil {
				t.Errorf("VerifyToken() error = %v", err)
				return
			}
			// 同値性の確認
			if gotSub != tt.args.sub {
				t.Errorf("VerifyToken() got = %v, want = %v", gotSub, tt.args.sub)
			}
			if gotJti != tt.args.jti {
				t.Errorf("VerifyToken() got = %v, want = %v", gotJti, tt.args.jti)
			}
		})
	}
}