GOMODULES
/
ksql
mirror of https://github.com/VinGarcia/ksql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #24 from jadson-medeiros/change-test-lib-reference 

Change the test lib reference
add-transactionCtx-method
Vinícius Garcia 2022-07-10 11:53:32 -03:00 committed by GitHub
parent 7adc6473b7 e464f3b6ea
commit 19429143d1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 258 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
kbuilder/insert_test.go
View File

@ -3,7 +3,7 @@ package kbuilder_test
import (
"testing"
"github.com/ditointernet/go-assert"
tt "github.com/vingarcia/ksql/internal/testtools"
"github.com/vingarcia/ksql/kbuilder"
)
@ -80,13 +80,13 @@ func TestInsertQuery(t *testing.T) {
for _, test := range tests {
t.Run(test.desc, func(t *testing.T) {
b, err := kbuilder.New("postgres")
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
query, params, err := b.Build(test.query)
expectError(t, test.expectedErr, err)
assert.Equal(t, test.expectedQuery, query)
assert.Equal(t, test.expectedParams, params)
tt.AssertEqual(t, query, test.expectedQuery)
tt.AssertEqual(t, params, test.expectedParams)
})
}
}

8
kbuilder/query_test.go
View File

@ -4,8 +4,8 @@ import (
"fmt"
"testing"
"github.com/ditointernet/go-assert"
"github.com/stretchr/testify/require"
tt "github.com/vingarcia/ksql/internal/testtools"
"github.com/vingarcia/ksql/kbuilder"
)
@ -124,13 +124,13 @@ func TestSelectQuery(t *testing.T) {
for _, test := range tests {
t.Run(test.desc, func(t *testing.T) {
b, err := kbuilder.New("postgres")
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
query, params, err := b.Build(test.query)
expectError(t, test.expectedErr, err)
assert.Equal(t, test.expectedQuery, query)
assert.Equal(t, test.expectedParams, params)
tt.AssertEqual(t, query, test.expectedQuery)
tt.AssertEqual(t, params, test.expectedParams)
})
}
}

10
ksql_test.go
View File

@ -3,8 +3,6 @@ package ksql
import (
"testing"
"github.com/ditointernet/go-assert"
tt "github.com/vingarcia/ksql/internal/testtools"
)
@ -25,9 +23,9 @@ func TestNewAdapterWith(t *testing.T) {
dialectName,
)
assert.Equal(t, nil, err)
assert.Equal(t, supportedDialects[dialectName], db.dialect)
assert.Equal(t, dialectName, db.driver)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, db.dialect, supportedDialects[dialectName])
tt.AssertEqual(t, db.driver, dialectName)
}
})
@ -37,6 +35,6 @@ func TestNewAdapterWith(t *testing.T) {
"fake-dialect-name",
)
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
}

71
ksqltest/testhelpers_test.go
View File

