func TestMap(t *testing.T) {
m := bson.Map{
"int": int(1),
"int8": int8(2),
"float64": float64(123.456),
"bson": map[string]interface{}{
"i_int": int(10),
},
"array": []interface{}{int(1), float64(123.456), "hello", bson.NewObjectId()},
"objectid": bson.NewObjectId(),
"bool": true,
"null": nil,
"maxkey": bson.MaxKey,
"minkey": bson.MinKey,
"string": "hello",
}
m2 := m.Bson().Map()
if len(m2) != len(m) {
t.Errorf("bson fields num: %d, map fileds num: %d", len(m2), len(m))
}
for k, _ := range m {
_, exist := m2[k]
if !exist {
t.Errorf("bson missing field [%s]", k)
}
}
}
func TestBsonIterator(t *testing.T) {
obj := bson.NewBsonBuilder().AppendString("name", "hello").Finish().Bson()
array := bson.NewBsonArrayBuilder().AppendString("hello").Finish().BsonArray()
var tests = [...]struct {
bsonType bson.BsonType
name string
value interface{}
}{
{bson.BsonTypeFloat64, "double", float64(123.45)},
{bson.BsonTypeString, "string", "hello, bson"},
{bson.BsonTypeBson, "bson", obj},
{bson.BsonTypeArray, "array", array},
{bson.BsonTypeBinary, "binary", bson.Binary{Subtype: bson.BinaryTypeGeneral, Data: []byte("hello")}},
{bson.BsonTypeObjectId, "objectid", bson.NewObjectId()},
{bson.BsonTypeBool, "bool", true},
{bson.BsonTypeDate, "date", bson.Date(12345678)},
{bson.BsonTypeNull, "null", nil},
{bson.BsonTypeRegEx, "regex", bson.RegEx{Pattern: "/s/", Options: "g"}},
{bson.BsonTypeInt32, "int32", int32(100)},
{bson.BsonTypeTimestamp, "timestamp", bson.Timestamp{Second: 123, Increment: 10}},
{bson.BsonTypeInt64, "int64", int64(5000000000)},
{bson.BsonTypeMaxKey, "maxkey", nil},
{bson.BsonTypeMinKey, "minkey", nil},
}
doc := bson.NewBsonBuilder()
for i := 0; i < len(tests); i++ {
test := tests[i]
switch test.bsonType {
case bson.BsonTypeFloat64:
doc.AppendFloat64(test.name, test.value.(float64))
case bson.BsonTypeString:
doc.AppendString(test.name, test.value.(string))
case bson.BsonTypeBson:
doc.AppendBson(test.name, test.value.(*bson.Bson))
case bson.BsonTypeArray:
doc.AppendArray(test.name, test.value.(*bson.BsonArray))
case bson.BsonTypeBinary:
doc.AppendBinary(test.name, test.value.(bson.Binary))
case bson.BsonTypeObjectId:
doc.AppendObjectId(test.name, test.value.(bson.ObjectId))
case bson.BsonTypeBool:
doc.AppendBool(test.name, test.value.(bool))
case bson.BsonTypeDate:
doc.AppendDate(test.name, test.value.(bson.Date))
case bson.BsonTypeNull:
doc.AppendNull(test.name)
case bson.BsonTypeRegEx:
doc.AppendRegex(test.name, test.value.(bson.RegEx))
case bson.BsonTypeInt32:
doc.AppendInt32(test.name, test.value.(int32))
case bson.BsonTypeInt64:
doc.AppendInt64(test.name, test.value.(int64))
case bson.BsonTypeTimestamp:
doc.AppendTimestamp(test.name, test.value.(bson.Timestamp))
case bson.BsonTypeMaxKey:
doc.AppendMaxKey(test.name)
case bson.BsonTypeMinKey:
doc.AppendMinKey(test.name)
default:
t.Fatalf("invalid bson type")
}
}
doc.Finish()
it := doc.Bson().Iterator()
id := 0
for it.Next() {
ts := tests[id]
tp := it.BsonType()
name := it.Name()
id++
if tp != ts.bsonType {
t.Errorf("expected type: %v, actual type: %v", ts.bsonType, tp)
}
if name != ts.name {
t.Errorf("expected name: %v, len=%v; actual name: %v, len=%v",
ts.name, len(ts.name), name, len(name))
}
switch tp {
case bson.BsonTypeFloat64:
val := it.Float64()
if val != ts.value.(float64) {
t.Errorf("double value, expected %v, actual %v", ts.value, val)
}
case bson.BsonTypeString:
val := it.UTF8String()
if val != ts.value.(string) {
t.Errorf("string value, expected %v, actual %v", ts.value, val)
}
case bson.BsonTypeBson:
val := it.Bson()
obj := ts.value.(*bson.Bson)
valIt := val.Iterator()
objIt := obj.Iterator()
for valIt.Next() && objIt.Next() {
if valIt.BsonType() != objIt.BsonType() {
t.Errorf("value type in doc, expected %v, actual %v", objIt.BsonType(), valIt.BsonType())
}
if valIt.Name() != objIt.Name() {
t.Errorf("name in doc, expected %v, actual %v", objIt.Name(), valIt.Name())
}
}
if valIt.More() || objIt.More() {
t.Errorf("invalid it.More()")
}
case bson.BsonTypeArray:
val := it.BsonArray()
obj := ts.value.(*bson.BsonArray)
valIt := val.Iterator()
objIt := obj.Iterator()
for valIt.Next() && objIt.Next() {
if valIt.BsonType() != objIt.BsonType() {
t.Errorf("value type in doc, expected %v, actual %v", objIt.BsonType(), valIt.BsonType())
}
if valIt.Name() != objIt.Name() {
t.Errorf("name in doc, expected %v, actual %v", objIt.Name(), valIt.Name())
}
}
case bson.BsonTypeBinary:
val := it.Binary()
expected := ts.value.(bson.Binary)
if val.Subtype != expected.Subtype {
t.Errorf("binary subtype, expected %v, actual %v", expected.Subtype, val.Subtype)
}
if string(val.Data) != string(expected.Data) {
t.Errorf("binary data, expected %v, actual %v", expected.Data, val.Data)
}
case bson.BsonTypeObjectId:
val := it.ObjectId()
if val != ts.value.(bson.ObjectId) {
t.Errorf("objectid value, expected %v, actual %v", ts.value, val)
}
case bson.BsonTypeBool:
val := it.Bool()
if val != ts.value.(bool) {
t.Errorf("bool value, expected %v, actual %v", ts.value, val)
}
case bson.BsonTypeDate:
val := it.Date()
if val != ts.value.(bson.Date) {
t.Errorf("date value, expected %v, actual %v", ts.value, val)
}
case bson.BsonTypeNull:
// no value
case bson.BsonTypeRegEx:
val := it.RegEx()
expected := ts.value.(bson.RegEx)
if val.Pattern != expected.Pattern || val.Options != expected.Options {
t.Errorf("regex value, expected %v, actual %v", ts.value, val)
}
case bson.BsonTypeInt32:
val := it.Int32()
if val != ts.value.(int32) {
t.Errorf("int32 value, expected %v, actual %v", ts.value, val)
}
case bson.BsonTypeInt64:
val := it.Int64()
if val != ts.value.(int64) {
t.Errorf("int64 value, expected %v, actual %v", ts.value, val)
}
case bson.BsonTypeTimestamp:
val := it.Timestamp()
expected := ts.value.(bson.Timestamp)
if val.Increment != expected.Increment || val.Second != expected.Second {
t.Errorf("timestamp value, expected %v, actual %v", ts.value, val)
}
case bson.BsonTypeMaxKey:
// no value
case bson.BsonTypeMinKey:
// no value
default:
t.Fatalf("invalid bson type")
}
}
if it.More() {
t.Errorf("invalid it.More()")
}
if it.BsonType() != bson.BsonTypeEOD {
t.Errorf("invalid end of iterator")
}
}
func TestObjectId(t *testing.T) {
oid := bson.NewObjectId()
if !oid.IsValid() {
t.Errorf("invalid ObjectId: %s", oid)
}
}