fix: move implementation to "internal" package

test/auth2_test.go

@@ -0,0 +1,154 @@
+package test_test
+
+import (
+	"spend-sparrow/internal/db"
+	"spend-sparrow/internal/service"
+	"spend-sparrow/internal/types"
+	"spend-sparrow/mocks"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	settings = types.Settings{
+		Port:              "",
+		PrometheusEnabled: false,
+		BaseUrl:           "",
+		Environment:       "test",
+		Smtp:              nil,
+	}
+)
+
+func TestSignUp(t *testing.T) {
+	t.Parallel()
+	t.Run("should check for correct email address", func(t *testing.T) {
+		t.Parallel()
+
+		mockAuthDb := mocks.NewMockAuth(t)
+		mockRandom := mocks.NewMockRandom(t)
+		mockClock := mocks.NewMockClock(t)
+		mockMail := mocks.NewMockMail(t)
+
+		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)
+
+		_, err := underTest.SignUp("invalid email address", "SomeStrongPassword123!")
+
+		assert.Equal(t, service.ErrInvalidEmail, err)
+	})
+	t.Run("should check for password complexity", func(t *testing.T) {
+		t.Parallel()
+
+		mockAuthDb := mocks.NewMockAuth(t)
+		mockRandom := mocks.NewMockRandom(t)
+		mockClock := mocks.NewMockClock(t)
+		mockMail := mocks.NewMockMail(t)
+
+		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)
+
+		weakPasswords := []string{
+			"123!ab", // too short
+			"no_upper_case_123",
+			"NO_LOWER_CASE_123",
+			"noSpecialChar123",
+		}
+
+		for _, password := range weakPasswords {
+			_, err := underTest.SignUp("some@valid.email", password)
+			assert.Equal(t, service.ErrInvalidPassword, err)
+		}
+	})
+	t.Run("should signup correctly", func(t *testing.T) {
+		t.Parallel()
+
+		mockAuthDb := mocks.NewMockAuth(t)
+		mockRandom := mocks.NewMockRandom(t)
+		mockClock := mocks.NewMockClock(t)
+		mockMail := mocks.NewMockMail(t)
+
+		userId := uuid.New()
+		email := "mail@mail.de"
+		password := "SomeStrongPassword123!"
+		salt := []byte("salt")
+		createTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+
+		expected := types.NewUser(userId, email, false, nil, false, service.GetHashPassword(password, salt), salt, createTime)
+
+		mockRandom.EXPECT().UUID().Return(userId, nil)
+		mockRandom.EXPECT().Bytes(16).Return(salt, nil)
+		mockClock.EXPECT().Now().Return(createTime)
+		mockAuthDb.EXPECT().InsertUser(expected).Return(nil)
+
+		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)
+		actual, err := underTest.SignUp(email, password)
+
+		require.NoError(t, err)
+
+		assert.Equal(t, expected, actual)
+	})
+	t.Run("should return ErrAccountExists", func(t *testing.T) {
+		t.Parallel()
+
+		mockAuthDb := mocks.NewMockAuth(t)
+		mockRandom := mocks.NewMockRandom(t)
+		mockClock := mocks.NewMockClock(t)
+		mockMail := mocks.NewMockMail(t)
+
+		userId := uuid.New()
+		email := "some@valid.email"
+		createTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+		password := "SomeStrongPassword123!"
+		salt := []byte("salt")
+		user := types.NewUser(userId, email, false, nil, false, service.GetHashPassword(password, salt), salt, createTime)
+
+		mockRandom.EXPECT().UUID().Return(user.Id, nil)
+		mockRandom.EXPECT().Bytes(16).Return(salt, nil)
+		mockClock.EXPECT().Now().Return(createTime)
+
+		mockAuthDb.EXPECT().InsertUser(user).Return(db.ErrAlreadyExists)
+
+		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)
+
+		_, err := underTest.SignUp(user.Email, password)
+		assert.Equal(t, service.ErrAccountExists, err)
+	})
+}
+
+func TestSendVerificationMail(t *testing.T) {
+	t.Parallel()
+	t.Run("should use stored token and send mail", func(t *testing.T) {
+		t.Parallel()
+
+		token := types.NewToken(
+			uuid.New(),
+			"sessionId",
+			"someRandomTokenToUse",
+			types.TokenTypeEmailVerify,
+			time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC),
+			time.Date(2020, 1, 2, 0, 0, 0, 0, time.UTC))
+		tokens := []*types.Token{token}
+
+		email := "some@email.de"
+		userId := uuid.New()
+
+		mockAuthDb := mocks.NewMockAuth(t)
+		mockRandom := mocks.NewMockRandom(t)
+		mockClock := mocks.NewMockClock(t)
+		mockMail := mocks.NewMockMail(t)
+
+		mockAuthDb.EXPECT().GetTokensByUserIdAndType(userId, types.TokenTypeEmailVerify).Return(tokens, nil)
+
+		mockMail.EXPECT().SendMail(email, "Welcome to spend-sparrow", mock.MatchedBy(func(message string) bool {
+			return strings.Contains(message, token.Token)
+		})).Return()
+
+		underTest := service.NewAuth(mockAuthDb, mockRandom, mockClock, mockMail, &settings)
+
+		underTest.SendVerificationMail(userId, email)
+	})
+}

test/auth_test.go

