miniauth/pkg/userstore/users_test.go

package userstore

import (
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
)

func TestWriteUser(t *testing.T) {
	tts := []struct {
		name            string
		username        string
		password        string
		exptError       error
		exptErrorString string
		exptUserId      int64
	}{
		{
			name:       "successfull-insert-first-user",
			username:   "kekskurse",
			password:   "kekskurse",
			exptError:  nil,
			exptUserId: 1,
		},
		{
			name:            "failed-username-alreadey-used",
			username:        "kekskurse",
			password:        "kekskurse",
			exptError:       ErrCantExecuteQuery,
			exptErrorString: "cant execute query: constraint failed: UNIQUE constraint failed: users.username (2067)",
			exptUserId:      0,
		},
		{
			name:       "successfull-insert-first-user",
			username:   "kekskurse2",
			password:   "kekskurse",
			exptError:  nil,
			exptUserId: 2,
		},
	}

	store, err := NewDummyStore()
	assert.Nil(t, err, "[setup] should be abel to create dummystore")

	for _, tt := range tts {
		t.Run(tt.name, func(t *testing.T) {
			id, err := store.UserWrite(tt.username, tt.password)
			assert.Equal(t, tt.exptUserId, id, "should return right user id")
			if tt.exptError == nil {
				assert.Nil(t, err, "should store user without error")
			} else {
				assert.ErrorIs(t, err, tt.exptError, "should return error")
				assert.Equal(t, tt.exptErrorString, err.Error(), "should return right error message")
			}
		})
	}

	var pw1 string
	var pw2 string
	err = store.db.QueryRow("SELECT password FROM users WHERE id = 1").Scan(&pw1)
	assert.Nil(t, err, "should be abel to query pw1")
	err = store.db.QueryRow("SELECT password FROM users WHERE id = 2").Scan(&pw2)
	assert.Nil(t, err, "should be abel to query pw2")

	assert.NotEmpty(t, pw1)
	assert.NotEmpty(t, pw2)
	assert.NotEqual(t, "kekskurse", pw1)
	assert.NotEqual(t, "kekskurse", pw2)
	assert.NotEqual(t, pw1, pw2, "passwords should not be equal")
}

func TestUserExists(t *testing.T) {
	store, err := NewDummyStore()
	assert.Nil(t, err, "[setup] should get dummy store without error")

	exists, err := store.UserExists("kekskurse")
	assert.Nil(t, err)
	assert.False(t, exists)

	_, err = store.UserWrite("kekskurse", "kekskurse")
	assert.Nil(t, err, "[setup] should be abel to create user")

	exists, err = store.UserExists("kekskurse")
	assert.Nil(t, err)
	assert.True(t, exists)
}

func TestUserRemove(t *testing.T) {
	store, err := NewDummyStore()
	assert.Nil(t, err, "[setup] should get dummy store without error")

	_, err = store.UserWrite("kekskurse", "kekskurse")
	assert.Nil(t, err, "[setup] should be abel to create user")

	_, err = store.UserWrite("kekskurse2", "kekskurse2")
	assert.Nil(t, err, "[setup] should be abel to create user2")

	var count int
	err = store.db.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
	assert.Nil(t, err, "should be abel to get user count without error")
	assert.Equal(t, 2, count, "should found 2 users")

	err = store.UserDelete("kekskurse2")
	assert.Nil(t, err, "should be abel to delete user without error")

	err = store.db.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
	assert.Nil(t, err, "should be abel to get user count without error")
	assert.Equal(t, 1, count, "should found 2 users")
}

func TestUserRemoveFaildMailExists(t *testing.T) {
	store, err := NewDummyStore()
	assert.Nil(t, err, "[setup] should get dummy store without error")

	_, err = store.UserWrite("kekskurse", "kekskurse")
	assert.Nil(t, err, "[setup] should be abel to create user")

	id, err := store.UserWrite("kekskurse2", "kekskurse2")
	assert.Nil(t, err, "[setup] should be abel to create user2")

	err = store.MailAdd("foo@example.com", id, true)
	assert.Nil(t, err, "[setup] should be abel to create mail for user2")

	var count int
	err = store.db.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
	assert.Nil(t, err, "should be abel to get user count without error")
	assert.Equal(t, 2, count, "should found 2 users")

	err = store.UserDelete("kekskurse2")
	assert.NotNil(t, err)
	assert.Equal(t, "cant execute query: constraint failed: FOREIGN KEY constraint failed (787)", err.Error())

	err = store.db.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
	assert.Nil(t, err, "should be abel to get user count without error")
	assert.Equal(t, 2, count, "should found 2 users")
}

func TestUserPasswordCheck(t *testing.T) {
	store, err := NewDummyStore()
	assert.Nil(t, err, "[setup] should get dummy store without error")

	_, err = store.UserWrite("kekskurse", "kekskurse")
	assert.Nil(t, err, "[setup] should be abel to create user")

	tts := []struct {
		name            string
		username        string
		password        string
		expectErr       error
		expectErrString string
		expectUsername  string
	}{
		{
			name:            "user not found",
			expectErr:       ErrCantExecuteQuery,
			expectErrString: "cant execute query: sql: no rows in result set",
		},
		{
			name:            "wrong password",
			username:        "kekskurse",
			expectErr:       ErrPasswordDontMatch,
			expectErrString: "user password dont match: crypto/bcrypt: hashedPassword is not the hash of the given password",
		},
		{
			name:           "successfull",
			username:       "kekskurse",
			password:       "kekskurse",
			expectErr:      nil,
			expectUsername: "kekskurse",
		},
	}

	for _, tt := range tts {
		t.Run(tt.name, func(t *testing.T) {
			user, err := store.UserCheckPassword(tt.username, tt.password)
			if tt.expectErr != nil {
				assert.ErrorIs(t, err, tt.expectErr)
				assert.Equal(t, tt.expectErrString, err.Error())
				return
			}

			assert.Nil(t, err)
			assert.Equal(t, tt.expectUsername, user.Username)
			assert.Equal(t, time.Now().Year(), user.CreatedAt.Year())
			assert.Equal(t, time.Now().Year(), user.UpdatedAt.Year())
		})
	}
}