miniauthold/pkg/miniauth/miniauth_test.go

package miniauth

import (
	"testing"

	"git.keks.cloud/kekskurse/miniauth/pkg/smtpclient"
	"git.keks.cloud/kekskurse/miniauth/pkg/userstore"
	"github.com/stretchr/testify/assert"
)

func TestRegistration(t *testing.T) {
	tts := []struct {
		name          string
		username      string
		password      string
		mail          string
		exptErr       error
		exptErrString string
	}{
		{
			name:          "invaloid username",
			username:      "abc",
			password:      "2b7B3Wm0KwIZ$Uvtc$!VOb",
			mail:          "mail@kekskurse.de",
			exptErr:       ErrUserHasInvalideChars,
			exptErrString: "username has invalide chars: username has invalide chars",
		},
		{
			name:          "invaloid password",
			username:      "kekskurse",
			password:      "abc123d",
			mail:          "mail@kekskurse.de",
			exptErr:       ErrPasswordNotComplexEnough,
			exptErrString: "password not complex enough: Password length must be not lower that 15 chars",
		},
		{
			name:          "invaloid password",
			username:      "kekskurse",
			password:      "abc123d,.,jfhfh",
			mail:          "mailabd.de",
			exptErr:       ErrMailAddressInvalide,
			exptErrString: "email address invalide: mail: missing '@' or angle-addr",
		},
		{
			name:          "invaloid password",
			username:      "kekskurse",
			password:      "abc123d,.,jfhfh",
			mail:          "error@error.error",
			exptErr:       ErrCantSendMail,
			exptErrString: "cant send mail: cant send mail to error mail",
		},
		{
			name:          "success",
			username:      "someuser",
			password:      "abc123d,.,jfhfh",
			mail:          "hello@example.com",
			exptErr:       nil,
			exptErrString: "",
		},
		{
			name:          "mail already used",
			username:      "someuser2",
			password:      "abc123d,.,jfhfh",
			mail:          "hello@example.com",
			exptErr:       ErrMailAddressInvalide,
			exptErrString: "email address invalide: email alreadys used",
		},
	}

	ma := getMiniAuth(t)
	for _, tt := range tts {
		t.Run(tt.name, func(t *testing.T) {
			err := ma.RegisterUser(tt.username, tt.mail, tt.password)
			assert.ErrorIs(t, err, tt.exptErr)
			if tt.exptErrString != "" {
				assert.Equal(t, tt.exptErrString, err.Error())
			}
		})
	}
}

func TestPasswordCheck(t *testing.T) {
	tts := []struct {
		name            string
		password        string
		exptErrorString string
	}{
		{
			name:            "to short",
			password:        "abc",
			exptErrorString: "Password length must be not lower that 15 chars",
		},
		{
			name:            "no number",
			password:        "abcdefghijklmnop",
			exptErrorString: "Password must contains at least 3 chars from 0123456789",
		},
		{
			name:            "no special characters",
			password:        "abcd0e3fg5hijklmnop",
			exptErrorString: "Password must contains at least 3 chars from ,;.:-_#+*?=}])[({/&%$§!<>|",
		},
		{
			name:            "no special characters",
			password:        "abcd0e,3.f-g5hijklmnop",
			exptErrorString: "",
		},
	}

	ma := getMiniAuth(t)
	for _, tt := range tts {
		t.Run(tt.name, func(t *testing.T) {
			err := ma.checkPasswordForRegistration(tt.password)
			if tt.exptErrorString != "" {
				assert.Equal(t, tt.exptErrorString, err.Error())
				return
			}
			assert.Nil(t, err)
		})
	}
}