@@ -0,0 +1,205 @@
+package test_test
+
+import (
+	"spend-sparrow/internal/db"
+	"spend-sparrow/internal/types"
+	"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 = db.RunMigrations(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 := db.NewAuthSqlite(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 := types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
+
+		err := underTest.InsertUser(expected)
+		require.NoError(t, err)
+
+		actual, err := underTest.GetUser(expected.Id)
+		require.NoError(t, err)
+		assert.Equal(t, expected, actual)
+
+		actual, err = underTest.GetUserByEmail(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 := db.NewAuthSqlite(d)
+
+		_, err := underTest.GetUserByEmail("nonExistentEmail")
+		assert.Equal(t, db.ErrNotFound, err)
+	})
+	t.Run("should return ErrUserExist", func(t *testing.T) {
+		t.Parallel()
+		d := setupDb(t)
+
+		underTest := db.NewAuthSqlite(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 := types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
+
+		err := underTest.InsertUser(user)
+		require.NoError(t, err)
+
+		err = underTest.InsertUser(user)
+		assert.Equal(t, db.ErrAlreadyExists, err)
+	})
+	t.Run("should return ErrInternal on missing NOT NULL fields", func(t *testing.T) {
+		t.Parallel()
+		d := setupDb(t)
+
+		underTest := db.NewAuthSqlite(d)
+
+		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
+		user := types.NewUser(uuid.New(), "some@email.de", false, nil, false, []byte("somePass"), nil, createAt)
+
+		err := underTest.InsertUser(user)
+		assert.Equal(t, types.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 := db.NewAuthSqlite(d)
+
+		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
+		expiresAt := createAt.Add(24 * time.Hour)
+		expected := types.NewToken(uuid.New(), "sessionId", "token", types.TokenTypeCsrf, createAt, expiresAt)
+
+		err := underTest.InsertToken(expected)
+		require.NoError(t, err)
+
+		actual, err := underTest.GetToken(expected.Token)
+		require.NoError(t, err)
+		assert.Equal(t, expected, actual)
+
+		expected.SessionId = ""
+		actuals, err := underTest.GetTokensByUserIdAndType(expected.UserId, expected.Type)
+		require.NoError(t, err)
+		assert.Equal(t, []*types.Token{expected}, actuals)
+
+		expected.SessionId = "sessionId"
+		expected.UserId = uuid.Nil
+		actuals, err = underTest.GetTokensBySessionIdAndType(expected.SessionId, expected.Type)
+		require.NoError(t, err)
+		assert.Equal(t, []*types.Token{expected}, actuals)
+	})
+	t.Run("should insert and return multiple tokens", func(t *testing.T) {
+		t.Parallel()
+		d := setupDb(t)
+
+		underTest := db.NewAuthSqlite(d)
+
+		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
+		expiresAt := createAt.Add(24 * time.Hour)
+		userId := uuid.New()
+		expected1 := types.NewToken(userId, "sessionId", "token1", types.TokenTypeCsrf, createAt, expiresAt)
+		expected2 := types.NewToken(userId, "sessionId", "token2", types.TokenTypeCsrf, createAt, expiresAt)
+
+		err := underTest.InsertToken(expected1)
+		require.NoError(t, err)
+		err = underTest.InsertToken(expected2)
+		require.NoError(t, err)
+
+		expected1.UserId = uuid.Nil
+		expected2.UserId = uuid.Nil
+		actuals, err := underTest.GetTokensBySessionIdAndType(expected1.SessionId, expected1.Type)
+		require.NoError(t, err)
+		assert.Equal(t, []*types.Token{expected1, expected2}, actuals)
+
+		expected1.SessionId = ""
+		expected2.SessionId = ""
+		expected1.UserId = userId
+		expected2.UserId = userId
+		actuals, err = underTest.GetTokensByUserIdAndType(userId, expected1.Type)
+		require.NoError(t, err)
+		assert.Equal(t, []*types.Token{expected1, expected2}, actuals)
+	})
+	t.Run("should return ErrNotFound", func(t *testing.T) {
+		t.Parallel()
+		d := setupDb(t)
+
+		underTest := db.NewAuthSqlite(d)
+
+		_, err := underTest.GetToken("nonExistent")
+		assert.Equal(t, db.ErrNotFound, err)
+
+		_, err = underTest.GetTokensByUserIdAndType(uuid.New(), types.TokenTypeEmailVerify)
+		assert.Equal(t, db.ErrNotFound, err)
+
+		_, err = underTest.GetTokensBySessionIdAndType("sessionId", types.TokenTypeEmailVerify)
+		assert.Equal(t, db.ErrNotFound, err)
+	})
+	t.Run("should return ErrAlreadyExists", func(t *testing.T) {
+		t.Parallel()
+		d := setupDb(t)
+
+		underTest := db.NewAuthSqlite(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 := types.NewUser(uuid.New(), "some@email.de", true, &verifiedAt, false, []byte("somePass"), []byte("someSalt"), createAt)
+
+		err := underTest.InsertUser(user)
+		require.NoError(t, err)
+
+		err = underTest.InsertUser(user)
+		assert.Equal(t, db.ErrAlreadyExists, err)
+	})
+	t.Run("should return ErrInternal on missing NOT NULL fields", func(t *testing.T) {
+		t.Parallel()
+		d := setupDb(t)
+
+		underTest := db.NewAuthSqlite(d)
+
+		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
+		user := types.NewUser(uuid.New(), "some@email.de", false, nil, false, []byte("somePass"), nil, createAt)
+
+		err := underTest.InsertUser(user)
+		assert.Equal(t, types.ErrInternal, err)
+	})
+}

test/treasure_chest_test.go

@@ -0,0 +1 @@
+package test_test