import "testing"

func Add(a, b int) int {
	return a + b
}

func TestAdd(t *testing.T) {
	tests := []struct {
		name     string
		a, b     int
		expected int
	}{
		{name: "양수_더하기", a: 1, b: 2, expected: 3},
		{name: "음수_더하기", a: -1, b: -1, expected: -2},
		{name: "양수와_음수_혼합", a: -1, b: 1},
		// 추가할 케이스가 있다면 단순히 여기 추가
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := Add(tt.a, tt.b)
			if result != tt.expected {
				t.Errorf("Add(%d, %d) = %d; expected %d", tt.a, tt.b, result, tt.expected)
			}
		})
	}
}

=== RUN   TestAdd
=== RUN   TestAdd/양수_더하기
--- PASS: TestAdd/양수_더하기 (0.00s)
=== RUN   TestAdd/음수_더하기
--- PASS: TestAdd/음수_더하기 (0.00s)
=== RUN   TestAdd/양수와_음수_혼합
--- PASS: TestAdd/양수와_음수_혼합 (0.00s)
--- PASS: TestAdd (0.00s)
PASS

import (
	"testing"
)

func TestCreateUser(t *testing.T) {
	user, err := CreateUser("김뱅샐")
	if err != nil {
		t.Fatalf("failed to create user: %v", err)
	}
	if user.Role != "member" {
		t.Errorf("expected role 'member', got '%s'", user.Role)
	}
	if user.Name != "김뱅샐" {
		t.Errorf("expected name '김뱅샐', got '%s'", user.Name)
	}
}

import (
	"testing"
	
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestCreateUser(t *testing.T) {
	user, err := CreateUser("김뱅샐")
	
	// 에러가 발생하면 user는 nil이므로 아래 실행될 코드에서 nil pointer 방지를 위해 require 사용
	require.NoError(t, err)
	
	// 마지막 파라미터로 string을 입력해 주석을 추가할 수 있음.
	assert.Equal(t, "member", user.Role, "역할은 member 여야 함")
	assert.Equal(t, "김뱅샐", user.Name)
}

import (
	"testing"
	
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestCreateUser(t *testing.T) {
	// given
	userName := "김뱅샐"

	// when
	user, err := CreateUser(userName)
	
	// then
	require.NoError(t, err)
	expectedUser := &User{
		// 입력한 유저 이름, Role은 member가 반환되어야 함
		Name: userName,
		Role: "member",
	}
	assert.Equal(t, expectedUser, user)
}	

Error:      	Not equal: 
            	expected: &user.User{Name:"김뱅샐", Role:"admin"}
            	actual  : &user.User{Name:"김뱅샐", Role:"member"}
            	
            	Diff:
            	--- Expected
            	+++ Actual
            	@@ -2,3 +2,3 @@
            	  Name: (string) (len=9) "김뱅샐",
            	- Role: (string) (len=5) "admin"
            	+ Role: (string) (len=6) "member"
            	 })
Test:       	TestCreateUser

Error:      	Not equal: 
            	expected: &user.User{Name:"김뱅샐", Role:"member", RegisteredAt:time.Date(2025, time.December, 1, 1, 36, 24, 845727000, time.Local)}
            	actual  : &user.User{Name:"김뱅샐", Role:"member", RegisteredAt:time.Date(2024, time.June, 10, 12, 0, 0, 0, time.UTC)}
            	
            	Diff:
            	--- Expected
            	+++ Actual
            	@@ -4,13 +4,5 @@
            	  RegisteredAt: (time.Time) {
            	-  wall: (uint64) 13998096397663520024,
            	-  ext: (int64) 1393209,
            	-  loc: (*time.Location)({
            	-   name: (string) "",
            	-   zone: ([]time.zone) <nil>,
            	-   tx: ([]time.zoneTrans) <nil>,
            	-   extend: (string) "",
            	-   cacheStart: (int64) 0,
            	-   cacheEnd: (int64) 0,
            	-   cacheZone: (*time.zone)(<nil>)
            	-  })
            	+  wall: (uint64) 0,
            	+  ext: (int64) 63853617600,
            	+  loc: (*time.Location)(<nil>)
            	  }
Test:       	TestCreateUser

func TestCreateUser(t *testing.T) {
	// given
	var (
		userName     = "김뱅샐"
		registeredAt = time.Date(2024, 6, 10, 12, 0, 0, 0, time.UTC)
	)

	// when
	user, err := CreateUser(userName, registeredAt)

	// then
	require.NoError(t, err)
	expectedUser := &User{
		Name:         "김뱅샐",
		Role:         "member",
		RegisteredAt: time.Now(),
	}
	// 깔끔한 diff 출력을 위해 cmp.Diff() 사용
	if diff := cmp.Diff(expectedUser, user); diff != "" {
		assert.Failf(t, "expectedUser not equal to user (-expected +user):\n", diff)
	}
}

/* 이전 코드보다 가독성이 좋아진 OUTPUT

// ...
  	Error:      	expectedUser not equal to user (-expected +user):
  	Test:       	TestCreateUser
  	Messages:   	  &user.User{
  	            	  	Name:         "김뱅샐",
  	            	  	Role:         "member",
  	            	- 	RegisteredAt: s"2025-12-01 01:39:56.351955 +0900 KST m=+0.001214001",
  	            	+ 	RegisteredAt: s"2024-06-10 12:00:00 +0000 UTC",
  	            	  }
--- FAIL: TestCreateUser (0.00s)

*/

