Increase test coverage

internal/adapters/repository/transaction.go

@@ -19,9 +19,9 @@ func NewTxRepository(opts RepositoryOpts) ports.ITxRepository {
 	}
 }
 
-// StartTransaction starts a new transaction.
-func (m *TxRepository) StartTransaction(ctx context.Context) (*sql.Tx, error) {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "repo.TxRepository.StartTransaction")
+// StartTx starts a new transaction.
+func (m *TxRepository) StartTx(ctx context.Context) (*sql.Tx, error) {
+	span, ctx := opentracing.StartSpanFromContext(ctx, "repo.TxRepository.StartTx")
 	defer span.Finish()
 
 	tx, err := m.MasterDB.BeginTx(ctx, nil)
@@ -32,17 +32,17 @@ func (m *TxRepository) StartTransaction(ctx context.Context) (*sql.Tx, error) {
 	return tx, nil
 }
 
-// CommitTransaction commits the given transaction.
-func (m *TxRepository) CommitTransaction(ctx context.Context, tx *sql.Tx) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "repo.TxRepository.CommitTransaction")
+// CommitTx commits the given transaction.
+func (m *TxRepository) CommitTx(ctx context.Context, tx *sql.Tx) error {
+	span, ctx := opentracing.StartSpanFromContext(ctx, "repo.TxRepository.CommitTx")
 	defer span.Finish()
 
 	return tx.Commit()
 }
 
-// RollbackTransaction rolls back the given transaction.
-func (m *TxRepository) RollbackTransaction(ctx context.Context, tx *sql.Tx) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "repo.TxRepository.RollbackTransaction")
+// RollbackTx rolls back the given transaction.
+func (m *TxRepository) RollbackTx(ctx context.Context, tx *sql.Tx) error {
+	span, ctx := opentracing.StartSpanFromContext(ctx, "repo.TxRepository.RollbackTx")
 	defer span.Finish()
 
 	return tx.Rollback()

internal/core/ports/tx_ports.go

@@ -9,7 +9,7 @@ import (
 
 // IRepositoryTx defines the transaction methods.
 type ITxRepository interface {
-	StartTransaction(ctx context.Context) (*sql.Tx, error)
-	CommitTransaction(ctx context.Context, tx *sql.Tx) error
-	RollbackTransaction(ctx context.Context, tx *sql.Tx) error
+	StartTx(ctx context.Context) (*sql.Tx, error)
+	CommitTx(ctx context.Context, tx *sql.Tx) error
+	RollbackTx(ctx context.Context, tx *sql.Tx) error
 }

internal/core/service/auth_service.go

@@ -110,14 +110,15 @@ func (s *AuthService) Register(ctx context.Context, userData entity.User) (int64
 		Email:          userData.Email,
 	}
 
-	tx, err := s.txRepository.StartTransaction(ctx)
+	tx, err := s.txRepository.StartTx(ctx)
 	if err != nil {
 		logger.LogStdErr.WithFields(logrus.Fields{
 			"username": userData.Username,
 			"error":    err,
-		}).Error("[AuthService] error on StartTransaction")
+		}).Error("[AuthService] error on StartTx")
+		return 0, err
 	}
-	defer s.txRepository.RollbackTransaction(ctx, tx)
+	defer s.txRepository.RollbackTx(ctx, tx)
 
 	result, err := s.userRepository.RegisterUser(ctx, tx, userDataProceed)
 	if err != nil {
@@ -128,12 +129,13 @@ func (s *AuthService) Register(ctx context.Context, userData entity.User) (int64
 		return 0, err
 	}
 
-	err = s.txRepository.CommitTransaction(ctx, tx)
+	err = s.txRepository.CommitTx(ctx, tx)
 	if err != nil {
 		logger.LogStdErr.WithFields(logrus.Fields{
 			"username": userData.Username,
 			"error":    err,
-		}).Error("[AuthService] error on CommitTransaction")
+		}).Error("[AuthService] error on CommitTx")
+		return 0, err
 	}
 
 	return result, nil

internal/core/service/auth_service_test.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"database/sql"
 	"errors"
 	"reflect"
 	"testing"
