test, refactor: Tests for reset-password & change mails structure for easier mocks

chmielulu · chmielulu · commit 430cc8cac53d · 2022-01-31T18:44:23.000+01:00
diff --git a/mails/init.go b/mails/init.go
@@ -9,9 +9,10 @@ import (
 
 var (
 	smtpClient *mail.SMTPClient
+	Service    *service
 )
 
-func InitClient() {
+func InitService() {
 	server := mail.NewSMTPClient()
 	server.Host = env.SmtpHost
 	port, err := strconv.ParseUint(env.SmtpPort, 10, 32)
@@ -22,9 +23,11 @@ func InitClient() {
 	server.Username = env.SmtpUsername
 	server.Password = env.SmtpPassword
 
-	client, err := server.Connect()
+	c, err := server.Connect()
 	if err != nil {
 		log.Fatal(err)
 	}
-	smtpClient = client
+
+	smtpClient = c
+	Service = GetService(&Client{})
 }
diff --git a/mails/mails.client.go b/mails/mails.client.go
@@ -0,0 +1,29 @@
+package mails
+
+import (
+	mail "github.com/xhit/go-simple-mail/v2"
+)
+
+type Message struct {
+	From    string
+	To      string
+	Subject string
+	Body    string
+}
+
+type C interface {
+	Send(*Message) error
+}
+
+type Client struct{}
+
+func (c *Client) Send(message *Message) error {
+	msg := mail.NewMSG()
+	msg.SetFrom(message.From)
+	msg.AddTo(message.To)
+	msg.SetSubject(message.Subject)
+	msg.SetBody(mail.TextPlain, message.Body)
+	err := msg.Send(smtpClient)
+
+	return err
+}
diff --git a/mails/mails.client_mock.go b/mails/mails.client_mock.go
@@ -0,0 +1,13 @@
+package mails
+
+import "github.com/stretchr/testify/mock"
+
+type ClientMock struct {
+	mock.Mock
+}
+
+func (m *ClientMock) Send(message *Message) error {
+	args := m.Called(message)
+	err := args.Error(0)
+	return err
+}
diff --git a/mails/mails.service.go b/mails/mails.service.go
@@ -0,0 +1,32 @@
+package mails
+
+import (
+	"fmt"
+	"messagewith-server/env"
+)
+
+var (
+	client C
+)
+
+type service struct{}
+
+func GetService(c C) *service {
+	client = c
+	return &service{}
+}
+
+func (s *service) SendResetPasswordToken(email string, token string) bool {
+	err := client.Send(&Message{
+		From:    fmt.Sprintf("Messagewith <%v>", env.SmtpEmail),
+		To:      email,
+		Subject: "Reset your password on Messagewith.app",
+		Body:    fmt.Sprintf("Your reset password token is: %v", token),
+	})
+
+	if err != nil {
+		return false
+	}
+
+	return true
+}
diff --git a/mails/reset-password.go b/mails/reset-password.go
diff --git a/main.go b/main.go
@@ -42,7 +42,7 @@ func initDatabaseConnection() {
 func main() {
 	env.InitEnvConstants()
 	initDatabaseConnection()
-	mails.InitClient()
+	mails.InitService()
 	users.InitService()
 	sessions.InitService()
 	auth.InitService()
diff --git a/users/init.go b/users/init.go
@@ -6,11 +6,13 @@ import (
 )
 
 var (
-	Service    *service
-	collection *mgm.Collection
+	Service                 *service
+	collection              *mgm.Collection
+	resetPasswordCollection *mgm.Collection
 )
 
 func InitService() {
 	collection = database.GetDB().UseCollection()
-	Service = GetService(&Repository{})
+	resetPasswordCollection = database.GetResetPasswordDB().UseCollection()
+	Service = GetService(&Repository{}, &ResetPasswordRepository{})
 }
diff --git a/users/reset-password.repository.go b/users/reset-password.repository.go
@@ -0,0 +1,37 @@
+package users
+
+import (
+	"context"
+	"go.mongodb.org/mongo-driver/mongo"
+	database "messagewith-server/users/database"
+)
+
+type RP interface {
+	FindOne(ctx context.Context, filter interface{}) (*database.ResetPassword, error)
+	DeleteOne(ctx context.Context, filter interface{}) (*mongo.DeleteResult, error)
+	Create(document *database.ResetPassword) error
+}
+
+type ResetPasswordRepository struct{}
+
+func (r *ResetPasswordRepository) Create(document *database.ResetPassword) error {
+	err := resetPasswordCollection.Create(document)
+
+	return err
+}
+
+func (r *ResetPasswordRepository) FindOne(ctx context.Context, filter interface{}) (*database.ResetPassword, error) {
+	res := &database.ResetPassword{}
+	err := resetPasswordCollection.FindOne(ctx, filter).Decode(res)
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}
+
+func (r *ResetPasswordRepository) DeleteOne(ctx context.Context, filter interface{}) (*mongo.DeleteResult, error) {
+	res, err := resetPasswordCollection.DeleteOne(ctx, filter)
+
+	return res, err
+}
diff --git a/users/reset-password.repository_mock.go b/users/reset-password.repository_mock.go
@@ -0,0 +1,162 @@
+package users
+
+import (
+	"context"
+	"github.com/naamancurtis/mongo-go-struct-to-bson/mapper"
+	"github.com/stretchr/testify/mock"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	database "messagewith-server/users/database"
+	"reflect"
+)
+
+type ResetPasswordMockRepository struct {
+	mock.Mock
+}
+
+func (m *ResetPasswordMockRepository) FindOne(_ context.Context, filter interface{}) (*database.ResetPassword, error) {
+	args := m.Called(filter)
+	result := args.Get(0)
+	err := args.Get(1).(*error)
+
+	return *result.(**database.ResetPassword), *err
+}
+
+func GetResetPasswordFindOneRunHandler(mockDB *[]*database.ResetPassword) (**database.ResetPassword, *error, func(args mock.Arguments)) {
+	var res *database.ResetPassword
+	var err error
+
+	return &res, &err, func(args mock.Arguments) {
+		res = nil
+		err = nil
+		filters := args.Get(0)
+
+		resetPasswordType := reflect.TypeOf((*database.ResetPassword)(nil)).String()
+		filtersType := reflect.TypeOf(filters).String()
+		if filtersType == resetPasswordType {
+			for _, item := range *mockDB {
+				document := filters.(*database.ResetPassword)
+				if document == item {
+					res = item
+				}
+			}
+		} else {
+			filtersMap := filters.(primitive.M)
+
+			for _, item := range *mockDB {
+				bsonItem := mapper.ConvertStructToBSONMap(item, nil)
+				isEqual := false
+
+				for key, filter := range filtersMap {
+					filterKind := reflect.ValueOf(filter).Kind()
+
+					if filterKind == reflect.Ptr {
+						if bsonItem[key] == *filter.(*string) {
+							isEqual = true
+						}
+					} else {
+						if bsonItem[key] == filter {
+							isEqual = true
+						}
+					}
+				}
+
+				if isEqual {
+					res = item
+				}
+			}
+		}
+
+		if res == nil {
+			err = mongo.ErrNoDocuments
+		}
+	}
+}
+
+func (m *ResetPasswordMockRepository) DeleteOne(_ context.Context, filter interface{}) (*mongo.DeleteResult, error) {
+	args := m.Called(filter)
+	result := args.Get(0).(**mongo.DeleteResult)
+	err := args.Get(1).(*error)
+
+	return *result, *err
+}
+
+func GetResetPasswordDeleteOneRunHandler(db *[]*database.ResetPassword) (**mongo.DeleteResult, *error, func(args mock.Arguments)) {
+	var (
+		res *mongo.DeleteResult
+		err error
+	)
+
+	return &res, &err, func(args mock.Arguments) {
+		res = nil
+		err = nil
+		filters := args.Get(0)
+
+		var foundIndex = -1
+
+		resetPasswordType := reflect.TypeOf((*database.ResetPassword)(nil)).String()
+		filtersType := reflect.TypeOf(filters).String()
+		if filtersType == resetPasswordType {
+			for index, item := range *db {
+				document := filters.(*database.ResetPassword)
+				if document == item {
+					foundIndex = index
+				}
+			}
+		} else {
+			filtersMap := filters.(primitive.M)
+
+			for index, item := range *db {
+				bsonItem := mapper.ConvertStructToBSONMap(item, nil)
+				isEqual := false
+
+				for key, filter := range filtersMap {
+					filterKind := reflect.ValueOf(filter).Kind()
+
+					if filterKind == reflect.Ptr {
+						if bsonItem[key] == *filter.(*string) {
+							isEqual = true
+						}
+					} else {
+						if bsonItem[key] == filter {
+							isEqual = true
+						}
+					}
+				}
+
+				if isEqual {
+					foundIndex = index
+				}
+			}
+		}
+
+		if foundIndex == -1 {
+			err = mongo.ErrNoDocuments
+			return
+		}
+
+		(*db)[foundIndex] = (*db)[len(*db)-1]
+		(*db)[len(*db)-1] = nil
+		*db = (*db)[:len(*db)-1]
+
+		res = &mongo.DeleteResult{}
+	}
+}
+
+func (m *ResetPasswordMockRepository) Create(document *database.ResetPassword) error {
+	args := m.Called(document)
+	err := args.Get(0)
+
+	if err == nil {
+		return nil
+	}
+
+	return err.(error)
+}
+
+func GetResetPasswordCreateRunHandler(db *[]*database.ResetPassword) func(args mock.Arguments) {
+	return func(args mock.Arguments) {
+		document := args.Get(0).(*database.ResetPassword)
+		*db = append(*db, document)
+	}
+}
diff --git a/users/users.repository.go b/users/users.repository.go
@@ -2,13 +2,16 @@ package users
 
 import (
 	"context"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
 	database "messagewith-server/users/database"
 )
 
 type R interface {
 	FindOne(ctx context.Context, filter interface{}) (*database.User, error)
 	Find(ctx context.Context, filter interface{}) ([]*database.User, error)
 	Create(document *database.User) error
+	UpdateByID(ctx context.Context, id interface{}, filter interface{}) (*mongo.UpdateResult, error)
 }
 
 type Repository struct{}
@@ -43,3 +46,7 @@ func (r *Repository) Create(document *database.User) error {
 
 	return err
 }
+
+func (r *Repository) UpdateByID(ctx context.Context, id interface{}, update interface{}) (*mongo.UpdateResult, error) {
+	return collection.UpdateByID(ctx, id, bson.M{"$set": update})
+}
diff --git a/users/users.repository_mock.go b/users/users.repository_mock.go
diff --git a/users/users.service.go b/users/users.service.go
diff --git a/users/users.service_test.go b/users/users.service_test.go

Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,13 @@ import (`
`6`	`6`	`)`
`7`	`7`
`8`	`8`	`var (`
`9`		`- Service *service`
`10`		`- collection *mgm.Collection`
	`9`	`+ Service *service`
	`10`	`+ collection *mgm.Collection`
	`11`	`+ resetPasswordCollection *mgm.Collection`
`11`	`12`	`)`
`12`	`13`
`13`	`14`	`func InitService() {`
`14`	`15`	`collection = database.GetDB().UseCollection()`
`15`		`- Service = GetService(&Repository{})`
	`16`	`+ resetPasswordCollection = database.GetResetPasswordDB().UseCollection()`
	`17`	`+ Service = GetService(&Repository{}, &ResetPasswordRepository{})`
`16`	`18`	`}`