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

Update TestQueryChunks() to work with postgres

pull/2/head
Vinícius Garcia 2020-12-30 12:39:01 -03:00
parent 995ccd680c
commit 45380718f5
1 changed files with 236 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

468
kiss_orm_test.go
View File

@ -623,240 +623,244 @@ func TestStructToMap(t *testing.T) {
}
func TestQueryChunks(t *testing.T) {
t.Run("should query a single row correctly", func(t *testing.T) {
err := createTable("sqlite3")
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, "sqlite3")
defer db.Close()
ctx := context.Background()
c := newTestClient(db, "sqlite3", "users")
_ = c.Insert(ctx, &User{Name: "User1"})
var length int
var u User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name = ?;`,
Params: []interface{}{"User1"},
ChunkSize: 100,
ForEachChunk: func(users []User) error {
length = len(users)
if length > 0 {
u = users[0]
for _, driver := range []string{"sqlite3", "postgres"} {
t.Run(driver, func(t *testing.T) {
t.Run("should query a single row correctly", func(t *testing.T) {
err := createTable(driver)
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
return nil
},
db := connectDB(t, driver)
defer db.Close()
ctx := context.Background()
c := newTestClient(db, driver, "users")
_ = c.Insert(ctx, &User{Name: "User1"})
var length int
var u User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name = ` + c.dialect.Placeholder(0),
Params: []interface{}{"User1"},
ChunkSize: 100,
ForEachChunk: func(users []User) error {
length = len(users)
if length > 0 {
u = users[0]
}
return nil
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 1, length)
assert.NotEqual(t, uint(0), u.ID)
assert.Equal(t, "User1", u.Name)
})
t.Run("should query one chunk correctly", func(t *testing.T) {
err := createTable(driver)
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, driver)
defer db.Close()
ctx := context.Background()
c := newTestClient(db, driver, "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ` + c.dialect.Placeholder(0) + ` order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 2,
ForEachChunk: func(buffer []User) error {
users = append(users, buffer...)
lengths = append(lengths, len(buffer))
return nil
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 1, len(lengths))
assert.Equal(t, 2, lengths[0])
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)
})
t.Run("should query chunks of 1 correctly", func(t *testing.T) {
err := createTable(driver)
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, driver)
defer db.Close()
ctx := context.Background()
c := newTestClient(db, driver, "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ` + c.dialect.Placeholder(0) + ` order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 1,
ForEachChunk: func(buffer []User) error {
lengths = append(lengths, len(buffer))
users = append(users, buffer...)
return nil
},
})
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{1, 1}, lengths)
})
t.Run("should load partially filled chunks correctly", func(t *testing.T) {
err := createTable(driver)
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, driver)
defer db.Close()
ctx := context.Background()
c := newTestClient(db, driver, "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
_ = c.Insert(ctx, &User{Name: "User3"})
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ` + c.dialect.Placeholder(0) + ` order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 2,
ForEachChunk: func(buffer []User) error {
lengths = append(lengths, len(buffer))
users = append(users, buffer...)
return nil
},
})
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)
})
t.Run("should abort the first iteration when the callback returns an ErrAbortIteration", func(t *testing.T) {
err := createTable(driver)
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, driver)
defer db.Close()
ctx := context.Background()
c := newTestClient(db, driver, "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
_ = c.Insert(ctx, &User{Name: "User3"})
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ` + c.dialect.Placeholder(0) + ` order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 2,
ForEachChunk: func(buffer []User) error {
lengths = append(lengths, len(buffer))
users = append(users, buffer...)
return ErrAbortIteration
},
})
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)
})
t.Run("should abort the last iteration when the callback returns an ErrAbortIteration", func(t *testing.T) {
err := createTable(driver)
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, driver)
defer db.Close()
ctx := context.Background()
c := newTestClient(db, driver, "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
_ = c.Insert(ctx, &User{Name: "User3"})
returnVals := []error{nil, ErrAbortIteration}
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ` + c.dialect.Placeholder(0) + ` order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 2,
ForEachChunk: func(buffer []User) error {
lengths = append(lengths, len(buffer))
users = append(users, buffer...)
return shiftErrSlice(&returnVals)
},
})
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)
})
})
assert.Equal(t, nil, err)
assert.Equal(t, 1, length)
assert.NotEqual(t, uint(0), u.ID)
assert.Equal(t, "User1", u.Name)
})
t.Run("should query one chunk correctly", func(t *testing.T) {
err := createTable("sqlite3")
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, "sqlite3")
defer db.Close()
ctx := context.Background()
c := newTestClient(db, "sqlite3", "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ? order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 2,
ForEachChunk: func(buffer []User) error {
users = append(users, buffer...)
lengths = append(lengths, len(buffer))
return nil
},
})
assert.Equal(t, nil, err)
assert.Equal(t, 1, len(lengths))
assert.Equal(t, 2, lengths[0])
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)
})
t.Run("should query chunks of 1 correctly", func(t *testing.T) {
err := createTable("sqlite3")
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, "sqlite3")
defer db.Close()
ctx := context.Background()
c := newTestClient(db, "sqlite3", "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ? order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 1,
ForEachChunk: func(buffer []User) error {
lengths = append(lengths, len(buffer))
users = append(users, buffer...)
return nil
},
})
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{1, 1}, lengths)
})
t.Run("should load partially filled chunks correctly", func(t *testing.T) {
err := createTable("sqlite3")
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, "sqlite3")
defer db.Close()
ctx := context.Background()
c := newTestClient(db, "sqlite3", "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
_ = c.Insert(ctx, &User{Name: "User3"})
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ? order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 2,
ForEachChunk: func(buffer []User) error {
lengths = append(lengths, len(buffer))
users = append(users, buffer...)
return nil
},
})
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)
})
t.Run("should abort the first iteration when the callback returns an ErrAbortIteration", func(t *testing.T) {
err := createTable("sqlite3")
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, "sqlite3")
defer db.Close()
ctx := context.Background()
c := newTestClient(db, "sqlite3", "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
_ = c.Insert(ctx, &User{Name: "User3"})
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ? order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 2,
ForEachChunk: func(buffer []User) error {
lengths = append(lengths, len(buffer))
users = append(users, buffer...)
return ErrAbortIteration
},
})
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)
})
t.Run("should abort the last iteration when the callback returns an ErrAbortIteration", func(t *testing.T) {
err := createTable("sqlite3")
if err != nil {
t.Fatal("could not create test table!, reason:", err.Error())
}
db := connectDB(t, "sqlite3")
defer db.Close()
ctx := context.Background()
c := newTestClient(db, "sqlite3", "users")
_ = c.Insert(ctx, &User{Name: "User1"})
_ = c.Insert(ctx, &User{Name: "User2"})
_ = c.Insert(ctx, &User{Name: "User3"})
returnVals := []error{nil, ErrAbortIteration}
var lengths []int
var users []User
err = c.QueryChunks(ctx, ChunkParser{
Query: `select * from users where name like ? order by name asc;`,
Params: []interface{}{"User%"},
ChunkSize: 2,
ForEachChunk: func(buffer []User) error {
lengths = append(lengths, len(buffer))
users = append(users, buffer...)
return shiftErrSlice(&returnVals)
},
})
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)
})
}
}
func TestFillSliceWith(t *testing.T) {