// pkg/hash/hash.go
package hash

import "golang.org/x/crypto/bcrypt"

func Hash(target string) (string, error) {
	hashed, err := bcrypt.GenerateFromPassword([]byte(target), bcrypt.DefaultCost)
	if err != nil {
		return "", err
	}
	return string(hashed), nil
}

func Compare(hashed, target string) error {
	err := bcrypt.CompareHashAndPassword([]byte(hashed), []byte(target))
	return err
}

// pkg/hash/hash_test.go
package hash

import "testing"

func TestHash(t *testing.T) {
	tests := []struct {
		name     string
		password string
		wantErr  bool
	}{
		{
			name:     "valid password",
			password: "testPassword",
			wantErr:  false,
		},
		{
			name:     "empty password",
			password: "",
			wantErr:  false,
		},
		{
			name:     "long password",
			password: "verylongpassword123456",
			wantErr:  false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// ハッシュ化
			hashedPassword, err := Hash(tt.password)

			// エラーの検証
			if (err != nil) != tt.wantErr {
				t.Errorf("expected error: %v, got: %v", tt.wantErr, err)
			}

			// エラーがない場合、ハッシュ化されたパスワードが空でないことを確認
			if !tt.wantErr && hashedPassword == "" {
				t.Fatal("hashed password should not be empty")
			}
		})
	}
}

func TestCompare(t *testing.T) {
	tests := []struct {
		name           string
		password       string
		targetPassword string
		wantErr        bool
	}{
		{
			name:           "correct password match",
			password:       "testPassword",
			targetPassword: "testPassword",
			wantErr:        false,
		},
		{
			name:           "incorrect password match",
			password:       "testPassword",
			targetPassword: "wrongPassword",
			wantErr:        true,
		},
		{
			name:           "empty password match",
			password:       "",
			targetPassword: "",
			wantErr:        false,
		},
		{
			name:           "empty password mismatch",
			password:       "testPassword",
			targetPassword: "",
			wantErr:        true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// ハッシュ化
			hashedPassword, err := Hash(tt.password)
			if err != nil {
				t.Fatalf("expected no error during hashing, got %v", err)
			}

			// 比較結果の検証

			if err := Compare(hashedPassword, tt.targetPassword); (err != nil) != tt.wantErr {
				t.Errorf("Compaire() error = %v,wantErr %v", err, tt.wantErr)
			}
		})
	}
}

// app/domain/user/user.go
package user

import (
	"github.com/kakkky/pkg/ulid"
)

type User struct {
	id             string
	email          Email
	name           string
	hashedPassword HashedPassword
}

// ファクトリー関数
func NewUser(
	email string,
	name string,
	password string,
) (*User, error) {
	validatedEmail, err := NewEmail(email)
	if err != nil {
		return nil, err
	}
	HashedPassword, err := newHashedPassword(password)
	if err != nil {
		return nil, err
	}
	return &User{
		id:             ulid.NewUlid(),
		email:          validatedEmail,
		name:           name,
		hashedPassword: HashedPassword,
	}, nil
}

// 既存のユーザーを返す
// インスタンスの再構成
func ReconstructUser(
	id string,
	email string,
	name string,
	hashedPassword string,
) *User {
	return &User{
		id:             id,
		email:          reconstructEmail(email),
		name:           name,
		hashedPassword: reconstructHashedPassword(hashedPassword),
	}
}

// ユーザーオブジェクト更新
func (u *User) UpdateUser(
	email string,
	name string,
) (*User, error) {
	validatedEmail, err := NewEmail(email)
	if err != nil {
		return nil, err
	}
	return &User{
		id:             u.id,
		email:          validatedEmail,
		name:           name,
		hashedPassword: u.hashedPassword,
	}, nil
}

// 値のゲッターメソッド
func (u *User) GetID() string {
	return u.id
}
func (u *User) GetName() string {
	return u.name
}
func (u *User) GetEmail() Email {
	return u.email
}
func (u *User) GetHashedPassword() HashedPassword {
	return u.hashedPassword
}