@ -4,7 +4,6 @@ import (
"fmt"
"testing"
"github.com/ditointernet/go-assert"
tt "github.com/vingarcia/ksql/internal/testtools"
"github.com/vingarcia/ksql/nullable"
)
@ -20,11 +19,11 @@ func TestStructToMap(t *testing.T) {
Age: 22,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{
"name_attr": "my name",
"age_attr": 22,
}, m)
})
})
t.Run("should not ignore zero value attrs, if they are not pointers", func(t *testing.T) {
@ -33,11 +32,11 @@ func TestStructToMap(t *testing.T) {
Age: 0,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{
"name_attr": "",
"age_attr": 0,
}, m)
})
})
type S2 struct {
@ -53,11 +52,11 @@ func TestStructToMap(t *testing.T) {
Age: &age,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{
"name": "",
"age": 0,
}, m)
})
})
t.Run("should ignore nil pointers", func(t *testing.T) {
@ -66,8 +65,8 @@ func TestStructToMap(t *testing.T) {
Age: nil,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{}, m)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{})
})
t.Run("should ignore fields not tagged with ksql", func(t *testing.T) {
@ -81,11 +80,11 @@ func TestStructToMap(t *testing.T) {
NotPartOfTheQuery: 42,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{
"name_attr": "fake-name",
"age_attr": 42,
}, m)
})
})
t.Run("should return error for duplicated ksql tag names", func(t *testing.T) {
@ -99,7 +98,7 @@ func TestStructToMap(t *testing.T) {
DuplicatedName: "fake-duplicated-name",
})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
t.Run("should return error for structs with no ksql tags", func(t *testing.T) {
@ -111,7 +110,7 @@ func TestStructToMap(t *testing.T) {
Age: 42,
})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
}
@ -126,9 +125,9 @@ func TestFillStructWith(t *testing.T) {
"age": 22,
})
assert.Equal(t, nil, err)
assert.Equal(t, "Breno", user.Name)
assert.Equal(t, 22, user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, "Breno")
tt.AssertEqual(t, user.Age, 22)
})
t.Run("should fill ptr fields with ptr values", func(t *testing.T) {
@ -141,9 +140,9 @@ func TestFillStructWith(t *testing.T) {
"age": nullable.Int(22),
})
assert.Equal(t, nil, err)
assert.Equal(t, nullable.String("Breno"), user.Name)
assert.Equal(t, nullable.Int(22), user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, nullable.String("Breno"))
tt.AssertEqual(t, user.Age, nullable.Int(22))
})
t.Run("should fill ptr fields with non-ptr values", func(t *testing.T) {
@ -156,9 +155,9 @@ func TestFillStructWith(t *testing.T) {
"age": 22,
})
assert.Equal(t, nil, err)
assert.Equal(t, nullable.String("Breno"), user.Name)
assert.Equal(t, nullable.Int(22), user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, nullable.String("Breno"))
tt.AssertEqual(t, user.Age, nullable.Int(22))
})
t.Run("should fill non ptr fields with ptr values", func(t *testing.T) {
@ -171,9 +170,9 @@ func TestFillStructWith(t *testing.T) {
"age": nullable.Int(22),
})
assert.Equal(t, nil, err)
assert.Equal(t, "Breno", user.Name)
assert.Equal(t, 22, user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, "Breno")
tt.AssertEqual(t, user.Age, 22)
})
t.Run("should fill ptr fields with nil when necessary", func(t *testing.T) {
@ -186,9 +185,9 @@ func TestFillStructWith(t *testing.T) {
"age": nil,
})
assert.Equal(t, nil, err)
assert.Equal(t, (*string)(nil), user.Name)
assert.Equal(t, (*int)(nil), user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, (*string)(nil))
tt.AssertEqual(t, user.Age, (*int)(nil))
})
t.Run("should interpret nil fields as zero values when necessary", func(t *testing.T) {
@ -204,9 +203,9 @@ func TestFillStructWith(t *testing.T) {
"age": nil,
})
assert.Equal(t, nil, err)
assert.Equal(t, "", user.Name)
assert.Equal(t, 0, user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, "")
tt.AssertEqual(t, user.Age, 0)
})
t.Run("should ignore extra or missing fields", func(t *testing.T) {
@ -295,7 +294,7 @@ func TestFillSliceWith(t *testing.T) {
},
})
tt.AssertEqual(t, err, nil)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, len(users), 3)
tt.AssertEqual(t, users[0].Name, "Jorge")
tt.AssertEqual(t, users[1].Name, "Luciana")

71
kstructs/testhelpers_test.go
View File

