TEST(CollectionOptions, MaxTimeMSWhitelistedOptionIgnored) { CollectionOptions options; auto status = options.parse(fromjson("{maxTimeMS: 1}")); ASSERT_OK(status); }
TEST(QueryRequestTest, PositiveBatchSize) { QueryRequest qr(testns); qr.setBatchSize(1); ASSERT_OK(qr.validate()); }
TEST(QueryRequestTest, ZeroNToReturn) { QueryRequest qr(testns); qr.setNToReturn(0); ASSERT_OK(qr.validate()); }
void addIndex(const BSONObj& obj) { ASSERT_OK(dbtests::createIndex(&_txn, ns(), obj)); }
TEST(QueryRequestTest, ParseMaxTimeMSZeroSucceeds) { BSONObj maxTimeObj = BSON(QueryRequest::cmdOptionMaxTimeMS << 0); auto maxTime = QueryRequest::parseMaxTimeMS(maxTimeObj[QueryRequest::cmdOptionMaxTimeMS]); ASSERT_OK(maxTime); ASSERT_EQ(maxTime.getValue(), 0); }
static void test_trailing_spaces_ok(void) { ASSERT_OK("$ENV ", "NV"); }
TEST_F(PropertiesTest, SetString) { // Null key -> unsuccessful set { // Null key -> fails EXPECT_GT(0, property_set(/*key*/NULL, PROPERTY_TEST_VALUE_DEFAULT)); } // Null value -> returns default value { // Null value -> OK , and it clears the value EXPECT_OK(property_set(PROPERTY_TEST_KEY, /*value*/NULL)); ResetValue(); // Since the value is null, default value will be returned size_t len = property_get(PROPERTY_TEST_KEY, mValue, PROPERTY_TEST_VALUE_DEFAULT); EXPECT_EQ(strlen(PROPERTY_TEST_VALUE_DEFAULT), len); EXPECT_STREQ(PROPERTY_TEST_VALUE_DEFAULT, mValue); } // Trivial case => get returns what was set { size_t len = SetAndGetProperty("hello_world"); EXPECT_EQ(strlen("hello_world"), len) << "hello_world key"; EXPECT_STREQ("hello_world", mValue); ResetValue(); } // Set to empty string => get returns default always { const char* EMPTY_STRING_DEFAULT = "EMPTY_STRING"; size_t len = SetAndGetProperty("", EMPTY_STRING_DEFAULT); EXPECT_EQ(strlen(EMPTY_STRING_DEFAULT), len) << "empty key"; EXPECT_STREQ(EMPTY_STRING_DEFAULT, mValue); ResetValue(); } // Set to max length => get returns what was set { std::string maxLengthString = std::string(PROPERTY_VALUE_MAX-1, 'a'); int len = SetAndGetProperty(maxLengthString.c_str()); EXPECT_EQ(PROPERTY_VALUE_MAX-1, len) << "max length key"; EXPECT_STREQ(maxLengthString.c_str(), mValue); ResetValue(); } // Set to max length + 1 => set fails { const char* VALID_TEST_VALUE = "VALID_VALUE"; ASSERT_OK(property_set(PROPERTY_TEST_KEY, VALID_TEST_VALUE)); std::string oneLongerString = std::string(PROPERTY_VALUE_MAX, 'a'); // Expect that the value set fails since it's too long EXPECT_GT(0, property_set(PROPERTY_TEST_KEY, oneLongerString.c_str())); size_t len = property_get(PROPERTY_TEST_KEY, mValue, PROPERTY_TEST_VALUE_DEFAULT); EXPECT_EQ(strlen(VALID_TEST_VALUE), len) << "set should've failed"; EXPECT_STREQ(VALID_TEST_VALUE, mValue); ResetValue(); } }
// Connect to a producer in a 'correct' fashion. // Precondition: Consumer is connected. void ConnectProducer() { ASSERT_OK(TryConnectProducer()); }
TEST_F(IGraphicBufferProducerTest, Disconnect_Succeeds) { ASSERT_NO_FATAL_FAILURE(ConnectProducer()); ASSERT_OK(mProducer->disconnect(TEST_API)); }
TEST(CollectionOptions, CollationFieldLeftEmptyWhenOmitted) { CollectionOptions options; ASSERT_OK(options.parse(fromjson("{validator: {a: 1}}"))); ASSERT_TRUE(options.collation.isEmpty()); }
TEST(CollectionOptions, IgnoreSizeWrongType) { CollectionOptions options; ASSERT_OK(options.parse(fromjson("{size: undefined, capped: undefined}"))); ASSERT_EQUALS(options.capped, false); ASSERT_EQUALS(options.cappedSize, 0); }
TEST(CollectionOptions, ParsedCollationObjShouldBeOwned) { CollectionOptions options; ASSERT_OK(options.parse(fromjson("{collation: {locale: 'en'}}"))); ASSERT_EQ(options.collation, fromjson("{locale: 'en'}")); ASSERT_TRUE(options.collation.isOwned()); }
TEST(CollectionOptions, IgnoreUnregisteredFields) { ASSERT_OK(CollectionOptions().parse(BSON("create" << "c"))); ASSERT_OK(CollectionOptions().parse(BSON("foo" << "bar"))); }
TEST(CollectionOptions, WriteConcernWhitelistedOptionIgnored) { CollectionOptions options; auto status = options.parse(fromjson("{writeConcern: 1}")); ASSERT_OK(status); }
// Insert a record and try to perform an in-place update on it. TEST( RecordStoreTestHarness, UpdateWithDamages ) { scoped_ptr<HarnessHelper> harnessHelper( newHarnessHelper() ); scoped_ptr<RecordStore> rs( harnessHelper->newNonCappedRecordStore() ); if (!rs->updateWithDamagesSupported()) return; { scoped_ptr<OperationContext> opCtx( harnessHelper->newOperationContext() ); ASSERT_EQUALS( 0, rs->numRecords( opCtx.get() ) ); } string data = "00010111"; RecordId loc; const RecordData rec(data.c_str(), data.size() + 1); { scoped_ptr<OperationContext> opCtx( harnessHelper->newOperationContext() ); { WriteUnitOfWork uow( opCtx.get() ); StatusWith<RecordId> res = rs->insertRecord( opCtx.get(), rec.data(), rec.size(), false ); ASSERT_OK( res.getStatus() ); loc = res.getValue(); uow.commit(); } } { scoped_ptr<OperationContext> opCtx( harnessHelper->newOperationContext() ); ASSERT_EQUALS( 1, rs->numRecords( opCtx.get() ) ); } { scoped_ptr<OperationContext> opCtx( harnessHelper->newOperationContext() ); { mutablebson::DamageVector dv( 3 ); dv[0].sourceOffset = 5; dv[0].targetOffset = 0; dv[0].size = 2; dv[1].sourceOffset = 3; dv[1].targetOffset = 2; dv[1].size = 3; dv[2].sourceOffset = 0; dv[2].targetOffset = 5; dv[2].size = 3; WriteUnitOfWork uow( opCtx.get() ); ASSERT_OK( rs->updateWithDamages( opCtx.get(), loc, rec, data.c_str(), dv ) ); uow.commit(); } } data = "11101000"; { scoped_ptr<OperationContext> opCtx( harnessHelper->newOperationContext() ); { RecordData record = rs->dataFor( opCtx.get(), loc ); ASSERT_EQUALS( data, record.data() ); } } }
TEST_F(IGraphicBufferProducerTest, Queue_ReturnsError) { ASSERT_NO_FATAL_FAILURE(ConnectProducer()); // Invalid slot number { // A generic "valid" input IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); IGraphicBufferProducer::QueueBufferOutput output; EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(/*slot*/-1, input, &output)); EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(/*slot*/0xDEADBEEF, input, &output)); EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(BufferQueue::NUM_BUFFER_SLOTS, input, &output)); } // Slot was not in the dequeued state (all slots start out in Free state) { IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); IGraphicBufferProducer::QueueBufferOutput output; EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(/*slot*/0, input, &output)); } // Put the slot into the "dequeued" state for the rest of the test int dequeuedSlot = -1; sp<Fence> dequeuedFence; ASSERT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & (mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT, TEST_PRODUCER_USAGE_BITS))); // Slot was enqueued without requesting a buffer { IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); IGraphicBufferProducer::QueueBufferOutput output; EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); } // Request the buffer so that the rest of the tests don't fail on earlier checks. sp<GraphicBuffer> dequeuedBuffer; ASSERT_OK(mProducer->requestBuffer(dequeuedSlot, &dequeuedBuffer)); // Fence was NULL { sp<Fence> nullFence = NULL; IGraphicBufferProducer::QueueBufferInput input = QueueBufferInputBuilder().setFence(nullFence).build(); IGraphicBufferProducer::QueueBufferOutput output; EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); } // Scaling mode was unknown { IGraphicBufferProducer::QueueBufferInput input = QueueBufferInputBuilder().setScalingMode(-1).build(); IGraphicBufferProducer::QueueBufferOutput output; EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); input = QueueBufferInputBuilder().setScalingMode(0xDEADBEEF).build(); EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); } // Crop rect is out of bounds of the buffer dimensions { IGraphicBufferProducer::QueueBufferInput input = QueueBufferInputBuilder().setCrop(Rect(DEFAULT_WIDTH + 1, DEFAULT_HEIGHT + 1)) .build(); IGraphicBufferProducer::QueueBufferOutput output; EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); } // Abandon the buffer queue so that the last test fails ASSERT_OK(mConsumer->consumerDisconnect()); // The buffer queue has been abandoned. { IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); IGraphicBufferProducer::QueueBufferOutput output; EXPECT_EQ(NO_INIT, mProducer->queueBuffer(dequeuedSlot, input, &output)); } }
static void test_simple_ok(void) { ASSERT_OK("$ENV", "NV"); }
TEST(SSLManager, MongoDBRolesParser) { /* openssl asn1parse -genconf mongodbroles.cnf -out foo.der -------- mongodbroles.cnf -------- asn1 = SET:MongoDBAuthorizationGrant [MongoDBAuthorizationGrant] grant1 = SEQUENCE:MongoDBRole [MongoDBRole] role = UTF8:role_name database = UTF8:Third field */ // Positive: Simple parsing test { unsigned char derData[] = {0x31, 0x1a, 0x30, 0x18, 0x0c, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0c, 0x0b, 0x54, 0x68, 0x69, 0x72, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64}; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_OK(swPeer.getStatus()); auto item = *(swPeer.getValue().begin()); ASSERT_EQ(item.getRole(), "role_name"); ASSERT_EQ(item.getDB(), "Third field"); } // Positive: Very long role_name, and long form lengths { unsigned char derData[] = { 0x31, 0x82, 0x01, 0x3e, 0x30, 0x82, 0x01, 0x3a, 0x0c, 0x82, 0x01, 0x29, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0c, 0x0b, 0x54, 0x68, 0x69, 0x72, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64}; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_OK(swPeer.getStatus()); auto item = *(swPeer.getValue().begin()); ASSERT_EQ(item.getRole(), "role_namerole_namerole_namerole_namerole_namerole_namerole_namerole_namerole_" "namerole_namerole_namerole_namerole_namerole_namerole_namerole_namerole_" "namerole_namerole_namerole_namerole_namerole_namerole_namerole_namerole_" "namerole_namerole_namerole_namerole_namerole_namerole_namerole_namerole_name"); ASSERT_EQ(item.getDB(), "Third field"); } // Negative: Encode MAX_INT64 into a length { unsigned char derData[] = {0x31, 0x88, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x18, 0x0c, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0c, 0x0b, 0x54, 0x68, 0x69, 0x72, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64}; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_NOT_OK(swPeer.getStatus()); } // Negative: Runt, only a tag { unsigned char derData[] = {0x31}; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_NOT_OK(swPeer.getStatus()); } // Negative: Runt, only a tag and short length { unsigned char derData[] = {0x31, 0x0b}; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_NOT_OK(swPeer.getStatus()); } // Negative: Runt, only a tag and long length with wrong missing length { unsigned char derData[] = { 0x31, 0x88, 0xff, 0xff, }; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_NOT_OK(swPeer.getStatus()); } // Negative: Runt, only a tag and long length { unsigned char derData[] = { 0x31, 0x82, 0xff, 0xff, }; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_NOT_OK(swPeer.getStatus()); } // Negative: Single UTF8 String { unsigned char derData[] = { 0x0c, 0x0b, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64}; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_NOT_OK(swPeer.getStatus()); } // Negative: Unknown type - IAString { unsigned char derData[] = { 0x16, 0x0b, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64}; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_NOT_OK(swPeer.getStatus()); } // Positive: two roles { unsigned char derData[] = {0x31, 0x2b, 0x30, 0x0f, 0x0c, 0x06, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x0c, 0x05, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x30, 0x18, 0x0c, 0x0f, 0x72, 0x65, 0x61, 0x64, 0x41, 0x6e, 0x79, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x0c, 0x05, 0x61, 0x64, 0x6d, 0x69, 0x6e}; auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData), std::extent<decltype(derData)>::value)); ASSERT_OK(swPeer.getStatus()); auto roles = getSortedRoles(swPeer.getValue()); ASSERT_EQ(roles[0].getRole(), "backup"); ASSERT_EQ(roles[0].getDB(), "admin"); ASSERT_EQ(roles[1].getRole(), "readAnyDatabase"); ASSERT_EQ(roles[1].getDB(), "admin"); } }
TEST_F(PropertiesTest, GetString) { // Try to use a default value that's too long => get truncates the value { ASSERT_OK(property_set(PROPERTY_TEST_KEY, "")); std::string maxLengthString = std::string(PROPERTY_VALUE_MAX - 1, 'a'); std::string oneLongerString = std::string(PROPERTY_VALUE_MAX, 'a'); // Expect that the value is truncated since it's too long (by 1) int len = property_get(PROPERTY_TEST_KEY, mValue, oneLongerString.c_str()); EXPECT_EQ(PROPERTY_VALUE_MAX - 1, len); EXPECT_STREQ(maxLengthString.c_str(), mValue); ResetValue(); } // Try to use a default value that's the max length => get succeeds { ASSERT_OK(property_set(PROPERTY_TEST_KEY, "")); std::string maxLengthString = std::string(PROPERTY_VALUE_MAX - 1, 'b'); // Expect that the value matches maxLengthString int len = property_get(PROPERTY_TEST_KEY, mValue, maxLengthString.c_str()); EXPECT_EQ(PROPERTY_VALUE_MAX - 1, len); EXPECT_STREQ(maxLengthString.c_str(), mValue); ResetValue(); } // Try to use a default value of length one => get succeeds { ASSERT_OK(property_set(PROPERTY_TEST_KEY, "")); std::string oneCharString = std::string(1, 'c'); // Expect that the value matches oneCharString int len = property_get(PROPERTY_TEST_KEY, mValue, oneCharString.c_str()); EXPECT_EQ(1, len); EXPECT_STREQ(oneCharString.c_str(), mValue); ResetValue(); } // Try to use a default value of length zero => get succeeds { ASSERT_OK(property_set(PROPERTY_TEST_KEY, "")); std::string zeroCharString = std::string(0, 'd'); // Expect that the value matches oneCharString int len = property_get(PROPERTY_TEST_KEY, mValue, zeroCharString.c_str()); EXPECT_EQ(0, len); EXPECT_STREQ(zeroCharString.c_str(), mValue); ResetValue(); } // Try to use a NULL default value => get returns 0 { ASSERT_OK(property_set(PROPERTY_TEST_KEY, "")); // Expect a return value of 0 int len = property_get(PROPERTY_TEST_KEY, mValue, NULL); EXPECT_EQ(0, len); ResetValue(); } }
TEST(KVEngineTestHarness, AllCommittedTimestamp) { unique_ptr<KVHarnessHelper> helper(KVHarnessHelper::create()); KVEngine* engine = helper->getEngine(); if (!engine->supportsDocLocking()) return; unique_ptr<RecordStore> rs; { MyOperationContext opCtx(engine); WriteUnitOfWork uow(&opCtx); CollectionOptions options; options.capped = true; options.cappedSize = 10240; options.cappedMaxDocs = -1; NamespaceString oplogNss("local.oplog.rs"); ASSERT_OK(engine->createRecordStore(&opCtx, oplogNss.ns(), "ident", options)); rs = engine->getRecordStore(&opCtx, oplogNss.ns(), "ident", options); ASSERT(rs); } { Timestamp t11(1, 1); Timestamp t12(1, 2); Timestamp t21(2, 1); auto t11Doc = BSON("ts" << t11); auto t12Doc = BSON("ts" << t12); auto t21Doc = BSON("ts" << t21); Timestamp allCommitted = engine->getAllCommittedTimestamp(); MyOperationContext opCtx1(engine); WriteUnitOfWork uow1(&opCtx1); ASSERT_EQ(invariant(rs->insertRecord( &opCtx1, t11Doc.objdata(), t11Doc.objsize(), Timestamp::min())), RecordId(1, 1)); Timestamp lastAllCommitted = allCommitted; allCommitted = engine->getAllCommittedTimestamp(); ASSERT_GTE(allCommitted, lastAllCommitted); ASSERT_LT(allCommitted, t11); MyOperationContext opCtx2(engine); WriteUnitOfWork uow2(&opCtx2); ASSERT_EQ(invariant(rs->insertRecord( &opCtx2, t21Doc.objdata(), t21Doc.objsize(), Timestamp::min())), RecordId(2, 1)); uow2.commit(); lastAllCommitted = allCommitted; allCommitted = engine->getAllCommittedTimestamp(); ASSERT_GTE(allCommitted, lastAllCommitted); ASSERT_LT(allCommitted, t11); ASSERT_EQ(invariant(rs->insertRecord( &opCtx1, t12Doc.objdata(), t12Doc.objsize(), Timestamp::min())), RecordId(1, 2)); lastAllCommitted = allCommitted; allCommitted = engine->getAllCommittedTimestamp(); ASSERT_GTE(allCommitted, lastAllCommitted); ASSERT_LT(allCommitted, t11); uow1.commit(); lastAllCommitted = allCommitted; allCommitted = engine->getAllCommittedTimestamp(); ASSERT_GTE(allCommitted, lastAllCommitted); ASSERT_LTE(allCommitted, t21); } }
void insert(const BSONObj& doc) { WriteUnitOfWork wunit(&_txn); ASSERT_OK(_coll->insertDocument(&_txn, doc, false)); wunit.commit(); }
TEST(KVCatalogTest, Idx1) { unique_ptr<KVHarnessHelper> helper(KVHarnessHelper::create()); KVEngine* engine = helper->getEngine(); unique_ptr<RecordStore> rs; unique_ptr<KVCatalog> catalog; { MyOperationContext opCtx(engine); WriteUnitOfWork uow(&opCtx); ASSERT_OK(engine->createRecordStore(&opCtx, "catalog", "catalog", CollectionOptions())); rs = engine->getRecordStore(&opCtx, "catalog", "catalog", CollectionOptions()); catalog.reset(new KVCatalog(rs.get(), false, false)); uow.commit(); } { MyOperationContext opCtx(engine); WriteUnitOfWork uow(&opCtx); ASSERT_OK( catalog->newCollection(&opCtx, "a.b", CollectionOptions(), KVPrefix::kNotPrefixed)); ASSERT_NOT_EQUALS("a.b", catalog->getCollectionIdent("a.b")); ASSERT_TRUE(catalog->isUserDataIdent(catalog->getCollectionIdent("a.b"))); uow.commit(); } { MyOperationContext opCtx(engine); WriteUnitOfWork uow(&opCtx); BSONCollectionCatalogEntry::MetaData md; md.ns = "a.b"; BSONCollectionCatalogEntry::IndexMetaData imd; imd.spec = BSON("name" << "foo"); imd.ready = false; imd.head = RecordId(); imd.multikey = false; imd.prefix = KVPrefix::kNotPrefixed; imd.isBackgroundSecondaryBuild = false; md.indexes.push_back(imd); catalog->putMetaData(&opCtx, "a.b", md); uow.commit(); } string idxIndent; { MyOperationContext opCtx(engine); idxIndent = catalog->getIndexIdent(&opCtx, "a.b", "foo"); } { MyOperationContext opCtx(engine); ASSERT_EQUALS(idxIndent, catalog->getIndexIdent(&opCtx, "a.b", "foo")); ASSERT_TRUE(catalog->isUserDataIdent(catalog->getIndexIdent(&opCtx, "a.b", "foo"))); } { MyOperationContext opCtx(engine); WriteUnitOfWork uow(&opCtx); BSONCollectionCatalogEntry::MetaData md; md.ns = "a.b"; catalog->putMetaData(&opCtx, "a.b", md); // remove index BSONCollectionCatalogEntry::IndexMetaData imd; imd.spec = BSON("name" << "foo"); imd.ready = false; imd.head = RecordId(); imd.multikey = false; imd.prefix = KVPrefix::kNotPrefixed; imd.isBackgroundSecondaryBuild = false; md.indexes.push_back(imd); catalog->putMetaData(&opCtx, "a.b", md); uow.commit(); } { MyOperationContext opCtx(engine); ASSERT_NOT_EQUALS(idxIndent, catalog->getIndexIdent(&opCtx, "a.b", "foo")); } }
TEST(QueryRequestTest, ZeroBatchSize) { QueryRequest qr(testns); qr.setBatchSize(0); ASSERT_OK(qr.validate()); }
TEST(KVCatalogTest, RestartForPrefixes) { storageGlobalParams.groupCollections = true; ON_BLOCK_EXIT([&] { storageGlobalParams.groupCollections = false; }); KVPrefix abCollPrefix = KVPrefix::getNextPrefix(NamespaceString("a.b")); KVPrefix fooIndexPrefix = KVPrefix::getNextPrefix(NamespaceString("a.b")); unique_ptr<KVHarnessHelper> helper(KVHarnessHelper::create()); KVEngine* engine = helper->getEngine(); { unique_ptr<RecordStore> rs; unique_ptr<KVCatalog> catalog; { MyOperationContext opCtx(engine); WriteUnitOfWork uow(&opCtx); ASSERT_OK(engine->createRecordStore(&opCtx, "catalog", "catalog", CollectionOptions())); rs = engine->getRecordStore(&opCtx, "catalog", "catalog", CollectionOptions()); catalog.reset(new KVCatalog(rs.get(), false, false)); uow.commit(); } { MyOperationContext opCtx(engine); WriteUnitOfWork uow(&opCtx); ASSERT_OK(catalog->newCollection(&opCtx, "a.b", CollectionOptions(), abCollPrefix)); ASSERT_NOT_EQUALS("a.b", catalog->getCollectionIdent("a.b")); ASSERT_TRUE(catalog->isUserDataIdent(catalog->getCollectionIdent("a.b"))); uow.commit(); } { MyOperationContext opCtx(engine); WriteUnitOfWork uow(&opCtx); BSONCollectionCatalogEntry::MetaData md; md.ns = "a.b"; BSONCollectionCatalogEntry::IndexMetaData imd; imd.spec = BSON("name" << "foo"); imd.ready = false; imd.head = RecordId(); imd.multikey = false; imd.prefix = fooIndexPrefix; imd.isBackgroundSecondaryBuild = false; md.indexes.push_back(imd); md.prefix = abCollPrefix; catalog->putMetaData(&opCtx, "a.b", md); uow.commit(); } } engine = helper->restartEngine(); { MyOperationContext opCtx(engine); WriteUnitOfWork uow(&opCtx); unique_ptr<RecordStore> rs = engine->getRecordStore(&opCtx, "catalog", "catalog", CollectionOptions()); unique_ptr<KVCatalog> catalog = stdx::make_unique<KVCatalog>(rs.get(), false, false); catalog->init(&opCtx); const BSONCollectionCatalogEntry::MetaData md = catalog->getMetaData(&opCtx, "a.b"); ASSERT_EQ("a.b", md.ns); ASSERT_EQ(abCollPrefix, md.prefix); ASSERT_EQ(fooIndexPrefix, md.indexes[md.findIndexOffset("foo")].prefix); } }
TEST(QueryRequestTest, ParseMaxTimeMSPositiveInRangeSucceeds) { BSONObj maxTimeObj = BSON(QueryRequest::cmdOptionMaxTimeMS << 300); auto maxTime = QueryRequest::parseMaxTimeMS(maxTimeObj[QueryRequest::cmdOptionMaxTimeMS]); ASSERT_OK(maxTime); ASSERT_EQ(maxTime.getValue(), 300); }
void addSample(const BSONObj& sample) { ASSERT_OK(_writer.writeSample(sample, Date_t())); _docs.emplace_back(sample); }
TEST(QueryRequestTest, ConvertToAggregationWithNoWantMoreLimitOneSucceeds) { QueryRequest qr(testns); qr.setWantMore(false); qr.setLimit(1); ASSERT_OK(qr.asAggregationCommand()); }
} END_TEST START_TEST(calculate_age_from_current_and_birthday) { ASSERT_OK(subtract(roman, "MMXVI", "MCMLVIII")); ck_assert_str_eq(roman, "LVIII"); } END_TEST
TEST(QueryRequestTest, PositiveNToReturn) { QueryRequest qr(testns); qr.setNToReturn(1); ASSERT_OK(qr.validate()); }
TEST(CollectionOptions, DuplicateCreateOptionIgnoredIfCreateOptionNotFirst) { CollectionOptions options; auto status = options.parse(BSON("capped" << true << "create" << 1 << "create" << 1 << "size" << 1024)); ASSERT_OK(status); }