query_test.go

package kin

import (
	"database/sql"
	"fmt"
	"os"
	"testing"
	"time"

	_ "github.com/jmataya/renv/autoload"
	_ "github.com/lib/pq"
)

func prepareDatabaseTest() (*sql.DB, error) {
	sqlStmt := `
		CREATE TABLE IF NOT EXISTS test_model (
			id serial primary key,
			name text
		);

		TRUNCATE test_model;`

	connStr := os.Getenv("POSTGRES_URL")
	db, _ := sql.Open("postgres", connStr)
	if _, err := db.Exec(sqlStmt); err != nil {
		return nil, fmt.Errorf("Unable to create tables: %v", err)
	}

	return db, nil
}

type testModel struct {
	ID   int    `db:"id,primaryKey"`
	Name string `db:"name"`
}

func (tm testModel) TableName() string {
	return "test_model"
}

func TestInsertQuery(t *testing.T) {
	tm := &testModel{Name: "Donkey Hote"}
	queryObj := &query[testModel]{}
	queryStr := queryObj.insertQuery(tm)

	wantStmt := "INSERT INTO test_model (name) VALUES ($1) RETURNING *"
	if queryStr.stmt != wantStmt {
		t.Errorf("queryStr.stmt = %s, want %s", queryStr.stmt, wantStmt)
	}

	wantParams := []interface{}{"Donkey Hote"}
	if len(queryStr.params) != len(wantParams) {
		t.Errorf("len(queryStr.params) = %d, want %d", len(queryStr.params), len(wantParams))
		return
	}

	for i, param := range queryStr.params {
		if param != wantParams[i] {
			t.Errorf("queryStr.params[%d] = %v, want %v", i, param, wantParams[i])
		}
	}
}

func TestInsertAndGet(t *testing.T) {
	db, err := prepareDatabaseTest()
	if err != nil {
		t.Error(err.Error())
		return
	}

	query := NewQuery[testModel](db)
	dh, err := query.Insert(testModel{Name: "Donkey Hote"})
	if err != nil {
		t.Errorf("query.Insert(dh) = %v, want <nil>", err)
		return
	}

	sp, err := query.Insert(testModel{Name: "Sancho Panza"})
	if err != nil {
		t.Errorf("query.Insert(sp) = %v, want <nil>", err)
		return
	}

	models, err := query.Get("test_model")
	if err != nil {
		t.Errorf("query.Get(...) = %v, want <nil>", err)
		return
	}

	if len(models) != 2 {
		t.Errorf("len(models) = %d, want 2", len(models))
		return
	}

	if models[0].Name != dh.Name {
		t.Errorf("models[0].Name = %s, want %s", models[0].Name, dh.Name)
	}

	if models[1].Name != sp.Name {
		t.Errorf("models[1].Name = %s, want %s", models[1].Name, sp.Name)
	}
}

type testModelTime struct {
	ID        int       `db:"id,primaryKey"`
	Name      string    `db:"name"`
	CreatedAt time.Time `db:"created_at"`
}

func (tm testModelTime) TableName() string {
	return "test_model"
}

func TestInsertSetTime(t *testing.T) {
	createdAt := time.Now()
	tm := testModelTime{Name: "Donkey Hote", CreatedAt: createdAt}
	db := &query[testModelTime]{}
	q := db.insertQuery(tm)

	wantStmt := "INSERT INTO test_model (name, created_at) VALUES ($1, $2) RETURNING *"
	if q.stmt != wantStmt {
		t.Errorf("q.stmt = %s, want %s", q.stmt, wantStmt)
	}

	wantParams := []interface{}{"Donkey Hote", createdAt}
	if len(q.params) != len(wantParams) {
		t.Errorf("len(q.params) = %d, want %d", len(q.params), len(wantParams))
		return
	}

	for i, param := range q.params {
		if param != wantParams[i] {
			t.Errorf("q.params[%d] = %v, want %v", i, param, wantParams[i])
		}
	}
}