diff --git a/cmd/api/main.go b/cmd/api/main.go index b6ca88c..cb58152 100644 --- a/cmd/api/main.go +++ b/cmd/api/main.go @@ -5,14 +5,27 @@ import ( "github.com/gin-gonic/gin" + "user-register-api/config" "user-register-api/infrastructure/persistence" "user-register-api/interfaces/handler" "user-register-api/usecase" ) func main() { - userPersistence := persistence.NewUserPersistence() - tokenPersistence := persistence.NewTokenPersistence() + db, err := config.ConnectDB() + if err != nil { + panic(err) + } + defer db.Close() + + cdb, err := config.ConnectCacheDB() + if err != nil { + panic(err) + } + defer cdb.Close() + + userPersistence := persistence.NewUserPersistence(db) + tokenPersistence := persistence.NewTokenPersistence(cdb) userUseCase := usecase.NewUserUseCase(userPersistence) tokenUseCase := usecase.NewTokenUseCase(tokenPersistence) diff --git a/cmd/api/test/main1_test.go b/cmd/api/test/main1_test.go index 08e67f9..fcea23d 100644 --- a/cmd/api/test/main1_test.go +++ b/cmd/api/test/main1_test.go @@ -20,6 +20,11 @@ type requestBody struct { Password string `json:"password"` } +type responseBody struct { + User domain.User `json:"user"` + TokenString string `json:"token"` +} + type errorString struct { message string } @@ -51,34 +56,34 @@ func sendRequest(method string, endpoint string, sendingBody *bytes.Buffer) (*ht return resp, nil } -func verifyExpectedResponse(resp *http.Response, expectedStatusCode int, expectedMessage string, expectedUser *domain.User) error { +func verifyExpectedResponse(resp *http.Response, expectedStatusCode int, expectedMessage string) (*responseBody, error) { var response struct { - Message string `json:"message"` - User domain.User `json:"user"` + Message string `json:"message"` + User domain.User `json:"user"` + TokenString string `json:"token"` } if resp.StatusCode != expectedStatusCode { - return &errorString{message: fmt.Sprintf("Expected status code %v, got %v", expectedStatusCode, resp.StatusCode)} + return nil, &errorString{message: fmt.Sprintf("Expected status code %v, got %v", expectedStatusCode, resp.StatusCode)} } responseData, _ := ioutil.ReadAll(resp.Body) err := json.Unmarshal(responseData, &response) if err != nil { - return err + return nil, err } if response.Message != expectedMessage { - return &errorString{message: fmt.Sprintf("Expected message %v, got %v", expectedMessage, response.Message)} + return nil, &errorString{message: fmt.Sprintf("Expected message %v, got %v", expectedMessage, response.Message)} } - if expectedUser != nil { - if response.User != *expectedUser { - return &errorString{message: fmt.Sprintf("Expected user %v, got %v", expectedUser, response.User)} - } + responseBody := &responseBody{ + User: response.User, + TokenString: response.TokenString, } - return nil + return responseBody, nil } func TestConnectionApi(t *testing.T) { @@ -90,7 +95,7 @@ func TestConnectionApi(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } diff --git a/cmd/api/test/main2_signup_test.go b/cmd/api/test/main2_signup_test.go index 0e4039c..cb24bc6 100644 --- a/cmd/api/test/main2_signup_test.go +++ b/cmd/api/test/main2_signup_test.go @@ -5,8 +5,6 @@ import ( "encoding/json" "net/http" "testing" - - "user-register-api/domain" ) func TestSignupBodyNotExist(t *testing.T) { @@ -18,7 +16,7 @@ func TestSignupBodyNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -43,7 +41,7 @@ func TestSignupUserIDNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -68,7 +66,7 @@ func TestSignupPasswordNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -84,11 +82,6 @@ func TestSignupSuccessUsernameExist(t *testing.T) { Password: "testpass", } - expectedUser := &domain.User{ - UserID: "testuser", - Username: "testname", - } - jsonString, err := json.Marshal(requestBody) if err != nil { t.Fatal(err) @@ -99,7 +92,7 @@ func TestSignupSuccessUsernameExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, expectedUser) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -114,11 +107,6 @@ func TestSignupSuccessUsernameNotExist(t *testing.T) { Password: "testpass", } - expectedUser := &domain.User{ - UserID: "testuser_name_not_exist", - Username: "testuser_name_not_exist", - } - jsonString, err := json.Marshal(requestBody) if err != nil { t.Fatal(err) @@ -129,7 +117,7 @@ func TestSignupSuccessUsernameNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, expectedUser) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -155,7 +143,7 @@ func TestSignupUserConflict(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } diff --git a/cmd/api/test/main3_auth_test.go b/cmd/api/test/main3_auth_test.go index 75d0388..77a8376 100644 --- a/cmd/api/test/main3_auth_test.go +++ b/cmd/api/test/main3_auth_test.go @@ -6,7 +6,6 @@ import ( "io/ioutil" "net/http" "testing" - "user-register-api/domain" ) var accessToken string @@ -20,7 +19,7 @@ func TestSigninBodyNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -30,7 +29,7 @@ func TestSigninUserIDNotExist(t *testing.T) { expectedStatusCode := http.StatusUnauthorized expectedMessage := "Body is not valid" - requestBody := &domain.User{ + requestBody := requestBody{ Password: "testpass", } @@ -44,7 +43,7 @@ func TestSigninUserIDNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -54,7 +53,7 @@ func TestSigninPasswordNotExist(t *testing.T) { expectedStatusCode := http.StatusUnauthorized expectedMessage := "Body is not valid" - requestBody := &domain.User{ + requestBody := requestBody{ UserID: "testuser", } @@ -68,7 +67,7 @@ func TestSigninPasswordNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -78,7 +77,7 @@ func TestSigninUserNotExist(t *testing.T) { expectedStatusCode := http.StatusUnauthorized expectedMessage := "User ID or password is incorrect" - requestBody := &domain.User{ + requestBody := requestBody{ UserID: "testuser_not_exist", Password: "testpass", } @@ -93,7 +92,7 @@ func TestSigninUserNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -103,7 +102,7 @@ func TestSigninPasswordNotCorrect(t *testing.T) { expectedStatusCode := http.StatusUnauthorized expectedMessage := "User ID or password is incorrect" - requestBody := &domain.User{ + requestBody := requestBody{ UserID: "testuser", Password: "testpass_not_correct", } @@ -118,7 +117,7 @@ func TestSigninPasswordNotCorrect(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -128,7 +127,7 @@ func TestSigninSuccess(t *testing.T) { expectedStatusCode := http.StatusCreated expectedMessage := "Token can be acquired" - requestBody := &domain.User{ + requestBody := requestBody{ UserID: "testuser", Password: "testpass", } @@ -143,25 +142,7 @@ func TestSigninSuccess(t *testing.T) { t.Fatal(err) } - var response struct { - Message string `json:"message"` - TokenString string `json:"token"` - } - - if resp.StatusCode != expectedStatusCode { - t.Fatalf("Expected status code %v, got %v", expectedStatusCode, resp.StatusCode) - } - - responseData, _ := ioutil.ReadAll(resp.Body) - - err = json.Unmarshal(responseData, &response) - if err != nil { - t.Fatal(err) - } - - if response.Message != expectedMessage { - t.Fatalf("Expected message %v, got %v", expectedMessage, response.Message) - } + response, err := verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if response.TokenString == "" { t.Fatal("Token is empty") @@ -179,7 +160,7 @@ func TestSignoutBodyNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -189,7 +170,7 @@ func TestSignoutTokenNotExist(t *testing.T) { expectedStatusCode := http.StatusUnauthorized expectedMessage := "Body is not valid" - requestBody := &domain.Token{} + requestBody := requestBody{} jsonString, err := json.Marshal(requestBody) if err != nil { @@ -201,7 +182,7 @@ func TestSignoutTokenNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -211,7 +192,7 @@ func TestSignoutIncorrectToken(t *testing.T) { expectedStatusCode := http.StatusUnauthorized expectedMessage := "Failed to authenticate" - requestBody := &domain.Token{ + requestBody := requestBody{ TokenString: "incorrect_token", } jsonString, err := json.Marshal(requestBody) @@ -224,7 +205,7 @@ func TestSignoutIncorrectToken(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -234,7 +215,7 @@ func TestSignoutSuccess(t *testing.T) { expectedStatusCode := http.StatusOK expectedMessage := "Token can be deleted" - requestBody := &domain.Token{ + requestBody := requestBody{ TokenString: accessToken, } @@ -248,7 +229,7 @@ func TestSignoutSuccess(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -258,7 +239,7 @@ func TestCanDeletedToken(t *testing.T) { expectedStatusCode := http.StatusUnauthorized expectedMessage := "Failed to authenticate" - requestBody := &domain.Token{ + requestBody := requestBody{ TokenString: accessToken, } @@ -272,14 +253,14 @@ func TestCanDeletedToken(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } } func TestGetAccessToken(t *testing.T) { - requestBody := &domain.User{ + requestBody := requestBody{ UserID: "testuser", Password: "testpass", } diff --git a/cmd/api/test/main4_user_get_test.go b/cmd/api/test/main4_user_get_test.go index d7a331e..0eddc30 100644 --- a/cmd/api/test/main4_user_get_test.go +++ b/cmd/api/test/main4_user_get_test.go @@ -9,8 +9,6 @@ import ( "user-register-api/domain" ) -var userID = "testuser" - func TestGetUserBodyNotExist(t *testing.T) { expectedStatusCode := http.StatusBadRequest expectedMessage := "Body does not exist" @@ -20,7 +18,7 @@ func TestGetUserBodyNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -42,7 +40,7 @@ func TestGetUserTokenNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -66,7 +64,7 @@ func TestGetUserTokenNotCorrect(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -94,8 +92,12 @@ func TestGetUserSuccess(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, expectedUser) + response, err := verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } + + if response.User != *expectedUser { + t.Fatal("User does not match") + } } diff --git a/cmd/api/test/main5_user_put_test.go b/cmd/api/test/main5_user_put_test.go index dec5270..03849b8 100644 --- a/cmd/api/test/main5_user_put_test.go +++ b/cmd/api/test/main5_user_put_test.go @@ -5,7 +5,6 @@ import ( "encoding/json" "net/http" "testing" - "user-register-api/domain" ) @@ -18,7 +17,7 @@ func TestPutUserBodyNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -42,7 +41,7 @@ func TestPutUserTokenNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -66,7 +65,7 @@ func TestPutUserUsernameNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -91,7 +90,7 @@ func TestPutUserTokenNotCorrect(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -100,6 +99,7 @@ func TestPutUserTokenNotCorrect(t *testing.T) { func TestPutUserSuccess(t *testing.T) { expectedStatusCode := http.StatusOK expectedMessage := "User can be updated" + expectedUser := &domain.User{ UserID: "testuser", Username: "testname_updated", @@ -120,8 +120,22 @@ func TestPutUserSuccess(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, expectedUser) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) + if err != nil { + t.Fatal(err) + } + + resp, err = sendRequest("GET", endpoint+"/user", bytes.NewBuffer(jsonString)) if err != nil { t.Fatal(err) } + + response, err := verifyExpectedResponse(resp, expectedStatusCode, "User can be acquired") + if err != nil { + t.Fatal(err) + } + + if response.User != *expectedUser { + t.Fatal("Username is not updated") + } } diff --git a/cmd/api/test/main6_user_delete_test.go b/cmd/api/test/main6_user_delete_test.go index 67f4989..c2b1e4b 100644 --- a/cmd/api/test/main6_user_delete_test.go +++ b/cmd/api/test/main6_user_delete_test.go @@ -16,7 +16,7 @@ func TestDeleteUserBodyNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -38,7 +38,7 @@ func TestDeleteUserTokenNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -62,7 +62,7 @@ func TestDeleteUserTokenNotCorrect(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -86,7 +86,7 @@ func TestDeleteUserSuccess(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -110,7 +110,7 @@ func TestDeleteUserIsUserNotExist(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } @@ -135,7 +135,7 @@ func TestUserCanBeDeleted(t *testing.T) { t.Fatal(err) } - err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage, nil) + _, err = verifyExpectedResponse(resp, expectedStatusCode, expectedMessage) if err != nil { t.Fatal(err) } diff --git a/docker-compose.yml b/docker-compose.yml index 8f37798..2cd07e0 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -8,8 +8,10 @@ services: - .:/app tty: true depends_on: - - db - - cache + db: + condition: service_healthy + cache: + condition: service_healthy ports: - 8080:8080 @@ -21,6 +23,12 @@ services: - ./build/db/initdb.d:/docker-entrypoint-initdb.d ports: - 3306:3306 + healthcheck: + test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-proot"] + interval: 10s + retries: 5 + start_period: 10s + timeout: 10s environment: MYSQL_ROOT_PASSWORD: root @@ -30,3 +38,9 @@ services: dockerfile: Dockerfile ports: - 6379:6379 + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 10s + retries: 5 + start_period: 10s + timeout: 10s diff --git a/document.yaml b/document.yaml index f0398a2..4aa2d27 100644 --- a/document.yaml +++ b/document.yaml @@ -65,15 +65,6 @@ paths: message: type: string example: "User created successfully" - user: - type: object - properties: - user_id: - type: string - example: "user_id" - username: - type: string - example: "username" 400: description: Bad Request content: @@ -234,15 +225,6 @@ paths: message: type: string example: "User can be updated" - user: - type: object - properties: - user_id: - type: string - example: "user_id" - username: - type: string - example: "username" 400: description: Bad Request content: diff --git a/domain/repository/token_repository.go b/domain/repository/token_repository.go index 6e28779..49079c8 100644 --- a/domain/repository/token_repository.go +++ b/domain/repository/token_repository.go @@ -1,7 +1,7 @@ package repository type TokenRepository interface { - SaveToken(userID, tokenUuid string) error + SaveToken(userID, tokenUUID string) error ValidateToken(userID string) (string, error) DeleteToken(userID string) error } diff --git a/domain/repository/user_repository.go b/domain/repository/user_repository.go index 48f5ac9..4b81a00 100644 --- a/domain/repository/user_repository.go +++ b/domain/repository/user_repository.go @@ -1,14 +1,12 @@ package repository import ( - "database/sql" - "user-register-api/domain" ) type UserRepository interface { - InsertUser(db *sql.DB, userID, username, password string) error - FindUserByUserID(db *sql.DB, userID string) (*domain.User, error) - UpdateUsername(db *sql.DB, userID string, username string) error - DeleteUser(db *sql.DB, userID string) error -} \ No newline at end of file + InsertUser(user *domain.User) error + FindUserByUserID(userID string) (*domain.User, error) + UpdateUsername(userID string, username string) error + DeleteUser(userID string) error +} diff --git a/domain/token.go b/domain/token.go index 754c1ae..f89cc75 100644 --- a/domain/token.go +++ b/domain/token.go @@ -1,5 +1,55 @@ package domain +import ( + "errors" + "time" + + "github.com/golang-jwt/jwt" + "github.com/google/uuid" +) + type Token struct { - TokenString string `json:"token"` + value *jwt.Token +} + +var secretKey = "secret" + +func NewToken(userID string) *Token { + claims := jwt.MapClaims{ + "user_id": userID, + "uuid": uuid.New().String(), + "exp": time.Now().Add(time.Hour * 24).Unix(), + } + token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + + return &Token{value: token} +} + +func (t *Token) ToString() (string, error) { + tokenString, err := t.value.SignedString([]byte(secretKey)) + if err != nil { + return "", err + } + return tokenString, nil +} + +func ParseToken(tokenString string) (*Token, error) { + token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) { + if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok { + return nil, errors.New("invalid token") + } + return []byte(secretKey), nil + }) + if err != nil { + return nil, err + } + return &Token{value: token}, nil +} + +func (t *Token) UUID() string { + return t.value.Claims.(jwt.MapClaims)["uuid"].(string) +} + +func (t *Token) UserID() string { + return t.value.Claims.(jwt.MapClaims)["user_id"].(string) } diff --git a/domain/token_test.go b/domain/token_test.go new file mode 100644 index 0000000..54761ca --- /dev/null +++ b/domain/token_test.go @@ -0,0 +1,26 @@ +package domain + +import "testing" + +func TestDomainToken(t *testing.T) { + userID := "test_user" + token := NewToken(userID) + tokenString, err := token.ToString() + if err != nil { + t.Error("Error while generating token") + } + if tokenString == "" { + t.Error("TokenString is empty") + } + + parsedToken, err := ParseToken(tokenString) + if err != nil { + t.Error("Error while parsing token") + } + if parsedToken.UserID() != userID { + t.Error("UserID is not matched") + } + if parsedToken.UUID() == "" { + t.Error("UUID is empty") + } +} diff --git a/domain/user.go b/domain/user.go index 897b4a2..2fbcb2c 100644 --- a/domain/user.go +++ b/domain/user.go @@ -4,4 +4,16 @@ type User struct { UserID string `json:"user_id"` Username string `json:"username"` Password string `json:"password"` -} \ No newline at end of file +} + +func NewUser(userID, username, password string) *User { + if username == "" { + username = userID + } + + return &User{ + UserID: userID, + Username: username, + Password: password, + } +} diff --git a/go.mod b/go.mod index 950a121..18639ff 100644 --- a/go.mod +++ b/go.mod @@ -16,6 +16,7 @@ require ( github.com/go-playground/validator/v10 v10.16.0 // indirect github.com/go-sql-driver/mysql v1.7.1 // indirect github.com/goccy/go-json v0.10.2 // indirect + github.com/golang-jwt/jwt v3.2.2+incompatible github.com/golang-jwt/jwt/v5 v5.2.1 // indirect github.com/google/uuid v1.6.0 // indirect github.com/json-iterator/go v1.1.12 // indirect diff --git a/go.sum b/go.sum index 467fe76..a4328a2 100644 --- a/go.sum +++ b/go.sum @@ -31,6 +31,8 @@ github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrt github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= +github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk= github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= diff --git a/infrastructure/persistence/token.go b/infrastructure/persistence/token.go index fb2e10d..7a86c9b 100644 --- a/infrastructure/persistence/token.go +++ b/infrastructure/persistence/token.go @@ -3,26 +3,24 @@ package persistence import ( "context" "time" - "user-register-api/config" "user-register-api/domain/repository" + + "github.com/redis/go-redis/v9" ) -type tokenPersistence struct{} +type tokenPersistence struct { + *redis.Client +} -func NewTokenPersistence() repository.TokenRepository { - return &tokenPersistence{} +func NewTokenPersistence(cdb *redis.Client) repository.TokenRepository { + return &tokenPersistence{cdb} } -func (tp tokenPersistence) SaveToken(userID, tokenUuid string) error { +func (tp tokenPersistence) SaveToken(userID, tokenUUID string) error { ctx := context.Background() - cdb, err := config.ConnectCacheDB() - if err != nil { - return err - } - - err = cdb.Set(ctx, userID, tokenUuid, time.Hour).Err() + err := tp.Set(ctx, userID, tokenUUID, time.Hour).Err() if err != nil { return err } @@ -33,33 +31,23 @@ func (tp tokenPersistence) SaveToken(userID, tokenUuid string) error { func (tp tokenPersistence) ValidateToken(userID string) (string, error) { ctx := context.Background() - cdb, err := config.ConnectCacheDB() - if err != nil { - return "", err - } - - tokenUuid, err := cdb.Get(ctx, userID).Result() + tokenUUID, err := tp.Get(ctx, userID).Result() if err != nil { return "", err } - err = cdb.Expire(ctx, userID, time.Hour).Err() + err = tp.Expire(ctx, userID, time.Hour).Err() if err != nil { return "", err } - return tokenUuid, nil + return tokenUUID, nil } func (tp tokenPersistence) DeleteToken(userID string) error { ctx := context.Background() - cdb, err := config.ConnectCacheDB() - if err != nil { - return err - } - - err = cdb.Del(ctx, userID).Err() + err := tp.Del(ctx, userID).Err() if err != nil { return err } diff --git a/infrastructure/persistence/token_test.go b/infrastructure/persistence/token_test.go index 63b0fed..6dfe830 100644 --- a/infrastructure/persistence/token_test.go +++ b/infrastructure/persistence/token_test.go @@ -1,43 +1,66 @@ package persistence -import "testing" +import ( + "testing" + "user-register-api/config" +) -var exampleUuid = "de5fe5d7-eec2-4fba-e071-fa2de7c1e440" +var exampleUUID = "de5fe5d7-eec2-4fba-e071-fa2de7c1e440" func TestSaveToken(t *testing.T) { - tokenPersistence := NewTokenPersistence() + cdb, err := config.ConnectCacheDB() + if err != nil { + t.Error(err) + } + + tokenPersistence := NewTokenPersistence(cdb) - err := tokenPersistence.SaveToken(testUser.UserID, exampleUuid) + err = tokenPersistence.SaveToken(testUser.UserID, exampleUUID) if err != nil { t.Error(err) } } func TestValidateToken(t *testing.T) { - tokenPersistence := NewTokenPersistence() + cdb, err := config.ConnectCacheDB() + if err != nil { + t.Error(err) + } + + tokenPersistence := NewTokenPersistence(cdb) token, err := tokenPersistence.ValidateToken(testUser.UserID) if err != nil { t.Error(err) } - if token != exampleUuid { + if token != exampleUUID { t.Errorf("UUID is not match") } } func TestDeleteToken(t *testing.T) { - tokenPersistence := NewTokenPersistence() + cdb, err := config.ConnectCacheDB() + if err != nil { + t.Error(err) + } + + tokenPersistence := NewTokenPersistence(cdb) - err := tokenPersistence.DeleteToken(testUser.UserID) + err = tokenPersistence.DeleteToken(testUser.UserID) if err != nil { t.Error(err) } } func TestValidateTokenDeleted(t *testing.T) { - tokenPersistence := NewTokenPersistence() + cdb, err := config.ConnectCacheDB() + if err != nil { + t.Error(err) + } + + tokenPersistence := NewTokenPersistence(cdb) - _, err := tokenPersistence.ValidateToken(testUser.UserID) + _, err = tokenPersistence.ValidateToken(testUser.UserID) if err == nil { t.Error("Token is not deleted") } diff --git a/infrastructure/persistence/user.go b/infrastructure/persistence/user.go index ef19a71..798df37 100644 --- a/infrastructure/persistence/user.go +++ b/infrastructure/persistence/user.go @@ -7,18 +7,20 @@ import ( "user-register-api/domain/repository" ) -type userPersistence struct{} +type userPersistence struct { + *sql.DB +} -func NewUserPersistence() repository.UserRepository { - return &userPersistence{} +func NewUserPersistence(db *sql.DB) repository.UserRepository { + return &userPersistence{db} } -func (up userPersistence) InsertUser(db *sql.DB, userID, username, password string) error { - _, err := db.Exec( +func (up userPersistence) InsertUser(user *domain.User) error { + _, err := up.Exec( "INSERT INTO users (user_id, username, password) VALUES (?, ?, ?)", - userID, - username, - password, + user.UserID, + user.Username, + user.Password, ) if err != nil { return err @@ -27,9 +29,9 @@ func (up userPersistence) InsertUser(db *sql.DB, userID, username, password stri return nil } -func (up userPersistence) FindUserByUserID(db *sql.DB, userID string) (*domain.User, error) { +func (up userPersistence) FindUserByUserID(userID string) (*domain.User, error) { user := domain.User{} - err := db.QueryRow( + err := up.QueryRow( "SELECT user_id, username, password FROM users WHERE user_id = ?", userID, ).Scan( @@ -44,8 +46,8 @@ func (up userPersistence) FindUserByUserID(db *sql.DB, userID string) (*domain.U return &user, nil } -func (up userPersistence) UpdateUsername(db *sql.DB, userID, username string) error { - _, err := db.Exec( +func (up userPersistence) UpdateUsername(userID, username string) error { + _, err := up.Exec( "UPDATE users SET username = ? WHERE user_id = ?", username, userID, @@ -57,8 +59,8 @@ func (up userPersistence) UpdateUsername(db *sql.DB, userID, username string) er return nil } -func (up userPersistence) DeleteUser(db *sql.DB, userID string) error { - _, err := db.Exec( +func (up userPersistence) DeleteUser(userID string) error { + _, err := up.Exec( "DELETE FROM users WHERE user_id = ?", userID, ) @@ -67,4 +69,4 @@ func (up userPersistence) DeleteUser(db *sql.DB, userID string) error { } return nil -} \ No newline at end of file +} diff --git a/infrastructure/persistence/user_test.go b/infrastructure/persistence/user_test.go index ea7f624..da8576b 100644 --- a/infrastructure/persistence/user_test.go +++ b/infrastructure/persistence/user_test.go @@ -19,9 +19,9 @@ func TestInsertUser(t *testing.T) { t.Error(err) } defer db.Close() - userPersistence := NewUserPersistence() + userPersistence := NewUserPersistence(db) - err = userPersistence.InsertUser(db, testUser.UserID, testUser.Username, testUser.Password) + err = userPersistence.InsertUser(&testUser) if err != nil { t.Error(err) } @@ -33,9 +33,9 @@ func TestInsertUserDuplicate(t *testing.T) { t.Error(err) } defer db.Close() - userPersistence := NewUserPersistence() + userPersistence := NewUserPersistence(db) - err = userPersistence.InsertUser(db, testUser.UserID, testUser.Username, testUser.Password) + err = userPersistence.InsertUser(&testUser) if err == nil { t.Error("Expected error, got nil") } @@ -47,9 +47,9 @@ func TestFindUserByUserID(t *testing.T) { t.Error(err) } defer db.Close() - userPersistence := NewUserPersistence() + userPersistence := NewUserPersistence(db) - user, err := userPersistence.FindUserByUserID(db, testUser.UserID) + user, err := userPersistence.FindUserByUserID(testUser.UserID) if err != nil { t.Error(err) } @@ -70,15 +70,15 @@ func TestUpdateUsername(t *testing.T) { t.Error(err) } defer db.Close() - userPersistence := NewUserPersistence() + userPersistence := NewUserPersistence(db) updatedName := "testuser_db_updated" - err = userPersistence.UpdateUsername(db, testUser.UserID, updatedName) + err = userPersistence.UpdateUsername(testUser.UserID, updatedName) if err != nil { t.Error(err) } - user, err := userPersistence.FindUserByUserID(db, testUser.UserID) + user, err := userPersistence.FindUserByUserID(testUser.UserID) if err != nil { t.Error(err) } @@ -93,9 +93,9 @@ func TestDeleteUser(t *testing.T) { t.Error(err) } defer db.Close() - userPersistence := NewUserPersistence() + userPersistence := NewUserPersistence(db) - err = userPersistence.DeleteUser(db, testUser.UserID) + err = userPersistence.DeleteUser(testUser.UserID) if err != nil { t.Error(err) } diff --git a/interfaces/handler/auth.go b/interfaces/handler/auth.go index 194bc62..74a3140 100644 --- a/interfaces/handler/auth.go +++ b/interfaces/handler/auth.go @@ -2,7 +2,6 @@ package handler import ( "net/http" - "user-register-api/config" "user-register-api/domain" "user-register-api/usecase" @@ -45,16 +44,7 @@ func (ah authHandler) HandleSignin(c *gin.Context) { return } - db, err := config.ConnectDB() - if err != nil { - c.JSON(http.StatusInternalServerError, gin.H{ - "message": "Database connection error", - }) - return - } - defer db.Close() - - user, err := ah.userUseCase.FindUserByUserID(db, requestBody.UserID) + user, err := ah.userUseCase.FindUserByUserID(requestBody.UserID) if err != nil { c.JSON(http.StatusUnauthorized, gin.H{ "message": "User ID or password is incorrect", diff --git a/interfaces/handler/user.go b/interfaces/handler/user.go index 834db31..36eafbe 100644 --- a/interfaces/handler/user.go +++ b/interfaces/handler/user.go @@ -5,7 +5,6 @@ import ( "github.com/gin-gonic/gin" - "user-register-api/config" "user-register-api/usecase" ) @@ -53,16 +52,7 @@ func (uh userHandler) HandleUserSignup(c *gin.Context) { return } - db, err := config.ConnectDB() - if err != nil { - c.JSON(http.StatusInternalServerError, gin.H{ - "message": "Database connection error", - }) - return - } - defer db.Close() - - user, err := uh.userUseCase.InsertUser(db, requestBody.UserID, requestBody.Username, requestBody.Password) + err := uh.userUseCase.InsertUser(requestBody.UserID, requestBody.Username, requestBody.Password) if err != nil { c.JSON(http.StatusConflict, gin.H{ "message": "User already exists", @@ -72,10 +62,6 @@ func (uh userHandler) HandleUserSignup(c *gin.Context) { c.JSON(http.StatusCreated, gin.H{ "message": "User created successfully", - "user": &responseUser{ - UserID: user.UserID, - Username: user.Username, - }, }) } @@ -106,16 +92,7 @@ func (uh userHandler) HandleUserGet(c *gin.Context) { return } - db, err := config.ConnectDB() - if err != nil { - c.JSON(http.StatusInternalServerError, gin.H{ - "message": "Database connection error", - }) - return - } - defer db.Close() - - user, err := uh.userUseCase.FindUserByUserID(db, userID) + user, err := uh.userUseCase.FindUserByUserID(userID) if err != nil { c.JSON(http.StatusInternalServerError, gin.H{ "message": "User not found", @@ -160,16 +137,7 @@ func (uh userHandler) HandleUserPut(c *gin.Context) { return } - db, err := config.ConnectDB() - if err != nil { - c.JSON(http.StatusInternalServerError, gin.H{ - "message": "Database connection error", - }) - return - } - defer db.Close() - - user, err := uh.userUseCase.UpdateUsername(db, userID, requestBody.NewUsername) + err = uh.userUseCase.UpdateUsername(userID, requestBody.NewUsername) if err != nil { c.JSON(http.StatusInternalServerError, gin.H{ "message": "User can not be updated", @@ -179,10 +147,6 @@ func (uh userHandler) HandleUserPut(c *gin.Context) { c.JSON(http.StatusOK, gin.H{ "message": "User can be updated", - "user": &responseUser{ - UserID: user.UserID, - Username: user.Username, - }, }) } @@ -213,16 +177,7 @@ func (uh userHandler) HandleUserDelete(c *gin.Context) { return } - db, err := config.ConnectDB() - if err != nil { - c.JSON(http.StatusInternalServerError, gin.H{ - "message": "Database connection error", - }) - return - } - defer db.Close() - - err = uh.userUseCase.DeleteUser(db, userID) + err = uh.userUseCase.DeleteUser(userID) if err != nil { c.JSON(http.StatusInternalServerError, gin.H{ "message": "User can not be deleted", diff --git a/usecase/token.go b/usecase/token.go index c664575..bff0c73 100644 --- a/usecase/token.go +++ b/usecase/token.go @@ -2,11 +2,8 @@ package usecase import ( "errors" - "time" + "user-register-api/domain" "user-register-api/domain/repository" - - "github.com/golang-jwt/jwt/v5" - "github.com/google/uuid" ) type TokenUseCase interface { @@ -25,35 +22,15 @@ func NewTokenUseCase(tr repository.TokenRepository) TokenUseCase { } } -var secretKey = "secret" - -func tokenParse(tokenString string) (*jwt.Token, error) { - token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) { - if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok { - return nil, errors.New("invalid token") - } - return []byte(secretKey), nil - }) - if err != nil { - return nil, err - } - return token, nil -} - func (tu tokenUseCase) GenerateToken(userID string) (string, error) { - claims := jwt.MapClaims{ - "user_id": userID, - "uuid": uuid.New().String(), - "exp": time.Now().Add(time.Hour * 24).Unix(), - } - token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + token := domain.NewToken(userID) - tokenString, err := token.SignedString([]byte(secretKey)) + tokenString, err := token.ToString() if err != nil { return "", err } - err = tu.tokenRepository.SaveToken(userID, claims["uuid"].(string)) + err = tu.tokenRepository.SaveToken(userID, token.UUID()) if err != nil { return "", err } @@ -61,18 +38,18 @@ func (tu tokenUseCase) GenerateToken(userID string) (string, error) { } func (tu tokenUseCase) ValidateToken(tokenString string) (string, error) { - token, err := tokenParse(tokenString) + token, err := domain.ParseToken(tokenString) if err != nil { return "", err } - userID := token.Claims.(jwt.MapClaims)["user_id"].(string) - tokenUuid, err := tu.tokenRepository.ValidateToken(userID) + userID := token.UserID() + tokenUUID, err := tu.tokenRepository.ValidateToken(userID) if err != nil { return "", err } - if tokenUuid != token.Claims.(jwt.MapClaims)["uuid"].(string) { + if tokenUUID != token.UUID() { return "", errors.New("invalid token") } @@ -80,12 +57,12 @@ func (tu tokenUseCase) ValidateToken(tokenString string) (string, error) { } func (tu tokenUseCase) DeleteToken(tokenString string) error { - token, err := tokenParse(tokenString) + token, err := domain.ParseToken(tokenString) if err != nil { return err } - userID := token.Claims.(jwt.MapClaims)["user_id"].(string) + userID := token.UserID() err = tu.tokenRepository.DeleteToken(userID) if err != nil { return err diff --git a/usecase/token_test.go b/usecase/token_test.go index 4eec4ff..cf92fcf 100644 --- a/usecase/token_test.go +++ b/usecase/token_test.go @@ -2,21 +2,32 @@ package usecase import ( "testing" + "user-register-api/config" "user-register-api/infrastructure/persistence" ) func TestUsecaseGenerateToken(t *testing.T) { - tokenPersistence := persistence.NewTokenPersistence() + cdb, err := config.ConnectCacheDB() + if err != nil { + t.Error(err) + } + + tokenPersistence := persistence.NewTokenPersistence(cdb) tokenUseCase := NewTokenUseCase(tokenPersistence) - _, err := tokenUseCase.GenerateToken(testUser.UserID) + _, err = tokenUseCase.GenerateToken(testUser.UserID) if err != nil { t.Error(err) } } func TestUsecaseValidateToken(t *testing.T) { - tokenPersistence := persistence.NewTokenPersistence() + cdb, err := config.ConnectCacheDB() + if err != nil { + t.Error(err) + } + + tokenPersistence := persistence.NewTokenPersistence(cdb) tokenUseCase := NewTokenUseCase(tokenPersistence) token, err := tokenUseCase.GenerateToken(testUser.UserID) @@ -34,19 +45,29 @@ func TestUsecaseValidateToken(t *testing.T) { } func TestUsecaseValidateInvalidToken(t *testing.T) { - tokenPersistence := persistence.NewTokenPersistence() + cdb, err := config.ConnectCacheDB() + if err != nil { + t.Error(err) + } + + tokenPersistence := persistence.NewTokenPersistence(cdb) tokenUseCase := NewTokenUseCase(tokenPersistence) token := "invalid_token" - _, err := tokenUseCase.ValidateToken(token) + _, err = tokenUseCase.ValidateToken(token) if err == nil { t.Errorf("Invalid token is accepted") } } func TestUsecaseDeleteToken(t *testing.T) { - tokenPersistence := persistence.NewTokenPersistence() + cdb, err := config.ConnectCacheDB() + if err != nil { + t.Error(err) + } + + tokenPersistence := persistence.NewTokenPersistence(cdb) tokenUseCase := NewTokenUseCase(tokenPersistence) token, err := tokenUseCase.GenerateToken(testUser.UserID) diff --git a/usecase/user.go b/usecase/user.go index 3b85db5..17a88c5 100644 --- a/usecase/user.go +++ b/usecase/user.go @@ -1,17 +1,15 @@ package usecase import ( - "database/sql" - "user-register-api/domain" "user-register-api/domain/repository" ) type UserUseCase interface { - InsertUser(db *sql.DB, userID, username, password string) (*domain.User, error) - FindUserByUserID(db *sql.DB, userID string) (*domain.User, error) - UpdateUsername(db *sql.DB, userID, username string) (*domain.User, error) - DeleteUser(db *sql.DB, userID string) error + InsertUser(userID, username, password string) error + FindUserByUserID(userID string) (*domain.User, error) + UpdateUsername(userID, username string) error + DeleteUser(userID string) error } type userUseCase struct { @@ -24,53 +22,41 @@ func NewUserUseCase(ur repository.UserRepository) UserUseCase { } } -func (uu userUseCase) InsertUser(db *sql.DB, userID, username, password string) (*domain.User, error) { - if username == "" { - username = userID - } - +func (uu userUseCase) InsertUser(userID, username, password string) error { hashPassword, err := domain.NewPassword(password).ToHash() if err != nil { - return nil, err + return err } - err = uu.userRepository.InsertUser(db, userID, username, hashPassword) - if err != nil { - return nil, err - } + user := domain.NewUser(userID, username, hashPassword) - user, err := uu.userRepository.FindUserByUserID(db, userID) + err = uu.userRepository.InsertUser(user) if err != nil { - return nil, err + return err } - return user, nil + return nil } -func (uu userUseCase) FindUserByUserID(db *sql.DB, userID string) (*domain.User, error) { - user, err := uu.userRepository.FindUserByUserID(db, userID) +func (uu userUseCase) FindUserByUserID(userID string) (*domain.User, error) { + user, err := uu.userRepository.FindUserByUserID(userID) if err != nil { return nil, err } return user, nil } -func (uu userUseCase) UpdateUsername(db *sql.DB, userID, username string) (*domain.User, error) { - err := uu.userRepository.UpdateUsername(db, userID, username) - if err != nil { - return nil, err - } - - user, err := uu.userRepository.FindUserByUserID(db, userID) +func (uu userUseCase) UpdateUsername(userID, username string) error { + err := uu.userRepository.UpdateUsername(userID, username) if err != nil { - return nil, err + return err } - return user, nil + return nil } -func (uu userUseCase) DeleteUser(db *sql.DB, userID string) error { - err := uu.userRepository.DeleteUser(db, userID) +func (uu userUseCase) DeleteUser(userID string) error { + err := uu.userRepository.DeleteUser(userID) if err != nil { return err } diff --git a/usecase/user_test.go b/usecase/user_test.go index 78e05d2..f5345e1 100644 --- a/usecase/user_test.go +++ b/usecase/user_test.go @@ -19,13 +19,19 @@ func TestUsecaseInsertUser(t *testing.T) { t.Error(err) } defer db.Close() - userPersistence := persistence.NewUserPersistence() + userPersistence := persistence.NewUserPersistence(db) userUseCase := NewUserUseCase(userPersistence) - user, err := userUseCase.InsertUser(db, testUser.UserID, testUser.Username, testUser.Password) + err = userUseCase.InsertUser(testUser.UserID, testUser.Username, testUser.Password) if err != nil { t.Error(err) } + + user, err := userUseCase.FindUserByUserID(testUser.UserID) + if err != nil { + t.Error(err) + } + if user.Username != testUser.UserID { t.Errorf("Username is not correct") } @@ -39,13 +45,19 @@ func TestUsecaseUpdateUser(t *testing.T) { t.Error(err) } defer db.Close() - userPersistence := persistence.NewUserPersistence() + userPersistence := persistence.NewUserPersistence(db) userUseCase := NewUserUseCase(userPersistence) - user, err := userUseCase.UpdateUsername(db, testUser.UserID, updatedUsername) + err = userUseCase.UpdateUsername(testUser.UserID, updatedUsername) if err != nil { t.Error(err) } + + user, err := userUseCase.FindUserByUserID(testUser.UserID) + if err != nil { + t.Error(err) + } + if user.Username != updatedUsername { t.Errorf("Username is not correct") } @@ -57,10 +69,10 @@ func TestUsecaseDeleteUser(t *testing.T) { t.Error(err) } defer db.Close() - userPersistence := persistence.NewUserPersistence() + userPersistence := persistence.NewUserPersistence(db) userUseCase := NewUserUseCase(userPersistence) - err = userUseCase.DeleteUser(db, testUser.UserID) + err = userUseCase.DeleteUser(testUser.UserID) if err != nil { t.Error(err) }