// Tests datatype conversions.
func TestDataTypes(t *testing.T) {
var res db.Result
var items []db.Item
sess, err := db.Open(wrapperName, settings)
if err != nil {
t.Fatalf(err.Error())
}
defer sess.Close()
dataTypes := sess.ExistentCollection("data_types")
dataTypes.Truncate()
ids, err := dataTypes.Append(testValues)
if err != nil {
t.Fatalf(err.Error())
}
found, err := dataTypes.Count(db.Cond{"id": db.Id(ids[0])})
if err != nil {
t.Fatalf(err.Error())
}
if found == 0 {
t.Errorf("Expecting an item.")
}
// Getting and reinserting (a db.Item).
item, _ := dataTypes.Find()
_, err = dataTypes.Append(item)
if err == nil {
t.Fatalf("Expecting duplicated-key error.")
}
delete(item, "id")
_, err = dataTypes.Append(item)
if err != nil {
t.Fatalf(err.Error())
}
// Testing date ranges
items, err = dataTypes.FindAll(db.Cond{
"_date": time.Now(),
})
if err != nil {
t.Fatalf(err.Error())
}
if len(items) > 0 {
t.Fatalf("Expecting no results.")
}
items, err = dataTypes.FindAll(db.Cond{
"_date <=": time.Now(),
})
if err != nil {
t.Fatalf(err.Error())
}
if len(items) != 2 {
t.Fatalf("Expecting some results.")
}
// Testing struct
sresults := []testValuesStruct{}
res, err = dataTypes.Query()
if err != nil {
t.Fatalf(err.Error())
}
err = res.All(&sresults)
if err != nil {
t.Fatalf(err.Error())
}
// Testing struct equality
for _, item := range sresults {
if reflect.DeepEqual(item, testValues) == false {
t.Errorf("Struct is different.")
}
}
// Testing maps
results, _ := dataTypes.FindAll()
for _, item := range results {
for key, _ := range item {
switch key {
// Signed integers.
case
"_int",
"_int8",
"_int16",
"_int32",
"_int64":
if to.Int64(item[key]) != testValues.Int64 {
t.Fatalf("Wrong datatype %v.", key)
}
// Unsigned integers.
case
"_uint",
"_uint8",
"_uint16",
"_uint32",
"_uint64":
if to.Uint64(item[key]) != testValues.Uint64 {
t.Fatalf("Wrong datatype %v.", key)
}
// Floating point.
case "_float32":
case "_float64":
if to.Float64(item[key]) != testValues.Float64 {
t.Fatalf("Wrong datatype %v.", key)
}
// Boolean
case "_bool":
if to.Bool(item[key]) != testValues.Bool {
t.Fatalf("Wrong datatype %v.", key)
}
// String
case "_string":
if to.String(item[key]) != testValues.String {
t.Fatalf("Wrong datatype %v.", key)
}
// Date
case "_date":
if to.Time(item[key]).Equal(testValues.Date) == false {
t.Fatalf("Wrong datatype %v.", key)
}
}
}
}
}
// Tries to find and fetch rows.
func TestFind(t *testing.T) {
var err error
var res db.Result
sess, err := db.Open(wrapperName, settings)
if err != nil {
t.Fatalf(err.Error())
}
defer sess.Close()
people, _ := sess.Collection("people")
// Testing Find()
item, _ := people.Find(db.Cond{"name": "José"})
if item["name"] != "José" {
t.Fatalf("Could not find a recently appended item.")
}
// Fetch into map slice.
dst := []map[string]string{}
res, err = people.Query(db.Cond{"name": "José"})
if err != nil {
t.Fatalf(err.Error())
}
err = res.All(&dst)
if err != nil {
t.Fatalf(err.Error())
}
if len(dst) != 1 {
t.Fatalf("Could not find a recently appended item.")
}
if dst[0]["name"] != "José" {
t.Fatalf("Could not find a recently appended item.")
}
// Fetch into struct slice.
dst2 := []struct{ Name string }{}
res, err = people.Query(db.Cond{"name": "José"})
if err != nil {
t.Fatalf(err.Error())
}
err = res.All(&dst2)
if err != nil {
t.Fatalf(err.Error())
}
if len(dst2) != 1 {
t.Fatalf("Could not find a recently appended item.")
}
if dst2[0].Name != "José" {
t.Fatalf("Could not find a recently appended item.")
}
// Fetch into map.
dst3 := map[string]interface{}{}
res, err = people.Query(db.Cond{"name": "José"})
if err != nil {
t.Fatalf(err.Error())
}
err = res.One(&dst3)
if err != nil {
t.Fatalf(err.Error())
}
// Fetch into struct.
dst4 := struct{ Name string }{}
res, err = people.Query(db.Cond{"name": "José"})
if err != nil {
t.Fatalf(err.Error())
}
err = res.One(&dst4)
if err != nil {
t.Fatalf(err.Error())
}
if dst4.Name != "José" {
t.Fatalf("Could not find a recently appended item.")
}
// Makes a query and stores the result
res, err = people.Query(nil)
if err != nil {
t.Fatalf(err.Error())
}
dst5 := struct{ Name string }{}
found := false
for {
err = res.Next(&dst5)
if err != nil {
break
}
if dst5.Name == "José" {
found = true
}
}
res.Close()
if found == false {
t.Fatalf("José was not found.")
}
}
// Tests relations between collections using structs.
func TestRelationStruct(t *testing.T) {
var err error
var res db.Result
sess, err := db.Open(wrapperName, settings)
if err != nil {
t.Errorf(err.Error())
}
defer sess.Close()
people := sess.ExistentCollection("people")
results := []struct {
Id int
Name string
PlaceCodeId int
LivesIn struct {
Name string
}
HasChildren []struct {
Name string
}
HasVisited []struct {
PlaceId int
Place struct {
Name string
}
}
}{}
res, err = people.Query(
db.Relate{
"LivesIn": db.On{
sess.ExistentCollection("places"),
db.Cond{"code_id": "{PlaceCodeId}"},
},
},
db.RelateAll{
"HasChildren": db.On{
sess.ExistentCollection("children"),
db.Cond{"parent_id": "{Id}"},
},
"HasVisited": db.On{
sess.ExistentCollection("visits"),
db.Cond{"person_id": "{Id}"},
db.Relate{
"Place": db.On{
sess.ExistentCollection("places"),
db.Cond{"id": "{PlaceId}"},
},
},
},
},
)
if err != nil {
t.Fatalf(err.Error())
}
err = res.All(&results)
if err != nil {
t.Fatalf(err.Error())
}
fmt.Printf("relations (2) %# v\n", pretty.Formatter(results))
}
// Tries to find and fetch rows.
func TestFind(t *testing.T) {
var err error
var res db.Result
sess, err := db.Open(wrapperName, settings)
if err != nil {
t.Fatalf(err.Error())
}
defer sess.Close()
/*
// Testing simultaneous connection.
sess2, err := db.Open(wrapperName, db.DataSource {
Database: "mysql",
Socket: socket,
User: "******",
})
if err != nil {
t.Fatalf(err.Error())
}
defer sess2.Close()
*/
people, _ := sess.Collection("people")
// Testing Find()
item, _ := people.Find(db.Cond{"name": "José"})
if item["name"] != "José" {
t.Fatalf("Could not find a recently appended item.")
}
// Fetch into map slice.
dst := []map[string]string{}
res, err = people.Query(db.Cond{"name": "José"})
if err != nil {
t.Fatalf(err.Error())
}
err = res.All(&dst)
if err != nil {
t.Fatalf(err.Error())
}
if len(dst) != 1 {
t.Fatalf("Could not find a recently appended item.")
}
if dst[0]["name"] != "José" {
t.Fatalf("Could not find a recently appended item.")
}
// Fetch into struct slice.
dst2 := []struct {
foo string
PersonName string `field:"name"`
none string
}{}
res, err = people.Query(db.Cond{"name": "José"})
if err != nil {
t.Fatalf(err.Error())
}
err = res.All(&dst2)
if err != nil {
t.Fatalf(err.Error())
}
if len(dst2) != 1 {
t.Fatalf("Could not find a recently appended item.")
}
if dst2[0].PersonName != "José" {
t.Fatalf("Could not find a recently appended item.")
}
// Fetch into map.
dst3 := map[string]interface{}{}
res, err = people.Query(db.Cond{"name": "José"})
if err != nil {
t.Fatalf(err.Error())
}
err = res.One(&dst3)
if err != nil {
t.Fatalf(err.Error())
}
// Fetch into struct.
dst4 := struct{ Name string }{}
res, err = people.Query(db.Cond{"name": "José"})
if err != nil {
t.Fatalf(err.Error())
}
err = res.One(&dst4)
if err != nil {
t.Fatalf(err.Error())
}
if dst4.Name != "José" {
t.Fatalf("Could not find a recently appended item.")
}
// Makes a query and stores the result
res, err = people.Query(nil)
if err != nil {
t.Fatalf(err.Error())
}
dst5 := struct {
PersonName string `field:"name"`
}{}
found := false
for {
err = res.Next(&dst5)
if err == nil {
if dst5.PersonName == "José" {
found = true
}
} else if err == db.ErrNoMoreRows {
break
} else {
t.Fatalf(err.Error())
}
}
res.Close()
if found == false {
t.Fatalf("José was not found.")
}
}