// パスワードを比較する
func (u *User) ComparePassword(plainPassword string) error {
	return u.hashedPassword.compare(plainPassword)
}

テストコード

// app/domain/user/user_test.go
package user

import (
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/kakkky/app/domain/errors"
)

func TestNewUser(t *testing.T) {
	t.Parallel()
	type args struct {
		name     string
		email    string
		password string
	}
	tests := []struct {
		name    string
		args    args
		want    *User
		errType error
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				name:     "test",
				email:    "[email protected]",
				password: "password",
			},
			want: &User{
				email: Email{value: "[email protected]"},
				name:  "test",
			},
			wantErr: false,
		},
		{
			name: "準正常系：emailアドレスが不正",
			args: args{
				email: "test.com",
			},
			errType: errors.ErrInvalidEmail,
			wantErr: true,
		},
		{
			name: "準正常系：パスワードが短い(4文字)",
			args: args{
				password: "test",
			},
			errType: errors.ErrPasswordTooShort,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			got, err := NewUser(tt.args.email, tt.args.name, tt.args.password)
			if (err != nil) != tt.wantErr && errors.Is(err, tt.errType) {
				t.Fatalf("NewUser() error=%v,but wantErr %v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(User{}, Email{}, HashedPassword{}), cmpopts.IgnoreFields(User{}, "id", "hashedPassword")); diff != "" {
				t.Errorf("NewProduct() -got,+want :%v ", diff)
			}
		})
	}
}
func TestUser_UpdateUser(t *testing.T) {
	user, _ := NewUser(
		"[email protected]",
		"testuser",
		"password",
	)
	t.Parallel()
	type args struct {
		email string
		name  string
	}
	tests := []struct {
		name    string
		args    args
		want    *User
		errType error
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				email: "[email protected]",
				name:  "test",
			},
			want: &User{
				id:             "1",
				email:          Email{value: "[email protected]"},
				name:           "test",
				hashedPassword: HashedPassword{value: "hashedPassword"},
			},
			wantErr: false,
		},
		{
			name: "準正常系：emailアドレスが不正",
			args: args{
				email: "invalid-email",
				name:  "test",
			},
			errType: errors.ErrInvalidEmail,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			got, err := user.UpdateUser(tt.args.email, tt.args.name)
			if (err != nil) != tt.wantErr {
				t.Fatalf("UpdateUser() error=%v, wantErr=%v", err, tt.wantErr)
			}
			if err != nil && !errors.Is(err, tt.errType) {
				t.Fatalf("UpdateUser() error type=%v, wantErr type=%v", err, tt.errType)
			}
			if diff := cmp.Diff(got, tt.want, cmp.AllowUnexported(User{}, Email{}, HashedPassword{}), cmpopts.IgnoreFields(User{}, "id", "hashedPassword")); diff != "" {
				t.Errorf("UpdateUser() -got,+want :%v", diff)
			}
		})
	}
}

func TestCompairePassword(t *testing.T) {
	t.Parallel()
	// パスワードを持ったユーザーを用意
	user, _ := NewUser(
		"[email protected]",
		"testuser",
		"password",
	)
	tests := []struct {
		name    string
		plain   string
		wantErr bool
	}{
		{
			name:    "正常形：パスワードの比較で成功する",
			plain:   "password",
			wantErr: false,
		},
		{
			name:    "準正常形：パスワードの比較で成功する",
			plain:   "incorrect",
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			err := user.ComparePassword(tt.plain)
			if (err != nil) != tt.wantErr && errors.Is(err, errors.ErrPasswordMismatch) {
				t.Errorf("ComparePassword() = %v,want %v", err, tt.wantErr)
			}

		})
	}
}

// pkg/ulid/ulid.go
package ulid

import "github.com/oklog/ulid/v2"

func NewUlid() string {
	return ulid.Make().String()
}

func IsValid(id string) bool {
	_, err := ulid.Parse(id)
	return err == nil
}

// pkg/ulid/ulid_test.go
package ulid

import "testing"

