func (s *oplogSuite) TestNewMongoTimestamp(c *gc.C) {
t := time.Date(2015, 6, 24, 12, 47, 0, 0, time.FixedZone("somewhere", 5*3600))
expected := bson.MongoTimestamp(6163845091342417920)
c.Assert(mongo.NewMongoTimestamp(t), gc.Equals, expected)
c.Assert(mongo.NewMongoTimestamp(t.In(time.UTC)), gc.Equals, expected)
}
func (s *oplogSuite) TestHonoursInitialTs(c *gc.C) {
_, session := s.startMongo(c)
t := time.Now()
oplog := s.makeFakeOplog(c, session)
for offset := -1; offset <= 1; offset++ {
tDoc := t.Add(time.Duration(offset) * time.Second)
s.insertDoc(c, session, oplog,
&mongo.OplogDoc{Timestamp: mongo.NewMongoTimestamp(tDoc)},
)
}
tailer := mongo.NewOplogTailer(oplog, nil, t)
defer tailer.Stop()
for offset := 0; offset <= 1; offset++ {
doc := s.getNextOplog(c, tailer)
tExpected := t.Add(time.Duration(offset) * time.Second)
c.Assert(doc.Timestamp, gc.Equals, mongo.NewMongoTimestamp(tExpected))
}
}
func (s *oplogSuite) TestNoRepeatsAfterIterRestart(c *gc.C) {
// A bunch of documents with the same timestamp but different ids.
// These will be split across 2 iterators.
docs := make([]*mongo.OplogDoc, 11)
for i := 0; i < 10; i++ {
id := int64(i + 10)
docs[i] = &mongo.OplogDoc{
Timestamp: 1,
OperationId: id,
}
}
// Add one more with a different timestamp.
docs[10] = &mongo.OplogDoc{
Timestamp: 2,
OperationId: 42,
}
session := newFakeSession(
// First block of documents, all time 1
newFakeIterator(nil, docs[:5]...),
// Second block, some time 1, one time 2
newFakeIterator(nil, docs[5:]...),
)
tailer := mongo.NewOplogTailer(session, time.Time{})
defer tailer.Stop()
for id := int64(10); id < 15; id++ {
doc := s.getNextOplog(c, tailer)
c.Assert(doc.Timestamp, gc.Equals, bson.MongoTimestamp(1))
c.Assert(doc.OperationId, gc.Equals, id)
}
// Check the query doesn't exclude any in the first request.
session.checkLastArgs(c, mongo.NewMongoTimestamp(time.Time{}), nil)
// The OplogTailer will fall off the end of the iterator and get a new one.
// Ensure that only previously unreported entries are now reported.
for id := int64(15); id < 20; id++ {
doc := s.getNextOplog(c, tailer)
c.Assert(doc.Timestamp, gc.Equals, bson.MongoTimestamp(1))
c.Assert(doc.OperationId, gc.Equals, id)
}
// Check we got the next block correctly
session.checkLastArgs(c, bson.MongoTimestamp(1), []int64{10, 11, 12, 13, 14})
doc := s.getNextOplog(c, tailer)
c.Assert(doc.Timestamp, gc.Equals, bson.MongoTimestamp(2))
c.Assert(doc.OperationId, gc.Equals, int64(42))
}
func (s *oplogSuite) TestRestartsOnErrCursor(c *gc.C) {
session := newFakeSession(
// First iterator terminates with an ErrCursor
newFakeIterator(mgo.ErrCursor, &mongo.OplogDoc{Timestamp: 1, OperationId: 99}),
newFakeIterator(nil, &mongo.OplogDoc{Timestamp: 2, OperationId: 42}),
)
tailer := mongo.NewOplogTailer(session, time.Time{})
defer tailer.Stop()
// First, ensure that the tailer is seeing oplog rows and handles
// the ErrCursor that occurs at the end.
doc := s.getNextOplog(c, tailer)
c.Check(doc.Timestamp, gc.Equals, bson.MongoTimestamp(1))
session.checkLastArgs(c, mongo.NewMongoTimestamp(time.Time{}), nil)
// Ensure that the tailer continues after getting a new iterator.
doc = s.getNextOplog(c, tailer)
c.Check(doc.Timestamp, gc.Equals, bson.MongoTimestamp(2))
session.checkLastArgs(c, bson.MongoTimestamp(1), []int64{99})
}
func (s *oplogSuite) TestNewMongoTimestampBeforeUnixEpoch(c *gc.C) {
c.Assert(mongo.NewMongoTimestamp(time.Time{}), gc.Equals, bson.MongoTimestamp(0))
}
