fix: refactor code to be testable #181

2024-10-12 21:57:39 +02:00
parent 9fd9f9649e
commit 1ed504c49b
19 changed files with 1022 additions and 710 deletions
--- a/db/auth.go
+++ b/db/auth.go
@@ -13,8 +13,9 @@ import (
 )

 var (
-	ErrUserNotFound = errors.New("User not found")
-	ErrUserExists   = errors.New("User already exists")
+	ErrUserNotFound    = errors.New("User not found")
+	ErrUserExists      = errors.New("User already exists")
+	ErrSessionNotFound = errors.New("Session not found")
 )

 type User struct {
@@ -41,23 +42,63 @@ func NewUser(id uuid.UUID, email string, emailVerified bool, emailVerifiedAt *ti
 	}
 }

-type DbAuth interface {
-	GetUser(email string) (*User, error)
-	InsertUser(user *User) error
-
-	GetEmailVerificationToken(userId uuid.UUID) (string, error)
-	InsertEmailVerificationToken(userId uuid.UUID, token string) error
+type Session struct {
+	Id        string
+	UserId    uuid.UUID
+	CreatedAt time.Time
 }

-type DbAuthSqlite struct {
+func NewSession(id string, userId uuid.UUID, createdAt time.Time) *Session {
+	return &Session{
+		Id:        id,
+		UserId:    userId,
+		CreatedAt: createdAt,
+	}
+}
+
+type AuthDb interface {
+	InsertUser(user *User) error
+	GetUser(email string) (*User, error)
+	GetUserById(userId uuid.UUID) (*User, error)
+	DeleteUser(userId uuid.UUID) error
+	UpdateUserPassword(userId uuid.UUID, newHash []byte) error
+
+	InsertEmailVerificationToken(userId uuid.UUID, token string) error
+	GetEmailVerificationToken(userId uuid.UUID) (string, error)
+
+	InsertSession(session *Session) error
+	GetSession(sessionId string) (*Session, error)
+	DeleteOldSessions(userId uuid.UUID) error
+	DeleteSession(sessionId string) error
+}
+
+type AuthDbSqlite struct {
 	db *sql.DB
 }

-func NewDbAuthSqlite(db *sql.DB) *DbAuthSqlite {
-	return &DbAuthSqlite{db: db}
+func NewAuthDbSqlite(db *sql.DB) *AuthDbSqlite {
+	return &AuthDbSqlite{db: db}
 }

-func (db DbAuthSqlite) GetUser(email string) (*User, error) {
+func (db AuthDbSqlite) InsertUser(user *User) error {
+	_, err := db.db.Exec(`
+		INSERT INTO user (user_uuid, email, email_verified, email_verified_at, is_admin, password, salt, created_at) 
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+		user.Id, user.Email, user.EmailVerified, user.EmailVerifiedAt, user.IsAdmin, user.Password, user.Salt, user.CreateAt)
+
+	if err != nil {
+		if strings.Contains(err.Error(), "email") {
+			return ErrUserExists
+		}
+
+		utils.LogError("SQL error InsertUser", err)
+		return types.ErrInternal
+	}
+
+	return nil
+}
+
+func (db AuthDbSqlite) GetUser(email string) (*User, error) {
 	var (
 		userId          uuid.UUID
 		emailVerified   bool
@@ -83,25 +124,102 @@ func (db DbAuthSqlite) GetUser(email string) (*User, error) {

 	return NewUser(userId, email, emailVerified, emailVerifiedAt, isAdmin, password, salt, createdAt), nil
 }
-func (db DbAuthSqlite) InsertUser(user *User) error {
-	_, err := db.db.Exec(`
-		INSERT INTO user (user_uuid, email, email_verified, email_verified_at, is_admin, password, salt, created_at) 
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-		user.Id, user.Email, user.EmailVerified, user.EmailVerifiedAt, user.IsAdmin, user.Password, user.Salt, user.CreateAt)

+func (db AuthDbSqlite) GetUserById(userId uuid.UUID) (*User, error) {
+	var (
+		email           string
+		emailVerified   bool
+		emailVerifiedAt *time.Time
+		isAdmin         bool
+		password        []byte
+		salt            []byte
+		createdAt       time.Time
+	)
+
+	err := db.db.QueryRow(`
+		SELECT email, email_verified, email_verified_at, password, salt, created_at
+		FROM user 
+		WHERE user_uuid = ?`, userId).Scan(&email, &emailVerified, &emailVerifiedAt, &password, &salt, &createdAt)
 	if err != nil {
-		if strings.Contains(err.Error(), "email") {
-			return ErrUserExists
+		if err == sql.ErrNoRows {
+			return nil, ErrUserNotFound
+		} else {
+			utils.LogError("SQL error GetUser", err)
+			return nil, types.ErrInternal
 		}
+	}

-		utils.LogError("SQL error InsertUser", err)
+	return NewUser(userId, email, emailVerified, emailVerifiedAt, isAdmin, password, salt, createdAt), nil
+}
+
+func (db AuthDbSqlite) DeleteUser(userId uuid.UUID) error {
+
+	tx, err := db.db.Begin()
+	if err != nil {
+		utils.LogError("Could not start transaction", err)
+		return types.ErrInternal
+	}
+
+	_, err = tx.Exec("DELETE FROM workout WHERE user_id = ?", userId)
+	if err != nil {
+		tx.Rollback()
+		utils.LogError("Could not delete workouts", err)
+		return types.ErrInternal
+	}
+
+	_, err = tx.Exec("DELETE FROM user_token WHERE user_uuid = ?", userId)
+	if err != nil {
+		tx.Rollback()
+		utils.LogError("Could not delete user tokens", err)
+		return types.ErrInternal
+	}
+
+	_, err = tx.Exec("DELETE FROM session WHERE user_uuid = ?", userId)
+	if err != nil {
+		tx.Rollback()
+		utils.LogError("Could not delete sessions", err)
+		return types.ErrInternal
+	}
+
+	_, err = tx.Exec("DELETE FROM user WHERE user_uuid = ?", userId)
+	if err != nil {
+		tx.Rollback()
+		utils.LogError("Could not delete user", err)
+		return types.ErrInternal
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		utils.LogError("Could not commit transaction", err)
 		return types.ErrInternal
 	}

 	return nil
 }

-func (db DbAuthSqlite) GetEmailVerificationToken(userId uuid.UUID) (string, error) {
+func (db AuthDbSqlite) UpdateUserPassword(userId uuid.UUID, newHash []byte) error {
+	_, err := db.db.Exec("UPDATE user SET password = ? WHERE user_uuid = ?", newHash, userId)
+	if err != nil {
+		utils.LogError("Could not update password", err)
+		return types.ErrInternal
+	}
+	return nil
+}
+
+func (db AuthDbSqlite) InsertEmailVerificationToken(userId uuid.UUID, token string) error {
+	_, err := db.db.Exec(`
+		INSERT INTO user_token (user_uuid, type, token, created_at) 
+		VALUES (?, 'email_verify', ?, datetime())`, userId, token)
+
+	if err != nil {
+		utils.LogError("Could not insert token", err)
+		return types.ErrInternal
+	}
+
+	return nil
+}
+
+func (db AuthDbSqlite) GetEmailVerificationToken(userId uuid.UUID) (string, error) {
 	var token string

 	err := db.db.QueryRow(`
@@ -117,15 +235,60 @@ func (db DbAuthSqlite) GetEmailVerificationToken(userId uuid.UUID) (string, erro

 	return token, nil
 }
-func (db DbAuthSqlite) InsertEmailVerificationToken(userId uuid.UUID, token string) error {
+
+func (db AuthDbSqlite) InsertSession(session *Session) error {
+
 	_, err := db.db.Exec(`
-		INSERT INTO user_token (user_uuid, type, token, created_at) 
-		VALUES (?, 'email_verify', ?, datetime())`, userId, token)
+		INSERT INTO session (session_id, user_uuid, created_at) 
+		VALUES (?, ?, ?)`, session.Id, session.UserId, session.CreatedAt)

 	if err != nil {
-		utils.LogError("Could not insert token", err)
+		utils.LogError("Could not insert new session", err)
 		return types.ErrInternal
 	}

 	return nil
 }
+
+func (db AuthDbSqlite) GetSession(sessionId string) (*Session, error) {
+
+	var (
+		userId           uuid.UUID
+		sessionCreatedAt time.Time
+	)
+
+	err := db.db.QueryRow(`
+			SELECT u.user_uuid, s.created_at
+			FROM session s
+			INNER JOIN user u ON s.user_uuid = u.user_uuid
+			WHERE session_id = ?`, sessionId).Scan(&userId, &sessionCreatedAt)
+
+	if err != nil {
+		return nil, ErrSessionNotFound
+	}
+
+	return NewSession(sessionId, userId, sessionCreatedAt), nil
+}
+
+func (db AuthDbSqlite) DeleteOldSessions(userId uuid.UUID) error {
+	// Delete old inactive sessions
+	_, err := db.db.Exec("DELETE FROM session WHERE created_at < datetime('now','-8 hours') AND user_uuid = ?", userId)
+	if err != nil {
+		utils.LogError("Could not delete old sessions", err)
+		return types.ErrInternal
+	}
+	return nil
+}
+
+func (db AuthDbSqlite) DeleteSession(sessionId string) error {
+	if sessionId != "" {
+
+		_, err := db.db.Exec("DELETE FROM session WHERE session_id = ?", sessionId)
+		if err != nil {
+			utils.LogError("Could not delete session", err)
+			return types.ErrInternal
+		}
+	}
+
+	return nil
+}
--- a/db/auth_test.go
+++ b/db/auth_test.go
@@ -35,7 +35,7 @@ func TestUser(t *testing.T) {
 		t.Parallel()
 		db := setupDb(t)

-		underTest := DbAuthSqlite{db: db}
+		underTest := AuthDbSqlite{db: db}

 		_, err := underTest.GetUser("someNonExistentEmail")
 		assert.Equal(t, ErrUserNotFound, err)
@@ -45,7 +45,7 @@ func TestUser(t *testing.T) {
 		t.Parallel()
 		db := setupDb(t)

-		underTest := DbAuthSqlite{db: db}
+		underTest := AuthDbSqlite{db: db}

 		verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
 		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
@@ -64,7 +64,7 @@ func TestUser(t *testing.T) {
 		t.Parallel()
 		db := setupDb(t)

-		underTest := DbAuthSqlite{db: db}
+		underTest := AuthDbSqlite{db: db}

 		verifiedAt := time.Date(2020, 1, 5, 13, 0, 0, 0, time.UTC)
 		createAt := time.Date(2020, 1, 5, 12, 0, 0, 0, time.UTC)
@@ -85,7 +85,7 @@ func TestEmailVerification(t *testing.T) {
 		t.Parallel()
 		db := setupDb(t)

-		underTest := DbAuthSqlite{db: db}
+		underTest := AuthDbSqlite{db: db}

 		token, err := underTest.GetEmailVerificationToken(uuid.New())

@@ -96,7 +96,7 @@ func TestEmailVerification(t *testing.T) {
 		t.Parallel()
 		db := setupDb(t)

-		underTest := DbAuthSqlite{db: db}
+		underTest := AuthDbSqlite{db: db}

 		userId := uuid.New()
 		expectedToken := "someToken"
--- a/db/workout.go
+++ b/db/workout.go
@@ -0,0 +1,110 @@
+package db
+
+import (
+	"me-fit/types"
+	"me-fit/utils"
+
+	"database/sql"
+	"errors"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+var (
+	ErrWorkoutNotExists = errors.New("Workout does not exist")
+)
+
+type WorkoutDb interface {
+	InsertWorkout(userId uuid.UUID, workout *WorkoutInsert) (*Workout, error)
+	GetWorkouts(userId uuid.UUID) ([]Workout, error)
+	DeleteWorkout(userId uuid.UUID, rowId int) error
+}
+
+type WorkoutDbSqlite struct {
+	db *sql.DB
+}
+
+func NewWorkoutDbSqlite(db *sql.DB) *WorkoutDbSqlite {
+	return &WorkoutDbSqlite{db: db}
+}
+
+type WorkoutInsert struct {
+	Date time.Time
+	Type string
+	Sets int
+	Reps int
+}
+
+type Workout struct {
+	RowId int
+	Date  time.Time
+	Type  string
+	Sets  int
+	Reps  int
+}
+
+func NewWorkoutInsert(date time.Time, workoutType string, sets int, reps int) *WorkoutInsert {
+	return &WorkoutInsert{Date: date, Type: workoutType, Sets: sets, Reps: reps}
+}
+
+func NewWorkoutFromInsert(rowId int, workoutInsert *WorkoutInsert) *Workout {
+	return &Workout{RowId: rowId, Date: workoutInsert.Date, Type: workoutInsert.Type, Sets: workoutInsert.Sets, Reps: workoutInsert.Reps}
+}
+
+func (db WorkoutDbSqlite) InsertWorkout(userId uuid.UUID, workout *WorkoutInsert) (*Workout, error) {
+	var rowId int
+	err := db.db.QueryRow(`
+		INSERT INTO workout (user_id, date, type, sets, reps) 
+		VALUES (?, ?, ?, ?, ?) 
+		RETURNING rowid`, userId, workout.Date, workout.Type, workout.Sets, workout.Reps).Scan(&rowId)
+	if err != nil {
+		utils.LogError("Error inserting workout", err)
+		return nil, types.ErrInternal
+	}
+
+	return NewWorkoutFromInsert(rowId, workout), nil
+}
+
+func (db WorkoutDbSqlite) GetWorkouts(userId uuid.UUID) ([]Workout, error) {
+
+	rows, err := db.db.Query("SELECT rowid, date, type, sets, reps FROM workout WHERE user_id = ? ORDER BY date desc", userId)
+	if err != nil {
+		utils.LogError("Could not get workouts", err)
+		return nil, types.ErrInternal
+	}
+
+	var workouts = make([]Workout, 0)
+	for rows.Next() {
+		var workout Workout
+
+		err = rows.Scan(&workout.RowId, &workout.Date, &workout.Type, &workout.Sets, &workout.Reps)
+		if err != nil {
+			utils.LogError("Could not scan workout", err)
+			return nil, types.ErrInternal
+		}
+
+		workouts = append(workouts, workout)
+	}
+
+	return workouts, nil
+}
+
+func (db WorkoutDbSqlite) DeleteWorkout(userId uuid.UUID, rowId int) error {
+
+	res, err := db.db.Exec("DELETE FROM workout WHERE user_id = ? AND rowid = ?", userId, rowId)
+	if err != nil {
+		return types.ErrInternal
+	}
+
+	rows, err := res.RowsAffected()
+	if err != nil {
+		return types.ErrInternal
+	}
+
+	if rows == 0 {
+		return ErrWorkoutNotExists
+	}
+
+	return nil
+}