func TestIsValid(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		{
			name: "正常系",
			args: args{
				s: NewUlid(),
			},
			want: true,
		},
		{
			name: "正常系: 空文字",
			args: args{
				s: "",
			},
			want: false,
		},
		{
			name: "正常系: 32文字",
			args: args{
				s: "01234567890123456789012345678901",
			},
			want: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := IsValid(tt.args.s); got != tt.want {
				t.Errorf("IsValid() = %v, want %v", got, tt.want)
			}
		})
	}
}

func (u *User) UpdateUser(email string, name string) error {
	validatedEmail, err := NewEmail(email)
	if err != nil {
		return err
	}
	u.email = validatedEmail // 元のインスタンスを直接変更
	u.name = name
	return nil
}

func main() {
	// 元のインスタンス
	user := &User{id: "123", email: MustNewEmail("[email protected]"), name: "John"}

	// 同じインスタンスを参照
	anotherRef := user

	// userの属性を更新
	_ = user.UpdateUser("[email protected]", "Jane")

	// 元のインスタンスが直接変更され、意図せず影響が出る
	fmt.Println(user.email.value)       // "[email protected]"
	fmt.Println(anotherRef.email.value) // "[email protected]"（意図せず変更）
}

// task.go
package task

import (
	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/pkg/ulid"
)

type Task struct {
	id      string
	userId  string
	content Content
	state   State
}

func NewTask(
	userId string,
	content string,
	state string,
) (*Task, error) {
	validatedContent, err := newContent(content)
	if err != nil {
		return nil, err
	}
	validatedState, err := newState(state)
	if err != nil {
		return nil, err
	}
	return &Task{
		id:      ulid.NewUlid(),
		userId:  userId,
		content: validatedContent,
		state:   validatedState,
	}, nil
}

// リポジトリから使用
func ReconstructTask(
	id string,
	userId string,
	content string,
	state int, //DBにはint型でタスク状態を保存している
) *Task {
	return &Task{
		id:      id,
		userId:  userId,
		content: reconstructContent(content),
		state:   reconstructState(state),
	}
}

func (t *Task) UpdateState(
	state string,
) (*Task, error) {
	validatedState, err := newState(state)
	if err != nil {
		return nil, err
	}
	return &Task{
		id:      t.id,
		userId:  t.userId,
		content: t.content,
		state:   validatedState,
	}, nil
}

func (t *Task) IsOperableBy(userId string) error {
	if t.userId != userId {
		return errors.ErrForbiddenTaskOperation
	}
	return nil
}

func (t *Task) GetID() string {
	return t.id
}
func (t *Task) GetUserId() string {
	return t.userId
}
func (t *Task) GetContent() Content {
	return t.content
}
func (t *Task) GetState() State {
	return t.state
}

テストコード

// task_test.go
package task

import (
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/kakkky/app/domain/errors"
)

func TestNewTask(t *testing.T) {
	t.Parallel()
	type args struct {
		userId  string
		content string
		state   string
	}
	tests := []struct {
		name    string
		args    args
		want    *Task
		errType error
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				userId:  "1",
				content: "This is a task",
				state:   "todo",
			},
			want: &Task{
				userId:  "1",
				content: Content{value: "This is a task"},
				state:   Todo,
			},
			wantErr: false,
		},
		{
			name: "準正常系：contentが空",
			args: args{
				content: "",
				state:   "todo",
			},
			errType: errors.ErrContentEmpty,
			wantErr: true,
		},
		{
			name: "準正常系：stateが不正",
			args: args{
				content: "This is a task",
				state:   "invalid",
			},
			errType: errors.ErrInvalidTaskState,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			got, err := NewTask(tt.args.userId, tt.args.content, tt.args.state)
			if (err != nil) != tt.wantErr && errors.Is(err, tt.errType) {
				t.Fatalf("NewTask() error=%v, but wantErr %v", err, tt.wantErr)
			}
			if diff := cmp.Diff(got, tt.want, cmpopts.IgnoreFields(Task{}, "id"), cmp.AllowUnexported(Task{}, Content{})); diff != "" {
				t.Errorf("NewTask() -got,+want :%v", diff)
			}
		})
	}
}