func TestInvalideUsernames(t *testing.T) {
	tts := []struct {
		name     string
		username string
		exptErr  error
	}{
		{
			name:     "not-to-short",
			username: "abc",
			exptErr:  ErrUserHasInvalideChars,
		},
		{
			name:     "not-to-long",
			username: "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
			exptErr:  ErrUserHasInvalideChars,
		},
		{
			name:     "special charakters",
			username: "abcöfg",
			exptErr:  ErrUserHasInvalideChars,
		},
		{
			name:     "with a dot",
			username: "kekskurse.16",
			exptErr:  ErrUserHasInvalideChars,
		},
		{
			name:     "username-ok",
			username: "kekskurse",
			exptErr:  nil,
		},
		{
			name:     "username already taken",
			username: "testuser",
			exptErr:  ErrUsernameIsTaken,
		},
	}

	ma := getMiniAuth(t)
	_, err := ma.store.UserWrite("testuser", "testpassword")
	assert.Nil(t, err, "[setup] should be abel to write user without error")
	for _, tt := range tts {
		t.Run(tt.name, func(t *testing.T) {
			err := ma.checkUsernameForRegistration(tt.username)
			assert.Equal(t, tt.exptErr, err)
		})
	}
}

func TestUserAndMailIsDeletedIfMailCantBeSend(t *testing.T) {
	ma := getMiniAuth(t)
	err := ma.RegisterUser("kekskurse", "error@error.error", "GM18slErbHpuGl7M$!!DD9ZayQzzMWwxqEuTfzJ%XEMjf")
	assert.ErrorIs(t, err, ErrCantSendMail, "should not be abeld to create user")

	res, err := ma.store.MailCheckExists("error@error.error")
	assert.Nil(t, err)
	assert.False(t, res, "should not found mail")

	res, err = ma.store.UserExists("kekskurse")
	assert.Nil(t, err)
	assert.False(t, res, "should not found user")
}

func TestLogin(t *testing.T) {
	ma := getMiniAuth(t)
	err := ma.RegisterUser("kekskurser", "foobar@example.com", "oDzry!!!YPEtHuofKE9hnea8TLTe2Doabi6ddy")
	assert.Nil(t, err)

	tts := []struct {
		name               string
		username           string
		password           string
		ExpectErr          error
		EcpectErrString    string
		ExpectEmptyUser    bool
		ExpectUserUsername string
		config             MiniauthConfig
	}{
		{
			name:               "login-successfull",
			username:           "kekskurser",
			password:           "oDzry!!!YPEtHuofKE9hnea8TLTe2Doabi6ddy",
			config:             MiniauthConfig{LoginWithNotApprovedMail: true},
			ExpectEmptyUser:    false,
			ExpectUserUsername: "kekskurser",
		},
		{
			name:            "login-failed-mail-not-approved",
			username:        "kekskurser",
			password:        "oDzry!!!YPEtHuofKE9hnea8TLTe2Doabi6ddy",
			ExpectErr:       ErrLoginFailed,
			EcpectErrString: "cant login: mail is not validated",
			ExpectEmptyUser: true,
		},
		{
			name:            "login-failed-user-not-found",
			username:        "kekstest",
			password:        "oDzry!!!YPEtHuofKE9hnea8TLTe2Doabi6ddy",
			ExpectErr:       ErrLoginFailed,
			EcpectErrString: "cant login: cant execute query: sql: no rows in result set",
			ExpectEmptyUser: true,
		},
		{
			name:            "login-failed-user-not-found",
			username:        "kekskurser",
			password:        "oDzry!!!YPEtHuofKE9hnea8TLTe2Doabi6ddyTEST",
			ExpectErr:       ErrLoginFailed,
			EcpectErrString: "cant login: user password dont match: crypto/bcrypt: hashedPassword is not the hash of the given password",
			ExpectEmptyUser: true,
		},
	}

	for _, tt := range tts {
		t.Run(tt.name, func(t *testing.T) {
			ma.config = tt.config
			user, err := ma.UserLogin(tt.username, tt.password)
			if tt.ExpectEmptyUser {
				assert.Equal(t, User{}, user, "should return expected user")
			} else {
				assert.Equal(t, tt.ExpectUserUsername, user.Username, "should return right username")
			}
			if tt.ExpectErr == nil {
				assert.Nil(t, err)
				return
			}
			assert.ErrorIs(t, err, tt.ExpectErr)
			assert.Equal(t, tt.EcpectErrString, err.Error())
		})
	}
}

func getMiniAuth(t *testing.T) Miniauth {
	us, err := userstore.NewDummyStore()
	assert.Nil(t, err, "[setup] should be abel to creat dummy store")

	config := MiniauthConfig{}

	sc := smtpclient.NewDummySMTPClient()
	m := NewMiniauth(config, us, sc)
	return m
}