mirror of
https://github.com/LeRoid-hub/Bookholder-API.git
synced 2025-01-31 02:34:57 +00:00
910 lines
28 KiB
Go
910 lines
28 KiB
Go
|
package database
|
||
|
|
|
||
|
|
import (
|
||
|
|
"database/sql"
|
||
|
|
"fmt"
|
||
|
|
"log"
|
||
|
|
"os"
|
||
|
|
"strings"
|
||
|
|
"testing"
|
||
|
|
"time"
|
||
|
|
|
||
|
|
"github.com/ory/dockertest/v3"
|
||
|
|
"github.com/ory/dockertest/v3/docker"
|
||
|
|
"github.com/stretchr/testify/assert"
|
||
|
|
)
|
||
|
|
|
||
|
|
var db *sql.DB
|
||
|
|
|
||
|
|
func TestMain(m *testing.M) {
|
||
|
|
// uses a sensible default on windows (tcp/http) and linux/osx (socket)
|
||
|
|
pool, err := dockertest.NewPool("")
|
||
|
|
if err != nil {
|
||
|
|
log.Fatalf("Could not construct pool: %s", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
err = pool.Client.Ping()
|
||
|
|
if err != nil {
|
||
|
|
log.Fatalf("Could not connect to Docker: %s", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// pulls an image, creates a container based on it and runs it
|
||
|
|
resource, err := pool.RunWithOptions(&dockertest.RunOptions{
|
||
|
|
Repository: "postgres",
|
||
|
|
Tag: "17",
|
||
|
|
Env: []string{
|
||
|
|
"POSTGRES_PASSWORD=secret",
|
||
|
|
"POSTGRES_USER=user_name",
|
||
|
|
"POSTGRES_DB=dbname",
|
||
|
|
"listen_addresses = '*'",
|
||
|
|
},
|
||
|
|
}, func(config *docker.HostConfig) {
|
||
|
|
// set AutoRemove to true so that stopped container goes away by itself
|
||
|
|
config.AutoRemove = true
|
||
|
|
config.RestartPolicy = docker.RestartPolicy{Name: "no"}
|
||
|
|
})
|
||
|
|
if err != nil {
|
||
|
|
log.Fatalf("Could not start resource: %s", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
hostAndPort := resource.GetHostPort("5432/tcp")
|
||
|
|
databaseUrl := fmt.Sprintf("postgres://user_name:secret@%s/dbname?sslmode=disable", hostAndPort)
|
||
|
|
|
||
|
|
log.Println("Connecting to database on url: ", databaseUrl)
|
||
|
|
|
||
|
|
resource.Expire(120) // Tell docker to hard kill the container in 120 seconds
|
||
|
|
|
||
|
|
// exponential backoff-retry, because the application in the container might not be ready to accept connections yet
|
||
|
|
pool.MaxWait = 120 * time.Second
|
||
|
|
if err = pool.Retry(func() error {
|
||
|
|
db, err = sql.Open("pgx", databaseUrl)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
return db.Ping()
|
||
|
|
}); err != nil {
|
||
|
|
log.Fatalf("Could not connect to docker: %s", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
defer func() {
|
||
|
|
if err := pool.Purge(resource); err != nil {
|
||
|
|
log.Fatalf("Could not purge resource: %s", err)
|
||
|
|
}
|
||
|
|
}()
|
||
|
|
|
||
|
|
// setup database
|
||
|
|
|
||
|
|
sqlFile, err := os.ReadFile("../database/bookholder.sql")
|
||
|
|
if err != nil {
|
||
|
|
log.Fatalf("Could not read sql file: %s", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
sqlStatements := strings.Split(string(sqlFile), ";")
|
||
|
|
for _, statement := range sqlStatements {
|
||
|
|
_, err = db.Exec(statement)
|
||
|
|
if err != nil {
|
||
|
|
log.Fatalf("Could not create tables: %s", err)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// load sample data
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES (1, 'Test Account', '1000.00')")
|
||
|
|
if err != nil {
|
||
|
|
log.Fatalf("Could not insert sample data: %s", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// run tests
|
||
|
|
m.Run()
|
||
|
|
}
|
||
|
|
|
||
|
|
func cleanTables() {
|
||
|
|
_, err := db.Exec("DELETE FROM transactions")
|
||
|
|
if err != nil {
|
||
|
|
log.Fatalf("Could not clean tables: %s", err)
|
||
|
|
}
|
||
|
|
_, err = db.Exec("DELETE FROM accounts")
|
||
|
|
if err != nil {
|
||
|
|
log.Fatalf("Could not clean tables: %s", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
_, err = db.Exec("DELETE FROM users")
|
||
|
|
if err != nil {
|
||
|
|
log.Fatalf("Could not clean tables: %s", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewAccount(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account := Account{ID: 1000, Name: "Test Account 2", Kind: "1000.00"}
|
||
|
|
err := NewAccount(db, account)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if account was created
|
||
|
|
var id uint
|
||
|
|
err = db.QueryRow("SELECT id FROM accounts WHERE id = $1", account.ID).Scan(&id)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
t.Log("Retrieved id:", id)
|
||
|
|
t.Log("Expected id:", account.ID)
|
||
|
|
assert.Equal(t, account.ID, id)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewAccountAlreadyExists(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
iniAccount := Account{ID: 1, Name: "Test Account", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", iniAccount.ID, iniAccount.Name, iniAccount.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account := Account{ID: 1, Name: "Test Account 2", Kind: "1000.00"}
|
||
|
|
err = NewAccount(db, account)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Error:", err)
|
||
|
|
t.Log("Expected error: account already exists")
|
||
|
|
assert.Equal(t, "account already exists", err.Error())
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestExistAccount(t *testing.T) {
|
||
|
|
exists, err := existAccount(db, 1)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Account exists:", exists)
|
||
|
|
t.Log("Expected account exists: true")
|
||
|
|
assert.True(t, exists)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestExistAccountNotExists(t *testing.T) {
|
||
|
|
exists, err := existAccount(db, 2)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Account exists:", exists)
|
||
|
|
t.Log("Expected account exists: false")
|
||
|
|
assert.False(t, exists)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUpdateAccount(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
iniAccount := Account{ID: 3, Name: "Test Account", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", iniAccount.ID, iniAccount.Name, iniAccount.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account := Account{ID: 3, Name: "Test Account 3", Kind: "1000.00"}
|
||
|
|
err = UpdateAccount(db, account)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if account was updated
|
||
|
|
var name string
|
||
|
|
err = db.QueryRow("SELECT name FROM accounts WHERE id = $1", account.ID).Scan(&name)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
t.Log("Retrieved name:", name)
|
||
|
|
t.Log("Expected name:", account.Name)
|
||
|
|
assert.Equal(t, account.Name, name)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUpdateAccountNotExists(t *testing.T) {
|
||
|
|
account := Account{ID: 4, Name: "Test Account 4", Kind: "1000.00"}
|
||
|
|
err := UpdateAccount(db, account)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Error:", err)
|
||
|
|
t.Log("Expected error: account does not exist")
|
||
|
|
assert.Equal(t, "account does not exist", err.Error())
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDeleteAccount(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account := Account{ID: 5, Name: "Test Account 5", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account.ID, account.Name, account.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
err = DeleteAccount(db, int(account.ID))
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if account was deleted
|
||
|
|
var id uint
|
||
|
|
err = db.QueryRow("SELECT id FROM accounts WHERE id = $1", account.ID).Scan(&id)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("account was not deleted")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDeleteAccountNotExists(t *testing.T) {
|
||
|
|
err := DeleteAccount(db, 6)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Error:", err)
|
||
|
|
t.Log("Expected error: account does not exist")
|
||
|
|
assert.Equal(t, "account does not exist", err.Error())
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetAccount(t *testing.T) {
|
||
|
|
account := Account{ID: 7, Name: "Test Account 7", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account.ID, account.Name, account.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
acc, err := GetAccount(db, int(account.ID))
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved account:", acc)
|
||
|
|
t.Log("Expected account:", account)
|
||
|
|
assert.Equal(t, account, acc)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetAccountNotExists(t *testing.T) {
|
||
|
|
_, err := GetAccount(db, 8)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Error:", err)
|
||
|
|
t.Log("Expected error: account does not exist")
|
||
|
|
assert.Equal(t, "account does not exist", err.Error())
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestExistTransaction(t *testing.T) {
|
||
|
|
account1 := Account{ID: 9, Name: "Test Account 9", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 10, Name: "Test Account 10", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 0, Amount: 1234.56, Debit: true, OffsetAccount: 9, Account: 10, Date: time.Now()}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions (amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction.Amount, transaction.Debit, transaction.OffsetAccount, transaction.Account, transaction.Date, transaction.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
exists, err := existTransaction(db, 1)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Transaction exists:", exists)
|
||
|
|
t.Log("Expected transaction exists: true")
|
||
|
|
assert.True(t, exists)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestExistTransactionNotExists(t *testing.T) {
|
||
|
|
exists, err := existTransaction(db, 2)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Transaction exists:", exists)
|
||
|
|
t.Log("Expected transaction exists: false")
|
||
|
|
assert.False(t, exists)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewTransaction(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account1 := Account{ID: 11, Name: "Test Account 11", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 12, Name: "Test Account 12", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 1, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: time.Now(), Description: "Test Transaction"}
|
||
|
|
err = NewTransaction(db, transaction)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
var id uint
|
||
|
|
err = db.QueryRow("SELECT id FROM transactions limit 1").Scan(&id)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if transaction was created
|
||
|
|
var account uint
|
||
|
|
err = db.QueryRow("SELECT account FROM transactions WHERE id = $1", id).Scan(&account)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
t.Log("Retrieved id:", id)
|
||
|
|
t.Log("Expected id:", transaction.ID)
|
||
|
|
assert.Equal(t, transaction.Account, account)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewTransactionAccountNotExists(t *testing.T) {
|
||
|
|
transaction := Transaction{ID: 2, Amount: 1234.56, Debit: true, OffsetAccount: 13, Account: 14, Date: time.Now(), Description: "Test Transaction"}
|
||
|
|
err := NewTransaction(db, transaction)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewTransactionOffsetAccountNotExists(t *testing.T) {
|
||
|
|
account := Account{ID: 15, Name: "Test Account 15", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account.ID, account.Name, account.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 3, Amount: 1234.56, Debit: true, OffsetAccount: 16, Account: account.ID, Date: time.Now(), Description: "Test Transaction"}
|
||
|
|
err = NewTransaction(db, transaction)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewTransactionOffsetAccountEqualsAccount(t *testing.T) {
|
||
|
|
account := Account{ID: 17, Name: "Test Account 17", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account.ID, account.Name, account.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 4, Amount: 1234.56, Debit: true, OffsetAccount: account.ID, Account: account.ID, Date: time.Now(), Description: "Test Transaction"}
|
||
|
|
err = NewTransaction(db, transaction)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewTransactionAmountZero(t *testing.T) {
|
||
|
|
account1 := Account{ID: 18, Name: "Test Account 18", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 19, Name: "Test Account 19", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 5, Amount: 0, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: time.Now(), Description: "Test Transaction"}
|
||
|
|
err = NewTransaction(db, transaction)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewTransactionDateZero(t *testing.T) {
|
||
|
|
account1 := Account{ID: 20, Name: "Test Account 20", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 21, Name: "Test Account 21", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 6, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: time.Time{}, Description: "Test Transaction"}
|
||
|
|
err = NewTransaction(db, transaction)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUpdateTransaction(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account1 := Account{ID: 22, Name: "Test Account 22", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 23, Name: "Test Account 23", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
iniTransaction := Transaction{ID: 7, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: time.Now(), Description: "Test Transaction"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions (id, amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6, $7)", iniTransaction.ID, iniTransaction.Amount, iniTransaction.Debit, iniTransaction.OffsetAccount, iniTransaction.Account, iniTransaction.Date, iniTransaction.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 7, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: time.Now(), Description: "Test Transaction 2"}
|
||
|
|
err = UpdateTransaction(db, transaction)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if transaction was updated
|
||
|
|
var description string
|
||
|
|
err = db.QueryRow("SELECT description FROM transactions WHERE id = $1", transaction.ID).Scan(&description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
t.Log("Retrieved description:", description)
|
||
|
|
t.Log("Expected description:", transaction.Description)
|
||
|
|
assert.Equal(t, transaction.Description, description)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUpdateTransactionNotExists(t *testing.T) {
|
||
|
|
account1 := Account{ID: 24, Name: "Test Account 24", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 25, Name: "Test Account 25", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 8, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: time.Now(), Description: "Test Transaction"}
|
||
|
|
err = UpdateTransaction(db, transaction)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDeleteTransaction(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account1 := Account{ID: 26, Name: "Test Account 26", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 27, Name: "Test Account 27", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 9, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: time.Now(), Description: "Test Transaction"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions (id, amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6, $7)", transaction.ID, transaction.Amount, transaction.Debit, transaction.OffsetAccount, transaction.Account, transaction.Date, transaction.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
err = DeleteTransaction(db, int(transaction.ID))
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if transaction was deleted
|
||
|
|
var id uint
|
||
|
|
err = db.QueryRow("SELECT id FROM transactions WHERE id = $1", transaction.ID).Scan(&id)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("transaction was not deleted")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDeleteTransactionNotExists(t *testing.T) {
|
||
|
|
err := DeleteTransaction(db, 10)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetTransaction(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account1 := Account{ID: 28, Name: "Test Account 28", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 29, Name: "Test Account 29", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction := Transaction{ID: 1, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: time.Now(), Description: "Test Transaction"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions ( amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction.Amount, transaction.Debit, transaction.OffsetAccount, transaction.Account, transaction.Date, transaction.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
var id int
|
||
|
|
err = db.QueryRow("SELECT id FROM transactions limit 1").Scan(&id)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
result, err := GetTransaction(db, id)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved transaction:", result.Amount)
|
||
|
|
t.Log("Expected transaction:", transaction.Amount)
|
||
|
|
assert.Equal(t, result.Amount, transaction.Amount)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetTransactionNotExists(t *testing.T) {
|
||
|
|
_, err := GetTransaction(db, 2)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetTransactionsAccountYear(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account1 := Account{ID: 30, Name: "Test Account 30", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 31, Name: "Test Account 31", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
date, _ := time.Parse("2006-01-02", "2024-01-01")
|
||
|
|
|
||
|
|
transaction1 := Transaction{ID: 1, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: date, Description: "Test Transaction 1"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions ( amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction1.Amount, transaction1.Debit, transaction1.OffsetAccount, transaction1.Account, transaction1.Date, transaction1.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction2 := Transaction{ID: 2, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: date, Description: "Test Transaction 2"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions ( amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction2.Amount, transaction2.Debit, transaction2.OffsetAccount, transaction2.Account, transaction2.Date, transaction2.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transactions, err := GetTransactions(db, 31, 2024, 0)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved transactions:", transactions)
|
||
|
|
t.Log("Expected transactions:", []Transaction{transaction1, transaction2})
|
||
|
|
assert.Equal(t, transaction1.Amount, transactions[0].Amount)
|
||
|
|
assert.Equal(t, transaction2.Amount, transactions[1].Amount)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetTransactionsOfffsetAccountYear(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account1 := Account{ID: 30, Name: "Test Account 30", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 31, Name: "Test Account 31", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
date, _ := time.Parse("2006-01-02", "2024-01-01")
|
||
|
|
|
||
|
|
transaction1 := Transaction{ID: 1, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: date, Description: "Test Transaction 1"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions ( amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction1.Amount, transaction1.Debit, transaction1.OffsetAccount, transaction1.Account, transaction1.Date, transaction1.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction2 := Transaction{ID: 2, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: date, Description: "Test Transaction 2"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions ( amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction2.Amount, transaction2.Debit, transaction2.OffsetAccount, transaction2.Account, transaction2.Date, transaction2.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transactions, err := GetTransactions(db, 30, 2024, 0)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved transactions:", transactions)
|
||
|
|
t.Log("Expected transactions:", []Transaction{transaction1, transaction2})
|
||
|
|
assert.Equal(t, transaction1.Amount, transactions[0].Amount)
|
||
|
|
assert.Equal(t, transaction2.Amount, transactions[1].Amount)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetTransactionsAccountYearMonth(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account1 := Account{ID: 30, Name: "Test Account 30", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 31, Name: "Test Account 31", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
date, _ := time.Parse("2006-01-02", "2024-01-01")
|
||
|
|
|
||
|
|
transaction1 := Transaction{ID: 1, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: date, Description: "Test Transaction 1"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions ( amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction1.Amount, transaction1.Debit, transaction1.OffsetAccount, transaction1.Account, transaction1.Date, transaction1.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction2 := Transaction{ID: 2, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: date, Description: "Test Transaction 2"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions ( amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction2.Amount, transaction2.Debit, transaction2.OffsetAccount, transaction2.Account, transaction2.Date, transaction2.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transactions, err := GetTransactions(db, 31, 2024, 1)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved transactions:", transactions)
|
||
|
|
t.Log("Expected transactions:", []Transaction{transaction1, transaction2})
|
||
|
|
assert.Equal(t, transaction1.Amount, transactions[0].Amount)
|
||
|
|
assert.Equal(t, transaction2.Amount, transactions[1].Amount)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetTransactionsOfffsetAccountYearMonth(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
account1 := Account{ID: 30, Name: "Test Account 30", Kind: "1000.00"}
|
||
|
|
_, err := db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account1.ID, account1.Name, account1.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
account2 := Account{ID: 31, Name: "Test Account 31", Kind: "1000.00"}
|
||
|
|
_, err = db.Exec("INSERT INTO accounts (id, name, kind) VALUES ($1, $2, $3)", account2.ID, account2.Name, account2.Kind)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
date, _ := time.Parse("2006-01-02", "2024-01-01")
|
||
|
|
|
||
|
|
transaction1 := Transaction{ID: 1, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: date, Description: "Test Transaction 1"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions ( amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction1.Amount, transaction1.Debit, transaction1.OffsetAccount, transaction1.Account, transaction1.Date, transaction1.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transaction2 := Transaction{ID: 2, Amount: 1234.56, Debit: true, OffsetAccount: account1.ID, Account: account2.ID, Date: date, Description: "Test Transaction 2"}
|
||
|
|
_, err = db.Exec("INSERT INTO transactions ( amount, debit, offset_account, account, date, description) VALUES ($1, $2, $3, $4, $5, $6)", transaction2.Amount, transaction2.Debit, transaction2.OffsetAccount, transaction2.Account, transaction2.Date, transaction2.Description)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
transactions, err := GetTransactions(db, 30, 2024, 1)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved transactions:", transactions)
|
||
|
|
t.Log("Expected transactions:", []Transaction{transaction1, transaction2})
|
||
|
|
assert.Equal(t, transaction1.Amount, transactions[0].Amount)
|
||
|
|
assert.Equal(t, transaction2.Amount, transactions[1].Amount)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewUser(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
user := User{ID: "1", Name: "Test User", Password: "password"}
|
||
|
|
err := NewUser(db, user)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if user was created
|
||
|
|
var Name string
|
||
|
|
err = db.QueryRow("SELECT name FROM users WHERE name = $1", user.Name).Scan(&Name)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved id:", Name)
|
||
|
|
t.Log("Expected id:", user.Name)
|
||
|
|
assert.Equal(t, user.Name, Name)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNewUserAlreadyExists(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
user1 := User{ID: "", Name: "Test User", Password: "password"}
|
||
|
|
err := NewUser(db, user1)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
user2 := User{ID: "", Name: "Test User", Password: "password"}
|
||
|
|
err = NewUser(db, user2)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUpdateUser(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
iniUser := User{ID: "2", Name: "Test User", Password: "password"}
|
||
|
|
_, err := db.Exec("INSERT INTO users ( name, password) VALUES ($1, $2)", iniUser.Name, iniUser.Password)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
var id string
|
||
|
|
err = db.QueryRow("SELECT id FROM users WHERE name = $1", iniUser.Name).Scan(&id)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
user := User{ID: id, Name: "Test User 2", Password: "password"}
|
||
|
|
err = UpdateUser(db, user)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if user was updated
|
||
|
|
var name string
|
||
|
|
err = db.QueryRow("SELECT name FROM users WHERE name = $1", user.Name).Scan(&name)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved name:", name)
|
||
|
|
t.Log("Expected name:", user.Name)
|
||
|
|
assert.Equal(t, user.Name, name)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDeleteUser(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
user := User{ID: "3", Name: "Test User", Password: "password"}
|
||
|
|
_, err := db.Exec("INSERT INTO users ( name, password) VALUES ($1, $2)", user.Name, user.Password)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
var id string
|
||
|
|
err = db.QueryRow("SELECT id FROM users WHERE name = $1", user.Name).Scan(&id)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
err = DeleteUser(db, id)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if user was deleted
|
||
|
|
err = db.QueryRow("SELECT id FROM users WHERE id = $1", user.ID).Scan(&id)
|
||
|
|
if err == nil {
|
||
|
|
t.Error("user was not deleted")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetUser(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
user := User{ID: "4", Name: "Test User", Password: "password"}
|
||
|
|
_, err := db.Exec("INSERT INTO users ( name, password) VALUES ($1, $2)", user.Name, user.Password)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
var id string
|
||
|
|
err = db.QueryRow("SELECT id FROM users WHERE name = $1", user.Name).Scan(&id)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
result, err := GetUser(db, id)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved user:", result.Name)
|
||
|
|
t.Log("Expected user:", user.Name)
|
||
|
|
assert.Equal(t, user.Name, result.Name)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetUserNotExists(t *testing.T) {
|
||
|
|
_, err := GetUser(db, "5")
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetUserByName(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
user := User{ID: "6", Name: "Test User", Password: "password"}
|
||
|
|
_, err := db.Exec("INSERT INTO users ( name, password) VALUES ($1, $2)", user.Name, user.Password)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
result, err := GetUserByName(db, user.Name)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved user:", result.Name)
|
||
|
|
t.Log("Expected user:", user.Name)
|
||
|
|
assert.Equal(t, user.Name, result.Name)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGetUserByNameNotExists(t *testing.T) {
|
||
|
|
_, err := GetUserByName(db, "SHITTY USER NAME")
|
||
|
|
if err == nil {
|
||
|
|
t.Error("expected error")
|
||
|
|
}
|
||
|
|
|
||
|
|
assert.Error(t, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestAuthenticateUser(t *testing.T) {
|
||
|
|
cleanTables()
|
||
|
|
user := User{ID: "7", Name: "Test User", Password: "password"}
|
||
|
|
_, err := db.Exec("INSERT INTO users ( name, password) VALUES ($1, $2)", user.Name, user.Password)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
result, err := AuthenticateUser(db, user.Name, user.Password)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
t.Log("Retrieved user:", result.Name)
|
||
|
|
t.Log("Expected user:", user.Name)
|
||
|
|
assert.Equal(t, user.Name, result.Name)
|
||
|
|
}
|