@@ -149,14 +150,15 @@ func TestUserService_Register(t *testing.T) {
 			want:    1,
 			wantErr: false,
 			setup: func(mockObj *MockObject) {
-				mockObj.MockUserRepo.EXPECT().GetUserByEmail(gomock.Any(), gomock.Any()).
-					Return(&models.UserORM{}, nil).Times(1)
-				mockObj.MockUserRepo.EXPECT().RegisterUser(gomock.Any(), gomock.Any(), gomock.Any()).
-					Return(int64(1), nil).Times(1)
+				mockObj.MockUserRepo.EXPECT().GetUserByEmail(gomock.Any(), gomock.Any()).Return(&models.UserORM{}, nil).Times(1)
+				mockObj.MockTxRepo.EXPECT().StartTx(gomock.Any()).Return(&sql.Tx{}, nil).Times(1)
+				mockObj.MockUserRepo.EXPECT().RegisterUser(gomock.Any(), gomock.Any(), gomock.Any()).Return(int64(1), nil).Times(1)
+				mockObj.MockTxRepo.EXPECT().CommitTx(gomock.Any(), gomock.Any()).Return(nil).Times(1)
+				mockObj.MockTxRepo.EXPECT().RollbackTx(gomock.Any(), gomock.Any()).Return(nil).Times(1)
 			},
 		},
 		{
-			name: "ERROR - GetUserByEmail",
+			name: "ERROR - on GetUserByEmail",
 			args: args{
 				ctx:      context.Background(),
 				username: "test-user",
@@ -172,7 +174,7 @@ func TestUserService_Register(t *testing.T) {
 			},
 		},
 		{
-			name: "ERROR - Register",
+			name: "ERROR - on StartTx",
 			args: args{
 				ctx:      context.Background(),
 				username: "test-user",
@@ -183,10 +185,45 @@ func TestUserService_Register(t *testing.T) {
 			want:    0,
 			wantErr: true,
 			setup: func(mockObj *MockObject) {
-				mockObj.MockUserRepo.EXPECT().GetUserByEmail(gomock.Any(), gomock.Any()).
-					Return(&models.UserORM{Username: ""}, errors.New("some error")).Times(1)
-				mockObj.MockUserRepo.EXPECT().RegisterUser(gomock.Any(), gomock.Any(), gomock.Any()).
-					Return(int64(0), errors.New("some error")).AnyTimes()
+				mockObj.MockUserRepo.EXPECT().GetUserByEmail(gomock.Any(), gomock.Any()).Return(&models.UserORM{}, nil).Times(1)
+				mockObj.MockTxRepo.EXPECT().StartTx(gomock.Any()).Return(nil, errors.New("some error")).Times(1)
+			},
+		},
+		{
+			name: "ERROR - on RegisterUser",
+			args: args{
+				ctx:      context.Background(),
+				username: "test-user",
+				password: "test-password",
+				email:    "test-email@email.com",
+				name:     "test-name",
+			},
+			want:    0,
+			wantErr: true,
+			setup: func(mockObj *MockObject) {
+				mockObj.MockUserRepo.EXPECT().GetUserByEmail(gomock.Any(), gomock.Any()).Return(&models.UserORM{}, nil).Times(1)
+				mockObj.MockTxRepo.EXPECT().StartTx(gomock.Any()).Return(&sql.Tx{}, nil).Times(1)
+				mockObj.MockUserRepo.EXPECT().RegisterUser(gomock.Any(), gomock.Any(), gomock.Any()).Return(int64(0), errors.New("some error")).Times(1)
+				mockObj.MockTxRepo.EXPECT().RollbackTx(gomock.Any(), gomock.Any()).Return(nil).Times(1)
+			},
+		},
+		{
+			name: "ERROR - on CommitTx",
+			args: args{
+				ctx:      context.Background(),
+				username: "test-user",
+				password: "test-password",
+				email:    "test-email@email.com",
+				name:     "test-name",
+			},
+			want:    0,
+			wantErr: true,
+			setup: func(mockObj *MockObject) {
+				mockObj.MockUserRepo.EXPECT().GetUserByEmail(gomock.Any(), gomock.Any()).Return(&models.UserORM{}, nil).Times(1)
+				mockObj.MockTxRepo.EXPECT().StartTx(gomock.Any()).Return(&sql.Tx{}, nil).Times(1)
+				mockObj.MockUserRepo.EXPECT().RegisterUser(gomock.Any(), gomock.Any(), gomock.Any()).Return(int64(1), nil).Times(1)
+				mockObj.MockTxRepo.EXPECT().CommitTx(gomock.Any(), gomock.Any()).Return(errors.New("some error")).Times(1)
+				mockObj.MockTxRepo.EXPECT().RollbackTx(gomock.Any(), gomock.Any()).Return(nil).Times(1)
 			},
 		},
 	}
@@ -201,16 +238,17 @@ func TestUserService_Register(t *testing.T) {
 
 			service := &AuthService{
 				userRepository: mockObj.MockUserRepo,
+				txRepository:   mockObj.MockTxRepo,
 			}
 
-			userData := &entity.User{
+			userData := entity.User{
 				Username: tt.args.username,
 				Password: tt.args.password,
 				Email:    tt.args.email,
 				Name:     tt.args.name,
 			}
 
-			got, err := service.Register(tt.args.ctx, *userData)
+			got, err := service.Register(tt.args.ctx, userData)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("AuthService.Register() error = %v, wantErr %v", err, tt.wantErr)
 				return