@ -4,7 +4,6 @@ import (
"fmt"
"testing"
"github.com/ditointernet/go-assert"
tt "github.com/vingarcia/ksql/internal/testtools"
"github.com/vingarcia/ksql/nullable"
)
@ -20,11 +19,11 @@ func TestStructToMap(t *testing.T) {
Age: 22,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{
"name_attr": "my name",
"age_attr": 22,
}, m)
})
})
t.Run("should not ignore zero value attrs, if they are not pointers", func(t *testing.T) {
@ -33,11 +32,11 @@ func TestStructToMap(t *testing.T) {
Age: 0,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{
"name_attr": "",
"age_attr": 0,
}, m)
})
})
type S2 struct {
@ -53,11 +52,11 @@ func TestStructToMap(t *testing.T) {
Age: &age,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{
"name": "",
"age": 0,
}, m)
})
})
t.Run("should ignore nil pointers", func(t *testing.T) {
@ -66,8 +65,8 @@ func TestStructToMap(t *testing.T) {
Age: nil,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{}, m)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{})
})
t.Run("should ignore fields not tagged with ksql", func(t *testing.T) {
@ -81,11 +80,11 @@ func TestStructToMap(t *testing.T) {
NotPartOfTheQuery: 42,
})
assert.Equal(t, nil, err)
assert.Equal(t, map[string]interface{}{
tt.AssertNoErr(t, err)
tt.AssertEqual(t, m, map[string]interface{}{
"name_attr": "fake-name",
"age_attr": 42,
}, m)
})
})
t.Run("should return error for duplicated ksql tag names", func(t *testing.T) {
@ -99,7 +98,7 @@ func TestStructToMap(t *testing.T) {
DuplicatedName: "fake-duplicated-name",
})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
t.Run("should return error for structs with no ksql tags", func(t *testing.T) {
@ -111,7 +110,7 @@ func TestStructToMap(t *testing.T) {
Age: 42,
})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
}
@ -126,9 +125,9 @@ func TestFillStructWith(t *testing.T) {
"age": 22,
})
assert.Equal(t, nil, err)
assert.Equal(t, "Breno", user.Name)
assert.Equal(t, 22, user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, "Breno")
tt.AssertEqual(t, user.Age, 22)
})
t.Run("should fill ptr fields with ptr values", func(t *testing.T) {
@ -141,9 +140,9 @@ func TestFillStructWith(t *testing.T) {
"age": nullable.Int(22),
})
assert.Equal(t, nil, err)
assert.Equal(t, nullable.String("Breno"), user.Name)
assert.Equal(t, nullable.Int(22), user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, nullable.String("Breno"))
tt.AssertEqual(t, user.Age, nullable.Int(22))
})
t.Run("should fill ptr fields with non-ptr values", func(t *testing.T) {
@ -156,9 +155,9 @@ func TestFillStructWith(t *testing.T) {
"age": 22,
})
assert.Equal(t, nil, err)
assert.Equal(t, nullable.String("Breno"), user.Name)
assert.Equal(t, nullable.Int(22), user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, nullable.String("Breno"))
tt.AssertEqual(t, user.Age, nullable.Int(22))
})
t.Run("should fill non ptr fields with ptr values", func(t *testing.T) {
@ -171,9 +170,9 @@ func TestFillStructWith(t *testing.T) {
"age": nullable.Int(22),
})
assert.Equal(t, nil, err)
assert.Equal(t, "Breno", user.Name)
assert.Equal(t, 22, user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, "Breno")
tt.AssertEqual(t, user.Age, 22)
})
t.Run("should fill ptr fields with nil when necessary", func(t *testing.T) {
@ -186,9 +185,9 @@ func TestFillStructWith(t *testing.T) {
"age": nil,
})
assert.Equal(t, nil, err)
assert.Equal(t, (*string)(nil), user.Name)
assert.Equal(t, (*int)(nil), user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, (*string)(nil))
tt.AssertEqual(t, user.Age, (*int)(nil))
})
t.Run("should interpret nil fields as zero values when necessary", func(t *testing.T) {
@ -204,9 +203,9 @@ func TestFillStructWith(t *testing.T) {
"age": nil,
})
assert.Equal(t, nil, err)
assert.Equal(t, "", user.Name)
assert.Equal(t, 0, user.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, user.Name, "")
tt.AssertEqual(t, user.Age, 0)
})
t.Run("should ignore extra or missing fields", func(t *testing.T) {
@ -295,7 +294,7 @@ func TestFillSliceWith(t *testing.T) {
},
})
tt.AssertEqual(t, err, nil)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, len(users), 3)
tt.AssertEqual(t, users[0].Name, "Jorge")
tt.AssertEqual(t, users[1].Name, "Luciana")

358
test_adapters.go
View File

