chore: add user test and create dummy user store for testing and locale development

pkg/miniauth/error.go

@@ -0,0 +1,8 @@
+package miniauth
+
+import "errors"
+
+var (
+	ErrUSernameInvalide     = errors.New("username not valide")
+	ErrUserHasInvalideChars = errors.New("username has invalide chars")
+)

pkg/miniauth/miniauth.go

@@ -0,0 +1,38 @@
+package miniauth
+
+import (
+	"regexp"
+
+	"git.keks.cloud/kekskurse/miniauth/pkg/userstore"
+	"git.keks.cloud/kekskurse/miniauth/pkg/utils"
+	"github.com/rs/zerolog"
+)
+
+type Miniauth struct {
+	store userstore.Store
+	log   zerolog.Logger
+}
+
+func NewMiniauth(us userstore.Store) Miniauth {
+	m := Miniauth{}
+	m.store = us
+	return m
+}
+
+func (m Miniauth) RegisterUser(username string, mail string, password string) error {
+	log := m.log.With().Str("func", "RegisterUser").Str("username", username).Str("mail", mail).Logger()
+	err := m.checkUsernameForRegistration(username)
+	if err != nil {
+		return utils.WrapError(ErrUserHasInvalideChars, err, log)
+	}
+
+	return nil
+}
+
+func (m Miniauth) checkUsernameForRegistration(username string) error {
+	reg := regexp.MustCompile("^[a-z0-9]{4,25}$")
+	if !reg.MatchString(username) {
+		return ErrUserHasInvalideChars
+	}
+	return nil
+}

pkg/miniauth/miniauth_test.go

@@ -0,0 +1,57 @@
+package miniauth
+
+import (
+	"testing"
+
+	"git.keks.cloud/kekskurse/miniauth/pkg/userstore"
+	"github.com/stretchr/testify/assert"
+)
+
+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,
+		},
+	}
+
+	ma := getMiniAuth(t)
+	for _, tt := range tts {
+		t.Run(tt.name, func(t *testing.T) {
+			err := ma.checkUsernameForRegistration(tt.username)
+			assert.Equal(t, tt.exptErr, err)
+		})
+	}
+}
+
+func getMiniAuth(t *testing.T) Miniauth {
+	us, err := userstore.NewDummyStore()
+	assert.Nil(t, err, "[setup] should be abel to creat dummy store")
+	m := NewMiniauth(us)
+	return m
+}

pkg/userstore/mail_test.go

@@ -7,8 +7,8 @@ import (
 )
 
 func TestAddMail(t *testing.T) {
-	store := getTestStore(t)
+	store, err := NewDummyStore()
-	initDabase(t, store)
+	assert.Nil(t, err, "[setup] should be abel to create dummystore")
 
 	tts := []struct {
 		name          string

pkg/userstore/store.go

@@ -2,14 +2,22 @@ package userstore
 
 import (
 	"database/sql"
+	_ "embed"
+	"fmt"
+	"os"
+	"strings"
 
 	"git.keks.cloud/kekskurse/miniauth/pkg/utils"
+	"github.com/google/uuid"
 	"github.com/rs/zerolog"
 
 	_ "github.com/tursodatabase/libsql-client-go/libsql"
 	_ "modernc.org/sqlite"
 )
 
+//go:embed migrations/schema.sql
+var schema string
+
 type Config struct {
 	SQLite struct {
 		Path string
@@ -42,3 +50,26 @@ func NewStore(c Config) (Store, error) {
 
 	return s, nil
 }
+
+func NewDummyStore() (Store, error) {
+	name, err := os.MkdirTemp("", "miniauth-teststore")
+	if err != nil {
+		return Store{}, err
+	}
+
+	c := Config{}
+	c.SQLite.Path = fmt.Sprintf("file://%v/%v.sqlite", name, uuid.NewString())
+
+	store, err := NewStore(c)
+	if err != nil {
+		return Store{}, err
+	}
+
+	newSchema := strings.Replace(schema, "CREATE TABLE sqlite_sequence(name,seq);", "", 1)
+	_, err = store.db.Exec(newSchema)
+	if err != nil {
+		return Store{}, err
+	}
+
+	return store, nil
+}

pkg/userstore/store_test.go

@@ -2,7 +2,6 @@ package userstore
 
 import (
 	"os"
-	"strings"
 	"testing"
 
 	_ "embed"
@@ -11,9 +10,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-//go:embed migrations/schema.sql
-var schema string
-
 func TestNewStore(t *testing.T) {
 	name, err := os.MkdirTemp("", "miniauth-teststore")
 	assert.Nil(t, err, "[setup] should create tmp folder without errror")
@@ -57,9 +53,3 @@ func TestNewStore(t *testing.T) {
 	err = os.RemoveAll(name)
 	assert.Nil(t, err, "[setup] should be abel to remove sqlite file from hdd after test")
 }
-
-func initDabase(t *testing.T, s Store) {
-	newSchema := strings.Replace(schema, "CREATE TABLE sqlite_sequence(name,seq);", "", 1)
-	_, err := s.db.Exec(newSchema)
-	assert.Nil(t, err, " [setup] should be abel to run schmea sql without error")
-}

pkg/userstore/users_test.go

@@ -1,11 +1,8 @@
 package userstore
 
 import (
-	"fmt"
-	"os"
 	"testing"
 
-	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -42,8 +39,9 @@ func TestWriteUser(t *testing.T) {
 		},
 	}
 
-	store := getTestStore(t)
+	store, err := NewDummyStore()
-	initDabase(t, store)
+	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)
@@ -59,7 +57,7 @@ func TestWriteUser(t *testing.T) {
 
 	var pw1 string
 	var pw2 string
-	err := store.db.QueryRow("SELECT password FROM users WHERE id = 1").Scan(&pw1)
+	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")
@@ -70,16 +68,3 @@ func TestWriteUser(t *testing.T) {
 	assert.NotEqual(t, "kekskurse", pw2)
 	assert.NotEqual(t, pw1, pw2, "passwords should not be equal")
 }
-
-func getTestStore(t *testing.T) Store {
-	name, err := os.MkdirTemp("", "miniauth-teststore")
-	assert.Nil(t, err, "[setup] should be abel to create tmp folder")
-
-	c := Config{}
-	c.SQLite.Path = fmt.Sprintf("file://%v/%v", name, uuid.NewString())
-
-	store, err := NewStore(c)
-	assert.Nil(t, err, "[setup] should be abel to create store")
-
-	return store
-}