func TestTask_UpdateState(t *testing.T) {
	// 初期タスクを作成
	task, _ := NewTask("1", "This is a task", "todo")

	t.Parallel()
	type args struct {
		state string
	}
	tests := []struct {
		name    string
		args    args
		want    *Task
		errType error
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				state: "done",
			},
			want: &Task{
				id:      task.id,
				userId:  task.userId,
				content: task.content,
				state:   Done,
			},
			wantErr: false,
		},
		{
			name: "準正常系：不正なstate",
			args: args{
				state: "invalid",
			},
			errType: errors.ErrInvalidTaskState,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			got, err := task.UpdateState(tt.args.state)
			if (err != nil) != tt.wantErr && errors.Is(err, tt.errType) {
				t.Fatalf("UpdateState() error=%v, wantErr=%v", err, tt.wantErr)
			}
			if err != nil && !errors.Is(err, tt.errType) {
				t.Fatalf("UpdateState() error type=%v, wantErr type=%v", err, tt.errType)
			}
			if diff := cmp.Diff(got, tt.want, cmpopts.IgnoreFields(Task{}, "id"), cmp.AllowUnexported(Task{}, Content{})); diff != "" {
				t.Errorf("UpdateState() -got,+want :%v", diff)
			}
		})
	}
}

タスク内容のコード

// domain/task/task_content.go
package task

