// Attempts to fetch results one by one.
func TestResultFetch(t *testing.T) {
var err error
var res db.Result
var sess db.Database
var artist db.Collection
if sess, err = db.Open(Adapter, settings); err != nil {
t.Fatal(err)
}
defer sess.Close()
if artist, err = sess.Collection("artist"); err != nil {
t.Fatal(err)
}
// Dumping into a map.
rowMap := map[string]interface{}{}
res = artist.Find()
for {
err = res.Next(&rowMap)
if err == db.ErrNoMoreRows {
break
}
if err == nil {
if to.Int64(rowMap["id"]) == 0 {
t.Fatalf("Expecting a not null ID.")
}
if to.String(rowMap["name"]) == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Dumping into an struct with no tags.
rowStruct := struct {
ID uint64
Name string
}{}
res = artist.Find()
for {
err = res.Next(&rowStruct)
if err == db.ErrNoMoreRows {
break
}
if err == nil {
if rowStruct.ID == 0 {
t.Fatalf("Expecting a not null ID.")
}
if rowStruct.Name == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Dumping into a tagged struct.
rowStruct2 := struct {
Value1 uint64 `field:"id"`
Value2 string `field:"name"`
}{}
res = artist.Find()
for {
err = res.Next(&rowStruct2)
if err == db.ErrNoMoreRows {
break
}
if err == nil {
if rowStruct2.Value1 == 0 {
t.Fatalf("Expecting a not null ID.")
}
if rowStruct2.Value2 == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Dumping into an slice of maps.
allRowsMap := []map[string]interface{}{}
res = artist.Find()
if err = res.All(&allRowsMap); err != nil {
t.Fatal(err)
}
if len(allRowsMap) != 4 {
t.Fatalf("Expecting 4 items.")
}
for _, singleRowMap := range allRowsMap {
if to.Int64(singleRowMap["id"]) == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
// Dumping into an slice of structs.
allRowsStruct := []struct {
ID uint64
Name string
}{}
res = artist.Find()
if err = res.All(&allRowsStruct); err != nil {
t.Fatal(err)
}
if len(allRowsStruct) != 4 {
t.Fatalf("Expecting 4 items.")
}
for _, singleRowStruct := range allRowsStruct {
if singleRowStruct.ID == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
// Dumping into an slice of tagged structs.
allRowsStruct2 := []struct {
Value1 uint64 `field:"id"`
Value2 string `field:"name"`
}{}
res = artist.Find()
if err = res.All(&allRowsStruct2); err != nil {
t.Fatal(err)
}
if len(allRowsStruct2) != 4 {
t.Fatalf("Expecting 4 items.")
}
for _, singleRowStruct2 := range allRowsStruct2 {
if singleRowStruct2.Value1 == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
}
func TestFibonacci(t *testing.T) {
var err error
var res db.Result
var total uint64
for _, wrapper := range wrappers {
if settings[wrapper] == nil {
t.Fatalf(`No such settings entry for wrapper %s.`, wrapper)
} else {
var sess db.Database
sess, err = db.Open(wrapper, *settings[wrapper])
if err != nil {
t.Fatalf(`Test for wrapper %s failed: %q`, wrapper, err)
}
defer sess.Close()
var col db.Collection
col, err = sess.Collection("fibonacci")
if err != nil {
if wrapper == `mongo` && err == db.ErrCollectionDoesNotExist {
// Expected error with mongodb.
} else {
t.Fatalf(`Could not use collection with wrapper %s: %q`, wrapper, err)
}
}
// Adding some items.
var i uint64
for i = 0; i < 10; i++ {
item := fibonacci{Input: i, Output: fib(i)}
_, err = col.Append(item)
if err != nil {
t.Fatalf(`Could not append item with wrapper %s: %q`, wrapper, err)
}
}
// Testing sorting by function.
res = col.Find(
// 5, 6, 7, 3
db.Or{
db.And{
db.Cond{"input >=": 5},
db.Cond{"input <=": 7},
},
db.Cond{"input": 3},
},
)
// Testing sort by function.
switch wrapper {
case `postgresql`:
res = res.Sort(db.Raw{`RANDOM()`})
case `sqlite`:
res = res.Sort(db.Raw{`RANDOM()`})
case `mysql`:
res = res.Sort(db.Raw{`RAND()`})
}
total, err = res.Count()
if err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total != 4 {
t.Fatalf("%s: Expecting a count of 4, got %d.", wrapper, total)
}
// Find() with IN/$in
var whereIn db.Cond
switch wrapper {
case `mongo`:
whereIn = db.Cond{"input": db.Func{"$in", []int{3, 5, 6, 7}}}
default:
whereIn = db.Cond{"input": db.Func{"IN", []int{3, 5, 6, 7}}}
}
res = col.Find(whereIn).Sort("input")
total, err = res.Count()
if err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total != 4 {
t.Fatalf(`Expecting a count of 4.`)
}
res = res.Skip(1).Limit(2)
for {
var item fibonacci
err = res.Next(&item)
if err == nil {
switch item.Input {
case 5:
case 6:
if fib(item.Input) != item.Output {
t.Fatalf(`Unexpected value in item with wrapper %s.`, wrapper)
}
default:
t.Fatalf(`Unexpected item: %v with wrapper %s.`, item, wrapper)
}
} else if err == db.ErrNoMoreRows {
break
} else {
t.Fatalf(`%s: %q`, wrapper, err)
}
}
// Find() with range
res = col.Find(
// 5, 6, 7, 3
db.Or{
db.And{
db.Cond{"input >=": 5},
db.Cond{"input <=": 7},
},
db.Cond{"input": 3},
},
).Sort("-input")
if total, err = res.Count(); err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total != 4 {
t.Fatalf(`Expecting a count of 4.`)
}
// Skipping.
res = res.Skip(1).Limit(2)
for {
var item fibonacci
err = res.Next(&item)
if err == nil {
switch item.Input {
case 5:
case 6:
if fib(item.Input) != item.Output {
t.Fatalf(`Unexpected value in item with wrapper %s.`, wrapper)
}
default:
t.Fatalf(`Unexpected item: %v with wrapper %s.`, item, wrapper)
}
} else if err == db.ErrNoMoreRows {
break
} else {
t.Fatalf(`%s: %q`, wrapper, err)
}
}
if err = res.Remove(); err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total, err = res.Count(); err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
if total != 0 {
t.Fatalf(`%s: Unexpected count %d.`, wrapper, total)
}
res = col.Find()
total, err = res.Count()
if total != 6 {
t.Fatalf(`%s: Unexpected count %d.`, wrapper, total)
}
var items []fibonacci
err = res.All(&items)
if err != nil {
t.Fatalf(`%s: %q`, wrapper, err)
}
for _, item := range items {
switch item.Input {
case 0:
case 1:
case 2:
case 4:
case 8:
case 9:
if fib(item.Input) != item.Output {
t.Fatalf(`Unexpected value in item with wrapper %s.`, wrapper)
}
default:
t.Fatalf(`Unexpected item: %v with wrapper %s.`, item, wrapper)
}
}
err = res.Close()
if err != nil {
t.Errorf("Failed to close result %s: %q.", wrapper, err)
}
err = sess.Close()
if err != nil {
t.Errorf("Failed to close %s: %q.", wrapper, err)
}
}
}
}
// This test uses and result and tries to fetch items one by one.
func TestResultFetch(t *testing.T) {
var err error
var res db.Result
// Opening database.
sess, err := db.Open(Adapter, settings)
if err != nil {
t.Fatal(err)
}
// We should close the database when it's no longer in use.
defer sess.Close()
artist, err := sess.Collection("artist")
if err != nil {
t.Fatal(err)
}
// Testing map
res = artist.Find()
row_m := map[string]interface{}{}
for {
err = res.Next(&row_m)
if err == db.ErrNoMoreRows {
// No more row_ms left.
break
}
if err == nil {
if row_m["_id"] == nil {
t.Fatalf("Expecting an ID.")
}
if _, ok := row_m["_id"].(bson.ObjectId); ok != true {
t.Fatalf("Expecting a bson.ObjectId.")
}
if row_m["_id"].(bson.ObjectId).Valid() != true {
t.Fatalf("Expecting a valid bson.ObjectId.")
}
if to.String(row_m["name"]) == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Testing struct
row_s := struct {
Id bson.ObjectId `bson:"_id"`
Name string `bson:"name"`
}{}
res = artist.Find()
for {
err = res.Next(&row_s)
if err == db.ErrNoMoreRows {
// No more row_s' left.
break
}
if err == nil {
if row_s.Id.Valid() == false {
t.Fatalf("Expecting a not null ID.")
}
if row_s.Name == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Testing tagged struct
row_t := struct {
Value1 bson.ObjectId `bson:"_id"`
Value2 string `bson:"name"`
}{}
res = artist.Find()
for {
err = res.Next(&row_t)
if err == db.ErrNoMoreRows {
// No more row_t's left.
break
}
if err == nil {
if row_t.Value1.Valid() == false {
t.Fatalf("Expecting a not null ID.")
}
if row_t.Value2 == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatal(err)
}
}
res.Close()
// Testing Result.All() with a slice of maps.
res = artist.Find()
all_rows_m := []map[string]interface{}{}
err = res.All(&all_rows_m)
if err != nil {
t.Fatal(err)
}
for _, single_row_m := range all_rows_m {
if single_row_m["_id"] == nil {
t.Fatalf("Expecting a not null ID.")
}
}
// Testing Result.All() with a slice of structs.
res = artist.Find()
all_rows_s := []struct {
Id bson.ObjectId `bson:"_id"`
Name string
}{}
err = res.All(&all_rows_s)
if err != nil {
t.Fatal(err)
}
for _, single_row_s := range all_rows_s {
if single_row_s.Id.Valid() == false {
t.Fatalf("Expecting a not null ID.")
}
}
// Testing Result.All() with a slice of tagged structs.
res = artist.Find()
all_rows_t := []struct {
Value1 bson.ObjectId `bson:"_id"`
Value2 string `bson:"name"`
}{}
err = res.All(&all_rows_t)
if err != nil {
t.Fatal(err)
}
for _, single_row_t := range all_rows_t {
if single_row_t.Value1.Valid() == false {
t.Fatalf("Expecting a not null ID.")
}
}
}
// This test uses and result and tries to fetch items one by one.
func TestResultFetch(t *testing.T) {
var err error
var res db.Result
// Opening database.
sess, err := db.Open(wrapperName, settings)
if err != nil {
t.Fatalf(err.Error())
}
// We should close the database when it's no longer in use.
defer sess.Close()
artist, err := sess.Collection("artist")
if err != nil {
t.Fatalf(err.Error())
}
// Testing map
res = artist.Find()
row_m := map[string]interface{}{}
for {
err = res.Next(&row_m)
if err == db.ErrNoMoreRows {
// No more row_ms left.
break
}
if err == nil {
if to.Int64(row_m["id"]) == 0 {
t.Fatalf("Expecting a not null ID.")
}
if to.String(row_m["name"]) == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatalf(err.Error())
}
}
res.Close()
// Testing struct
row_s := struct {
Id uint64
Name string
}{}
res = artist.Find()
for {
err = res.Next(&row_s)
if err == db.ErrNoMoreRows {
// No more row_s' left.
break
}
if err == nil {
if row_s.Id == 0 {
t.Fatalf("Expecting a not null ID.")
}
if row_s.Name == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatalf(err.Error())
}
}
res.Close()
// Testing tagged struct
row_t := struct {
Value1 uint64 `field:"id"`
Value2 string `field:"name"`
}{}
res = artist.Find()
for {
err = res.Next(&row_t)
if err == db.ErrNoMoreRows {
// No more row_t's left.
break
}
if err == nil {
if row_t.Value1 == 0 {
t.Fatalf("Expecting a not null ID.")
}
if row_t.Value2 == "" {
t.Fatalf("Expecting a name.")
}
} else {
t.Fatalf(err.Error())
}
}
res.Close()
// Testing Result.All() with a slice of maps.
res = artist.Find()
all_rows_m := []map[string]interface{}{}
err = res.All(&all_rows_m)
if err != nil {
t.Fatalf(err.Error())
}
for _, single_row_m := range all_rows_m {
if to.Int64(single_row_m["id"]) == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
// Testing Result.All() with a slice of structs.
res = artist.Find()
all_rows_s := []struct {
Id uint64
Name string
}{}
err = res.All(&all_rows_s)
if err != nil {
t.Fatalf(err.Error())
}
for _, single_row_s := range all_rows_s {
if single_row_s.Id == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
// Testing Result.All() with a slice of tagged structs.
res = artist.Find()
all_rows_t := []struct {
Value1 uint64 `field:"id"`
Value2 string `field:"name"`
}{}
err = res.All(&all_rows_t)
if err != nil {
t.Fatalf(err.Error())
}
for _, single_row_t := range all_rows_t {
if single_row_t.Value1 == 0 {
t.Fatalf("Expecting a not null ID.")
}
}
}