func (s *S) TestSafeInsert(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
coll := session.DB("mydb").C("mycoll")
// Insert an element with a predefined key.
err = coll.Insert(M{"_id": 1})
c.Assert(err, IsNil)
mgo.ResetStats()
// Session should be safe by default, so inserting it again must fail.
err = coll.Insert(M{"_id": 1})
c.Assert(err, Matches, "E11000 duplicate.*")
c.Assert(err.(*mgo.LastError).Code, Equals, 11000)
// It must have sent two operations (INSERT_OP + getLastError QUERY_OP)
stats := mgo.GetStats()
c.Assert(stats.SentOps, Equals, 2)
mgo.ResetStats()
// If we disable safety, though, it won't complain.
session.SetSafe(nil)
err = coll.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Must have sent a single operation this time (just the INSERT_OP)
stats = mgo.GetStats()
c.Assert(stats.SentOps, Equals, 1)
}
func (s *S) TestPrefetching(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
coll := session.DB("mydb").C("mycoll")
docs := make([]interface{}, 200)
for i := 0; i != 200; i++ {
docs[i] = M{"n": i}
}
coll.Insert(docs...)
// Same test three times. Once with prefetching via query, then with the
// default prefetching, and a third time tweaking the default settings in
// the session.
for testi := 0; testi != 3; testi++ {
mgo.ResetStats()
var iter *mgo.Iter
var nextn int
switch testi {
case 0: // First, using query methods.
iter, err = coll.Find(M{}).Prefetch(0.27).Batch(100).Iter()
c.Assert(err, IsNil)
nextn = 73
case 1: // Then, the default session value.
session.SetBatch(100)
iter, err = coll.Find(M{}).Iter()
c.Assert(err, IsNil)
nextn = 75
case 2: // Then, tweaking the session value.
session.SetBatch(100)
session.SetPrefetch(0.27)
iter, err = coll.Find(M{}).Iter()
c.Assert(err, IsNil)
nextn = 73
}
result := struct{ N int }{}
for i := 0; i != nextn; i++ {
iter.Next(&result)
}
stats := mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 100)
iter.Next(&result)
// Ping the database just to wait for the fetch above
// to get delivered.
session.Run("ping", M{}) // XXX Should support nil here.
stats = mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 201) // 200 + the ping result
}
}
func (s *S) SetUpTest(c *C) {
err := run("mongo --nodb testdb/dropall.js")
if err != nil {
panic(err.Error())
}
mgo.SetLogger((*cLogger)(c))
mgo.ResetStats()
}
func (s *S) TestNewSession(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
// Do a dummy operation to wait for connection.
coll := session.DB("mydb").C("mycoll")
err = coll.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Tweak safety and query settings to ensure other has copied those.
session.SetSafe(nil)
session.SetBatch(-1)
other := session.New()
defer other.Close()
session.SetSafe(&mgo.Safe{})
// Clone was copied while session was unsafe, so no errors.
otherColl := other.DB("mydb").C("mycoll")
err = otherColl.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Original session was made safe again.
err = coll.Insert(M{"_id": 1})
c.Assert(err, NotNil)
// With New(), each session has its own socket now.
stats := mgo.GetStats()
c.Assert(stats.MasterConns, Equals, 2)
c.Assert(stats.SocketsInUse, Equals, 2)
// Ensure query parameters were cloned.
err = otherColl.Insert(M{"_id": 2})
c.Assert(err, IsNil)
// Ping the database to ensure the nonce has been received already.
c.Assert(other.Ping(), IsNil)
mgo.ResetStats()
iter := otherColl.Find(M{}).Iter()
c.Assert(err, IsNil)
m := M{}
ok := iter.Next(m)
c.Assert(ok, Equals, true)
err = iter.Err()
c.Assert(err, IsNil)
// If Batch(-1) is in effect, a single document must have been received.
stats = mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 1)
}
func (s *S) TestEnsureIndexCaching(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
coll := session.DB("mydb").C("mycoll")
err = coll.EnsureIndexKey([]string{"a"})
c.Assert(err, IsNil)
mgo.ResetStats()
// Second EnsureIndex should be cached and do nothing.
err = coll.EnsureIndexKey([]string{"a"})
c.Assert(err, IsNil)
stats := mgo.GetStats()
c.Assert(stats.SentOps, Equals, 0)
// Resetting the cache should make it contact the server again.
session.ResetIndexCache()
err = coll.EnsureIndexKey([]string{"a"})
c.Assert(err, IsNil)
stats = mgo.GetStats()
c.Assert(stats.SentOps, Equals, 2)
// Dropping the index should also drop the cached index key.
err = coll.DropIndex([]string{"a"})
c.Assert(err, IsNil)
mgo.ResetStats()
err = coll.EnsureIndexKey([]string{"a"})
c.Assert(err, IsNil)
stats = mgo.GetStats()
c.Assert(stats.SentOps, Equals, 2)
}
func (s *S) TestFindIterLimitWithBatch(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
coll := session.DB("mydb").C("mycoll")
ns := []int{40, 41, 42, 43, 44, 45, 46}
for _, n := range ns {
coll.Insert(M{"n": n})
}
// Ping the database to ensure the nonce has been received already.
c.Assert(session.Ping(), IsNil)
session.Refresh() // Release socket.
mgo.ResetStats()
query := coll.Find(M{"n": M{"$gte": 42}}).Sort(M{"$natural": 1}).Limit(3).Batch(2)
iter, err := query.Iter()
c.Assert(err, IsNil)
result := struct{ N int }{}
for i := 2; i < 5; i++ {
err = iter.Next(&result)
c.Assert(err, IsNil)
c.Assert(result.N, Equals, ns[i])
if i == 3 {
stats := mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 2)
}
}
err = iter.Next(&result)
c.Assert(err == mgo.NotFound, Equals, true)
session.Refresh() // Release socket.
stats := mgo.GetStats()
c.Assert(stats.SentOps, Equals, 2) // 1*QUERY_OP + 1*GET_MORE_OP
c.Assert(stats.ReceivedOps, Equals, 2) // and its REPLY_OPs
c.Assert(stats.ReceivedDocs, Equals, 3)
c.Assert(stats.SocketsInUse, Equals, 0)
}
func (s *S) TestPing(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
// Just ensure the nonce has been received.
result := struct{}{}
err = session.Run("ping", &result)
mgo.ResetStats()
err = session.Ping()
c.Assert(err, IsNil)
// Pretty boring.
stats := mgo.GetStats()
c.Assert(stats.SentOps, Equals, 1)
c.Assert(stats.ReceivedOps, Equals, 1)
}
func (s *S) TestFindForOnIter(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
coll := session.DB("mydb").C("mycoll")
ns := []int{40, 41, 42, 43, 44, 45, 46}
for _, n := range ns {
coll.Insert(M{"n": n})
}
session.Refresh() // Release socket.
mgo.ResetStats()
query := coll.Find(M{"n": M{"$gte": 42}}).Sort(M{"$natural": 1}).Prefetch(0).Batch(2)
iter, err := query.Iter()
c.Assert(err, IsNil)
i := 2
var result *struct{ N int }
err = iter.For(&result, func() os.Error {
c.Assert(i < 7, Equals, true)
c.Assert(result.N, Equals, ns[i])
if i == 1 {
stats := mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 2)
}
i++
return nil
})
c.Assert(err, IsNil)
session.Refresh() // Release socket.
stats := mgo.GetStats()
c.Assert(stats.SentOps, Equals, 3) // 1*QUERY_OP + 2*GET_MORE_OP
c.Assert(stats.ReceivedOps, Equals, 3) // and their REPLY_OPs.
c.Assert(stats.ReceivedDocs, Equals, 5)
c.Assert(stats.SocketsInUse, Equals, 0)
}
func (s *S) TestFindIterLimit(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
coll := session.DB("mydb").C("mycoll")
ns := []int{40, 41, 42, 43, 44, 45, 46}
for _, n := range ns {
coll.Insert(M{"n": n})
}
session.Refresh() // Release socket.
mgo.ResetStats()
query := coll.Find(M{"n": M{"$gte": 42}}).Sort(M{"$natural": 1}).Limit(3)
iter, err := query.Iter()
c.Assert(err, IsNil)
result := struct{ N int }{}
for i := 2; i < 5; i++ {
err = iter.Next(&result)
c.Assert(err, IsNil)
c.Assert(result.N, Equals, ns[i])
}
err = iter.Next(&result)
c.Assert(err == mgo.NotFound, Equals, true)
session.Refresh() // Release socket.
stats := mgo.GetStats()
c.Assert(stats.SentOps, Equals, 1) // 1*QUERY_OP
c.Assert(stats.ReceivedOps, Equals, 1) // and its REPLY_OP
c.Assert(stats.ReceivedDocs, Equals, 3)
c.Assert(stats.SocketsInUse, Equals, 0)
}
// Test tailable cursors in a situation where Next never gets to sleep once
// to respect the timeout requested on Tail.
func (s *S) TestFindTailNoTimeout(c *C) {
if *fast {
c.Skip("-fast")
}
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
cresult := struct{ ErrMsg string }{}
db := session.DB("mydb")
err = db.Run(bson.D{{"create", "mycoll"}, {"capped", true}, {"size", 1024}}, &cresult)
c.Assert(err, IsNil)
c.Assert(cresult.ErrMsg, Equals, "")
coll := db.C("mycoll")
ns := []int{40, 41, 42, 43, 44, 45, 46}
for _, n := range ns {
coll.Insert(M{"n": n})
}
session.Refresh() // Release socket.
mgo.ResetStats()
query := coll.Find(M{"n": M{"$gte": 42}}).Sort(M{"$natural": 1}).Prefetch(0).Batch(2)
iter, err := query.Tail(-1)
c.Assert(err, IsNil)
n := len(ns)
result := struct{ N int }{}
for i := 2; i != n; i++ {
err = iter.Next(&result)
c.Assert(err, IsNil)
c.Assert(result.N, Equals, ns[i])
if i == 3 { // The batch boundary.
stats := mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 2)
}
}
mgo.ResetStats()
// The following call to Next will block.
go func() {
time.Sleep(5e8)
session := session.New()
defer session.Close()
coll := session.DB("mydb").C("mycoll")
coll.Insert(M{"n": 47})
}()
c.Log("Will wait for Next with N=47...")
err = iter.Next(&result)
c.Assert(err, IsNil)
c.Assert(result.N, Equals, 47)
c.Log("Got Next with N=47!")
// The following may break because it depends a bit on the internal
// timing used by MongoDB's AwaitData logic. If it does, the problem
// will be observed as more GET_MORE_OPs than predicted:
// 1*QUERY_OP for nonce + 1*GET_MORE_OP on Next +
// 1*INSERT_OP + 1*QUERY_OP for getLastError on insert of 47
stats := mgo.GetStats()
c.Assert(stats.SentOps, Equals, 4)
c.Assert(stats.ReceivedOps, Equals, 3) // REPLY_OPs for 1*QUERY_OP for nonce + 1*GET_MORE_OPs and 1*QUERY_OP
c.Assert(stats.ReceivedDocs, Equals, 3) // nonce + N=47 result + getLastError response
c.Log("Will wait for a result which will never come...")
gotNext := make(chan os.Error)
go func() {
err := iter.Next(&result)
gotNext <- err
}()
select {
case err := <-gotNext:
c.Fatal("Next returned: " + err.String())
case <-time.After(3e9):
// Good. Should still be sleeping at that point.
}
// Closing the session should cause Next to return.
session.Close()
select {
case err := <-gotNext:
c.Assert(err, Matches, "Closed explicitly")
case <-time.After(1e9):
c.Fatal("Closing the session did not unblock Next")
}
}
// Test tailable cursors in a situation where Next never gets to sleep once
// to respect the timeout requested on Tail.
func (s *S) TestFindTailTimeoutNoSleep(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
cresult := struct{ ErrMsg string }{}
db := session.DB("mydb")
err = db.Run(bson.D{{"create", "mycoll"}, {"capped", true}, {"size", 1024}}, &cresult)
c.Assert(err, IsNil)
c.Assert(cresult.ErrMsg, Equals, "")
coll := db.C("mycoll")
ns := []int{40, 41, 42, 43, 44, 45, 46}
for _, n := range ns {
coll.Insert(M{"n": n})
}
session.Refresh() // Release socket.
mgo.ResetStats()
const timeout = 1
query := coll.Find(M{"n": M{"$gte": 42}}).Sort(M{"$natural": 1}).Prefetch(0).Batch(2)
iter, err := query.Tail(timeout)
c.Assert(err, IsNil)
n := len(ns)
result := struct{ N int }{}
for i := 2; i != n; i++ {
err = iter.Next(&result)
c.Assert(err, IsNil)
c.Assert(result.N, Equals, ns[i])
if i == 3 { // The batch boundary.
stats := mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 2)
}
}
mgo.ResetStats()
// The following call to Next will block.
go func() {
// The internal AwaitData timing of MongoDB is around 2 seconds,
// so this item should arrive within the AwaitData threshold.
time.Sleep(5e8)
session := session.New()
defer session.Close()
coll := session.DB("mydb").C("mycoll")
coll.Insert(M{"n": 47})
}()
c.Log("Will wait for Next with N=47...")
err = iter.Next(&result)
c.Assert(err, IsNil)
c.Assert(result.N, Equals, 47)
c.Log("Got Next with N=47!")
// The following may break because it depends a bit on the internal
// timing used by MongoDB's AwaitData logic. If it does, the problem
// will be observed as more GET_MORE_OPs than predicted:
// 1*QUERY_OP for nonce + 1*GET_MORE_OP on Next +
// 1*INSERT_OP + 1*QUERY_OP for getLastError on insert of 47
stats := mgo.GetStats()
c.Assert(stats.SentOps, Equals, 4)
c.Assert(stats.ReceivedOps, Equals, 3) // REPLY_OPs for 1*QUERY_OP for nonce + 1*GET_MORE_OPs and 1*QUERY_OP
c.Assert(stats.ReceivedDocs, Equals, 3) // nonce + N=47 result + getLastError response
c.Log("Will wait for a result which will never come...")
started := time.Nanoseconds()
err = iter.Next(&result)
c.Assert(time.Nanoseconds()-started > timeout*1e9, Equals, true)
c.Assert(err == mgo.TailTimeout, Equals, true)
}
func (s *S) TestCloneSession(c *C) {
session, err := mgo.Mongo("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
// Do a dummy operation to wait for connection.
coll := session.DB("mydb").C("mycoll")
err = coll.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Tweak safety and query settings to ensure clone is copying those.
session.SetSafe(nil)
session.SetBatch(-1)
clone := session.Clone()
defer clone.Close()
session.SetSafe(&mgo.Safe{})
// Clone was copied while session was unsafe, so no errors.
cloneColl := clone.DB("mydb").C("mycoll")
err = cloneColl.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Original session was made safe again.
err = coll.Insert(M{"_id": 1})
c.Assert(err, NotNil)
// With Clone(), same socket is shared between sessions now.
stats := mgo.GetStats()
c.Assert(stats.SocketsInUse, Equals, 1)
c.Assert(stats.SocketRefs, Equals, 2)
// Refreshing one of them should let the original socket go,
// while preserving the safety settings.
clone.Refresh()
err = cloneColl.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Must have used another connection now.
stats = mgo.GetStats()
c.Assert(stats.SocketsInUse, Equals, 2)
c.Assert(stats.SocketRefs, Equals, 2)
// Ensure query parameters were cloned.
err = cloneColl.Insert(M{"_id": 2})
c.Assert(err, IsNil)
// Ping the database to ensure the nonce has been received already.
c.Assert(clone.Ping(), IsNil)
mgo.ResetStats()
iter := cloneColl.Find(M{}).Iter()
c.Assert(err, IsNil)
m := M{}
ok := iter.Next(m)
c.Assert(ok, Equals, true)
err = iter.Err()
c.Assert(err, IsNil)
// If Batch(-1) is in effect, a single document must have been received.
stats = mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 1)
}