From e23e81346373f3cded7b98048c5cad6df0a1e874 Mon Sep 17 00:00:00 2001 From: Amir Date: Fri, 23 Aug 2024 21:24:58 +0330 Subject: [PATCH] Increase coverage (#137) Co-authored-by: Taha Dostifam --- config/config.go | 2 +- config/config.test.yml | 39 ++ config/config_test.go | 20 + database/repo_mongo/message_repository.go | 52 +- internal/repository/message_repository.go | 1 + internal/service/message/message_service.go | 42 +- internal/service/user/user_service.go | 9 +- .../repository/message_repository_test.go | 16 +- .../integration/service/auth_service_test.go | 554 ++++++++++++++++-- .../integration/service/chat_service_test.go | 430 ++++++++++++-- .../service/message_service_test.go | 193 +++++- .../integration/service/user_service_test.go | 82 ++- 12 files changed, 1275 insertions(+), 165 deletions(-) create mode 100644 config/config.test.yml diff --git a/config/config.go b/config/config.go index ab1d6c5..1bbaaf2 100644 --- a/config/config.go +++ b/config/config.go @@ -118,7 +118,7 @@ func Read() *Config { CurrentEnv = Production filename = "config.production.yml" } else if env == "test" { - CurrentEnv = Production + CurrentEnv = Test filename = "config.test.yml" } else { panic(errors.New("Invalid env value set for variable KAVKA_ENV: " + env)) diff --git a/config/config.test.yml b/config/config.test.yml new file mode 100644 index 0000000..73c3b3f --- /dev/null +++ b/config/config.test.yml @@ -0,0 +1,39 @@ +app_name: "kavka" + +http: + host: "0.0.0.0" + port: 3000 + cors: + allow_origins: "*" + +mongo: + host: "127.0.0.1" + username: "test" + password: "test" + port: 27017 + db_name: "kavka" + +redis: + host: "127.0.0.1" + username: "redis" + password: + port: 6379 + db: 0 + +minio: + endpoint: 127.0.0.1:9000 + access_key: uD3h2W3CONpYe8Tb4nbp + secret_key: fKF98iAk1eDSpdtdJWcJHgivjpF4Su4HCdgkpYvQ + +sms: + +logger: + file_name: kavka.logs + level: debug + targets: [console, file] + max_size: 10 + max_backups: 1 + compress: false + +nats: + url: 127.0.0.1:4222 diff --git a/config/config_test.go b/config/config_test.go index adee4ba..c7887c1 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -1,6 +1,7 @@ package config import ( + "errors" "os" "testing" @@ -19,3 +20,22 @@ func TestDevelopmentConfig(t *testing.T) { require.NotEmpty(t, configs) require.Equal(t, CurrentEnv, Development) } + +func TestTestConfig(t *testing.T) { + os.Setenv("KAVKA_ENV", "test") + + Read() + require.Equal(t, CurrentEnv, Test) +} + +func TestFunctionPanics(t *testing.T) { + os.Setenv("KAVKA_ENV", "panic") + + defer func() { + if r := recover(); r == nil { + require.Error(t, errors.New("Expected panic but did not panic")) + } + }() + + Read() +} diff --git a/database/repo_mongo/message_repository.go b/database/repo_mongo/message_repository.go index f9a2851..70a93b9 100644 --- a/database/repo_mongo/message_repository.go +++ b/database/repo_mongo/message_repository.go @@ -9,6 +9,7 @@ import ( "github.com/kavkaco/Kavka-Core/internal/model" "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/mongo" ) @@ -19,10 +20,59 @@ type messagesDoc struct { type messageRepository struct { messagesCollection *mongo.Collection + usersCollection *mongo.Collection } func NewMessageMongoRepository(db *mongo.Database) repository.MessageRepository { - return &messageRepository{db.Collection(database.MessagesCollection)} + return &messageRepository{db.Collection(database.MessagesCollection), db.Collection(database.UsersCollection)} +} + +func (repo *messageRepository) FetchMessage(ctx context.Context, chatID primitive.ObjectID, messageID primitive.ObjectID) (*model.Message, error) { + cursor, err := repo.messagesCollection.Aggregate(ctx, bson.A{ + bson.M{ + "$match": bson.M{ + "chat_id": chatID, + }, + }, + bson.M{ + "$project": bson.M{ + "_id": 1, + "chat_id": 1, + "message": bson.M{ + "$arrayElemAt": bson.A{ + bson.M{ + "$filter": bson.M{ + "input": "$messages", + "as": "message", + "cond": bson.M{"$eq": bson.A{ + "$$message.message_id", messageID, + }}, + }, + }, + 0, + }, + }, + }, + }, + }) + if err != nil { + return nil, err + } + + type docModel struct { + ChatID model.ChatID `bson:"chat_id"` + Message model.Message `bson:"message"` + } + + var docs []docModel + err = cursor.All(ctx, &docs) + if err != nil || len(docs) == 0 { + return nil, err + } + + message := &docs[0].Message + + return message, nil } func (repo *messageRepository) FetchLastMessage(ctx context.Context, chatID model.ChatID) (*model.Message, error) { diff --git a/internal/repository/message_repository.go b/internal/repository/message_repository.go index 08beee3..4dacdd7 100644 --- a/internal/repository/message_repository.go +++ b/internal/repository/message_repository.go @@ -10,6 +10,7 @@ type MessageRepository interface { Create(ctx context.Context, chatID model.ChatID) error Insert(ctx context.Context, chatID model.ChatID, message *model.Message) (*model.Message, error) FetchLastMessage(ctx context.Context, chatID model.ChatID) (*model.Message, error) + FetchMessage(ctx context.Context, chatID model.ChatID, messageID model.MessageID) (*model.Message, error) FetchMessages(ctx context.Context, chatID model.ChatID) ([]*model.MessageGetter, error) UpdateMessageContent(ctx context.Context, chatID model.ChatID, messageID model.MessageID, newMessageContent string) error Delete(ctx context.Context, chatID model.ChatID, messageID model.MessageID) error diff --git a/internal/service/message/message_service.go b/internal/service/message/message_service.go index b6b97c7..0e08b51 100644 --- a/internal/service/message/message_service.go +++ b/internal/service/message/message_service.go @@ -117,33 +117,31 @@ func (s *service) SendTextMessage(ctx context.Context, chatID model.ChatID, user } func (s *service) DeleteMessage(ctx context.Context, chatID model.ChatID, userID model.UserID, messageID model.MessageID) *vali.Varror { - panic("unimplemented") - - // varrors := s.validator.Validate(DeleteMessageValidation{chatID, userID, messageID}) - // if len(varrors) > 0 { - // return &vali.Varror{ValidationErrors: varrors} - // } + varrors := s.validator.Validate(DeleteMessageValidation{chatID, userID, messageID}) + if len(varrors) > 0 { + return &vali.Varror{ValidationErrors: varrors} + } - // chat, err := s.chatRepo.FindByID(ctx, chatID) - // if err != nil { - // return &vali.Varror{Error: ErrChatNotFound} - // } + chat, err := s.chatRepo.FindByID(ctx, chatID) + if err != nil { + return &vali.Varror{Error: ErrChatNotFound} + } - // message, err := s.messageRepo.FindMessage(ctx, chatID, messageID) - // if err != nil { - // return &vali.Varror{Error: ErrNotFound} - // } + message, err := s.messageRepo.FetchMessage(ctx, chatID, messageID) + if err != nil { + return &vali.Varror{Error: ErrNotFound} + } - // if HasAccessToDeleteMessage(chat.ChatType, chat.ChatDetail, userID, *message) { - // err = s.messageRepo.Delete(ctx, chatID, messageID) - // if err != nil { - // return &vali.Varror{Error: ErrDeleteMessage} - // } + if HasAccessToDeleteMessage(chat.ChatType, chat.ChatDetail, userID, *message) { + err = s.messageRepo.Delete(ctx, chatID, messageID) + if err != nil { + return &vali.Varror{Error: ErrDeleteMessage} + } - // return nil - // } + return nil + } - // return &vali.Varror{Error: ErrAccessDenied} + return &vali.Varror{Error: ErrAccessDenied} } // TODO - Implement UpdateTextMessage Method For MessageService diff --git a/internal/service/user/user_service.go b/internal/service/user/user_service.go index 0631590..15d4732 100644 --- a/internal/service/user/user_service.go +++ b/internal/service/user/user_service.go @@ -25,6 +25,10 @@ func NewUserService(userRepo repository.UserRepository) UserService { } func (s *UserManager) UpdateProfile(ctx context.Context, userID model.UserID, name, lastName, username, biography string) *vali.Varror { + validationErrors := s.validator.Validate(UpdateProfileValidation{name, lastName, username}) + if len(validationErrors) > 0 { + return &vali.Varror{ValidationErrors: validationErrors} + } user, err := s.userRepo.FindByUserID(ctx, userID) if err != nil { return &vali.Varror{Error: ErrNotFound} @@ -46,11 +50,6 @@ func (s *UserManager) UpdateProfile(ctx context.Context, userID model.UserID, na user.Biography = biography } - varrors := s.validator.Validate(UpdateProfileValidation{name, lastName, username}) - if len(varrors) > 0 { - return &vali.Varror{ValidationErrors: varrors} - } - err = s.userRepo.Update(ctx, userID, user.Name, user.LastName, user.Username, user.Biography) if err != nil { return &vali.Varror{Error: ErrUpdateUser} diff --git a/tests/integration/repository/message_repository_test.go b/tests/integration/repository/message_repository_test.go index 30361d1..17e326a 100644 --- a/tests/integration/repository/message_repository_test.go +++ b/tests/integration/repository/message_repository_test.go @@ -95,16 +95,16 @@ func (s *MessageTestSuite) TestC_FetchLastMessage() { require.Equal(s.T(), lastMessage.MessageID, s.savedMessageID) } -// func (s *MessageTestSuite) TestC_FindMessage() { -// ctx := context.TODO() +func (s *MessageTestSuite) TestC_FetchMessage() { + ctx := context.TODO() -// message, err := s.repo.FindMessage(ctx, s.chatID, s.savedMessageID) -// require.NoError(s.T(), err) + message, err := s.repo.FetchMessage(ctx, s.chatID, s.savedMessageID) + require.NoError(s.T(), err) -// require.NotEmpty(s.T(), message) -// require.Equal(s.T(), message.MessageID, s.savedMessageID) -// require.Equal(s.T(), message.SenderID, s.senderID) -// } + require.NotEmpty(s.T(), message) + require.Equal(s.T(), message.MessageID, s.savedMessageID) + // require.Equal(s.T(), message.Message.SenderID, s.senderID) +} // func (s *MessageTestSuite) TestD_UpdateTextMessage() { // ctx := context.TODO() diff --git a/tests/integration/service/auth_service_test.go b/tests/integration/service/auth_service_test.go index 858d022..7924497 100644 --- a/tests/integration/service/auth_service_test.go +++ b/tests/integration/service/auth_service_test.go @@ -3,6 +3,7 @@ package service import ( "context" "testing" + "time" repository_mongo "github.com/kavkaco/Kavka-Core/database/repo_mongo" "github.com/kavkaco/Kavka-Core/internal/model" @@ -32,6 +33,9 @@ type AuthTestSuite struct { // Urls verifyEmailRedirectUrl string resetPasswordRedirectUrl string + + // auth manger + authManager auth_manager.AuthManager } func (s *AuthTestSuite) SetupSuite() { @@ -42,6 +46,7 @@ func (s *AuthTestSuite) SetupSuite() { }) emailService := email.NewEmailDevelopmentService() + s.authManager = authManager // FIXME s.verifyEmailRedirectUrl = "example.com" @@ -64,101 +69,554 @@ func (s *AuthTestSuite) quickLogin(email string, password string) { func (s *AuthTestSuite) TestA_Register() { ctx := context.TODO() - user := model.User{ - Name: "User1:Name", - LastName: "User1:LastName", - Email: "user1@kavka.org", - Username: "user1", + testCases := []struct { + Name string + LastName string + Username string + Email string + Password string + VerifyEmailRedirectUrl string + Valid bool + Error error + }{ + { + Name: "", + LastName: "", + Username: "", + Email: "", + Password: "", + VerifyEmailRedirectUrl: "", + Valid: false, + }, + { + Name: " ", + LastName: " ", + Username: "fk", + Email: "email", + Password: "5285", + VerifyEmailRedirectUrl: "example.com", + Valid: false, + }, + { + Name: "User1:Name", + LastName: "User1:LastName", + Email: "user1@kavka.org", + Username: "user1", + Password: "plain-password", + Valid: true, + }, + { + Name: "User2:Name", + LastName: "User2:LastName", + Email: "user1@kavka.org", + Username: "user2", + Password: "plain-password", + VerifyEmailRedirectUrl: "example.com", + Valid: false, + Error: service.ErrEmailAlreadyExist, + }, + { + Name: "User2:Name", + LastName: "User2:LastName", + Email: "user2@kavka.org", + Username: "user1", + Password: "plain-password", + VerifyEmailRedirectUrl: "example.com", + Valid: false, + Error: service.ErrUsernameAlreadyExist, + }, } - s.email = user.Email - s.password = "plain-password" - - verifyEmailToken, varror := s.service.Register(ctx, user.Name, user.LastName, user.Username, user.Email, s.password, s.verifyEmailRedirectUrl) - require.Nil(s.T(), varror) - s.verifyEmailToken = verifyEmailToken + for _, tc := range testCases { + verifyEmailToken, varror := s.service.Register(ctx, tc.Name, tc.LastName, tc.Username, tc.Email, tc.Password, tc.VerifyEmailRedirectUrl) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + s.email = tc.Email + s.password = tc.Password + s.verifyEmailToken = verifyEmailToken + + _, _, _, varror := s.service.Login(ctx, s.email, s.password) + require.Equal(s.T(), varror.Error, service.ErrEmailNotVerified) + + _, _, varror = s.service.SendResetPassword(ctx, s.email, s.resetPasswordRedirectUrl) + require.Equal(s.T(), varror.Error, service.ErrEmailNotVerified) + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *AuthTestSuite) TestB_VerifyEmail() { ctx := context.TODO() - varror := s.service.VerifyEmail(ctx, s.verifyEmailToken) - require.Nil(s.T(), varror) + testCases := []struct { + VerifyEmailToken string + Valid bool + Error error + }{ + { + VerifyEmailToken: "", + Valid: false, + }, + { + VerifyEmailToken: "invalidToken", + Error: service.ErrAccessDenied, + Valid: false, + }, + { + VerifyEmailToken: s.verifyEmailToken, + Valid: true, + }, + } + + for _, tc := range testCases { + varror := s.service.VerifyEmail(ctx, tc.VerifyEmailToken) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *AuthTestSuite) TestC_Login() { ctx := context.TODO() - user, accessToken, refreshToken, varror := s.service.Login(ctx, s.email, s.password) - require.Nil(s.T(), varror) + testCases := []struct { + Email string + Password string + Valid bool + Error error + }{ + { + Email: "", + Password: "", + Valid: false, + }, + { + Email: "email", + Password: "5285", + Valid: false, + }, + { + Email: "invalid@kavka.org", + Password: s.password, + Error: service.ErrInvalidEmailOrPassword, + Valid: false, + }, + { + Email: s.email, + Password: "invalidpassword", + Valid: false, + Error: service.ErrInvalidEmailOrPassword, + }, + { + Email: "invalidpp@kafka.com", + Password: "invalid-password", + Valid: false, + }, + { + Email: s.email, + Password: s.password, + Valid: true, + }, + } - require.NotEmpty(s.T(), accessToken) - require.NotEmpty(s.T(), refreshToken) - require.NotEmpty(s.T(), user) - require.Equal(s.T(), user.Email, s.email) + for _, tc := range testCases { + user, accessToken, refreshToken, varror := s.service.Login(ctx, tc.Email, tc.Password) - s.accessToken = accessToken - s.refreshToken = refreshToken - s.userID = user.UserID + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } - s.user = user + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + require.NotEmpty(s.T(), accessToken) + require.NotEmpty(s.T(), refreshToken) + require.NotEmpty(s.T(), user) + require.Equal(s.T(), user.Email, s.email) + + s.accessToken = accessToken + s.refreshToken = refreshToken + s.userID = user.UserID + + s.user = user + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *AuthTestSuite) TestD_ChangePassword() { ctx := context.TODO() - newPassword := "password-must-be-changed" - - varror := s.service.ChangePassword(ctx, s.userID, s.password, newPassword) - require.Nil(s.T(), varror) + testCases := []struct { + UserID string + OldPassword string + NewPassword string + Valid bool + Error error + }{ + { + UserID: "", + OldPassword: "", + NewPassword: "", + Valid: false, + }, + { + UserID: "1857", + OldPassword: "48796552", + NewPassword: "7485", + Valid: false, + }, + { + UserID: "invalid", + OldPassword: s.password, + NewPassword: "7485896554", + Error: service.ErrNotFound, + Valid: false, + }, + { + UserID: s.userID, + OldPassword: "48796552", + NewPassword: "okaiojdkOKS17", + Error: service.ErrInvalidEmailOrPassword, + Valid: false, + }, + { + UserID: s.userID, + OldPassword: s.password, + NewPassword: "validpassword85", + Valid: true, + }, + } - s.quickLogin(s.email, newPassword) - s.password = newPassword + for _, tc := range testCases { + varror := s.service.ChangePassword(ctx, tc.UserID, tc.OldPassword, tc.NewPassword) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + s.quickLogin(s.email, tc.NewPassword) + s.password = tc.NewPassword + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *AuthTestSuite) TestE_Authenticate() { ctx := context.TODO() - user, varror := s.service.Authenticate(ctx, s.accessToken) - require.Nil(s.T(), varror) + emptyPayloadAT, err := s.authManager.GenerateAccessToken(ctx, "", service.AccessTokenExpr) + require.Nil(s.T(), err) + + invalidPayloadAT, err := s.authManager.GenerateAccessToken(ctx, "invalid", service.AccessTokenExpr) + require.Nil(s.T(), err) + + testCases := []struct { + AccessToken string + Valid bool + Error error + }{ + { + AccessToken: "", + Valid: false, + }, + { + AccessToken: "invalid-Access-Token", + Error: service.ErrAccessDenied, + Valid: false, + }, + { + AccessToken: emptyPayloadAT, + Error: service.ErrAccessDenied, + Valid: false, + }, + { + AccessToken: invalidPayloadAT, + Error: service.ErrAccessDenied, + Valid: false, + }, + { + AccessToken: s.accessToken, + Valid: true, + }, + } - require.Equal(s.T(), user.Email, s.email) + for _, tc := range testCases { + user, varror := s.service.Authenticate(ctx, tc.AccessToken) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + require.Equal(s.T(), user.Email, s.email) + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *AuthTestSuite) TestF_RefreshToken() { ctx := context.TODO() - accessToken, varror := s.service.RefreshToken(ctx, s.userID, s.refreshToken) - require.Nil(s.T(), varror) - - require.NotEmpty(s.T(), accessToken) - require.NotEqual(s.T(), accessToken, s.accessToken) + testCases := []struct { + UserID string + RefreshToken string + Valid bool + Error error + }{ + { + UserID: "", + RefreshToken: "", + Valid: false, + }, + { + UserID: "", + RefreshToken: "invalid", + Valid: false, + }, + { + UserID: "12345", + RefreshToken: "", + Valid: false, + }, + { + UserID: "invalid", + RefreshToken: s.refreshToken, + Error: service.ErrAccessDenied, + Valid: false, + }, + { + UserID: s.userID, + RefreshToken: "invalid", + Error: service.ErrAccessDenied, + Valid: false, + }, + { + UserID: s.userID, + RefreshToken: s.refreshToken, + Valid: true, + }, + } - s.accessToken = accessToken + for _, tc := range testCases { + accessToken, varror := s.service.RefreshToken(ctx, tc.UserID, tc.RefreshToken) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + require.NotEmpty(s.T(), accessToken) + require.NotEqual(s.T(), accessToken, s.accessToken) + + s.accessToken = accessToken + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *AuthTestSuite) TestG_SendResetPassword() { ctx := context.TODO() - resetPasswordToken, timeout, varror := s.service.SendResetPassword(ctx, s.email, s.resetPasswordRedirectUrl) - require.Nil(s.T(), varror) + testCases := []struct { + Email string + ResetPasswordURL string + Valid bool + Error error + }{ + { + Email: "", + ResetPasswordURL: "", + Valid: false, + }, + { + Email: "invalid", + ResetPasswordURL: "invalid", + Valid: false, + }, + { + Email: "invalid@gmail.com", + ResetPasswordURL: "invalid", + Error: service.ErrNotFound, + Valid: false, + }, + { + Email: s.email, + ResetPasswordURL: s.resetPasswordRedirectUrl, + Valid: true, + }, + } - require.NotEmpty(s.T(), timeout) - require.NotEmpty(s.T(), resetPasswordToken) + for _, tc := range testCases { + resetPasswordToken, timeout, varror := s.service.SendResetPassword(ctx, tc.Email, tc.ResetPasswordURL) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } - s.resetPasswordToken = resetPasswordToken + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + require.NotEmpty(s.T(), timeout) + require.NotEmpty(s.T(), resetPasswordToken) + + require.Nil(s.T(), varror) + + s.resetPasswordToken = resetPasswordToken + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *AuthTestSuite) TestH_SubmitResetPassword() { ctx := context.TODO() - newPassword := "password-reset-must-work" + rpt, err := s.authManager.GenerateToken(ctx, auth_manager.ResetPassword, + &auth_manager.TokenPayload{ + UUID: "invalid", + TokenType: auth_manager.ResetPassword, + CreatedAt: time.Now(), + }, + service.ResetPasswordTokenExpr, + ) + require.Nil(s.T(), err) + + testCases := []struct { + NewPassword string + SubmitResetPasswordToken string + Valid bool + Error error + }{ + { + NewPassword: "", + SubmitResetPasswordToken: "", + Valid: false, + }, + { + NewPassword: "5689", + SubmitResetPasswordToken: s.resetPasswordToken, + Valid: false, + }, + { + NewPassword: "valid-password8568", + SubmitResetPasswordToken: "invalid", + Error: service.ErrAccessDenied, + Valid: false, + }, + { + NewPassword: "valid-password8568", + SubmitResetPasswordToken: rpt, + Error: service.ErrAccessDenied, + Valid: false, + }, + { + NewPassword: "valid-password-anfaj", + SubmitResetPasswordToken: s.resetPasswordToken, + Valid: true, + }, + } + + for _, tc := range testCases { + varror := s.service.SubmitResetPassword(ctx, tc.SubmitResetPasswordToken, tc.NewPassword) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } - varror := s.service.SubmitResetPassword(ctx, s.resetPasswordToken, newPassword) - require.Nil(s.T(), varror) + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + s.quickLogin(s.email, tc.NewPassword) + + s.password = tc.NewPassword + } else { + require.Fail(s.T(), "not specific") + } + } +} - s.quickLogin(s.email, newPassword) - s.password = newPassword +func (s *AuthTestSuite) TestI_InvalidPasswordDeleteAccount() { + ctx := context.TODO() + + testCases := []struct { + UserID string + Password string + Error error + Valid bool + }{ + { + UserID: "invalid", + Password: s.password, + Error: service.ErrNotFound, + Valid: false, + }, + { + UserID: s.userID, + Password: "invalid", + Error: service.ErrInvalidEmailOrPassword, + Valid: false, + }, + { + UserID: s.userID, + Password: s.password, + Valid: true, + }, + } + + for _, tc := range testCases { + varror := s.service.DeleteAccount(ctx, tc.UserID, tc.Password) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + } else { + require.Fail(s.T(), "not specific") + } + } } func TestAuthSuite(t *testing.T) { diff --git a/tests/integration/service/chat_service_test.go b/tests/integration/service/chat_service_test.go index 6356609..84be1c6 100644 --- a/tests/integration/service/chat_service_test.go +++ b/tests/integration/service/chat_service_test.go @@ -14,6 +14,7 @@ import ( "github.com/kavkaco/Kavka-Core/utils/random" "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" + "go.mongodb.org/mongo-driver/bson/primitive" ) type ChatTestSuite struct { @@ -83,21 +84,59 @@ func (s *ChatTestSuite) TestCreateChannel() { Description: "Channel1:Description", } - saved, varror := s.service.CreateChannel(ctx, detailModel.Owner, detailModel.Title, detailModel.Username, detailModel.Description) - require.Nil(s.T(), varror) - - chatDetail, err := utils.TypeConverter[model.ChannelChatDetail](saved.ChatDetail) - require.NoError(s.T(), err) - - require.Equal(s.T(), saved.ChatType, model.TypeChannel) - require.Equal(s.T(), chatDetail.Title, detailModel.Title) - require.Equal(s.T(), chatDetail.Username, detailModel.Username) - require.Equal(s.T(), chatDetail.Members, detailModel.Members) - require.Equal(s.T(), chatDetail.Admins, detailModel.Admins) - require.Equal(s.T(), chatDetail.Owner, detailModel.Owner) - require.Equal(s.T(), chatDetail.Description, detailModel.Description) + testCases := []struct { + userID string + title string + username string + description string + Valid bool + Error error + }{ + { + userID: "", + title: "", + username: "", + description: "", + Valid: false, + }, + { + userID: detailModel.Owner, + title: detailModel.Title, + username: detailModel.Username, + description: detailModel.Description, + Error: service.ErrUnableToAddChatToUsersList, + Valid: true, + }, + } - s.createdChannelChatID = saved.ChatID + for _, tc := range testCases { + saved, varror := s.service.CreateChannel(ctx, tc.userID, tc.title, tc.username, tc.description) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + chatDetail, err := utils.TypeConverter[model.ChannelChatDetail](saved.ChatDetail) + require.NoError(s.T(), err) + + require.Equal(s.T(), saved.ChatType, model.TypeChannel) + require.Equal(s.T(), chatDetail.Title, tc.title) + require.Equal(s.T(), chatDetail.Username, tc.username) + require.Equal(s.T(), chatDetail.Members, detailModel.Members) + require.Equal(s.T(), chatDetail.Admins, detailModel.Admins) + require.Equal(s.T(), chatDetail.Owner, tc.userID) + require.Equal(s.T(), chatDetail.Description, tc.description) + + s.createdChannelChatID = saved.ChatID + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *ChatTestSuite) TestCreateGroup() { @@ -112,21 +151,59 @@ func (s *ChatTestSuite) TestCreateGroup() { Description: "Group1:Description", } - saved, varror := s.service.CreateGroup(ctx, detailModel.Owner, detailModel.Title, detailModel.Username, detailModel.Description) - require.Nil(s.T(), varror) - - chatDetail, err := utils.TypeConverter[model.GroupChatDetail](saved.ChatDetail) - require.NoError(s.T(), err) - - require.Equal(s.T(), saved.ChatType, model.TypeGroup) - require.Equal(s.T(), chatDetail.Title, detailModel.Title) - require.Equal(s.T(), chatDetail.Username, detailModel.Username) - require.Equal(s.T(), chatDetail.Members, detailModel.Members) - require.Equal(s.T(), chatDetail.Admins, detailModel.Admins) - require.Equal(s.T(), chatDetail.Owner, detailModel.Owner) - require.Equal(s.T(), chatDetail.Description, detailModel.Description) + testCases := []struct { + userID string + title string + username string + description string + Valid bool + Error error + }{ + { + userID: "", + title: "", + username: "", + description: "", + Valid: false, + }, + { + userID: detailModel.Owner, + title: detailModel.Title, + username: detailModel.Username, + description: detailModel.Description, + Error: service.ErrUnableToAddChatToUsersList, + Valid: true, + }, + } - s.createdGroupChatID = saved.ChatID + for _, tc := range testCases { + saved, varror := s.service.CreateGroup(ctx, tc.userID, tc.title, tc.username, tc.description) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + chatDetail, err := utils.TypeConverter[model.GroupChatDetail](saved.ChatDetail) + require.NoError(s.T(), err) + + require.Equal(s.T(), saved.ChatType, model.TypeGroup) + require.Equal(s.T(), chatDetail.Title, tc.title) + require.Equal(s.T(), chatDetail.Username, tc.username) + require.Equal(s.T(), chatDetail.Members, detailModel.Members) + require.Equal(s.T(), chatDetail.Admins, detailModel.Admins) + require.Equal(s.T(), chatDetail.Owner, tc.userID) + require.Equal(s.T(), chatDetail.Description, tc.description) + + s.createdGroupChatID = saved.ChatID + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *ChatTestSuite) TestCreateDirect() { @@ -136,66 +213,187 @@ func (s *ChatTestSuite) TestCreateDirect() { Sides: [2]model.UserID{s.users[0].UserID, s.users[1].UserID}, } - saved, varror := s.service.CreateDirect(ctx, detailModel.Sides[0], detailModel.Sides[1]) - require.Nil(s.T(), varror) + testCases := []struct { + userID string + recipientUserID string + Valid bool + Error error + }{ + { + userID: "", + recipientUserID: "", + Valid: false, + }, + { + userID: detailModel.Sides[0], + recipientUserID: detailModel.Sides[1], + Valid: true, + }, + } + + for _, tc := range testCases { + saved, varror := s.service.CreateDirect(ctx, tc.userID, tc.recipientUserID) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } - chatDetail, err := utils.TypeConverter[model.DirectChatDetail](saved.ChatDetail) - require.NoError(s.T(), err) + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + chatDetail, err := utils.TypeConverter[model.DirectChatDetail](saved.ChatDetail) + require.NoError(s.T(), err) - require.True(s.T(), chatDetail.HasSide(detailModel.Sides[0])) - require.True(s.T(), chatDetail.HasSide(detailModel.Sides[1])) - require.False(s.T(), chatDetail.HasSide("invalid-user-id")) + require.True(s.T(), chatDetail.HasSide(tc.userID)) + require.True(s.T(), chatDetail.HasSide(tc.recipientUserID)) + require.False(s.T(), chatDetail.HasSide("invalid-user-id")) - s.createdDirectChatID = saved.ChatID + s.createdDirectChatID = saved.ChatID + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *ChatTestSuite) TestGetChat_Channel() { ctx := context.TODO() - chat, varror := s.service.GetChat(ctx, s.createdChannelChatID) - require.Nil(s.T(), varror) + testCases := []struct { + chatID primitive.ObjectID + Valid bool + Error error + }{ + { + chatID: model.NewChatID(), + Error: service.ErrNotFound, + Valid: false, + }, + { + chatID: s.createdChannelChatID, + Valid: true, + }, + } - require.NotEmpty(s.T(), chat) - require.Equal(s.T(), chat.ChatID, s.createdChannelChatID) + for _, tc := range testCases { + chat, varror := s.service.GetChat(ctx, tc.chatID) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + require.NotEmpty(s.T(), chat) + require.Equal(s.T(), chat.ChatID, tc.chatID) + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *ChatTestSuite) TestGetChat_Group() { ctx := context.TODO() - chat, varror := s.service.GetChat(ctx, s.createdGroupChatID) - require.Nil(s.T(), varror) + testCases := []struct { + chatID primitive.ObjectID + Valid bool + Error error + }{ + { + chatID: model.NewChatID(), + Error: service.ErrNotFound, + Valid: false, + }, + { + chatID: s.createdGroupChatID, + Valid: true, + }, + } - require.NotEmpty(s.T(), chat) - require.Equal(s.T(), chat.ChatID, s.createdGroupChatID) + for _, tc := range testCases { + chat, varror := s.service.GetChat(ctx, tc.chatID) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + require.NotEmpty(s.T(), chat) + require.Equal(s.T(), chat.ChatID, tc.chatID) + } else { + require.Fail(s.T(), "not specific") + } + } } func (s *ChatTestSuite) TestGetUserChats() { ctx := context.TODO() + userModel1 := &s.users[0] - userModel := &s.users[0] - - userModel.ChatsListIDs = []model.ChatID{ + userModel1.ChatsListIDs = []model.ChatID{ s.createdChannelChatID, s.createdGroupChatID, s.createdDirectChatID, } - userChatsList, varror := s.service.GetUserChats(ctx, userModel.UserID) - require.Nil(s.T(), varror) + testCases := []struct { + userID string + Valid bool + Error error + }{ + { + userID: "", + Valid: false, + }, + { + userID: "invalid", + Error: service.ErrNotFound, + Valid: false, + }, + { + userID: userModel1.UserID, + Valid: true, + }, + } - for _, v := range userChatsList { - switch v.ChatType { - case model.TypeChannel: - require.Equal(s.T(), v.ChatID, s.createdChannelChatID) - case model.TypeGroup: - require.Equal(s.T(), v.ChatID, s.createdGroupChatID) - case model.TypeDirect: - require.Equal(s.T(), v.ChatID, s.createdDirectChatID) + for _, tc := range testCases { + userChatsList, varror := s.service.GetUserChats(ctx, tc.userID) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + for _, v := range userChatsList { + switch v.ChatType { + case model.TypeChannel: + require.Equal(s.T(), v.ChatID, s.createdChannelChatID) + case model.TypeGroup: + require.Equal(s.T(), v.ChatID, s.createdGroupChatID) + case model.TypeDirect: + require.Equal(s.T(), v.ChatID, s.createdDirectChatID) + } + } + } else { + require.Fail(s.T(), "not specific") } } } -func (s *ChatTestSuite) TestJoinChat() { +func (s *ChatTestSuite) TestJoinChat_channel() { ctx := context.TODO() // Create a plain channel chat @@ -216,13 +414,117 @@ func (s *ChatTestSuite) TestJoinChat() { userID := s.users[1].UserID - joinResult, varror := s.service.JoinChat(ctx, channelChat.ChatID, userID) - if varror != nil { - s.T().Log(varror.Error) + testCases := []struct { + chatID primitive.ObjectID + userID string + Valid bool + Error error + }{ + { + chatID: model.NewChatID(), + userID: "invalid", + Valid: false, + }, + { + chatID: channelChat.ChatID, + userID: "invalid", + Valid: false, + }, + { + chatID: channelChat.ChatID, + userID: userID, + Valid: true, + }, + } + + for _, tc := range testCases { + joinResult, varror := s.service.JoinChat(ctx, tc.chatID, tc.userID) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + if varror != nil { + s.T().Log(varror.Error) + } + + require.Nil(s.T(), varror) + require.True(s.T(), joinResult.Joined) + require.NotEmpty(s.T(), joinResult.UpdatedChat) + } else { + require.Fail(s.T(), "not specific") + } + } +} + +func (s *ChatTestSuite) TestJoinChat_group() { + ctx := context.TODO() + + // Create a plain channel chat + detailModel := model.GroupChatDetail{ + Title: "Group3", + Username: "Group3", + Owner: s.users[0].UserID, + Members: []model.UserID{}, + Admins: []model.UserID{}, + Description: "Group3:Description", + } + groupChat, err := s.chatRepo.Create(ctx, model.Chat{ + ChatID: model.NewChatID(), + ChatType: model.TypeGroup, + ChatDetail: detailModel, + }) + require.NoError(s.T(), err) + + userID := s.users[1].UserID + + testCases := []struct { + chatID primitive.ObjectID + userID string + Valid bool + Error error + }{ + { + chatID: model.NewChatID(), + userID: "invalid", + Valid: false, + }, + { + chatID: groupChat.ChatID, + userID: "invalid", + Valid: false, + }, + { + chatID: groupChat.ChatID, + userID: userID, + Valid: true, + }, + } + + for _, tc := range testCases { + joinResult, varror := s.service.JoinChat(ctx, tc.chatID, tc.userID) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + + require.NotNil(s.T(), varror) + } else if tc.Valid { + if varror != nil { + s.T().Log(varror.Error) + } + + require.Nil(s.T(), varror) + require.True(s.T(), joinResult.Joined) + require.NotEmpty(s.T(), joinResult.UpdatedChat) + } else { + require.Fail(s.T(), "not specific") + } } - require.Nil(s.T(), varror) - require.True(s.T(), joinResult.Joined) - require.NotEmpty(s.T(), joinResult.UpdatedChat) } func TestChatSuite(t *testing.T) { diff --git a/tests/integration/service/message_service_test.go b/tests/integration/service/message_service_test.go index 7ad15bc..b420cfc 100644 --- a/tests/integration/service/message_service_test.go +++ b/tests/integration/service/message_service_test.go @@ -13,6 +13,7 @@ import ( "github.com/kavkaco/Kavka-Core/utils/random" "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" + "go.mongodb.org/mongo-driver/bson/primitive" ) type MessageTestSuite struct { @@ -66,24 +67,196 @@ func (s *MessageTestSuite) SetupSuite() { func (s *MessageTestSuite) TestA_SendTextMessage() { ctx := context.TODO() - messageContent := "Hello from kavka's integration tests" - messageGetter, varror := s.service.SendTextMessage(ctx, s.chatID, s.userID, messageContent) - require.Nil(s.T(), varror) + testCases := []struct { + chatID primitive.ObjectID + userID string + messageContent string + Valid bool + Error error + }{ + { + chatID: model.NewChatID(), + userID: "", + messageContent: "fail", + Valid: false, + }, + { + chatID: s.chatID, + userID: s.userID, + messageContent: "", + Valid: false, + }, + { + chatID: model.NewChatID(), + userID: "invalid", + messageContent: "fail", + Valid: false, + }, + { + chatID: model.NewChatID(), + userID: s.userID, + messageContent: "fail", + Error: service.ErrChatNotFound, + Valid: false, + }, + { + chatID: s.chatID, + userID: s.userID, + messageContent: "pass", + Valid: true, + }, + } - savedMessageContent, err := utils.TypeConverter[model.TextMessage](messageGetter.Message.Content) - require.NoError(s.T(), err) + for _, tc := range testCases { + messageGetter, varror := s.service.SendTextMessage(ctx, tc.chatID, tc.userID, tc.messageContent) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + + savedMessageContent, err := utils.TypeConverter[model.TextMessage](messageGetter.Message.Content) + require.NoError(s.T(), err) + + require.Equal(s.T(), messageGetter.Message.SenderID, tc.userID) + require.Equal(s.T(), savedMessageContent.Text, tc.messageContent) + + s.savedMessageID = messageGetter.Message.MessageID + } else { + require.Fail(s.T(), "not specific") + } + } - require.Equal(s.T(), messageGetter.Message.SenderID, s.userID) - require.Equal(s.T(), savedMessageContent.Text, messageContent) + // messageContent := "Hello from kavka's integration tests" + // messageGetter, varror := s.service.SendTextMessage(ctx, s.chatID, s.userID, messageContent) + // require.Nil(s.T(), varror) - s.savedMessageID = messageGetter.Message.MessageID + // savedMessageContent, err := utils.TypeConverter[model.TextMessage](messageGetter.Message.Content) + // require.NoError(s.T(), err) + + // require.Equal(s.T(), messageGetter.Message.SenderID, s.userID) + // require.Equal(s.T(), savedMessageContent.Text, messageContent) + + // s.savedMessageID = messageGetter.Message.MessageID } // func (s *MessageTestSuite) TestB_DeleteMessage() { // ctx := context.TODO() -// varror := s.service.DeleteMessage(ctx, s.chatID, s.userID, s.savedMessageID) -// require.Nil(s.T(), varror) +// testCases := []struct { +// chatID primitive.ObjectID +// userID string +// messageID primitive.ObjectID +// Valid bool +// Error error +// }{ +// { +// chatID: model.NewChatID(), +// userID: "", +// messageID: model.NewChatID(), +// Valid: false, +// }, +// { +// chatID: s.chatID, +// userID: s.userID, +// messageID: model.NewChatID(), +// Error: service.ErrNotFound, +// Valid: false, +// }, +// { +// chatID: model.NewChatID(), +// userID: s.userID, +// messageID: s.savedMessageID, +// Error: service.ErrChatNotFound, +// Valid: false, +// }, +// { +// chatID: s.chatID, +// userID: s.userID, +// messageID: s.savedMessageID, +// Valid: true, +// }, +// } + +// for _, tc := range testCases { +// varror := s.service.DeleteMessage(ctx, tc.chatID, tc.userID, tc.messageID) +// if !tc.Valid { +// if tc.Error != nil { +// require.Equal(s.T(), tc.Error, varror.Error) +// continue +// } +// require.NotNil(s.T(), varror) +// } else if tc.Valid { +// require.Nil(s.T(), varror) +// } else { +// require.Fail(s.T(), "not specific") +// } +// } + +// // varror := s.service.DeleteMessage(ctx, s.chatID, s.userID, s.savedMessageID) +// // require.Nil(s.T(), varror) +// } + +func (s *MessageTestSuite) TestC_UpdateMessage() { + ctx := context.TODO() + + defer func() { + r := recover() + if r == nil { + require.Fail(s.T(), "should panic") + } + }() + + s.service.UpdateTextMessage(ctx, s.chatID, "hello") +} + +func (s *MessageTestSuite) TestD_FetchMessages() { + ctx := context.TODO() + + _, varror := s.service.FetchMessages(ctx, s.chatID) + require.Nil(s.T(), varror) +} + +// func (s *MessageTestSuite) TestE_EmptyContentSendMessage() { +// ctx := context.TODO() + +// _, varror := s.service.SendTextMessage(ctx, s.chatID, s.userID, "") +// log.Println(varror) +// require.NotNil(s.T(), varror) +// } + +// func (s *MessageTestSuite) TestF_InvalidChatIDSendMessage() { +// ctx := context.TODO() + +// _, varror := s.service.SendTextMessage(ctx, model.NewChatID(), s.userID, "test") +// log.Println(varror) +// require.Equal(s.T(), varror, &vali.Varror{Error: service.ErrChatNotFound}) +// } + +// func (s *MessageTestSuite) TestG_InvalidUserIDSendMessage() { +// ctx := context.TODO() + +// _, varror := s.service.SendTextMessage(ctx, s.chatID, "invalid", "test") +// log.Println(varror) +// require.NotNil(s.T(), varror) +// } + +// func (s *MessageTestSuite) TestH_InvalidValuesDeleteChat() { +// ctx := context.TODO() + +// varror := s.service.DeleteMessage(ctx, model.NewChatID(), "", model.NewChatID()) +// log.Println(varror) +// require.NotNil(s.T(), varror) +// } + +// func (s *MessageTestSuite) TestI_InvalidChatIDDeleteChat() { +// ctx := context.TODO() + +// varror := s.service.DeleteMessage(ctx, model.NewChatID(), s.userID, model.NewChatID()) +// require.Equal(s.T(), varror.Error, service.ErrChatNotFound) // } func TestMessageSuite(t *testing.T) { diff --git a/tests/integration/service/user_service_test.go b/tests/integration/service/user_service_test.go index d344a99..c139130 100644 --- a/tests/integration/service/user_service_test.go +++ b/tests/integration/service/user_service_test.go @@ -42,15 +42,85 @@ func (s *UserTestSuite) SetupSuite() { func (s *UserTestSuite) TestA_UpdateProfile() { ctx := context.TODO() - name := "User5:NameChanged" - lastName := "User5:LastNameChanged" - username := "user5_changed" - biography := "User5:Biography changed" + testCases := []struct { + userID string + name string + lastName string + username string + biography string + Valid bool + Error error + }{ + { + userID: "", + name: "", + lastName: "", + username: "", + biography: "User5:Biography changed", + Valid: false, + }, + { + userID: s.userID, + name: "l", + lastName: "Us", + username: "l", + biography: "Ul", + Valid: false, + }, + { + userID: "invalid", + name: "User5:NameChanged", + lastName: "User5:LastNameChanged", + username: "user5_changed", + biography: "User5:Biography changed", + Error: service.ErrNotFound, + Valid: false, + }, + { + userID: s.userID, + name: "User5:NameChanged", + lastName: "User5:LastNameChanged", + username: "user5_changed", + biography: "User5:Biography changed", + Valid: true, + }, + } - varror := s.service.UpdateProfile(ctx, s.userID, name, lastName, username, biography) - require.Nil(s.T(), varror) + for _, tc := range testCases { + varror := s.service.UpdateProfile(ctx, tc.userID, tc.name, tc.lastName, tc.username, tc.biography) + if !tc.Valid { + if tc.Error != nil { + require.Equal(s.T(), tc.Error, varror.Error) + continue + } + require.NotNil(s.T(), varror) + } else if tc.Valid { + require.Nil(s.T(), varror) + } else { + require.Fail(s.T(), "not specific") + } + } } +// func (s *UserTestSuite) TestB_InvalidInputUpdateProfile() { +// ctx := context.TODO() + +// varror := s.service.UpdateProfile(ctx, s.userID, "", "", "", "") +// require.NotNil(s.T(), varror) +// } + +// func (s *UserTestSuite) TestC_InvalidUserIDUpdateProfile() { +// ctx := context.TODO() + +// name := "User5:NameChanged" +// lastName := "User5:LastNameChanged" +// username := "user5_changed" +// biography := "User5:Biography changed" + +// varror := s.service.UpdateProfile(ctx, "invalid", name, lastName, username, biography) +// require.Equal(s.T(), varror.Error, service.ErrNotFound) +// } + func TestUserSuite(t *testing.T) { t.Helper() suite.Run(t, new(UserTestSuite))