refactor: [shitty claude AI first try] restructure server and user services, add new test cases, and improve error handling
This commit is contained in:
146
internal/api/auth/domain/auth_domain_test.go
Normal file
146
internal/api/auth/domain/auth_domain_test.go
Normal file
@ -0,0 +1,146 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestErrOtpNotFound_Error(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
uuid string
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "returns formatted error message",
|
||||
uuid: "123e4567-e89b-12d3-a456-426614174000",
|
||||
want: "OTP request not found for UUID: 123e4567-e89b-12d3-a456-426614174000",
|
||||
},
|
||||
{
|
||||
name: "handles empty uuid",
|
||||
uuid: "",
|
||||
want: "OTP request not found for UUID: ",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := ErrOtpNotFound{Uuid: tt.uuid}
|
||||
assert.Equal(t, tt.want, err.Error())
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestErrUserNotFound_Error(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
phoneNumber string
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "returns formatted error message",
|
||||
phoneNumber: "+1234567890",
|
||||
want: "User not found with phone number: +1234567890",
|
||||
},
|
||||
{
|
||||
name: "handles empty phone number",
|
||||
phoneNumber: "",
|
||||
want: "User not found with phone number: ",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := ErrUserNotFound{PhoneNumber: tt.phoneNumber}
|
||||
assert.Equal(t, tt.want, err.Error())
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestErrOtpInvalid_Error(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
code string
|
||||
uuid string
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "returns formatted error message",
|
||||
code: "123456",
|
||||
uuid: "123e4567-e89b-12d3-a456-426614174000",
|
||||
want: "Invalid OTP code: 123456 for UUID: 123e4567-e89b-12d3-a456-426614174000",
|
||||
},
|
||||
{
|
||||
name: "handles empty values",
|
||||
code: "",
|
||||
uuid: "",
|
||||
want: "Invalid OTP code: for UUID: ",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := ErrOtpInvalid{Code: tt.code, Uuid: tt.uuid}
|
||||
assert.Equal(t, tt.want, err.Error())
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestErrInvalidHydraAccept_Error(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
message string
|
||||
uuid string
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "returns formatted error message",
|
||||
message: "Invalid response",
|
||||
uuid: "123e4567-e89b-12d3-a456-426614174000",
|
||||
want: "Invalid Hydra accept request: Invalid response for UUID: 123e4567-e89b-12d3-a456-426614174000",
|
||||
},
|
||||
{
|
||||
name: "handles empty values",
|
||||
message: "",
|
||||
uuid: "",
|
||||
want: "Invalid Hydra accept request: for UUID: ",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := ErrInvalidHydraAccept{Message: tt.message, Uuid: tt.uuid}
|
||||
assert.Equal(t, tt.want, err.Error())
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestErrInvalidPhoneNumber_Error(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
phoneNumber string
|
||||
err error
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "returns formatted error message with nested error",
|
||||
phoneNumber: "invalid",
|
||||
err: assert.AnError,
|
||||
want: "Invalid phone number: invalid, error: assert.AnError general error for testing",
|
||||
},
|
||||
{
|
||||
name: "handles empty phone number",
|
||||
phoneNumber: "",
|
||||
err: assert.AnError,
|
||||
want: "Invalid phone number: , error: assert.AnError general error for testing",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := ErrInvalidPhoneNumber{PhoneNumber: tt.phoneNumber, Err: tt.err}
|
||||
assert.Equal(t, tt.want, err.Error())
|
||||
})
|
||||
}
|
||||
}
|
||||
293
internal/api/auth/handler/impl_test.go
Normal file
293
internal/api/auth/handler/impl_test.go
Normal file
@ -0,0 +1,293 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
// MockAuthService implements service.AuthService
|
||||
type MockAuthService struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
func (m *MockAuthService) OtpRequest(ctx context.Context, phoneNumber string) error {
|
||||
args := m.Called(ctx, phoneNumber)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockAuthService) OtpVerify(ctx context.Context, phoneNumber, code string, loginChallenge string) (string, error) {
|
||||
args := m.Called(ctx, phoneNumber, code, loginChallenge)
|
||||
return args.String(0), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockAuthService) AcceptConsent(ctx context.Context, phoneNumber string, challenge string) (string, error) {
|
||||
args := m.Called(ctx, phoneNumber, challenge)
|
||||
return args.String(0), args.Error(1)
|
||||
}
|
||||
|
||||
func TestNewAuthHandler(t *testing.T) {
|
||||
mockService := &MockAuthService{}
|
||||
handler := NewAuthHandler(mockService)
|
||||
|
||||
assert.NotNil(t, handler)
|
||||
assert.Equal(t, mockService, handler.service)
|
||||
assert.Implements(t, (*StrictServerInterface)(nil), handler)
|
||||
}
|
||||
|
||||
func TestAuthHandler_PostAuthOtpRequest(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
phoneNumber string
|
||||
setupMock func(*MockAuthService)
|
||||
expectedStatus int
|
||||
expectedOk bool
|
||||
expectedMsg string
|
||||
}{
|
||||
{
|
||||
name: "successful otp request",
|
||||
phoneNumber: "+79161234567",
|
||||
setupMock: func(m *MockAuthService) {
|
||||
m.On("OtpRequest", mock.Anything, "+79161234567").Return(nil).Once()
|
||||
},
|
||||
expectedStatus: 200,
|
||||
expectedOk: true,
|
||||
expectedMsg: "OTP request successful",
|
||||
},
|
||||
{
|
||||
name: "service error",
|
||||
phoneNumber: "invalid",
|
||||
setupMock: func(m *MockAuthService) {
|
||||
m.On("OtpRequest", mock.Anything, "invalid").Return(assert.AnError).Once()
|
||||
},
|
||||
expectedStatus: 400,
|
||||
expectedOk: false,
|
||||
expectedMsg: assert.AnError.Error(),
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
mockService := &MockAuthService{}
|
||||
handler := &AuthHandler{service: mockService}
|
||||
ctx := context.Background()
|
||||
|
||||
tt.setupMock(mockService)
|
||||
|
||||
request := PostAuthOtpRequestRequestObject{
|
||||
Body: &PostAuthOtpRequestJSONRequestBody{
|
||||
PhoneNumber: tt.phoneNumber,
|
||||
},
|
||||
}
|
||||
|
||||
result, err := handler.PostAuthOtpRequest(ctx, request)
|
||||
|
||||
assert.NoError(t, err) // Handler should not return errors, only response objects
|
||||
|
||||
if tt.expectedStatus == 200 {
|
||||
response, ok := result.(PostAuthOtpRequest200JSONResponse)
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, tt.expectedOk, response.Ok)
|
||||
assert.Equal(t, tt.expectedMsg, response.Message)
|
||||
} else {
|
||||
response, ok := result.(PostAuthOtpRequest400JSONResponse)
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, tt.expectedOk, response.Ok)
|
||||
assert.Equal(t, tt.expectedMsg, response.Message)
|
||||
}
|
||||
|
||||
mockService.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthHandler_PostAuthOtpVerify(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
phoneNumber string
|
||||
otp string
|
||||
loginChallenge string
|
||||
setupMock func(*MockAuthService)
|
||||
expectedStatus int
|
||||
expectedOk bool
|
||||
expectedMsg string
|
||||
expectedRedirect string
|
||||
}{
|
||||
{
|
||||
name: "successful otp verification",
|
||||
phoneNumber: "+79161234567",
|
||||
otp: "123456",
|
||||
loginChallenge: "challenge123",
|
||||
setupMock: func(m *MockAuthService) {
|
||||
m.On("OtpVerify", mock.Anything, "+79161234567", "123456", "challenge123").
|
||||
Return("https://example.com/callback", nil).Once()
|
||||
},
|
||||
expectedStatus: 200,
|
||||
expectedOk: true,
|
||||
expectedMsg: "OTP verification successful",
|
||||
expectedRedirect: "https://example.com/callback",
|
||||
},
|
||||
{
|
||||
name: "service error",
|
||||
phoneNumber: "+79161234567",
|
||||
otp: "wrong",
|
||||
loginChallenge: "challenge123",
|
||||
setupMock: func(m *MockAuthService) {
|
||||
m.On("OtpVerify", mock.Anything, "+79161234567", "wrong", "challenge123").
|
||||
Return("", assert.AnError).Once()
|
||||
},
|
||||
expectedStatus: 400,
|
||||
expectedOk: false,
|
||||
expectedMsg: assert.AnError.Error(),
|
||||
expectedRedirect: "",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
mockService := &MockAuthService{}
|
||||
handler := &AuthHandler{service: mockService}
|
||||
ctx := context.Background()
|
||||
|
||||
tt.setupMock(mockService)
|
||||
|
||||
request := PostAuthOtpVerifyRequestObject{
|
||||
Body: &PostAuthOtpVerifyJSONRequestBody{
|
||||
PhoneNumber: tt.phoneNumber,
|
||||
Otp: tt.otp,
|
||||
LoginChallenge: tt.loginChallenge,
|
||||
},
|
||||
}
|
||||
|
||||
result, err := handler.PostAuthOtpVerify(ctx, request)
|
||||
|
||||
assert.NoError(t, err)
|
||||
|
||||
if tt.expectedStatus == 200 {
|
||||
response, ok := result.(PostAuthOtpVerify200JSONResponse)
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, tt.expectedOk, response.Ok)
|
||||
assert.Equal(t, tt.expectedMsg, response.Message)
|
||||
assert.Equal(t, tt.expectedRedirect, response.RedirectUrl)
|
||||
} else {
|
||||
response, ok := result.(PostAuthOtpVerify400JSONResponse)
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, tt.expectedOk, response.Ok)
|
||||
assert.Equal(t, tt.expectedMsg, response.Message)
|
||||
assert.Equal(t, tt.expectedRedirect, response.RedirectUrl)
|
||||
}
|
||||
|
||||
mockService.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthHandler_PostAuthConsentAccept(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
phoneNumber string
|
||||
consentChallenge string
|
||||
setupMock func(*MockAuthService)
|
||||
expectedStatus int
|
||||
expectedOk bool
|
||||
expectedMsg string
|
||||
expectedRedirect string
|
||||
}{
|
||||
{
|
||||
name: "successful consent accept",
|
||||
phoneNumber: "+79161234567",
|
||||
consentChallenge: "consent123",
|
||||
setupMock: func(m *MockAuthService) {
|
||||
m.On("AcceptConsent", mock.Anything, "+79161234567", "consent123").
|
||||
Return("https://example.com/callback", nil).Once()
|
||||
},
|
||||
expectedStatus: 200,
|
||||
expectedOk: true,
|
||||
expectedMsg: "Consent accepted successfully",
|
||||
expectedRedirect: "https://example.com/callback",
|
||||
},
|
||||
{
|
||||
name: "service error",
|
||||
phoneNumber: "+79161234567",
|
||||
consentChallenge: "invalid",
|
||||
setupMock: func(m *MockAuthService) {
|
||||
m.On("AcceptConsent", mock.Anything, "+79161234567", "invalid").
|
||||
Return("", assert.AnError).Once()
|
||||
},
|
||||
expectedStatus: 400,
|
||||
expectedOk: false,
|
||||
expectedMsg: assert.AnError.Error(),
|
||||
expectedRedirect: "",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
mockService := &MockAuthService{}
|
||||
handler := &AuthHandler{service: mockService}
|
||||
ctx := context.Background()
|
||||
|
||||
tt.setupMock(mockService)
|
||||
|
||||
request := PostAuthConsentAcceptRequestObject{
|
||||
Body: &PostAuthConsentAcceptJSONRequestBody{
|
||||
PhoneNumber: tt.phoneNumber,
|
||||
ConsentChallenge: tt.consentChallenge,
|
||||
},
|
||||
}
|
||||
|
||||
result, err := handler.PostAuthConsentAccept(ctx, request)
|
||||
|
||||
assert.NoError(t, err)
|
||||
|
||||
if tt.expectedStatus == 200 {
|
||||
response, ok := result.(PostAuthConsentAccept200JSONResponse)
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, tt.expectedOk, response.Ok)
|
||||
assert.Equal(t, tt.expectedMsg, response.Message)
|
||||
assert.Equal(t, tt.expectedRedirect, response.RedirectUrl)
|
||||
} else {
|
||||
response, ok := result.(PostAuthConsentAccept400JSONResponse)
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, tt.expectedOk, response.Ok)
|
||||
assert.Equal(t, tt.expectedMsg, response.Message)
|
||||
assert.Equal(t, tt.expectedRedirect, response.RedirectUrl)
|
||||
}
|
||||
|
||||
mockService.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthHandler_EdgeCases(t *testing.T) {
|
||||
t.Run("nil request body should not panic", func(t *testing.T) {
|
||||
mockService := &MockAuthService{}
|
||||
handler := &AuthHandler{service: mockService}
|
||||
ctx := context.Background()
|
||||
|
||||
// Test with nil body - this should be handled by the generated code
|
||||
// but we test that our handler doesn't panic
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
t.Errorf("Handler panicked with nil body: %v", r)
|
||||
}
|
||||
}()
|
||||
|
||||
request := PostAuthOtpRequestRequestObject{
|
||||
Body: &PostAuthOtpRequestJSONRequestBody{
|
||||
PhoneNumber: "",
|
||||
},
|
||||
}
|
||||
|
||||
mockService.On("OtpRequest", mock.Anything, "").Return(assert.AnError).Once()
|
||||
|
||||
result, err := handler.PostAuthOtpRequest(ctx, request)
|
||||
|
||||
assert.NoError(t, err)
|
||||
assert.NotNil(t, result)
|
||||
|
||||
mockService.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
34
internal/api/auth/repo/auth_repo_test.go
Normal file
34
internal/api/auth/repo/auth_repo_test.go
Normal file
@ -0,0 +1,34 @@
|
||||
package repo
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"git.logidex.ru/fakz9/logidex-id/internal/api/auth/domain"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestNewAuthRepo(t *testing.T) {
|
||||
// Test with nil client for interface testing
|
||||
// In real tests, you would use a mock or test container
|
||||
repo := NewAuthRepo(nil)
|
||||
|
||||
assert.NotNil(t, repo)
|
||||
assert.Implements(t, (*domain.AuthRepository)(nil), repo)
|
||||
}
|
||||
|
||||
func TestAuthRepo_Interface(t *testing.T) {
|
||||
// Test that our auth repo implements the domain interface
|
||||
var _ domain.AuthRepository = (*authRepo)(nil)
|
||||
|
||||
// Test constructor returns correct interface
|
||||
repo := NewAuthRepo(nil)
|
||||
|
||||
// Verify interface compliance
|
||||
assert.Implements(t, (*domain.AuthRepository)(nil), repo)
|
||||
}
|
||||
|
||||
// Note: Actual Redis operations testing requires either:
|
||||
// 1. Test containers with real Redis
|
||||
// 2. A simpler interface wrapper around Redis
|
||||
// 3. A Redis mock library specifically designed for rueidis
|
||||
// For now, we focus on interface compliance and constructor behavior
|
||||
@ -2,10 +2,12 @@ package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"strconv"
|
||||
|
||||
"git.logidex.ru/fakz9/logidex-id/internal/api/auth/domain"
|
||||
userDomain "git.logidex.ru/fakz9/logidex-id/internal/api/user/domain"
|
||||
userService "git.logidex.ru/fakz9/logidex-id/internal/api/user/service"
|
||||
"git.logidex.ru/fakz9/logidex-id/internal/phoneutil"
|
||||
hydraApi "github.com/ory/hydra-client-go"
|
||||
)
|
||||
@ -18,24 +20,75 @@ type AuthService interface {
|
||||
|
||||
type authService struct {
|
||||
repo domain.AuthRepository
|
||||
userRepo userDomain.UserRepository
|
||||
userService userService.UserService
|
||||
hydraClient *hydraApi.APIClient
|
||||
}
|
||||
|
||||
func (a authService) AcceptConsent(ctx context.Context, phoneNumber string, challenge string) (string, error) {
|
||||
phoneNumber, err := phoneutil.ParseAndFormatPhoneNumber(phoneNumber)
|
||||
func (a authService) validateAndFormatPhoneNumber(phoneNumber string) (string, error) {
|
||||
formattedPhone, err := phoneutil.ParseAndFormatPhoneNumber(phoneNumber)
|
||||
if err != nil {
|
||||
return "", domain.ErrInvalidPhoneNumber{
|
||||
PhoneNumber: phoneNumber,
|
||||
Err: err,
|
||||
}
|
||||
}
|
||||
user, err := a.userRepo.GetUserByPhoneNumber(ctx, phoneNumber)
|
||||
return formattedPhone, nil
|
||||
}
|
||||
|
||||
func (a authService) getUserByPhoneNumber(ctx context.Context, phoneNumber string) (*userDomain.User, error) {
|
||||
user, err := a.userService.GetUserByPhoneNumber(ctx, phoneNumber)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if user == nil {
|
||||
return nil, domain.ErrUserNotFound{PhoneNumber: phoneNumber}
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
|
||||
func (a authService) getOrCreateUser(ctx context.Context, phoneNumber string) (*userDomain.User, error) {
|
||||
user, err := a.userService.GetUserByPhoneNumber(ctx, phoneNumber)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if user == nil {
|
||||
user, err = a.userService.CreateUser(ctx, phoneNumber)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
|
||||
func (a authService) validateHydraResponse(rawRsp *http.Response, userUuid string) error {
|
||||
if rawRsp.StatusCode != 200 {
|
||||
return domain.ErrInvalidHydraAccept{
|
||||
Message: "Hydra response status: " + strconv.Itoa(rawRsp.StatusCode),
|
||||
Uuid: userUuid,
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (a authService) extractRedirectUrl(rsp interface{ GetRedirectToOk() (*string, bool) }, userUuid string) (string, error) {
|
||||
redirectTo, ok := rsp.GetRedirectToOk()
|
||||
if !ok || redirectTo == nil {
|
||||
return "", domain.ErrInvalidHydraAccept{
|
||||
Message: "Hydra redirectTo is nil",
|
||||
Uuid: userUuid,
|
||||
}
|
||||
}
|
||||
return *redirectTo, nil
|
||||
}
|
||||
|
||||
func (a authService) AcceptConsent(ctx context.Context, phoneNumber string, challenge string) (string, error) {
|
||||
phoneNumber, err := a.validateAndFormatPhoneNumber(phoneNumber)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if user == nil {
|
||||
return "", domain.ErrUserNotFound{PhoneNumber: phoneNumber}
|
||||
user, err := a.getUserByPhoneNumber(ctx, phoneNumber)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
request := hydraApi.AcceptConsentRequest{}
|
||||
request.SetGrantScope([]string{"openid"})
|
||||
@ -50,86 +103,65 @@ func (a authService) AcceptConsent(ctx context.Context, phoneNumber string, chal
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if rawRsp.StatusCode != 200 {
|
||||
return "", domain.ErrInvalidHydraAccept{
|
||||
Message: "Hydra response is nil: " + strconv.Itoa(rawRsp.StatusCode),
|
||||
Uuid: "",
|
||||
}
|
||||
if err = a.validateHydraResponse(rawRsp, user.Uuid); err != nil {
|
||||
return "", err
|
||||
}
|
||||
redirectTo, ok := rsp.GetRedirectToOk()
|
||||
if !ok || redirectTo == nil {
|
||||
return "", domain.ErrInvalidHydraAccept{
|
||||
Message: "Hydra redirectTo is nil",
|
||||
Uuid: "",
|
||||
}
|
||||
}
|
||||
// TODO: Verify user in the database
|
||||
_, err = a.userRepo.VerifyUser(ctx, user.Uuid.String())
|
||||
redirectUrl, err := a.extractRedirectUrl(rsp, user.Uuid)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return *redirectTo, nil
|
||||
// TODO: Verify user in the database
|
||||
_, err = a.userService.VerifyUser(ctx, user.Uuid)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return redirectUrl, nil
|
||||
}
|
||||
|
||||
func (a authService) OtpRequest(ctx context.Context, phoneNumber string) error {
|
||||
phoneNumber, err := phoneutil.ParseAndFormatPhoneNumber(phoneNumber)
|
||||
phoneNumber, err := a.validateAndFormatPhoneNumber(phoneNumber)
|
||||
if err != nil {
|
||||
return domain.ErrInvalidPhoneNumber{
|
||||
PhoneNumber: phoneNumber,
|
||||
Err: err,
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
user, err := a.userRepo.GetUserByPhoneNumber(ctx, phoneNumber)
|
||||
//if err != nil {
|
||||
// return err
|
||||
//}
|
||||
|
||||
if user == nil {
|
||||
// Create a new user if it does not exist
|
||||
user, err = a.userRepo.CreateUser(ctx, phoneNumber)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
user, err := a.getOrCreateUser(ctx, phoneNumber)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
code := "123456"
|
||||
err = a.repo.SaveOtpRequest(ctx, user.Uuid.String(), code)
|
||||
err = a.repo.SaveOtpRequest(ctx, user.Uuid, code)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// TODO implement sending OTP code via SMS
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (a authService) OtpVerify(ctx context.Context, phoneNumber string, code string, loggingChallenge string) (string, error) {
|
||||
phoneNumber, err := phoneutil.ParseAndFormatPhoneNumber(phoneNumber)
|
||||
if err != nil {
|
||||
return "", domain.ErrInvalidPhoneNumber{
|
||||
PhoneNumber: phoneNumber,
|
||||
Err: err,
|
||||
}
|
||||
}
|
||||
|
||||
user, err := a.userRepo.GetUserByPhoneNumber(ctx, phoneNumber)
|
||||
phoneNumber, err := a.validateAndFormatPhoneNumber(phoneNumber)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if user == nil {
|
||||
return "", domain.ErrUserNotFound{PhoneNumber: phoneNumber}
|
||||
|
||||
user, err := a.getUserByPhoneNumber(ctx, phoneNumber)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
otp, err := a.repo.GetOtpRequest(ctx, user.Uuid.String())
|
||||
|
||||
otp, err := a.repo.GetOtpRequest(ctx, user.Uuid)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if otp == nil {
|
||||
return "", domain.ErrOtpNotFound{Uuid: user.Uuid.String()}
|
||||
return "", domain.ErrOtpNotFound{Uuid: user.Uuid}
|
||||
}
|
||||
if *otp != code {
|
||||
return "", domain.ErrOtpInvalid{Uuid: user.Uuid.String(), Code: code}
|
||||
return "", domain.ErrOtpInvalid{Uuid: user.Uuid, Code: code}
|
||||
}
|
||||
|
||||
request := hydraApi.AcceptLoginRequest{}
|
||||
request.SetSubject(user.Uuid.String())
|
||||
request.SetSubject(user.Uuid)
|
||||
request.SetRemember(true)
|
||||
request.SetRememberFor(3600) // 1 hour
|
||||
|
||||
@ -141,27 +173,22 @@ func (a authService) OtpVerify(ctx context.Context, phoneNumber string, code str
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if rawRsp.StatusCode != 200 {
|
||||
return "", domain.ErrInvalidHydraAccept{
|
||||
Message: "Hydra response is nil: " + strconv.Itoa(rawRsp.StatusCode),
|
||||
Uuid: user.Uuid.String(),
|
||||
}
|
||||
if err = a.validateHydraResponse(rawRsp, user.Uuid); err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
redirectTo, ok := rsp.GetRedirectToOk()
|
||||
if !ok || redirectTo == nil {
|
||||
return "", domain.ErrInvalidHydraAccept{
|
||||
Message: "Hydra redirectTo is nil",
|
||||
Uuid: user.Uuid.String(),
|
||||
}
|
||||
redirectUrl, err := a.extractRedirectUrl(rsp, user.Uuid)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return *redirectTo, nil
|
||||
|
||||
return redirectUrl, nil
|
||||
}
|
||||
|
||||
func NewAuthService(repo domain.AuthRepository, userRepo userDomain.UserRepository, hydraClient *hydraApi.APIClient) AuthService {
|
||||
func NewAuthService(repo domain.AuthRepository, userService userService.UserService, hydraClient *hydraApi.APIClient) AuthService {
|
||||
return &authService{
|
||||
repo: repo,
|
||||
userRepo: userRepo,
|
||||
userService: userService,
|
||||
hydraClient: hydraClient,
|
||||
}
|
||||
}
|
||||
|
||||
429
internal/api/auth/service/auth_service_test.go
Normal file
429
internal/api/auth/service/auth_service_test.go
Normal file
@ -0,0 +1,429 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"git.logidex.ru/fakz9/logidex-id/internal/api/auth/domain"
|
||||
userDomain "git.logidex.ru/fakz9/logidex-id/internal/api/user/domain"
|
||||
hydraApi "github.com/ory/hydra-client-go"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
// MockAuthRepository implements domain.AuthRepository
|
||||
type MockAuthRepository struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
func (m *MockAuthRepository) SaveOtpRequest(ctx context.Context, uuid string, code string) error {
|
||||
args := m.Called(ctx, uuid, code)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockAuthRepository) GetOtpRequest(ctx context.Context, uuid string) (*string, error) {
|
||||
args := m.Called(ctx, uuid)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*string), args.Error(1)
|
||||
}
|
||||
|
||||
// MockUserService implements userService.UserService
|
||||
type MockUserService struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
func (m *MockUserService) GetUserByPhoneNumber(ctx context.Context, phoneNumber string) (*userDomain.User, error) {
|
||||
args := m.Called(ctx, phoneNumber)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*userDomain.User), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockUserService) GetUserByUuid(ctx context.Context, uuid string) (*userDomain.User, error) {
|
||||
args := m.Called(ctx, uuid)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*userDomain.User), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockUserService) CreateUser(ctx context.Context, phoneNumber string) (*userDomain.User, error) {
|
||||
args := m.Called(ctx, phoneNumber)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*userDomain.User), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockUserService) VerifyUser(ctx context.Context, uuid string) (*userDomain.User, error) {
|
||||
args := m.Called(ctx, uuid)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*userDomain.User), args.Error(1)
|
||||
}
|
||||
|
||||
// MockHydraResponse implements hydra response interface
|
||||
type MockHydraResponse struct {
|
||||
redirectTo *string
|
||||
}
|
||||
|
||||
func (m *MockHydraResponse) GetRedirectToOk() (*string, bool) {
|
||||
if m.redirectTo == nil {
|
||||
return nil, false
|
||||
}
|
||||
return m.redirectTo, true
|
||||
}
|
||||
|
||||
func TestNewAuthService(t *testing.T) {
|
||||
mockRepo := &MockAuthRepository{}
|
||||
mockUserService := &MockUserService{}
|
||||
mockHydraClient := &hydraApi.APIClient{}
|
||||
|
||||
service := NewAuthService(mockRepo, mockUserService, mockHydraClient)
|
||||
|
||||
assert.NotNil(t, service)
|
||||
assert.Implements(t, (*AuthService)(nil), service)
|
||||
}
|
||||
|
||||
func TestAuthService_getUserByPhoneNumber(t *testing.T) {
|
||||
mockUserService := &MockUserService{}
|
||||
service := &authService{userService: mockUserService}
|
||||
ctx := context.Background()
|
||||
phoneNumber := "+79161234567"
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
setupMock func()
|
||||
expectedUser *userDomain.User
|
||||
wantErr bool
|
||||
errType interface{}
|
||||
}{
|
||||
{
|
||||
name: "user found",
|
||||
setupMock: func() {
|
||||
user := &userDomain.User{
|
||||
Uuid: "test-uuid",
|
||||
PhoneNumber: phoneNumber,
|
||||
}
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(user, nil).Once()
|
||||
},
|
||||
expectedUser: &userDomain.User{
|
||||
Uuid: "test-uuid",
|
||||
PhoneNumber: phoneNumber,
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "user not found",
|
||||
setupMock: func() {
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(nil, nil).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
errType: domain.ErrUserNotFound{},
|
||||
},
|
||||
{
|
||||
name: "service error",
|
||||
setupMock: func() {
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(nil, assert.AnError).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
tt.setupMock()
|
||||
|
||||
result, err := service.getUserByPhoneNumber(ctx, phoneNumber)
|
||||
|
||||
if tt.wantErr {
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, result)
|
||||
if tt.errType != nil {
|
||||
assert.IsType(t, tt.errType, err)
|
||||
}
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, tt.expectedUser, result)
|
||||
}
|
||||
|
||||
mockUserService.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthService_getOrCreateUser(t *testing.T) {
|
||||
mockUserService := &MockUserService{}
|
||||
service := &authService{userService: mockUserService}
|
||||
ctx := context.Background()
|
||||
phoneNumber := "+79161234567"
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
setupMock func()
|
||||
expectedUser *userDomain.User
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "existing user found",
|
||||
setupMock: func() {
|
||||
user := &userDomain.User{
|
||||
Uuid: "test-uuid",
|
||||
PhoneNumber: phoneNumber,
|
||||
}
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(user, nil).Once()
|
||||
},
|
||||
expectedUser: &userDomain.User{
|
||||
Uuid: "test-uuid",
|
||||
PhoneNumber: phoneNumber,
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "user not found, create new",
|
||||
setupMock: func() {
|
||||
newUser := &userDomain.User{
|
||||
Uuid: "new-uuid",
|
||||
PhoneNumber: phoneNumber,
|
||||
}
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(nil, nil).Once()
|
||||
mockUserService.On("CreateUser", ctx, phoneNumber).Return(newUser, nil).Once()
|
||||
},
|
||||
expectedUser: &userDomain.User{
|
||||
Uuid: "new-uuid",
|
||||
PhoneNumber: phoneNumber,
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "get user service error",
|
||||
setupMock: func() {
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(nil, assert.AnError).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "create user service error",
|
||||
setupMock: func() {
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(nil, nil).Once()
|
||||
mockUserService.On("CreateUser", ctx, phoneNumber).Return(nil, assert.AnError).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
tt.setupMock()
|
||||
|
||||
result, err := service.getOrCreateUser(ctx, phoneNumber)
|
||||
|
||||
if tt.wantErr {
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, result)
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, tt.expectedUser, result)
|
||||
}
|
||||
|
||||
mockUserService.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthService_validateHydraResponse(t *testing.T) {
|
||||
service := &authService{}
|
||||
userUuid := "test-uuid"
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
statusCode int
|
||||
wantErr bool
|
||||
errType interface{}
|
||||
}{
|
||||
{
|
||||
name: "success status",
|
||||
statusCode: 200,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "bad request status",
|
||||
statusCode: 400,
|
||||
wantErr: true,
|
||||
errType: domain.ErrInvalidHydraAccept{},
|
||||
},
|
||||
{
|
||||
name: "internal server error status",
|
||||
statusCode: 500,
|
||||
wantErr: true,
|
||||
errType: domain.ErrInvalidHydraAccept{},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
resp := &http.Response{StatusCode: tt.statusCode}
|
||||
|
||||
err := service.validateHydraResponse(resp, userUuid)
|
||||
|
||||
if tt.wantErr {
|
||||
assert.Error(t, err)
|
||||
if tt.errType != nil {
|
||||
assert.IsType(t, tt.errType, err)
|
||||
}
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthService_extractRedirectUrl(t *testing.T) {
|
||||
service := &authService{}
|
||||
userUuid := "test-uuid"
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
response *MockHydraResponse
|
||||
expectedUrl string
|
||||
wantErr bool
|
||||
errType interface{}
|
||||
}{
|
||||
{
|
||||
name: "valid redirect url",
|
||||
response: &MockHydraResponse{
|
||||
redirectTo: stringPtr("https://example.com/callback"),
|
||||
},
|
||||
expectedUrl: "https://example.com/callback",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "nil redirect url",
|
||||
response: &MockHydraResponse{
|
||||
redirectTo: nil,
|
||||
},
|
||||
wantErr: true,
|
||||
errType: domain.ErrInvalidHydraAccept{},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result, err := service.extractRedirectUrl(tt.response, userUuid)
|
||||
|
||||
if tt.wantErr {
|
||||
assert.Error(t, err)
|
||||
assert.Empty(t, result)
|
||||
if tt.errType != nil {
|
||||
assert.IsType(t, tt.errType, err)
|
||||
}
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, tt.expectedUrl, result)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthService_OtpRequest(t *testing.T) {
|
||||
mockRepo := &MockAuthRepository{}
|
||||
mockUserService := &MockUserService{}
|
||||
service := &authService{
|
||||
repo: mockRepo,
|
||||
userService: mockUserService,
|
||||
}
|
||||
ctx := context.Background()
|
||||
phoneNumber := "89161234567" // will be formatted to +79161234567
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
setupMock func()
|
||||
wantErr bool
|
||||
errType interface{}
|
||||
}{
|
||||
{
|
||||
name: "success - existing user",
|
||||
setupMock: func() {
|
||||
user := &userDomain.User{
|
||||
Uuid: "test-uuid",
|
||||
PhoneNumber: "+79161234567",
|
||||
}
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, "+79161234567").Return(user, nil).Once()
|
||||
mockRepo.On("SaveOtpRequest", ctx, "test-uuid", "123456").Return(nil).Once()
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "success - create new user",
|
||||
setupMock: func() {
|
||||
newUser := &userDomain.User{
|
||||
Uuid: "new-uuid",
|
||||
PhoneNumber: "+79161234567",
|
||||
}
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, "+79161234567").Return(nil, nil).Once()
|
||||
mockUserService.On("CreateUser", ctx, "+79161234567").Return(newUser, nil).Once()
|
||||
mockRepo.On("SaveOtpRequest", ctx, "new-uuid", "123456").Return(nil).Once()
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "invalid phone number",
|
||||
setupMock: func() {
|
||||
// No mock setup needed for invalid phone
|
||||
},
|
||||
wantErr: true,
|
||||
errType: domain.ErrInvalidPhoneNumber{},
|
||||
},
|
||||
{
|
||||
name: "repo save error",
|
||||
setupMock: func() {
|
||||
user := &userDomain.User{
|
||||
Uuid: "test-uuid",
|
||||
PhoneNumber: "+79161234567",
|
||||
}
|
||||
mockUserService.On("GetUserByPhoneNumber", ctx, "+79161234567").Return(user, nil).Once()
|
||||
mockRepo.On("SaveOtpRequest", ctx, "test-uuid", "123456").Return(assert.AnError).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
// Reset mocks
|
||||
mockRepo.ExpectedCalls = nil
|
||||
mockUserService.ExpectedCalls = nil
|
||||
|
||||
tt.setupMock()
|
||||
|
||||
testPhone := phoneNumber
|
||||
if tt.name == "invalid phone number" {
|
||||
testPhone = "invalid"
|
||||
}
|
||||
|
||||
err := service.OtpRequest(ctx, testPhone)
|
||||
|
||||
if tt.wantErr {
|
||||
assert.Error(t, err)
|
||||
if tt.errType != nil {
|
||||
assert.IsType(t, tt.errType, err)
|
||||
}
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
mockRepo.AssertExpectations(t)
|
||||
mockUserService.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Helper function to create string pointer
|
||||
func stringPtr(s string) *string {
|
||||
return &s
|
||||
}
|
||||
53
internal/api/user/domain/user_domain_test.go
Normal file
53
internal/api/user/domain/user_domain_test.go
Normal file
@ -0,0 +1,53 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestUser_Structure(t *testing.T) {
|
||||
user := User{
|
||||
Uuid: "123e4567-e89b-12d3-a456-426614174000",
|
||||
PhoneNumber: "+1234567890",
|
||||
}
|
||||
|
||||
assert.Equal(t, "123e4567-e89b-12d3-a456-426614174000", user.Uuid)
|
||||
assert.Equal(t, "+1234567890", user.PhoneNumber)
|
||||
}
|
||||
|
||||
func TestErrUserNotFound_Error(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
phoneNumber string
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "returns formatted error message",
|
||||
phoneNumber: "+1234567890",
|
||||
want: "User not found with phone number: +1234567890",
|
||||
},
|
||||
{
|
||||
name: "handles empty phone number",
|
||||
phoneNumber: "",
|
||||
want: "User not found with phone number: ",
|
||||
},
|
||||
{
|
||||
name: "handles international phone number",
|
||||
phoneNumber: "+44123456789",
|
||||
want: "User not found with phone number: +44123456789",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := ErrUserNotFound{PhoneNumber: tt.phoneNumber}
|
||||
assert.Equal(t, tt.want, err.Error())
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestErrUserNotFound_IsError(t *testing.T) {
|
||||
err := ErrUserNotFound{PhoneNumber: "+1234567890"}
|
||||
assert.Implements(t, (*error)(nil), err)
|
||||
}
|
||||
@ -25,10 +25,9 @@ func (h UserHandler) GetUserById(ctx context.Context, request GetUserByIdRequest
|
||||
}, nil
|
||||
}
|
||||
var responseUser User
|
||||
err = copier.Copy(responseUser, user)
|
||||
err = copier.Copy(&responseUser, user)
|
||||
if err != nil {
|
||||
return GetUserById404JSONResponse{Message: err.Error()}, nil
|
||||
|
||||
}
|
||||
return GetUserById200JSONResponse{User: responseUser}, nil
|
||||
}
|
||||
@ -45,9 +44,3 @@ func (h UserHandler) RegisterRoutes(router fiber.Router) {
|
||||
server := NewStrictHandler(h, nil)
|
||||
RegisterHandlers(router, server)
|
||||
}
|
||||
|
||||
//func RegisterUserHandler(router fiber.Router) {
|
||||
// server := NewStrictHandler(NewUserHandler(), nil)
|
||||
// RegisterHandlers(router, server)
|
||||
//
|
||||
//}
|
||||
|
||||
198
internal/api/user/handler/impl_test.go
Normal file
198
internal/api/user/handler/impl_test.go
Normal file
@ -0,0 +1,198 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"git.logidex.ru/fakz9/logidex-id/internal/api/user/domain"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
// MockUserService implements service.UserService
|
||||
type MockUserService struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
func (m *MockUserService) GetUserByPhoneNumber(ctx context.Context, phoneNumber string) (*domain.User, error) {
|
||||
args := m.Called(ctx, phoneNumber)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*domain.User), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockUserService) GetUserByUuid(ctx context.Context, uuid string) (*domain.User, error) {
|
||||
args := m.Called(ctx, uuid)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*domain.User), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockUserService) CreateUser(ctx context.Context, phoneNumber string) (*domain.User, error) {
|
||||
args := m.Called(ctx, phoneNumber)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*domain.User), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockUserService) VerifyUser(ctx context.Context, uuid string) (*domain.User, error) {
|
||||
args := m.Called(ctx, uuid)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*domain.User), args.Error(1)
|
||||
}
|
||||
|
||||
func TestNewUserHandler(t *testing.T) {
|
||||
mockService := &MockUserService{}
|
||||
handler := NewUserHandler(mockService)
|
||||
|
||||
assert.NotNil(t, handler)
|
||||
assert.Equal(t, mockService, handler.service)
|
||||
assert.Implements(t, (*StrictServerInterface)(nil), handler)
|
||||
}
|
||||
|
||||
func TestUserHandler_GetUserById(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
userId string
|
||||
setupMock func(*MockUserService)
|
||||
expectedStatus int
|
||||
expectError bool
|
||||
expectedMsg string
|
||||
}{
|
||||
{
|
||||
name: "successful user retrieval",
|
||||
userId: "123e4567-e89b-12d3-a456-426614174000",
|
||||
setupMock: func(m *MockUserService) {
|
||||
user := &domain.User{
|
||||
Uuid: "123e4567-e89b-12d3-a456-426614174000",
|
||||
PhoneNumber: "+79161234567",
|
||||
}
|
||||
m.On("GetUserByUuid", mock.Anything, "123e4567-e89b-12d3-a456-426614174000").
|
||||
Return(user, nil).Once()
|
||||
},
|
||||
expectedStatus: 200, // Fixed copier bug
|
||||
expectError: false,
|
||||
},
|
||||
{
|
||||
name: "user not found",
|
||||
userId: "nonexistent-uuid",
|
||||
setupMock: func(m *MockUserService) {
|
||||
m.On("GetUserByUuid", mock.Anything, "nonexistent-uuid").
|
||||
Return(nil, domain.ErrUserNotFound{PhoneNumber: "nonexistent-uuid"}).Once()
|
||||
},
|
||||
expectedStatus: 404,
|
||||
expectError: true,
|
||||
expectedMsg: "User not found with phone number: nonexistent-uuid",
|
||||
},
|
||||
{
|
||||
name: "service error",
|
||||
userId: "error-uuid",
|
||||
setupMock: func(m *MockUserService) {
|
||||
m.On("GetUserByUuid", mock.Anything, "error-uuid").
|
||||
Return(nil, assert.AnError).Once()
|
||||
},
|
||||
expectedStatus: 404,
|
||||
expectError: true,
|
||||
expectedMsg: assert.AnError.Error(),
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
mockService := &MockUserService{}
|
||||
handler := &UserHandler{service: mockService}
|
||||
ctx := context.Background()
|
||||
|
||||
tt.setupMock(mockService)
|
||||
|
||||
request := GetUserByIdRequestObject{
|
||||
UserId: tt.userId,
|
||||
}
|
||||
|
||||
result, err := handler.GetUserById(ctx, request)
|
||||
|
||||
assert.NoError(t, err) // Handler should not return errors, only response objects
|
||||
|
||||
if tt.expectedStatus == 200 {
|
||||
response, ok := result.(GetUserById200JSONResponse)
|
||||
assert.True(t, ok, "Expected 200 response type")
|
||||
_ = response // Just to avoid unused variable error
|
||||
} else {
|
||||
response, ok := result.(GetUserById404JSONResponse)
|
||||
assert.True(t, ok, "Expected 404 response type")
|
||||
assert.Equal(t, tt.expectedMsg, response.Message)
|
||||
_ = response // Use the variable to avoid unused error
|
||||
}
|
||||
|
||||
mockService.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUserHandler_CreateUser(t *testing.T) {
|
||||
mockService := &MockUserService{}
|
||||
handler := &UserHandler{service: mockService}
|
||||
ctx := context.Background()
|
||||
|
||||
t.Run("create user not implemented", func(t *testing.T) {
|
||||
request := CreateUserRequestObject{}
|
||||
|
||||
// This should panic as per the current implementation
|
||||
assert.Panics(t, func() {
|
||||
_, _ = handler.CreateUser(ctx, request)
|
||||
}, "CreateUser should panic as it's not implemented")
|
||||
})
|
||||
}
|
||||
|
||||
func TestUserHandler_EdgeCases(t *testing.T) {
|
||||
t.Run("empty user ID should be handled gracefully", func(t *testing.T) {
|
||||
mockService := &MockUserService{}
|
||||
handler := &UserHandler{service: mockService}
|
||||
ctx := context.Background()
|
||||
|
||||
mockService.On("GetUserByUuid", mock.Anything, "").
|
||||
Return(nil, domain.ErrUserNotFound{PhoneNumber: ""}).Once()
|
||||
|
||||
request := GetUserByIdRequestObject{
|
||||
UserId: "",
|
||||
}
|
||||
|
||||
result, err := handler.GetUserById(ctx, request)
|
||||
|
||||
assert.NoError(t, err)
|
||||
response, ok := result.(GetUserById404JSONResponse)
|
||||
assert.True(t, ok)
|
||||
assert.Contains(t, response.Message, "User not found")
|
||||
|
||||
mockService.AssertExpectations(t)
|
||||
})
|
||||
|
||||
t.Run("special characters in user ID", func(t *testing.T) {
|
||||
mockService := &MockUserService{}
|
||||
handler := &UserHandler{service: mockService}
|
||||
ctx := context.Background()
|
||||
|
||||
specialUserId := "user@#$%^&*()"
|
||||
|
||||
mockService.On("GetUserByUuid", mock.Anything, specialUserId).
|
||||
Return(nil, domain.ErrUserNotFound{PhoneNumber: specialUserId}).Once()
|
||||
|
||||
request := GetUserByIdRequestObject{
|
||||
UserId: specialUserId,
|
||||
}
|
||||
|
||||
result, err := handler.GetUserById(ctx, request)
|
||||
|
||||
assert.NoError(t, err)
|
||||
response, ok := result.(GetUserById404JSONResponse)
|
||||
assert.True(t, ok)
|
||||
_ = response // Use the variable to avoid unused error
|
||||
|
||||
mockService.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
@ -40,13 +40,6 @@ func (u userRepo) GetUserByUuid(ctx context.Context, requestUuid string) (*db.Us
|
||||
return &dbUser, nil
|
||||
}
|
||||
|
||||
func userFromDbToDomain(dbUser db.User) *domain.User {
|
||||
return &domain.User{
|
||||
PhoneNumber: dbUser.PhoneNumber,
|
||||
Uuid: dbUser.Uuid.String(),
|
||||
}
|
||||
}
|
||||
|
||||
func (u userRepo) CreateUser(ctx context.Context, phoneNumber string) (*db.User, error) {
|
||||
queries := db.New(u.db)
|
||||
user, err := queries.CreateUser(ctx, phoneNumber)
|
||||
|
||||
@ -8,7 +8,9 @@ import (
|
||||
|
||||
type UserService interface {
|
||||
GetUserByPhoneNumber(ctx context.Context, phoneNumber string) (*domain.User, error)
|
||||
GetUserByUuid(ctx context.Context, phoneNumber string) (*domain.User, error)
|
||||
GetUserByUuid(ctx context.Context, uuid string) (*domain.User, error)
|
||||
CreateUser(ctx context.Context, phoneNumber string) (*domain.User, error)
|
||||
VerifyUser(ctx context.Context, uuid string) (*domain.User, error)
|
||||
}
|
||||
type userService struct {
|
||||
repo domain.UserRepository
|
||||
@ -42,6 +44,28 @@ func (u userService) GetUserByPhoneNumber(ctx context.Context, phoneNumber strin
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (u userService) CreateUser(ctx context.Context, phoneNumber string) (*domain.User, error) {
|
||||
dbUser, err := u.repo.CreateUser(ctx, phoneNumber)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &domain.User{
|
||||
Uuid: dbUser.Uuid.String(),
|
||||
PhoneNumber: dbUser.PhoneNumber,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (u userService) VerifyUser(ctx context.Context, uuid string) (*domain.User, error) {
|
||||
dbUser, err := u.repo.VerifyUser(ctx, uuid)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &domain.User{
|
||||
Uuid: dbUser.Uuid.String(),
|
||||
PhoneNumber: dbUser.PhoneNumber,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func NewUserService(repo domain.UserRepository) UserService {
|
||||
return &userService{repo: repo}
|
||||
}
|
||||
|
||||
337
internal/api/user/service/user_service_test.go
Normal file
337
internal/api/user/service/user_service_test.go
Normal file
@ -0,0 +1,337 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"git.logidex.ru/fakz9/logidex-id/internal/api/user/domain"
|
||||
db "git.logidex.ru/fakz9/logidex-id/internal/db/generated"
|
||||
"github.com/google/uuid"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
// MockUserRepository implements domain.UserRepository
|
||||
type MockUserRepository struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
func (m *MockUserRepository) GetUserByPhoneNumber(ctx context.Context, phoneNumber string) (*db.User, error) {
|
||||
args := m.Called(ctx, phoneNumber)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*db.User), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockUserRepository) GetUserByUuid(ctx context.Context, uuid string) (*db.User, error) {
|
||||
args := m.Called(ctx, uuid)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*db.User), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockUserRepository) CreateUser(ctx context.Context, phoneNumber string) (*db.User, error) {
|
||||
args := m.Called(ctx, phoneNumber)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*db.User), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockUserRepository) VerifyUser(ctx context.Context, uuid string) (*db.User, error) {
|
||||
args := m.Called(ctx, uuid)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*db.User), args.Error(1)
|
||||
}
|
||||
|
||||
func TestNewUserService(t *testing.T) {
|
||||
mockRepo := &MockUserRepository{}
|
||||
service := NewUserService(mockRepo)
|
||||
|
||||
assert.NotNil(t, service)
|
||||
assert.Implements(t, (*UserService)(nil), service)
|
||||
}
|
||||
|
||||
func TestUserService_GetUserByPhoneNumber(t *testing.T) {
|
||||
mockRepo := &MockUserRepository{}
|
||||
service := &userService{repo: mockRepo}
|
||||
ctx := context.Background()
|
||||
phoneNumber := "+79161234567"
|
||||
testUuid := uuid.New()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
setupMock func()
|
||||
expectedUser *domain.User
|
||||
wantErr bool
|
||||
errType interface{}
|
||||
}{
|
||||
{
|
||||
name: "user found",
|
||||
setupMock: func() {
|
||||
dbUser := &db.User{
|
||||
Uuid: testUuid,
|
||||
PhoneNumber: phoneNumber,
|
||||
}
|
||||
mockRepo.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(dbUser, nil).Once()
|
||||
},
|
||||
expectedUser: &domain.User{
|
||||
Uuid: testUuid.String(),
|
||||
PhoneNumber: phoneNumber,
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "user not found",
|
||||
setupMock: func() {
|
||||
mockRepo.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(nil, nil).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
errType: domain.ErrUserNotFound{},
|
||||
},
|
||||
{
|
||||
name: "repository error",
|
||||
setupMock: func() {
|
||||
mockRepo.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(nil, assert.AnError).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
// Reset mock
|
||||
mockRepo.ExpectedCalls = nil
|
||||
tt.setupMock()
|
||||
|
||||
result, err := service.GetUserByPhoneNumber(ctx, phoneNumber)
|
||||
|
||||
if tt.wantErr {
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, result)
|
||||
if tt.errType != nil {
|
||||
assert.IsType(t, tt.errType, err)
|
||||
}
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, tt.expectedUser, result)
|
||||
}
|
||||
|
||||
mockRepo.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUserService_GetUserByUuid(t *testing.T) {
|
||||
mockRepo := &MockUserRepository{}
|
||||
service := &userService{repo: mockRepo}
|
||||
ctx := context.Background()
|
||||
testUuid := uuid.New()
|
||||
uuidString := testUuid.String()
|
||||
phoneNumber := "+79161234567"
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
setupMock func()
|
||||
expectedUser *domain.User
|
||||
wantErr bool
|
||||
errType interface{}
|
||||
}{
|
||||
{
|
||||
name: "user found",
|
||||
setupMock: func() {
|
||||
dbUser := &db.User{
|
||||
Uuid: testUuid,
|
||||
PhoneNumber: phoneNumber,
|
||||
}
|
||||
mockRepo.On("GetUserByUuid", ctx, uuidString).Return(dbUser, nil).Once()
|
||||
},
|
||||
expectedUser: &domain.User{
|
||||
Uuid: uuidString,
|
||||
PhoneNumber: phoneNumber,
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "user not found",
|
||||
setupMock: func() {
|
||||
mockRepo.On("GetUserByUuid", ctx, uuidString).Return(nil, nil).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
errType: domain.ErrUserNotFound{},
|
||||
},
|
||||
{
|
||||
name: "repository error",
|
||||
setupMock: func() {
|
||||
mockRepo.On("GetUserByUuid", ctx, uuidString).Return(nil, assert.AnError).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
// Reset mock
|
||||
mockRepo.ExpectedCalls = nil
|
||||
tt.setupMock()
|
||||
|
||||
result, err := service.GetUserByUuid(ctx, uuidString)
|
||||
|
||||
if tt.wantErr {
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, result)
|
||||
if tt.errType != nil {
|
||||
assert.IsType(t, tt.errType, err)
|
||||
}
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, tt.expectedUser, result)
|
||||
}
|
||||
|
||||
mockRepo.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUserService_CreateUser(t *testing.T) {
|
||||
mockRepo := &MockUserRepository{}
|
||||
service := &userService{repo: mockRepo}
|
||||
ctx := context.Background()
|
||||
phoneNumber := "+79161234567"
|
||||
testUuid := uuid.New()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
setupMock func()
|
||||
expectedUser *domain.User
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "user created successfully",
|
||||
setupMock: func() {
|
||||
dbUser := &db.User{
|
||||
Uuid: testUuid,
|
||||
PhoneNumber: phoneNumber,
|
||||
}
|
||||
mockRepo.On("CreateUser", ctx, phoneNumber).Return(dbUser, nil).Once()
|
||||
},
|
||||
expectedUser: &domain.User{
|
||||
Uuid: testUuid.String(),
|
||||
PhoneNumber: phoneNumber,
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "repository error",
|
||||
setupMock: func() {
|
||||
mockRepo.On("CreateUser", ctx, phoneNumber).Return(nil, assert.AnError).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
// Reset mock
|
||||
mockRepo.ExpectedCalls = nil
|
||||
tt.setupMock()
|
||||
|
||||
result, err := service.CreateUser(ctx, phoneNumber)
|
||||
|
||||
if tt.wantErr {
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, result)
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, tt.expectedUser, result)
|
||||
}
|
||||
|
||||
mockRepo.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUserService_VerifyUser(t *testing.T) {
|
||||
mockRepo := &MockUserRepository{}
|
||||
service := &userService{repo: mockRepo}
|
||||
ctx := context.Background()
|
||||
testUuid := uuid.New()
|
||||
uuidString := testUuid.String()
|
||||
phoneNumber := "+79161234567"
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
setupMock func()
|
||||
expectedUser *domain.User
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "user verified successfully",
|
||||
setupMock: func() {
|
||||
dbUser := &db.User{
|
||||
Uuid: testUuid,
|
||||
PhoneNumber: phoneNumber,
|
||||
}
|
||||
mockRepo.On("VerifyUser", ctx, uuidString).Return(dbUser, nil).Once()
|
||||
},
|
||||
expectedUser: &domain.User{
|
||||
Uuid: uuidString,
|
||||
PhoneNumber: phoneNumber,
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "repository error",
|
||||
setupMock: func() {
|
||||
mockRepo.On("VerifyUser", ctx, uuidString).Return(nil, assert.AnError).Once()
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
// Reset mock
|
||||
mockRepo.ExpectedCalls = nil
|
||||
tt.setupMock()
|
||||
|
||||
result, err := service.VerifyUser(ctx, uuidString)
|
||||
|
||||
if tt.wantErr {
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, result)
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, tt.expectedUser, result)
|
||||
}
|
||||
|
||||
mockRepo.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Test edge cases and error scenarios
|
||||
func TestUserService_ErrorMessages(t *testing.T) {
|
||||
mockRepo := &MockUserRepository{}
|
||||
service := &userService{repo: mockRepo}
|
||||
ctx := context.Background()
|
||||
phoneNumber := "+79161234567"
|
||||
|
||||
t.Run("GetUserByPhoneNumber returns proper error message", func(t *testing.T) {
|
||||
mockRepo.On("GetUserByPhoneNumber", ctx, phoneNumber).Return(nil, nil).Once()
|
||||
|
||||
_, err := service.GetUserByPhoneNumber(ctx, phoneNumber)
|
||||
|
||||
assert.Error(t, err)
|
||||
userErr, ok := err.(domain.ErrUserNotFound)
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, phoneNumber, userErr.PhoneNumber)
|
||||
assert.Contains(t, err.Error(), phoneNumber)
|
||||
|
||||
mockRepo.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user