tests for repository

internal/repository/postgres/settings_postgres.go

@@ -17,7 +17,7 @@ func NewSettingsRepository(db *sqlx.DB) *SettingsRepository {
 
 func (r SettingsRepository) Get(key string) (value string, err error) {
 	query := fmt.Sprintf(`
-		SELECT *
+		SELECT value
 		FROM public.%s
 		WHERE key=$1
 		LIMIT 1`, settingsTable)
@@ -48,7 +48,7 @@ func (r SettingsRepository) Set(key string, value string) (settingId int, err er
 		RETURNING id`,
 		settingsTable)
 	id := -1
-	err = r.db.QueryRowx(query, value, key).Scan(&id)
+	err = r.db.QueryRowx(query, key, value).Scan(&id)
 
 	if err != nil || id == -1 {
 		return id, fmt.Errorf("team repository create error: %v", err)

internal/repository/postgres/settings_postgres_test.go

@@ -1,64 +1,96 @@
 package postgres_test
 
 import (
-	"borda/internal/repository"
 	"borda/internal/repository/postgres"
-	"fmt"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/jmoiron/sqlx"
 	"github.com/stretchr/testify/require"
 )
 
-func Test_NewSettingsRepository(t *testing.T) {
+func TestSettingsRepository_Get(t *testing.T) {
 	db := MustOpenDB(t)
+	defer MustCloseDB(t, db)
 
-	settingsRepository := postgres.NewSettingsRepository(db)
-
-	require.Implements(t, (*repository.SettingsRepository)(nil), settingsRepository)
-}
-
-func Test_SettingsRepository_Set(t *testing.T) {
-	db := MustOpenDB(t)
 	repo := postgres.NewSettingsRepository(db)
-	assert := assert.New(t)
-
-	key := "team_limit"
-	value := "5"
-	settingsId := 1
+	require := require.New(t)
 
-	id, err := repo.Set(key, value)
-	if err != nil {
-		t.Fatalf("Set error: %v\n", err)
+	type args struct {
+		key string
+	}
+	testTable := []struct {
+		name         string
+		args         args
+		wantResponse string
+		wantErr      error
+	}{
+		// TODO: Add test cases.
+		{
+			name: "OK",
+			args: args{
+				key: "team_limit",
+			},
+			wantResponse: "4",
+			wantErr:      nil,
+		},
 	}
+	for _, testCase := range testTable {
+		t.Run(testCase.name, func(t *testing.T) {
+			helpSetSettings(t, db, "team_limit", "4")
 
-	assert.Equal(id, settingsId, "they should be equal")
-	assert.NotNil(id, "must be not nil")
+			actualResponse, actualErr := repo.Get(testCase.args.key)
+
+			require.Equal(testCase.wantErr, actualErr, t)
+			require.Equal(testCase.wantResponse, actualResponse, t)
+		})
+	}
 }
 
-func Test_SettingsRepository_Get(t *testing.T) {
+func TestSettingsRepository_Set(t *testing.T) {
 	db := MustOpenDB(t)
-	repo := postgres.NewSettingsRepository(db)
-	assert := assert.New(t)
-
-	key := "team_limit"
-	value := "5"
+	defer MustCloseDB(t, db)
 
-	_, err := repo.Set(key, value)
-	if err != nil {
-		t.Fatalf("Test settings asserted not created: %v\n", err)
+	repo := postgres.NewSettingsRepository(db)
+	require := require.New(t)
 
+	type args struct {
+		key   string
+		value string
+	}
+	testTable := []struct {
+		name         string
+		args         args
+		wantResponse int
+		wantErr      error
+	}{
+		// TODO: Add test cases.
+		{
+			name: "OK",
+			args: args{
+				key:   "TEST",
+				value: "1337",
+			},
+			wantResponse: 1,
+			wantErr:      nil,
+		},
 	}
+	for _, testCase := range testTable {
+		t.Run(testCase.name, func(t *testing.T) {
+			actualResponse, actualErr := repo.Set(testCase.args.key, testCase.args.value)
 
-	testValue, err := repo.Get(key)
-	// if err != nil {
-	// 	t.Fatalf("Test settings asserted not created: %v\n", err)
-	// }
+			require.Equal(testCase.wantErr, actualErr, t)
+			require.Equal(testCase.wantResponse, actualResponse, t)
+		})
+	}
+}
 
-	assert.Error(err, "error should be nil")
-	assert.Equal(value, testValue, fmt.Sprintf("value should be equal <%v>, not <%v>", value, testValue))
+func helpSetSettings(t *testing.T, db *sqlx.DB, key string, value string) int {
+	t.Helper()
 
-	_, err = repo.Get("1337")
-	assert.Error(err, "Settings not found with key=1337", "they should be equal")
+	id, err := postgres.NewSettingsRepository(db).Set(key, value)
+	if err != nil {
+		t.Fatal(err)
+	}
 
+	return id
 }

internal/repository/postgres/task_postgres.go

@@ -30,7 +30,7 @@ func (r TaskRepository) SaveTask(task domain.Task) (int, error) {
 	}
 	defer tx.Rollback() //nolint
 
-	_, err = r.findOrCreateAuthor(tx, &task.Author)
+	task.Author.Id, err = r.findOrCreateAuthor(tx, task.Author)
 	if err != nil {
 		return 0, err
 	}
@@ -69,7 +69,7 @@ func (r TaskRepository) SaveTask(task domain.Task) (int, error) {
 	return task.Id, nil
 }
 
-func (r TaskRepository) findOrCreateAuthor(tx *sqlx.Tx, author *domain.Author) (int, error) {
+func (r TaskRepository) findOrCreateAuthor(tx *sqlx.Tx, author domain.Author) (int, error) {
 	query := fmt.Sprintf(`
 		SELECT id
 		FROM public.%s