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);
}
