github.com/devgek/webskeleton@v0.1.12-0.20231108100924-b903f5172d69/services/userservices_test.go (about)

     1  package services_test
     2  
     3  import (
     4  	"errors"
     5  
     6  	entitydata "github.com/devgek/webskeleton/entity/data"
     7  	genmodels "github.com/devgek/webskeleton/models/generated"
     8  
     9  	"testing"
    10  
    11  	"github.com/devgek/webskeleton/data"
    12  	"github.com/devgek/webskeleton/helper/password"
    13  	"github.com/devgek/webskeleton/models"
    14  	"github.com/devgek/webskeleton/services"
    15  	"github.com/devgek/webskeleton/types"
    16  	"github.com/stretchr/testify/assert"
    17  	"github.com/stretchr/testify/mock"
    18  	_ "gorm.io/driver/sqlite" // gorm for sqlite3
    19  )
    20  
    21  /*
    22  func init() {
    23  	fmt.Println("test init")
    24  	fmt.Println(os.Getwd())
    25  	os.Chdir("..")
    26  	fmt.Println(os.Getwd())
    27  }
    28  */
    29  
    30  // TestLoginUser test login service with mocking Datastore
    31  func TestLoginUser(t *testing.T) {
    32  	// create an instance of the mocked Datastore
    33  	mockedDB := &data.MockedDatastore{}
    34  	ef := genmodels.NewEntityFactoryImpl()
    35  	services := services.NewServices(ef, mockedDB)
    36  
    37  	passEncrypted := password.EncryptPassword("secret")
    38  	userGerald := &models.User{Name: "Gerald", Pass: passEncrypted, Email: "gerald.kahrer@gmail.com"}
    39  	// setup expectations
    40  	mockedDB.On("GetUser", "Gerald").Return(userGerald, nil)
    41  
    42  	// call the code we are testing
    43  	user, err := services.LoginUser("Gerald", "secret")
    44  	assert.Nil(t, err, "Login not allowed")
    45  	assert.Equal(t, userGerald, user, "Wrong user")
    46  
    47  	// assert that the expectations were met
    48  	mockedDB.AssertExpectations(t)
    49  }
    50  
    51  // TestLoginUserInMemory test login service with inmemory db
    52  func TestLoginUserInMemoryOK(t *testing.T) {
    53  	inMemoryDS, err := data.NewInMemoryDatastore()
    54  	ef := genmodels.NewEntityFactoryImpl()
    55  	services := services.NewServices(ef, inMemoryDS)
    56  
    57  	// happy test, user with correct password
    58  	user, err := services.LoginUser("Lionel", data.PassSecret)
    59  	assert.Nil(t, err, "Login user with error")
    60  	assert.NotNil(t, user, "User is nil")
    61  }
    62  func TestLoginUserInMemoryNOK(t *testing.T) {
    63  	inMemoryDS, err := data.NewInMemoryDatastore()
    64  	ef := genmodels.NewEntityFactoryImpl()
    65  	s := services.NewServices(ef, inMemoryDS)
    66  
    67  	// user with wrong password
    68  	user, err := s.LoginUser("Lionel", "wrongsecret")
    69  	assert.Nil(t, user, "User expected nil")
    70  	assert.NotNil(t, err, "Error expected")
    71  	assert.Equal(t, services.ErrorLoginNotAllowed, err, "Expected ErrorLoginNotAllowed")
    72  }
    73  
    74  func TestCreateUser(t *testing.T) {
    75  	// create an instance of the mocked Datastore
    76  	mockedDB := &data.MockedDatastore{}
    77  	ef := genmodels.NewEntityFactoryImpl()
    78  	s := services.NewServices(ef, mockedDB)
    79  
    80  	passEncrypted := password.EncryptPassword(data.PassSecret)
    81  	userRoger := &models.User{Name: "Roger", Pass: passEncrypted, Email: "roger.federer@atp.com", Role: types.RoleTypeUser}
    82  	// setup expectations
    83  	mockedDB.On("CreateEntity", mock.Anything).Return(nil)
    84  
    85  	userReturned, err := s.CreateUser("Roger", data.PassSecret, "roger.federer@atp.com", types.RoleTypeUser)
    86  	assert.Nil(t, err, "No error expected")
    87  	assert.Equal(t, userRoger.Name, userReturned.Name, "Expected name Roger")
    88  	assert.Equal(t, userRoger.Email, userReturned.Email, "Expected email not returned")
    89  	assert.Equal(t, userRoger.Role, userReturned.Role, "Expected admin not returned")
    90  
    91  	mockedDB.AssertExpectations(t)
    92  }
    93  
    94  func TestUpdateUser(t *testing.T) {
    95  	inMemoryDS, err := data.NewInMemoryDatastore()
    96  	ef := genmodels.NewEntityFactoryImpl()
    97  	s := services.NewServices(ef, inMemoryDS)
    98  
    99  	messi, err := s.DS.GetUser("Lionel")
   100  	assert.Nil(t, err, "No error expected")
   101  	messi.Email = "lm@barcelona.es"
   102  	messi2, err := s.UpdateUser(messi.Name, messi.Email, messi.Role)
   103  	assert.Equal(t, messi.Email, messi2.Email, "Email not expected")
   104  }
   105  
   106  func TestDeleteUser(t *testing.T) {
   107  	inMemoryDS, err := data.NewInMemoryDatastore()
   108  	ef := genmodels.NewEntityFactoryImpl()
   109  	s := services.NewServices(ef, inMemoryDS)
   110  
   111  	user, err := s.CreateUser("Rafa", data.PassSecret, "rafael.nadal@atp.com", types.RoleTypeUser)
   112  	assert.Nil(t, err, "No error expected")
   113  	err = s.DS.DeleteEntityByID(user, user.GormEntity.ID)
   114  	assert.Nil(t, err, "No error expected")
   115  }
   116  
   117  func TestDeleteUserError(t *testing.T) {
   118  	inMemoryDS, err := data.NewInMemoryDatastore()
   119  	ef := genmodels.NewEntityFactoryImpl()
   120  	s := services.NewServices(ef, inMemoryDS)
   121  
   122  	err = s.DS.DeleteEntityByID(&models.User{}, 99)
   123  	assert.Equal(t, entitydata.ErrorEntityNotDeleted, err, "Expected error not returned")
   124  }
   125  func TestDoTableBased(t *testing.T) {
   126  	tests := map[string]struct {
   127  		input1 int
   128  		input2 int
   129  		output int
   130  		err    error
   131  	}{
   132  		"successful addition": {
   133  			input1: 2,
   134  			input2: 3,
   135  			output: 5,
   136  			err:    nil,
   137  		},
   138  		"invalid addition": {
   139  			input1: 2,
   140  			input2: 2,
   141  			output: -1,
   142  			err:    nil,
   143  		},
   144  		"getting error": {
   145  			input1: 2,
   146  			input2: 4,
   147  			output: 6,
   148  			err:    errors.New("invalid: sum > 5"),
   149  		},
   150  	}
   151  	ef := genmodels.NewEntityFactoryImpl()
   152  	s := services.NewServices(ef, nil)
   153  
   154  	for testName, test := range tests {
   155  		t.Logf("Running test case %s", testName)
   156  		output, err := s.Do(test.input1, test.input2)
   157  		assert.IsType(t, test.err, err)
   158  		assert.Equal(t, test.output, output)
   159  	}
   160  }