import (
	"unicode/utf8"

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

type Content struct {
	value string
}

func newContent(value string) (Content, error) {
	if utf8.RuneCountInString(value) == 0 {
		return Content{}, errors.ErrContentEmpty
	}
	return Content{value: value}, nil
}

func reconstructContent(value string) Content {
	return Content{value: value}
}

func (c Content) Value() string {
	return c.value
}

タスク状態のコード

// domain/task/task_state.go
package task

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

type State int

const (
	Todo State = iota
	Doing
	Done
)

func newState(value string) (State, error) {
	switch value {
	case "todo":
		return Todo, nil
	case "doing":
		return Doing, nil
	case "done":
		return Done, nil
	default:
		return 0, errors.ErrInvalidTaskState
	}
}

func reconstructState(value int) State {
	switch value {
	case 1:
		return Doing
	case 2:
		return Done
	default:
		return Todo
	}
}

func (s State) StrValue() string {
	switch s {
	case Doing:
		return "doing"
	case Done:
		return "done"
	default:
		return "todo"
	}
}

func (s State) IntValue() int {
	return int(s)
}

ドメインサービスにもインターフェースを定義しておきます。

// interface_user_domain_service.go
package user

import "context"

//go:generate mockgen -package=user -source=./interface_user_domain_service.go -destination=./mock_user_domain_service.go
type UserDomainService interface {
	IsExists(ctx context.Context, email Email) (bool, error)
}

// app/domain/user/user_domain_service.go
package user

import (
	"context"

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

type userDomainService struct {
	userRepository UserRepository
}

func NewUserDomainService(userRepository UserRepository) UserDomainService {
	return &userDomainService{
		userRepository: userRepository,
	}
}

func (uds userDomainService) IsExists(ctx context.Context, email Email) (bool, error) {
	user, err := uds.userRepository.FindByEmail(ctx, email)
	// ユーザーが見つからない場合はエラーではない
	if err != nil && errors.Is(err, errors.ErrNotFoundUser) {
		return false, nil
	}
	// それ以外ならエラーとして返す
	if err != nil {
		return false, err
	}
	return user != nil, nil
}

テストコード

// app/domain/user/user_domain_service_test.go
package user

import (
	"context"
	"testing"

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

func TestUserDomainService_IsExists(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name    string
		email   Email
		mockFn  func(m *MockUserRepository)
		want    bool
		wantErr bool
	}{
		{
			name:  "正常系: ユーザー存在する",
			email: Email{value: "[email protected]"},
			mockFn: func(m *MockUserRepository) {
				// ErrNotFoundUserを返す
				m.EXPECT().FindByEmail(gomock.Any(), gomock.Any()).Return(&User{}, nil)
			},
			want:    true,
			wantErr: false,
		},
		{
			name:  "準正常系: ユーザーが存在しない",
			email: Email{value: "[email protected]"},
			mockFn: func(m *MockUserRepository) {
				m.EXPECT().FindByEmail(gomock.Any(), gomock.Any()).Return(nil, errors.ErrNotFoundUser)
			},
			want:    false,
			wantErr: false,
		},
		{
			name:  "異常系:リポジトリからErrNotFoundUser以外のエラーが返る場合",
			email: Email{value: "[email protected]"},
			mockFn: func(m *MockUserRepository) {
				m.EXPECT().FindByEmail(gomock.Any(), gomock.Any()).Return(nil, errors.New("Database error"))
			},
			want:    false,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			ctrl := gomock.NewController(t)
			mockUserRepository := NewMockUserRepository(ctrl)
			// モック呼び出しの設定
			tt.mockFn(mockUserRepository)
			// ドメインサービスを作成
			sut := NewUserDomainService(mockUserRepository)
			ctx := context.Background()
			got, err := sut.IsExists(ctx, tt.email)
			if (err != nil) != tt.wantErr {
				t.Errorf("userDomainService.IsExists() want error %v,but got %v : %v", tt.wantErr, got, err)
			}
			if got != tt.want {
				t.Errorf("userDomainService.IsExists()= %v,but want %v", got, tt.want)
			}

		})
	}
}

// app/domain/errors/errors.go
package errors

import (
	"errors"
	"fmt"
)

// ユーザー関連のドメインエラー
var (
	ErrAlreadyRegisterd = newErrDomain("ErrAlreadyRegisterd", "you have been already registerd")
	ErrInvalidEmail     = newErrDomain("ErrInvalidEmail", "invalid email address")
	ErrPasswordMismatch = newErrDomain("ErrPasswordMismatch", "the password is incorrect")
	ErrPasswordTooShort = newErrDomain("ErrPasswordTooShort", "password is too short")
	ErrNotFoundUser     = newErrDomain("ErrNotFoundUser", "user not found")
)

// タスク関係のドメインエラー
var (
	ErrNotFoundTask           = newErrDomain("ErrNotFoundTask", "task not found")
	ErrContentEmpty           = newErrDomain("ErrContentEmpty", "Do not empty the content")
	ErrInvalidTaskState       = newErrDomain("ErrInvalidTaskState", "invalid task state , please select todo/doing/done")
	ErrForbiddenTaskOperation = newErrDomain("ErrForbiddenTaskOperation", "can't operate others tasks")
)

// ドメインエラー
type ErrDomain struct {
	err error
}

// ドメインエラーのコンストラクタ
func newErrDomain(errType, message string) *ErrDomain {
	return &ErrDomain{
		err: fmt.Errorf("errType : %v , Message : %v", errType, message),
	}
}

// ドメインエラーかどうか
func IsDomainErr(target error) bool {
	var errDomain *ErrDomain
	return errors.As(target, &errDomain)
}

// errorインターフェースを満たすため
func (e *ErrDomain) Error() string {
	return e.err.Error()
}

// errors.Isをラップ
// パッケージ名の衝突を考慮
func Is(err, target error) bool {
	return errors.Is(err, target)
}
func New(message string) error {
	return errors.New(message)
}

テストコード

// app/domain/errors/errors_test.go
package errors

import "testing"

func TestErrors(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name string
		fn   func() error
		err  *ErrDomain
		want bool
	}{
		{
			name: "ErrDomain型としても、個別のエラー型としても判別できる",
			fn: func() error {
				return ErrNotFoundUser
			},
			err:  ErrNotFoundUser,
			want: true,
		},
		{
			name: "異なるエラー型オブジェクトは判別しない",
			fn: func() error {
				return New("other err obj")
			},
			err:  ErrNotFoundUser,
			want: false,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			err := tt.fn()
			if err != nil && Is(err, tt.err) != tt.want {
				t.Errorf("Is() want %v,but got%v", tt.want, Is(err, tt.err))
			}
			if IsDomainErr(err) != tt.want {
				t.Errorf("IsDomainErr() want %v,but got%v", tt.want, IsDomainErr(err))
			}
		})
	}
}