Tim Wundenberg
c927d917ec
All checks were successful
Build and Push Docker Image / Build-And-Push-Docker-Image (push) Successful in 1m19s
208 lines
6.6 KiB
Go
208 lines
6.6 KiB
Go
package test_test
|
|
|
|
import (
|
|
"context"
|
|
"spend-sparrow/internal/auth_types"
|
|
"spend-sparrow/internal/authentication"
|
|
"spend-sparrow/internal/core"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/jmoiron/sqlx"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func setupDb(t *testing.T) *sqlx.DB {
|
|
t.Helper()
|
|
|
|
d, err := sqlx.Open("sqlite3", ":memory:")
|
|
if err != nil {
|
|
t.Fatalf("Error opening database: %v", err)
|
|
}
|
|
t.Cleanup(func() {
|
|
err := d.Close()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
})
|
|
|
|
err = core.RunMigrations(context.Background(), d, "../")
|
|
if err != nil {
|
|
t.Fatalf("Error running migrations: %v", err)
|
|
}
|
|
|
|
return d
|
|
}
|
|
|
|
func TestUser(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("should insert and get the same", func(t *testing.T) {
|
|
t.Parallel()
|
|
d := setupDb(t)
|
|
|
|
underTest := authentication.NewDbSqlite(d)
|
|
|
|
verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
|
|
createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
|
|
expected := auth_types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
|
|
|
|
err := underTest.InsertUser(context.Background(), expected)
|
|
require.NoError(t, err)
|
|
|
|
actual, err := underTest.GetUser(context.Background(), expected.Id)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, expected, actual)
|
|
|
|
actual, err = underTest.GetUserByEmail(context.Background(), expected.Email)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, expected, actual)
|
|
})
|
|
t.Run("should return ErrNotFound", func(t *testing.T) {
|
|
t.Parallel()
|
|
d := setupDb(t)
|
|
|
|
underTest := authentication.NewDbSqlite(d)
|
|
|
|
_, err := underTest.GetUserByEmail(context.Background(), "nonExistentEmail")
|
|
assert.Equal(t, core.ErrNotFound, err)
|
|
})
|
|
t.Run("should return ErrUserExist", func(t *testing.T) {
|
|
t.Parallel()
|
|
d := setupDb(t)
|
|
|
|
underTest := authentication.NewDbSqlite(d)
|
|
|
|
verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
|
|
createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
|
|
user := auth_types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
|
|
|
|
err := underTest.InsertUser(context.Background(), user)
|
|
require.NoError(t, err)
|
|
|
|
err = underTest.InsertUser(context.Background(), user)
|
|
assert.Equal(t, core.ErrAlreadyExists, err)
|
|
})
|
|
t.Run("should return ErrInternal on missing NOT NULL fields", func(t *testing.T) {
|
|
t.Parallel()
|
|
d := setupDb(t)
|
|
|
|
underTest := authentication.NewDbSqlite(d)
|
|
|
|
createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
|
|
user := auth_types.NewUser(uuid.New(), "some@email.de", false, nil, false, []byte("somePass"), nil, createAt)
|
|
|
|
err := underTest.InsertUser(context.Background(), user)
|
|
assert.Equal(t, core.ErrInternal, err)
|
|
})
|
|
}
|
|
|
|
func TestToken(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("should insert and get the same", func(t *testing.T) {
|
|
t.Parallel()
|
|
d := setupDb(t)
|
|
|
|
underTest := authentication.NewDbSqlite(d)
|
|
|
|
createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
|
|
expiresAt := createAt.Add(24 * time.Hour)
|
|
expected := auth_types.NewToken(uuid.New(), "sessionId", "token", auth_types.TokenTypeCsrf, createAt, expiresAt)
|
|
|
|
err := underTest.InsertToken(context.Background(), expected)
|
|
require.NoError(t, err)
|
|
|
|
actual, err := underTest.GetToken(context.Background(), expected.Token)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, expected, actual)
|
|
|
|
expected.SessionId = ""
|
|
actuals, err := underTest.GetTokensByUserIdAndType(context.Background(), expected.UserId, expected.Type)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, []*auth_types.Token{expected}, actuals)
|
|
|
|
expected.SessionId = "sessionId"
|
|
expected.UserId = uuid.Nil
|
|
actuals, err = underTest.GetTokensBySessionIdAndType(context.Background(), expected.SessionId, expected.Type)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, []*auth_types.Token{expected}, actuals)
|
|
})
|
|
t.Run("should insert and return multiple tokens", func(t *testing.T) {
|
|
t.Parallel()
|
|
d := setupDb(t)
|
|
|
|
underTest := authentication.NewDbSqlite(d)
|
|
|
|
createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
|
|
expiresAt := createAt.Add(24 * time.Hour)
|
|
userId := uuid.New()
|
|
expected1 := auth_types.NewToken(userId, "sessionId", "token1", auth_types.TokenTypeCsrf, createAt, expiresAt)
|
|
expected2 := auth_types.NewToken(userId, "sessionId", "token2", auth_types.TokenTypeCsrf, createAt, expiresAt)
|
|
|
|
err := underTest.InsertToken(context.Background(), expected1)
|
|
require.NoError(t, err)
|
|
err = underTest.InsertToken(context.Background(), expected2)
|
|
require.NoError(t, err)
|
|
|
|
expected1.UserId = uuid.Nil
|
|
expected2.UserId = uuid.Nil
|
|
actuals, err := underTest.GetTokensBySessionIdAndType(context.Background(), expected1.SessionId, expected1.Type)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, []*auth_types.Token{expected1, expected2}, actuals)
|
|
|
|
expected1.SessionId = ""
|
|
expected2.SessionId = ""
|
|
expected1.UserId = userId
|
|
expected2.UserId = userId
|
|
actuals, err = underTest.GetTokensByUserIdAndType(context.Background(), userId, expected1.Type)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, []*auth_types.Token{expected1, expected2}, actuals)
|
|
})
|
|
t.Run("should return ErrNotFound", func(t *testing.T) {
|
|
t.Parallel()
|
|
d := setupDb(t)
|
|
|
|
underTest := authentication.NewDbSqlite(d)
|
|
|
|
_, err := underTest.GetToken(context.Background(), "nonExistent")
|
|
assert.Equal(t, core.ErrNotFound, err)
|
|
|
|
_, err = underTest.GetTokensByUserIdAndType(context.Background(), uuid.New(), auth_types.TokenTypeEmailVerify)
|
|
assert.Equal(t, core.ErrNotFound, err)
|
|
|
|
_, err = underTest.GetTokensBySessionIdAndType(context.Background(), "sessionId", auth_types.TokenTypeEmailVerify)
|
|
assert.Equal(t, core.ErrNotFound, err)
|
|
})
|
|
t.Run("should return ErrAlreadyExists", func(t *testing.T) {
|
|
t.Parallel()
|
|
d := setupDb(t)
|
|
|
|
underTest := authentication.NewDbSqlite(d)
|
|
|
|
verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
|
|
createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
|
|
user := auth_types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
|
|
|
|
err := underTest.InsertUser(context.Background(), user)
|
|
require.NoError(t, err)
|
|
|
|
err = underTest.InsertUser(context.Background(), user)
|
|
assert.Equal(t, core.ErrAlreadyExists, err)
|
|
})
|
|
t.Run("should return ErrInternal on missing NOT NULL fields", func(t *testing.T) {
|
|
t.Parallel()
|
|
d := setupDb(t)
|
|
|
|
underTest := authentication.NewDbSqlite(d)
|
|
|
|
createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
|
|
user := auth_types.NewUser(uuid.New(), "some@email.de", false, nil, false, []byte("somePass"), nil, createAt)
|
|
|
|
err := underTest.InsertUser(context.Background(), user)
|
|
assert.Equal(t, core.ErrInternal, err)
|
|
})
|
|
}
|