import (
  "testing"
  
	"github.com/ericlagergren/decimal"
	"github.com/google/go-cmp/cmp"
	"github.com/stretchr/testify/assert"
)

// DecimalComparer cmp.Diff 옵션으로 사용할 수 있는 decimal.Big Comparer를 반환합니다.
// [usecase]
// assert.Fail(t, "expected not equal to actual (-expected +actual)", diff)
func DecimalComparer() cmp.Option {
	return cmp.Comparer(func(a, b *decimal.Big) bool {
		if a == nil || b == nil {
			return a == b
		}

		return a.Cmp(b) == 0
	})
}

func TestCreateUserAccount(t *testing.T) {
	// given
	var (
		accountName = "Grace"
		balance     = decimal.New(1000000, 2) // 10,000.00
	)

	// when
	account, err := CreateUserAccount(accountName, balance)

	// then
	require.NoError(t, err)
	expectedAccount := &UserAccount{
		Name:    "Grace",
		// decimal이 표현하는 scale은 다르지만 value는 같음
		Balance: decimal.New(10000000, 3), // 10,000.000
	}
	
	// assert.Equal(t, expectedAccount, account) -> fail
	
	// DecimalComparer를 Diff() 옵션으로 추가
	if diff := cmp.Diff(expectedAccount, account, DecimalComparer()); diff != "" {
		assert.Fail(t, "expected not equal to actual (-expected +actual)", diff)
	}

}

import (
	"github.com/stretchr/testify/suite"
	"github.com/golang/mock/gomock"
	// ...
)

type CreditUserServiceTestSuite struct {
	suite.Suite
	// 여기에 의존성 정의
	ctrl *gomock.Controller // fyi; gomock을 mocking에 사용
	userService *user_app.MockUserService
	creditUserRepository *repository.MockCreditUserRepository
}

func (s *KCBUserServiceTestSuite) SetupTest() {
  // Test 실행 시마다 실행할 로직. (의존성 초기화 등)
	s.ctrl = gomock.NewController(s.T())
  s.userService = user_app.NewMockUserService(s.ctrl)
}

func (s *KCBUserServiceTestSuite) TearDownTest() {
	// Test 종료 시마다 실행할 로직. (의존성 제거 등)
	s.ctrl.Finish()
}

import (
	/* ... */
	"github.com/golang/mock/gomock" 
	"github.com/stretchr/testify/suite"
	/* ... */
)

type TermsServiceTestSuite struct {
	suite.Suite
	ctrl *gomock.Controller

	termsCli *client.MockTermsClient
}

func (s *TermsServiceTestSuite) SetupTest() {
	s.ctrl = gomock.NewController(s.T())

	s.termsCli = client.NewMockTermsClient(s.ctrl)
}

func (s *TermsServiceTestSuite) TearDownTest() {
	s.ctrl.Finish()
}

func (s *TermsServiceTestSuite) newService() *termsService {
	return &termsService{
		termsCli: s.termsCli,
	}
}

func TestTermsServiceTestSuite(t *testing.T) {
	suite.Run(t, new(TermsServiceTestSuite))
}

func (s *TermsServiceTestSuite) TestListUserTermsConsentStatusesByTermsTypes() {
	var (
		now = time.Date(2024, 6, 1, 12, 0, 0, 0, time.UTC)
	)
	
	s.Run("여러_약관_유형을_조회할_때_모두_동의한_경우_해당_수만큼_약관_상태를_반환", func() {
		// given
		ctx := context.Background()
		var (
			userID         int64 = 123
			termsTypeEnums       = []termspb.TermsType{/* ... */}
		)

		s.termsCli.EXPECT().
		  FindUserTermsConsentStatusesByTermsTypes(/* ... */).
			Return(
			  // 모두 동의한 상태면 request에 입력한 약관 유형 수와 동일한 수의 결과 반환
  			/* ... */
  		}, nil)

		// when
		termsService := s.newService()
		result, err := termsService.ListUserTermsConsentStatusesByTermsTypes(ctx, userID, termsTypeEnums)

		// then
		s.Require().NoError(err)
		s.Equal(termsTypeEnum, result.TermsTypeEnum, "반환된 약관 유형이 요청한 약관 유형과 동일해야 함")
	})
	
	// 케이스 추가 시 아래에 s.Run()과 함께 테스트 코드 추가
}

// 다른 Test 함수에서도 TermsServiceTestSuite에 정의한 의존성 사용 가능
func (s *TermsServiceTestSuite) TestGetUserTermsConsentStatusByTermsType() {
	var (
		now = time.Date(2024, 6, 1, 12, 0, 0, 0, time.UTC)
	)
	
	s.Run("단일_약관_유형을_조회할_때_동의한_경우_약관_상태를_반환", func() {
		// given
		ctx := context.Background()
		var (
			userID        int64 = 123
			termsTypeEnum       = /* ... */
		)

		s.termsCli.EXPECT().
		  FindOneUserTermsConsentStatusByTermsType(/* ... */).
		  Return(/* ... */, nil)

		// when
		termsService := s.newService()
		result, err := termsService.GetUserTermsConsentStatusByTermsType(ctx, userID, termsTypeEnum)

		// then
		s.Require().NoError(err)
		s.NotNil(result)
		s.Equal(termsTypeEnum, result.TermsTypeEnum, "반환된 약관 유형이 요청한 약관 유형과 동일해야 함")
	})
}