@ -6,10 +6,8 @@ import (
"encoding/json"
"fmt"
"io"
"strings"
"testing"
"github.com/ditointernet/go-assert"
"github.com/pkg/errors"
tt "github.com/vingarcia/ksql/internal/testtools"
"github.com/vingarcia/ksql/nullable"
@ -318,7 +316,7 @@ func QueryTest(
getUserByName(db, driver, &joao, "João Ribeiro")
_, err = db.ExecContext(ctx, `INSERT INTO users (name, age, address) VALUES ('Bia Ribeiro', 0, '{"country":"BR"}')`)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var bia user
getUserByName(db, driver, &bia, "Bia Ribeiro")
@ -723,15 +721,15 @@ func InsertTest(
}
err := c.Insert(ctx, usersTable, &u)
assert.Equal(t, nil, err)
assert.NotEqual(t, 0, u.ID)
tt.AssertNoErr(t, err)
tt.AssertNotEqual(t, u.ID, 0)
result := user{}
err = getUserByID(c.db, c.dialect, &result, u.ID)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
assert.Equal(t, u.Name, result.Name)
assert.Equal(t, u.Address, result.Address)
tt.AssertEqual(t, result.Name, u.Name)
tt.AssertEqual(t, result.Address, u.Address)
})
t.Run("should insert ignoring the ID with multiple ids", func(t *testing.T) {
@ -758,15 +756,15 @@ func InsertTest(
}
err = c.Insert(ctx, table, &u)
assert.Equal(t, nil, err)
assert.Equal(t, uint(0), u.ID)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, u.ID, uint(0))
result := user{}
err = getUserByName(c.db, driver, &result, "No ID returned")
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
assert.Equal(t, u.Age, result.Age)
assert.Equal(t, u.Address, result.Address)
tt.AssertEqual(t, result.Age, u.Age)
tt.AssertEqual(t, result.Address, u.Address)
})
t.Run("should work with anonymous structs", func(t *testing.T) {
@ -780,7 +778,7 @@ func InsertTest(
Name string `ksql:"name"`
Address map[string]interface{} `ksql:"address,json"`
}{Name: "fake-name", Address: map[string]interface{}{"city": "bar"}})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
})
t.Run("should work with preset IDs", func(t *testing.T) {
@ -796,12 +794,12 @@ func InsertTest(
Name string `ksql:"name"`
Age int `ksql:"age"`
}{Name: "Preset Name", Age: 5455})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var inserted user
err := getUserByName(db, driver, &inserted, "Preset Name")
assert.Equal(t, nil, err)
assert.Equal(t, 5455, inserted.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, inserted.Age, 5455)
})
})
@ -885,27 +883,27 @@ func InsertTest(
c := newTestDB(db, driver)
err = c.Insert(ctx, usersTable, "foo")
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
err = c.Insert(ctx, usersTable, nullable.String("foo"))
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
err = c.Insert(ctx, usersTable, map[string]interface{}{
"name": "foo",
"age": 12,
})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
cantInsertSlice := []interface{}{
&user{Name: "foo", Age: 22},
&user{Name: "bar", Age: 32},
}
err = c.Insert(ctx, usersTable, cantInsertSlice)
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
// We might want to support this in the future, but not for now:
err = c.Insert(ctx, usersTable, user{Name: "not a ptr to user", Age: 42})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
t.Run("should report error if for some reason the insertMethod is invalid", func(t *testing.T) {
@ -919,7 +917,7 @@ func InsertTest(
c.dialect = brokenDialect{}
err = c.Insert(ctx, usersTable, &user{Name: "foo"})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
t.Run("should report error if it receives a nil pointer to a struct", func(t *testing.T) {
@ -931,7 +929,7 @@ func InsertTest(
var u *user
err := c.Insert(ctx, usersTable, u)
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
t.Run("should report error if table contains an empty ID name", func(t *testing.T) {
@ -968,10 +966,8 @@ func InsertTest(
NonExistingColumn int `ksql:"non_existing"`
Name string `ksql:"name"`
}{NonExistingColumn: 42, Name: "fake-name"})
assert.NotEqual(t, nil, err)
msg := err.Error()
assert.Equal(t, true, strings.Contains(msg, "column"))
assert.Equal(t, true, strings.Contains(msg, "non_existing"))
tt.AssertErrContains(t, err, "column", "non_existing")
})
t.Run("should not panic if the ID column doesn't exist in the database", func(t *testing.T) {
@ -1001,13 +997,13 @@ func InsertTest(
Age int `ksql:"age"`
Name string `ksql:"name"`
}{Age: 42, Name: "Inserted With no ID"})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var u user
err = getUserByName(db, driver, &u, "Inserted With no ID")
assert.Equal(t, nil, err)
assert.NotEqual(t, uint(0), u.ID)
assert.Equal(t, 42, u.Age)
tt.AssertNoErr(t, err)
tt.AssertNotEqual(t, u.ID, uint(0))
tt.AssertEqual(t, u.Age, 42)
})
})
})
@ -1083,40 +1079,40 @@ func DeleteTest(
}
err := c.Insert(ctx, usersTable, &u1)
assert.Equal(t, nil, err)
assert.NotEqual(t, uint(0), u1.ID)
tt.AssertNoErr(t, err)
tt.AssertNotEqual(t, u1.ID, uint(0))
result := user{}
err = getUserByID(c.db, c.dialect, &result, u1.ID)
assert.Equal(t, nil, err)
assert.Equal(t, u1.ID, result.ID)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, result.ID, u1.ID)
u2 := user{
Name: "Won't be deleted",
}
err = c.Insert(ctx, usersTable, &u2)
assert.Equal(t, nil, err)
assert.NotEqual(t, uint(0), u2.ID)
tt.AssertNoErr(t, err)
tt.AssertNotEqual(t, u2.ID, uint(0))
result = user{}
err = getUserByID(c.db, c.dialect, &result, u2.ID)
assert.Equal(t, nil, err)
assert.Equal(t, u2.ID, result.ID)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, result.ID, u2.ID)
err = c.Delete(ctx, usersTable, test.deletionKeyForUser(u1))
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
result = user{}
err = getUserByID(c.db, c.dialect, &result, u1.ID)
assert.Equal(t, sql.ErrNoRows, err)
tt.AssertEqual(t, err, sql.ErrNoRows)
result = user{}
err = getUserByID(c.db, c.dialect, &result, u2.ID)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
assert.NotEqual(t, uint(0), result.ID)
assert.Equal(t, "Won't be deleted", result.Name)
tt.AssertNotEqual(t, result.ID, uint(0))
tt.AssertEqual(t, result.Name, "Won't be deleted")
})
}
})
@ -1200,7 +1196,7 @@ func DeleteTest(
c := newTestDB(db, driver)
err = c.Delete(ctx, usersTable, 4200)
assert.Equal(t, ErrRecordNotFound, err)
tt.AssertEqual(t, err, ErrRecordNotFound)
})
t.Run("should report error if it receives a nil pointer to a struct", func(t *testing.T) {
@ -1212,7 +1208,7 @@ func DeleteTest(
var u *user
err := c.Delete(ctx, usersTable, u)
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
t.Run("should report error if one of the ids is missing from the input", func(t *testing.T) {
@ -1361,22 +1357,22 @@ func UpdateTest(
Name: "Letícia",
}
_, err := db.ExecContext(ctx, `INSERT INTO users (name, age) VALUES ('Letícia', 0)`)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
err = getUserByName(db, driver, &u, "Letícia")
assert.Equal(t, nil, err)
assert.NotEqual(t, uint(0), u.ID)
tt.AssertNoErr(t, err)
tt.AssertNotEqual(t, u.ID, uint(0))
err = c.Update(ctx, usersTable, user{
ID: u.ID,
Name: "Thayane",
})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var result user
err = getUserByID(c.db, c.dialect, &result, u.ID)
assert.Equal(t, nil, err)
assert.Equal(t, "Thayane", result.Name)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, result.Name, "Thayane")
})
t.Run("should update one &user{} correctly", func(t *testing.T) {
@ -1390,22 +1386,22 @@ func UpdateTest(
Name: "Letícia",
}
_, err := db.ExecContext(ctx, `INSERT INTO users (name, age) VALUES ('Letícia', 0)`)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
err = getUserByName(db, driver, &u, "Letícia")
assert.Equal(t, nil, err)
assert.NotEqual(t, uint(0), u.ID)
tt.AssertNoErr(t, err)
tt.AssertNotEqual(t, u.ID, uint(0))
err = c.Update(ctx, usersTable, &user{
ID: u.ID,
Name: "Thayane",
})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var result user
err = getUserByID(c.db, c.dialect, &result, u.ID)
assert.Equal(t, nil, err)
assert.Equal(t, "Thayane", result.Name)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, result.Name, "Thayane")
})
t.Run("should ignore null pointers on partial updates", func(t *testing.T) {
@ -1422,12 +1418,12 @@ func UpdateTest(
}
_, err := db.ExecContext(ctx, `INSERT INTO users (name, age) VALUES ('Letícia', 22)`)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var u user
err = getUserByName(db, driver, &u, "Letícia")
assert.Equal(t, nil, err)
assert.NotEqual(t, uint(0), u.ID)
tt.AssertNoErr(t, err)
tt.AssertNotEqual(t, u.ID, uint(0))
err = c.Update(ctx, usersTable, partialUser{
ID: u.ID,
@ -1436,13 +1432,13 @@ func UpdateTest(
// Should not be updated because it is null:
Age: nil,
})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var result user
err = getUserByID(c.db, c.dialect, &result, u.ID)
assert.Equal(t, nil, err)
assert.Equal(t, "", result.Name)
assert.Equal(t, 22, result.Age)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, result.Name, "")
tt.AssertEqual(t, result.Age, 22)
})
t.Run("should update valid pointers on partial updates", func(t *testing.T) {
@ -1459,12 +1455,12 @@ func UpdateTest(
}
_, err := db.ExecContext(ctx, `INSERT INTO users (name, age) VALUES ('Letícia', 22)`)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var u user
err = getUserByName(db, driver, &u, "Letícia")
assert.Equal(t, nil, err)
assert.NotEqual(t, uint(0), u.ID)
tt.AssertNoErr(t, err)
tt.AssertNotEqual(t, u.ID, uint(0))
// Should update all fields:
err = c.Update(ctx, usersTable, partialUser{
@ -1472,14 +1468,14 @@ func UpdateTest(
Name: "Thay",
Age: nullable.Int(42),
})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var result user
err = getUserByID(c.db, c.dialect, &result, u.ID)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
assert.Equal(t, "Thay", result.Name)
assert.Equal(t, 42, result.Age)
tt.AssertEqual(t, result.Name, "Thay")
tt.AssertEqual(t, result.Age, 42)
})
t.Run("should return ErrRecordNotFound when asked to update an inexistent user", func(t *testing.T) {
@ -1493,7 +1489,7 @@ func UpdateTest(
ID: 4200,
Name: "Thayane",
})
assert.Equal(t, ErrRecordNotFound, err)
tt.AssertEqual(t, err, ErrRecordNotFound)
})
t.Run("should report database errors correctly", func(t *testing.T) {
@ -1507,7 +1503,7 @@ func UpdateTest(
ID: 1,
Name: "Thayane",
})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
t.Run("should report error if it receives a nil pointer to a struct", func(t *testing.T) {
@ -1519,7 +1515,7 @@ func UpdateTest(
var u *user
err := c.Update(ctx, usersTable, u)
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
})
}
@ -1581,11 +1577,11 @@ func QueryChunksTest(
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 1, length)
assert.NotEqual(t, uint(0), u.ID)
assert.Equal(t, "User1", u.Name)
assert.Equal(t, "BR", u.Address.Country)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, length, 1)
tt.AssertNotEqual(t, u.ID, uint(0))
tt.AssertEqual(t, u.Name, "User1")
tt.AssertEqual(t, u.Address.Country, "BR")
})
t.Run("should query one chunk correctly", func(t *testing.T) {
@ -1617,17 +1613,17 @@ func QueryChunksTest(
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 1, len(lengths))
assert.Equal(t, 2, lengths[0])
tt.AssertNoErr(t, err)
tt.AssertEqual(t, len(lengths), 1)
tt.AssertEqual(t, lengths[0], 2)
assert.NotEqual(t, uint(0), users[0].ID)
assert.Equal(t, "User1", users[0].Name)
assert.Equal(t, "US", users[0].Address.Country)
tt.AssertNotEqual(t, users[0].ID, uint(0))
tt.AssertEqual(t, users[0].Name, "User1")
tt.AssertEqual(t, users[0].Address.Country, "US")
assert.NotEqual(t, uint(0), users[1].ID)
assert.Equal(t, "User2", users[1].Name)
assert.Equal(t, "BR", users[1].Address.Country)
tt.AssertNotEqual(t, users[1].ID, uint(0))
tt.AssertEqual(t, users[1].Name, "User2")
tt.AssertEqual(t, users[1].Address.Country, "BR")
})
t.Run("should query chunks of 1 correctly", func(t *testing.T) {
@ -1659,17 +1655,17 @@ func QueryChunksTest(
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 2, len(users))
assert.Equal(t, []int{1, 1}, lengths)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, len(users), 2)
tt.AssertEqual(t, lengths, []int{1, 1})
assert.NotEqual(t, uint(0), users[0].ID)
assert.Equal(t, "User1", users[0].Name)
assert.Equal(t, "US", users[0].Address.Country)
tt.AssertNotEqual(t, users[0].ID, uint(0))
tt.AssertEqual(t, users[0].Name, "User1")
tt.AssertEqual(t, users[0].Address.Country, "US")
assert.NotEqual(t, uint(0), users[1].ID)
assert.Equal(t, "User2", users[1].Name)
assert.Equal(t, "BR", users[1].Address.Country)
tt.AssertNotEqual(t, users[1].ID, uint(0))
tt.AssertEqual(t, users[1].Name, "User2")
tt.AssertEqual(t, users[1].Address.Country, "BR")
})
t.Run("should load partially filled chunks correctly", func(t *testing.T) {
@ -1702,15 +1698,15 @@ func QueryChunksTest(
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 3, len(users))
assert.NotEqual(t, uint(0), users[0].ID)
assert.Equal(t, "User1", users[0].Name)
assert.NotEqual(t, uint(0), users[1].ID)
assert.Equal(t, "User2", users[1].Name)
assert.NotEqual(t, uint(0), users[2].ID)
assert.Equal(t, "User3", users[2].Name)
assert.Equal(t, []int{2, 1}, lengths)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, len(users), 3)
tt.AssertNotEqual(t, users[0].ID, uint(0))
tt.AssertEqual(t, users[0].Name, "User1")
tt.AssertNotEqual(t, users[1].ID, uint(0))
tt.AssertEqual(t, users[1].Name, "User2")
tt.AssertNotEqual(t, users[2].ID, uint(0))
tt.AssertEqual(t, users[2].Name, "User3")
tt.AssertEqual(t, lengths, []int{2, 1})
})
// xxx
@ -1738,11 +1734,11 @@ func QueryChunksTest(
_ = c.Insert(ctx, usersTable, &thatiana)
_, err := db.ExecContext(ctx, fmt.Sprint(`INSERT INTO posts (user_id, title) VALUES (`, thatiana.ID, `, 'Thatiana Post1')`))
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
_, err = db.ExecContext(ctx, fmt.Sprint(`INSERT INTO posts (user_id, title) VALUES (`, thatiana.ID, `, 'Thatiana Post2')`))
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
_, err = db.ExecContext(ctx, fmt.Sprint(`INSERT INTO posts (user_id, title) VALUES (`, joao.ID, `, 'Thiago Post1')`))
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var lengths []int
var users []user
@ -1769,20 +1765,20 @@ func QueryChunksTest(
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 3, len(posts))
tt.AssertNoErr(t, err)
tt.AssertEqual(t, len(posts), 3)
assert.Equal(t, joao.ID, users[0].ID)
assert.Equal(t, "Thiago Ribeiro", users[0].Name)
assert.Equal(t, "Thiago Post1", posts[0].Title)
tt.AssertEqual(t, users[0].ID, joao.ID)
tt.AssertEqual(t, users[0].Name, "Thiago Ribeiro")
tt.AssertEqual(t, posts[0].Title, "Thiago Post1")
assert.Equal(t, thatiana.ID, users[1].ID)
assert.Equal(t, "Thatiana Ribeiro", users[1].Name)
assert.Equal(t, "Thatiana Post1", posts[1].Title)
tt.AssertEqual(t, users[1].ID, thatiana.ID)
tt.AssertEqual(t, users[1].Name, "Thatiana Ribeiro")
tt.AssertEqual(t, posts[1].Title, "Thatiana Post1")
assert.Equal(t, thatiana.ID, users[2].ID)
assert.Equal(t, "Thatiana Ribeiro", users[2].Name)
assert.Equal(t, "Thatiana Post2", posts[2].Title)
tt.AssertEqual(t, users[2].ID, thatiana.ID)
tt.AssertEqual(t, users[2].Name, "Thatiana Ribeiro")
tt.AssertEqual(t, posts[2].Title, "Thatiana Post2")
})
t.Run("should abort the first iteration when the callback returns an ErrAbortIteration", func(t *testing.T) {
@ -1815,13 +1811,13 @@ func QueryChunksTest(
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 2, len(users))
assert.NotEqual(t, uint(0), users[0].ID)
assert.Equal(t, "User1", users[0].Name)
assert.NotEqual(t, uint(0), users[1].ID)
assert.Equal(t, "User2", users[1].Name)
assert.Equal(t, []int{2}, lengths)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, len(users), 2)
tt.AssertNotEqual(t, users[0].ID, uint(0))
tt.AssertEqual(t, users[0].Name, "User1")
tt.AssertNotEqual(t, users[1].ID, uint(0))
tt.AssertEqual(t, users[1].Name, "User2")
tt.AssertEqual(t, lengths, []int{2})
})
t.Run("should abort the last iteration when the callback returns an ErrAbortIteration", func(t *testing.T) {
@ -1856,15 +1852,15 @@ func QueryChunksTest(
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 3, len(users))
assert.NotEqual(t, uint(0), users[0].ID)
assert.Equal(t, "User1", users[0].Name)
assert.NotEqual(t, uint(0), users[1].ID)
assert.Equal(t, "User2", users[1].Name)
assert.NotEqual(t, uint(0), users[2].ID)
assert.Equal(t, "User3", users[2].Name)
assert.Equal(t, []int{2, 1}, lengths)
tt.AssertNoErr(t, err)
tt.AssertEqual(t, len(users), 3)
tt.AssertNotEqual(t, users[0].ID, uint(0))
tt.AssertEqual(t, users[0].Name, "User1")
tt.AssertNotEqual(t, users[1].ID, uint(0))
tt.AssertEqual(t, users[1].Name, "User2")
tt.AssertNotEqual(t, users[2].ID, uint(0))
tt.AssertEqual(t, users[2].Name, "User3")
tt.AssertEqual(t, lengths, []int{2, 1})
})
t.Run("should return error if the callback returns an error in the first iteration", func(t *testing.T) {
@ -1897,13 +1893,13 @@ func QueryChunksTest(
},
})
assert.NotEqual(t, nil, err)
assert.Equal(t, 2, len(users))
assert.NotEqual(t, uint(0), users[0].ID)
assert.Equal(t, "User1", users[0].Name)
assert.NotEqual(t, uint(0), users[1].ID)
assert.Equal(t, "User2", users[1].Name)
assert.Equal(t, []int{2}, lengths)
tt.AssertNotEqual(t, err, nil)
tt.AssertEqual(t, len(users), 2)
tt.AssertNotEqual(t, users[0].ID, uint(0))
tt.AssertEqual(t, users[0].Name, "User1")
tt.AssertNotEqual(t, users[1].ID, uint(0))
tt.AssertEqual(t, users[1].Name, "User2")
tt.AssertEqual(t, lengths, []int{2})
})
t.Run("should return error if the callback returns an error in the last iteration", func(t *testing.T) {
@ -1938,15 +1934,15 @@ func QueryChunksTest(
},
})
assert.NotEqual(t, nil, err)
assert.Equal(t, 3, len(users))
assert.NotEqual(t, uint(0), users[0].ID)
assert.Equal(t, "User1", users[0].Name)
assert.NotEqual(t, uint(0), users[1].ID)
assert.Equal(t, "User2", users[1].Name)
assert.NotEqual(t, uint(0), users[2].ID)
assert.Equal(t, "User3", users[2].Name)
assert.Equal(t, []int{2, 1}, lengths)
tt.AssertNotEqual(t, err, nil)
tt.AssertEqual(t, len(users), 3)
tt.AssertNotEqual(t, users[0].ID, uint(0))
tt.AssertEqual(t, users[0].Name, "User1")
tt.AssertNotEqual(t, users[1].ID, uint(0))
tt.AssertEqual(t, users[1].Name, "User2")
tt.AssertNotEqual(t, users[2].ID, uint(0))
tt.AssertEqual(t, users[2].Name, "User3")
tt.AssertEqual(t, lengths, []int{2, 1})
})
t.Run("should report error if the input function is invalid", func(t *testing.T) {
@ -1989,7 +1985,7 @@ func QueryChunksTest(
ChunkSize: 2,
ForEachChunk: fn,
})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
}
})
@ -2008,7 +2004,7 @@ func QueryChunksTest(
return nil
},
})
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
t.Run("should report error if using nested struct and the query starts with SELECT", func(t *testing.T) {
@ -2031,9 +2027,7 @@ func QueryChunksTest(
},
})
assert.NotEqual(t, nil, err)
assert.Equal(t, true, strings.Contains(err.Error(), "nested struct"), "unexpected error msg: "+err.Error())
assert.Equal(t, true, strings.Contains(err.Error(), "feature"), "unexpected error msg: "+err.Error())
tt.AssertErrContains(t, err, "nested struct", "feature")
})
})
}
@ -2069,11 +2063,11 @@ func TransactionTest(
db.Query(ctx, &users, "SELECT * FROM users ORDER BY id ASC")
return nil
})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
assert.Equal(t, 2, len(users))
assert.Equal(t, "User1", users[0].Name)
assert.Equal(t, "User2", users[1].Name)
tt.AssertEqual(t, len(users), 2)
tt.AssertEqual(t, users[0].Name, "User1")
tt.AssertEqual(t, users[1].Name, "User2")
})
t.Run("should rollback when there are errors", func(t *testing.T) {
@ -2095,22 +2089,22 @@ func TransactionTest(
err = c.Transaction(ctx, func(db Provider) error {
err = db.Insert(ctx, usersTable, &user{Name: "User3"})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
err = db.Insert(ctx, usersTable, &user{Name: "User4"})
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
_, err = db.Exec(ctx, "UPDATE users SET age = 22")
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
return errors.New("fake-error")
})
assert.NotEqual(t, nil, err)
assert.Equal(t, "fake-error", err.Error())
tt.AssertNotEqual(t, err, nil)
tt.AssertEqual(t, err.Error(), "fake-error")
var users []user
err = c.Query(ctx, &users, "SELECT * FROM users ORDER BY id ASC")
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
assert.Equal(t, []user{u1, u2}, users)
tt.AssertEqual(t, users, []user{u1, u2})
})
})
}
@ -2140,17 +2134,17 @@ func ScanRowsTest(
_ = c.Insert(ctx, usersTable, &user{Name: "User3", Age: 43})
rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE name='User2'")
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
defer rows.Close()
assert.Equal(t, true, rows.Next())
tt.AssertEqual(t, rows.Next(), true)
var u user
err = scanRows(dialect, rows, &u)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
assert.Equal(t, "User2", u.Name)
assert.Equal(t, 14, u.Age)
tt.AssertEqual(t, u.Name, "User2")
tt.AssertEqual(t, u.Age, 14)
})
t.Run("should ignore extra columns from query", func(t *testing.T) {
@ -2167,10 +2161,10 @@ func ScanRowsTest(
_ = c.Insert(ctx, usersTable, &user{Name: "User1", Age: 22})
rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE name='User1'")
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
defer rows.Close()
assert.Equal(t, true, rows.Next())
tt.AssertEqual(t, rows.Next(), true)
var u struct {
ID int `ksql:"id"`
@ -2180,9 +2174,9 @@ func ScanRowsTest(
// Name string `ksql:"name"`
}
err = scanRows(dialect, rows, &u)
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
assert.Equal(t, 22, u.Age)
tt.AssertEqual(t, u.Age, 22)
})
t.Run("should report error for closed rows", func(t *testing.T) {
@ -2197,13 +2191,13 @@ func ScanRowsTest(
defer closer.Close()
rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE name='User2'")
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
var u user
err = rows.Close()
assert.Equal(t, nil, err)
tt.AssertNoErr(t, err)
err = scanRows(dialect, rows, &u)
assert.NotEqual(t, nil, err)
tt.AssertNotEqual(t, err, nil)
})
t.Run("should report if record is not a pointer", func(t *testing.T) {