func (me *datasetTest) TestScanStructs_WithPreparedStatements() {
t := me.T()
mDb, mock, err := sqlmock.New()
assert.NoError(t, err)
mock.ExpectQuery(`SELECT "address", "name" FROM "items" WHERE \(\("address" = \?\) AND \("name" IN \(\?, \?, \?\)\)\)`).
WithArgs("111 Test Addr", "Bob", "Sally", "Billy").
WillReturnRows(sqlmock.NewRows([]string{"address", "name"}).FromCSVString("111 Test Addr,Test1\n211 Test Addr,Test2"))
mock.ExpectQuery(`SELECT "test" FROM "items" WHERE \(\("address" = \?\) AND \("name" IN \(\?, \?, \?\)\)\)`).
WithArgs("111 Test Addr", "Bob", "Sally", "Billy").
WillReturnRows(sqlmock.NewRows([]string{"test"}).FromCSVString("test1\ntest2"))
db := New("mock", mDb)
var items []dsTestActionItem
assert.NoError(t, db.From("items").Prepared(true).Where(Ex{"name": []string{"Bob", "Sally", "Billy"}, "address": "111 Test Addr"}).ScanStructs(&items))
assert.Len(t, items, 2)
assert.Equal(t, items[0].Address, "111 Test Addr")
assert.Equal(t, items[0].Name, "Test1")
assert.Equal(t, items[1].Address, "211 Test Addr")
assert.Equal(t, items[1].Name, "Test2")
items = items[0:0]
assert.EqualError(t, db.From("items").ScanStructs(items), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, db.From("items").ScanStructs(&dsTestActionItem{}), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, db.From("items").
Prepared(true).
Select("test").
Where(Ex{"name": []string{"Bob", "Sally", "Billy"}, "address": "111 Test Addr"}).
ScanStructs(&items), `goqu: Unable to find corresponding field to column "test" returned by query`)
}
func (me *postgresTest) TestInsertReturning() {
t := me.T()
ds := me.db.From("entry")
now := time.Now()
e := entry{Int: 10, Float: 1.000000, String: "1.000000", Time: now, Bool: true, Bytes: []byte("1.000000")}
found, err := ds.Returning(goqu.Star()).Insert(e).ScanStruct(&e)
assert.NoError(t, err)
assert.True(t, found)
assert.True(t, e.Id > 0)
var ids []uint32
assert.NoError(t, ds.Returning("id").Insert([]entry{
{Int: 11, Float: 1.100000, String: "1.100000", Time: now, Bool: false, Bytes: []byte("1.100000")},
{Int: 12, Float: 1.200000, String: "1.200000", Time: now, Bool: true, Bytes: []byte("1.200000")},
{Int: 13, Float: 1.300000, String: "1.300000", Time: now, Bool: false, Bytes: []byte("1.300000")},
{Int: 14, Float: 1.400000, String: "1.400000", Time: now, Bool: true, Bytes: []byte("1.400000")},
}).ScanVals(&ids))
assert.Len(t, ids, 4)
for _, id := range ids {
assert.True(t, id > 0)
}
var ints []int64
assert.NoError(t, ds.Returning("int").Insert(
entry{Int: 15, Float: 1.500000, String: "1.500000", Time: now, Bool: false, Bytes: []byte("1.500000")},
entry{Int: 16, Float: 1.600000, String: "1.600000", Time: now, Bool: true, Bytes: []byte("1.600000")},
entry{Int: 17, Float: 1.700000, String: "1.700000", Time: now, Bool: false, Bytes: []byte("1.700000")},
entry{Int: 18, Float: 1.800000, String: "1.800000", Time: now, Bool: true, Bytes: []byte("1.800000")},
).ScanVals(&ints))
assert.True(t, found)
assert.Equal(t, ints, []int64{15, 16, 17, 18})
}
func (me *databaseTest) TestScanStructs() {
t := me.T()
mDb, mock, err := sqlmock.New()
assert.NoError(t, err)
mock.ExpectQuery(`SELECT \* FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"address", "name"}).FromCSVString("111 Test Addr,Test1\n211 Test Addr,Test2"))
mock.ExpectQuery(`SELECT "test" FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"test"}).FromCSVString("test1\ntest2"))
db := New("db-mock", mDb)
var items []testActionItem
assert.NoError(t, db.ScanStructs(&items, `SELECT * FROM "items"`))
assert.Len(t, items, 2)
assert.Equal(t, items[0].Address, "111 Test Addr")
assert.Equal(t, items[0].Name, "Test1")
assert.Equal(t, items[1].Address, "211 Test Addr")
assert.Equal(t, items[1].Name, "Test2")
items = items[0:0]
assert.EqualError(t, db.ScanStructs(items, `SELECT * FROM "items"`), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, db.ScanStructs(&testActionItem{}, `SELECT * FROM "items"`), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, db.ScanStructs(&items, `SELECT "test" FROM "items"`), `goqu: Unable to find corresponding field to column "test" returned by query`)
}
func (me *crudExecTest) TestScanVals() {
t := me.T()
mDb, mock, err := sqlmock.New()
assert.NoError(t, err)
mock.ExpectQuery(`SELECT "id" FROM "items"`).
WillReturnError(fmt.Errorf("query error"))
mock.ExpectQuery(`SELECT "id" FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"id"}).FromCSVString("1\n2"))
mock.ExpectQuery(`SELECT "id" FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"id"}).FromCSVString("1\n2"))
db := New("db-mock", mDb)
exec := newCrudExec(db, nil, `SELECT "id" FROM "items"`)
var id int64
var ids []int64
assert.EqualError(t, exec.ScanVals(ids), "goqu: Type must be a pointer to a slice when calling ScanVals")
assert.EqualError(t, exec.ScanVals(&id), "goqu: Type must be a pointer to a slice when calling ScanVals")
assert.EqualError(t, exec.ScanVals(&ids), "query error")
assert.NoError(t, exec.ScanVals(&ids))
assert.Equal(t, ids, []int64{1, 2})
var pointers []*int64
assert.NoError(t, exec.ScanVals(&pointers))
assert.Len(t, pointers, 2)
assert.Equal(t, *pointers[0], 1)
assert.Equal(t, *pointers[1], 2)
}
func (me *postgresTest) TestInsert() {
t := me.T()
ds := me.db.From("entry")
now := time.Now()
e := entry{Int: 10, Float: 1.000000, String: "1.000000", Time: now, Bool: true, Bytes: []byte("1.000000")}
_, err := ds.Insert(e).Exec()
assert.NoError(t, err)
var insertedEntry entry
found, err := ds.Where(goqu.I("int").Eq(10)).ScanStruct(&insertedEntry)
assert.NoError(t, err)
assert.True(t, found)
assert.True(t, insertedEntry.Id > 0)
entries := []entry{
{Int: 11, Float: 1.100000, String: "1.100000", Time: now, Bool: false, Bytes: []byte("1.100000")},
{Int: 12, Float: 1.200000, String: "1.200000", Time: now, Bool: true, Bytes: []byte("1.200000")},
{Int: 13, Float: 1.300000, String: "1.300000", Time: now, Bool: false, Bytes: []byte("1.300000")},
{Int: 14, Float: 1.400000, String: "1.400000", Time: now, Bool: true, Bytes: []byte("1.400000")},
}
_, err = ds.Insert(entries).Exec()
assert.NoError(t, err)
var newEntries []entry
assert.NoError(t, ds.Where(goqu.I("int").In([]uint32{11, 12, 13, 14})).ScanStructs(&newEntries))
assert.Len(t, newEntries, 4)
_, err = ds.Insert(
entry{Int: 15, Float: 1.500000, String: "1.500000", Time: now, Bool: false, Bytes: []byte("1.500000")},
entry{Int: 16, Float: 1.600000, String: "1.600000", Time: now, Bool: true, Bytes: []byte("1.600000")},
entry{Int: 17, Float: 1.700000, String: "1.700000", Time: now, Bool: false, Bytes: []byte("1.700000")},
entry{Int: 18, Float: 1.800000, String: "1.800000", Time: now, Bool: true, Bytes: []byte("1.800000")},
).Exec()
assert.NoError(t, err)
newEntries = newEntries[0:0]
assert.NoError(t, ds.Where(goqu.I("int").In([]uint32{15, 16, 17, 18})).ScanStructs(&newEntries))
assert.Len(t, newEntries, 4)
}
func (me *databaseTest) TestScanVals() {
t := me.T()
mDb, mock, err := sqlmock.New()
assert.NoError(t, err)
mock.ExpectQuery(`SELECT "id" FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"id"}).FromCSVString("1\n2\n3\n4\n5"))
db := New("mock", mDb)
var ids []uint32
assert.NoError(t, db.ScanVals(&ids, `SELECT "id" FROM "items"`))
assert.Len(t, ids, 5)
assert.EqualError(t, db.ScanVals([]uint32{}, `SELECT "id" FROM "items"`), "goqu: Type must be a pointer to a slice when calling ScanVals")
assert.EqualError(t, db.ScanVals(testActionItem{}, `SELECT "id" FROM "items"`), "goqu: Type must be a pointer to a slice when calling ScanVals")
}
func (me *datasetTest) TestScanVals_WithPreparedStatment() {
t := me.T()
mDb, mock, err := sqlmock.New()
assert.NoError(t, err)
mock.ExpectQuery(`SELECT "id" FROM "items" WHERE \(\("address" = \?\) AND \("name" IN \(\?, \?, \?\)\)\)`).
WithArgs("111 Test Addr", "Bob", "Sally", "Billy").
WillReturnRows(sqlmock.NewRows([]string{"id"}).FromCSVString("1\n2\n3\n4\n5"))
db := New("mock", mDb)
var ids []uint32
assert.NoError(t, db.From("items").
Prepared(true).
Select("id").
Where(Ex{"name": []string{"Bob", "Sally", "Billy"}, "address": "111 Test Addr"}).
ScanVals(&ids))
assert.Len(t, ids, 5)
assert.EqualError(t, db.From("items").ScanVals([]uint32{}), "goqu: Type must be a pointer to a slice when calling ScanVals")
assert.EqualError(t, db.From("items").ScanVals(dsTestActionItem{}), "goqu: Type must be a pointer to a slice when calling ScanVals")
}
func (me *postgresTest) TestQuery() {
t := me.T()
var entries []entry
ds := me.db.From("entry")
assert.NoError(t, ds.Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 10)
floatVal := float64(0)
baseDate, err := time.Parse(time.RFC3339Nano, "2015-02-22T18:19:55.000000000-00:00")
assert.NoError(t, err)
baseDate = baseDate.UTC()
for i, entry := range entries {
f := fmt.Sprintf("%f", floatVal)
assert.Equal(t, entry.Id, uint32(i+1))
assert.Equal(t, entry.Int, i)
assert.Equal(t, fmt.Sprintf("%f", entry.Float), f)
assert.Equal(t, entry.String, f)
assert.Equal(t, entry.Bytes, []byte(f))
assert.Equal(t, entry.Bool, i%2 == 0)
assert.Equal(t, entry.Time.Unix(), baseDate.Add(time.Duration(i)*time.Hour).Unix())
floatVal += float64(0.1)
}
entries = entries[0:0]
assert.NoError(t, ds.Where(goqu.I("bool").IsTrue()).Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 5)
assert.NoError(t, err)
for _, entry := range entries {
assert.True(t, entry.Bool)
}
entries = entries[0:0]
assert.NoError(t, ds.Where(goqu.I("int").Gt(4)).Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 5)
assert.NoError(t, err)
for _, entry := range entries {
assert.True(t, entry.Int > 4)
}
entries = entries[0:0]
assert.NoError(t, ds.Where(goqu.I("int").Gte(5)).Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 5)
assert.NoError(t, err)
for _, entry := range entries {
assert.True(t, entry.Int >= 5)
}
entries = entries[0:0]
assert.NoError(t, ds.Where(goqu.I("int").Lt(5)).Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 5)
assert.NoError(t, err)
for _, entry := range entries {
assert.True(t, entry.Int < 5)
}
entries = entries[0:0]
assert.NoError(t, ds.Where(goqu.I("int").Lte(4)).Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 5)
assert.NoError(t, err)
for _, entry := range entries {
assert.True(t, entry.Int <= 4)
}
entries = entries[0:0]
assert.NoError(t, ds.Where(goqu.I("string").Eq("0.100000")).Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 1)
assert.NoError(t, err)
for _, entry := range entries {
assert.Equal(t, entry.String, "0.100000")
}
entries = entries[0:0]
assert.NoError(t, ds.Where(goqu.I("string").Like("0.1%")).Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 1)
assert.NoError(t, err)
for _, entry := range entries {
assert.Equal(t, entry.String, "0.100000")
}
entries = entries[0:0]
assert.NoError(t, ds.Where(goqu.I("string").NotLike("0.1%")).Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 9)
assert.NoError(t, err)
for _, entry := range entries {
assert.NotEqual(t, entry.String, "0.100000")
}
entries = entries[0:0]
assert.NoError(t, ds.Where(goqu.I("string").IsNull()).Order(goqu.I("id").Asc()).ScanStructs(&entries))
assert.Len(t, entries, 0)
}
// Len asserts that the specified object has specific length.
// Len also fails if the object has a type that len() not accept.
//
// require.Len(t, mySlice, 3, "The size of slice is not 3")
func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) {
if !assert.Len(t, object, length, msgAndArgs...) {
t.FailNow()
}
}
func (me *crudExecTest) TestScanStructs() {
t := me.T()
mDb, mock, err := sqlmock.New()
assert.NoError(t, err)
mock.ExpectQuery(`SELECT \* FROM "items"`).
WillReturnError(fmt.Errorf("query error"))
mock.ExpectQuery(`SELECT \* FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"address", "name"}).FromCSVString("111 Test Addr,Test1\n211 Test Addr,Test2"))
mock.ExpectQuery(`SELECT \* FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"address", "name", "phone_number", "age"}).FromCSVString("111 Test Addr,Test1,111-111-1111,20\n211 Test Addr,Test2,222-222-2222,30"))
mock.ExpectQuery(`SELECT \* FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"address", "name"}).FromCSVString("111 Test Addr,Test1\n211 Test Addr,Test2"))
mock.ExpectQuery(`SELECT \* FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"address", "name", "phone_number", "age"}).FromCSVString("111 Test Addr,Test1,111-111-1111,20\n211 Test Addr,Test2,222-222-2222,30"))
mock.ExpectQuery(`SELECT \* FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"address", "name"}).FromCSVString("111 Test Addr,Test1\n211 Test Addr,Test2"))
db := New("db-mock", mDb)
exec := newCrudExec(db, nil, `SELECT * FROM "items"`)
var items []testCrudActionItem
assert.EqualError(t, exec.ScanStructs(items), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, exec.ScanStructs(&testCrudActionItem{}), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, exec.ScanStructs(&items), "query error")
assert.NoError(t, exec.ScanStructs(&items))
assert.Len(t, items, 2)
assert.Equal(t, items[0].Address, "111 Test Addr")
assert.Equal(t, items[0].Name, "Test1")
assert.Equal(t, items[1].Address, "211 Test Addr")
assert.Equal(t, items[1].Name, "Test2")
var composed []testComposedCrudActionItem
assert.NoError(t, exec.ScanStructs(&composed))
assert.Len(t, composed, 2)
assert.Equal(t, composed[0].Address, "111 Test Addr")
assert.Equal(t, composed[0].Name, "Test1")
assert.Equal(t, composed[0].PhoneNumber, "111-111-1111")
assert.Equal(t, composed[0].Age, 20)
assert.Equal(t, composed[1].Address, "211 Test Addr")
assert.Equal(t, composed[1].Name, "Test2")
assert.Equal(t, composed[1].PhoneNumber, "222-222-2222")
assert.Equal(t, composed[1].Age, 30)
var pointers []*testCrudActionItem
assert.NoError(t, exec.ScanStructs(&pointers))
assert.Len(t, pointers, 2)
assert.Equal(t, pointers[0].Address, "111 Test Addr")
assert.Equal(t, pointers[0].Name, "Test1")
assert.Equal(t, pointers[1].Address, "211 Test Addr")
assert.Equal(t, pointers[1].Name, "Test2")
var composedPointers []*testComposedCrudActionItem
assert.NoError(t, exec.ScanStructs(&composedPointers))
assert.Len(t, composedPointers, 2)
assert.Equal(t, composedPointers[0].Address, "111 Test Addr")
assert.Equal(t, composedPointers[0].Name, "Test1")
assert.Equal(t, composedPointers[0].PhoneNumber, "111-111-1111")
assert.Equal(t, composedPointers[0].Age, 20)
assert.Equal(t, composedPointers[1].Address, "211 Test Addr")
assert.Equal(t, composedPointers[1].Name, "Test2")
assert.Equal(t, composedPointers[1].PhoneNumber, "222-222-2222")
assert.Equal(t, composedPointers[1].Age, 30)
var noTags []testCrudActionNoTagsItem
assert.NoError(t, exec.ScanStructs(&noTags))
assert.Len(t, noTags, 2)
assert.Equal(t, noTags[0].Address, "111 Test Addr")
assert.Equal(t, noTags[0].Name, "Test1")
assert.Equal(t, noTags[1].Address, "211 Test Addr")
assert.Equal(t, noTags[1].Name, "Test2")
}
