// Multi-language : test nested arrays
TEST(FTSElementIterator, Test4) {
BSONObj obj = fromjson(
"{ language : \"english\","
" a : ["
" { language : \"danish\","
" b :"
" [ { c : [\"foredrag\"] },"
" { c : [\"foredragsholder\"] },"
" { c : [\"lector\"] } ]"
" } ]"
"}");
BSONObj indexSpec = fromjson("{ key : { \"a.b.c\" : \"text\" }, weights : { \"a.b.c\" : 5 } }");
FTSSpec spec(assertGet(FTSSpec::fixSpec(indexSpec)));
FTSElementIterator it(spec, obj);
ASSERT(it.more());
FTSIteratorValue val = it.next();
ASSERT_EQUALS("foredrag", string(val._text));
ASSERT_EQUALS("danish", val._language->str());
ASSERT_EQUALS(5, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("foredragsholder", string(val._text));
ASSERT_EQUALS("danish", val._language->str());
ASSERT_EQUALS(5, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("lector", string(val._text));
ASSERT_EQUALS("danish", val._language->str());
ASSERT_EQUALS(5, val._weight);
}
void ShardingTestFixture::expectConfigCollectionInsert(const HostAndPort& configHost,
StringData collName,
Date_t timestamp,
const std::string& what,
const std::string& ns,
const BSONObj& detail) {
onCommand([&](const RemoteCommandRequest& request) {
ASSERT_EQUALS(configHost, request.target);
ASSERT_EQUALS("config", request.dbname);
BatchedInsertRequest actualBatchedInsert;
std::string errmsg;
ASSERT_TRUE(actualBatchedInsert.parseBSON(request.dbname, request.cmdObj, &errmsg));
ASSERT_EQ("config", actualBatchedInsert.getNS().db());
ASSERT_EQ(collName, actualBatchedInsert.getNS().coll());
auto inserts = actualBatchedInsert.getDocuments();
ASSERT_EQUALS(1U, inserts.size());
const ChangeLogType& actualChangeLog = assertGet(ChangeLogType::fromBSON(inserts.front()));
ASSERT_EQUALS(operationContext()->getClient()->clientAddress(true),
actualChangeLog.getClientAddr());
ASSERT_EQUALS(detail, actualChangeLog.getDetails());
ASSERT_EQUALS(ns, actualChangeLog.getNS());
ASSERT_EQUALS(network()->getHostName(), actualChangeLog.getServer());
ASSERT_EQUALS(timestamp, actualChangeLog.getTime());
ASSERT_EQUALS(what, actualChangeLog.getWhat());
// Handle changeId specially because there's no way to know what OID was generated
std::string changeId = actualChangeLog.getChangeId();
size_t firstDash = changeId.find("-");
size_t lastDash = changeId.rfind("-");
const std::string serverPiece = changeId.substr(0, firstDash);
const std::string timePiece = changeId.substr(firstDash + 1, lastDash - firstDash - 1);
const std::string oidPiece = changeId.substr(lastDash + 1);
ASSERT_EQUALS(grid.getNetwork()->getHostName(), serverPiece);
ASSERT_EQUALS(timestamp.toString(), timePiece);
OID generatedOID;
// Just make sure this doesn't throws and assume the OID is valid
generatedOID.init(oidPiece);
BatchedCommandResponse response;
response.setOk(true);
return response.toBSON();
});
}
void QueryPlannerTest::runQueryAsCommand(const BSONObj& cmdObj) {
solns.clear();
invariant(nss.isValid());
const bool isExplain = false;
std::unique_ptr<LiteParsedQuery> lpq(
assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
auto statusWithCQ = CanonicalQuery::canonicalize(lpq.release(), ExtensionsCallbackNoop());
ASSERT_OK(statusWithCQ.getStatus());
Status s = QueryPlanner::plan(*statusWithCQ.getValue(), params, &solns.mutableVector());
ASSERT_OK(s);
}
// Multi-language : Test Version 3 Language Override
TEST(FTSElementIterator, LanguageOverrideV3) {
BSONObj obj = fromjson(
"{ a :"
" { b :"
" [ { c : \"walked\", language : \"english\" },"
" { c : \"camminato\", language : \"italian\" },"
" { c : \"ging\", language : \"german\" } ]"
" },"
" d : \"Feliz Año Nuevo!\","
" language : \"spanish\""
" }");
BSONObj indexSpec =
fromjson("{ key : { \"a.b.c\" : \"text\", d : \"text\" }, textIndexVersion: 3.0 }");
FTSSpec spec(assertGet(FTSSpec::fixSpec(indexSpec)));
FTSElementIterator it(spec, obj);
ASSERT(it.more());
FTSIteratorValue val = it.next();
ASSERT_EQUALS("walked", string(val._text));
ASSERT_EQUALS("english", val._language->str());
ASSERT_EQUALS(val._language, FTSLanguage::make(val._language->str(), TEXT_INDEX_VERSION_3));
ASSERT_EQUALS(1, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("camminato", string(val._text));
ASSERT_EQUALS("italian", val._language->str());
ASSERT_EQUALS(val._language, FTSLanguage::make(val._language->str(), TEXT_INDEX_VERSION_3));
ASSERT_EQUALS(1, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("ging", string(val._text));
ASSERT_EQUALS("german", val._language->str());
ASSERT_EQUALS(val._language, FTSLanguage::make(val._language->str(), TEXT_INDEX_VERSION_3));
ASSERT_EQUALS(1, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("Feliz Año Nuevo!", string(val._text));
ASSERT_EQUALS("spanish", val._language->str());
ASSERT_EQUALS(val._language, FTSLanguage::make(val._language->str(), TEXT_INDEX_VERSION_3));
ASSERT_EQUALS(1, val._weight);
}
// Multi-language : test nested stemming per sub-document
TEST(FTSElementIterator, Test3) {
BSONObj obj = fromjson(
"{ language : \"english\","
" a :"
" { language : \"danish\","
" b :"
" [ { c : \"foredrag\" },"
" { c : \"foredragsholder\" },"
" { c : \"lector\" } ]"
" }"
"}");
BSONObj indexSpec =
fromjson("{ key : { a : \"text\", \"a.b.c\" : \"text\" }, weights : { \"a.b.c\" : 5 } }");
FTSSpec spec(assertGet(FTSSpec::fixSpec(indexSpec)));
Weights::const_iterator itt = spec.weights().begin();
ASSERT(itt != spec.weights().end());
ASSERT_EQUALS("a", itt->first);
ASSERT_EQUALS(1, itt->second);
++itt;
ASSERT(itt != spec.weights().end());
ASSERT_EQUALS("a.b.c", itt->first);
ASSERT_EQUALS(5, itt->second);
FTSElementIterator it(spec, obj);
ASSERT(it.more());
FTSIteratorValue val = it.next();
ASSERT_EQUALS("foredrag", string(val._text));
ASSERT_EQUALS("danish", val._language->str());
ASSERT_EQUALS(5, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("foredragsholder", string(val._text));
ASSERT_EQUALS("danish", val._language->str());
ASSERT_EQUALS(5, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("lector", string(val._text));
ASSERT_EQUALS("danish", val._language->str());
ASSERT_EQUALS(5, val._weight);
}
// Multi-language : test wildcard spec
TEST(FTSElementIterator, Test6) {
BSONObj obj = fromjson(
"{ language : \"english\","
" b : \"these boots were made for walking\","
" c : { e: \"I walked half way to the market before seeing the sunrise\" },"
" d : "
" { language : \"danish\","
" e :"
" [ { f : \"foredrag\", g : 12 },"
" { f : \"foredragsholder\", g : 13 },"
" { f : \"lector\", g : 14 } ]"
" }"
"}");
BSONObj indexSpec =
fromjson("{ key : { a : \"text\" }, weights : { b : 20, c : 10, \"d.e.f\" : 5 } }");
FTSSpec spec(assertGet(FTSSpec::fixSpec(indexSpec)));
FTSElementIterator it(spec, obj);
ASSERT(it.more());
FTSIteratorValue val = it.next();
ASSERT_EQUALS("these boots were made for walking", string(val._text));
ASSERT_EQUALS("english", val._language->str());
ASSERT_EQUALS(20, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("foredrag", string(val._text));
ASSERT_EQUALS("danish", val._language->str());
ASSERT_EQUALS(5, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("foredragsholder", string(val._text));
ASSERT_EQUALS("danish", val._language->str());
ASSERT_EQUALS(5, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("lector", string(val._text));
ASSERT_EQUALS("danish", val._language->str());
ASSERT_EQUALS(5, val._weight);
}
void QueryPlannerTest::runQueryAsCommand(const BSONObj& cmdObj) {
solns.clear();
const NamespaceString nss(ns);
invariant(nss.isValid());
const bool isExplain = false;
std::unique_ptr<LiteParsedQuery> lpq(
assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
CanonicalQuery* rawCq;
WhereCallbackNoop whereCallback;
Status canonStatus = CanonicalQuery::canonicalize(lpq.release(), &rawCq, whereCallback);
ASSERT_OK(canonStatus);
cq.reset(rawCq);
Status s = QueryPlanner::plan(*cq, params, &solns.mutableVector());
ASSERT_OK(s);
}
void ShardingTestFixture::expectSetShardVersion(const HostAndPort& expectedHost,
const ShardType& expectedShard,
const NamespaceString& expectedNs,
const ChunkVersion& expectedChunkVersion) {
onCommand([&](const RemoteCommandRequest& request) {
ASSERT_EQ(expectedHost, request.target);
ASSERT_EQUALS(rpc::makeEmptyMetadata(), request.metadata);
SetShardVersionRequest ssv =
assertGet(SetShardVersionRequest::parseFromBSON(request.cmdObj));
ASSERT(!ssv.isInit());
ASSERT(ssv.isAuthoritative());
ASSERT_EQ(grid.shardRegistry()->getConfigServerConnectionString().toString(),
ssv.getConfigServer().toString());
ASSERT_EQ(expectedShard.getHost(), ssv.getShardConnectionString().toString());
ASSERT_EQ(expectedNs.toString(), ssv.getNS().ns());
ASSERT_EQ(expectedChunkVersion.toString(), ssv.getNSVersion().toString());
return BSON("ok" << true);
});
}
TEST(FTSElementIterator, Test1) {
BSONObj obj = fromjson(
"{ b : \"walking\","
" c : { e: \"walked\" },"
" d : \"walker\""
" }");
BSONObj indexSpec = fromjson("{ key : { a : \"text\" }, weights : { b : 10, d : 5 } }");
FTSSpec spec(assertGet(FTSSpec::fixSpec(indexSpec)));
Weights::const_iterator itt = spec.weights().begin();
ASSERT(itt != spec.weights().end());
ASSERT_EQUALS("a", itt->first);
ASSERT_EQUALS(1, itt->second);
++itt;
ASSERT(itt != spec.weights().end());
ASSERT_EQUALS("b", itt->first);
ASSERT_EQUALS(10, itt->second);
++itt;
ASSERT(itt != spec.weights().end());
ASSERT_EQUALS("d", itt->first);
ASSERT_EQUALS(5, itt->second);
++itt;
FTSElementIterator it(spec, obj);
ASSERT(it.more());
FTSIteratorValue val = it.next();
ASSERT_EQUALS("walking", string(val._text));
ASSERT_EQUALS("english", val._language->str());
ASSERT_EQUALS(10, val._weight);
ASSERT(it.more());
val = it.next();
ASSERT_EQUALS("walker", string(val._text));
ASSERT_EQUALS("english", val._language->str());
ASSERT_EQUALS(5, val._weight);
}
void QueryPlannerTest::runInvalidQueryAsCommand(const BSONObj& cmdObj) {
solns.clear();
cq.reset();
invariant(nss.isValid());
const bool isExplain = false;
std::unique_ptr<QueryRequest> qr(
assertGet(QueryRequest::makeFromFindCommand(nss, cmdObj, isExplain)));
const boost::intrusive_ptr<ExpressionContext> expCtx;
auto statusWithCQ =
CanonicalQuery::canonicalize(opCtx.get(),
std::move(qr),
expCtx,
ExtensionsCallbackNoop(),
MatchExpressionParser::kAllowAllSpecialFeatures);
ASSERT_OK(statusWithCQ.getStatus());
cq = std::move(statusWithCQ.getValue());
auto statusWithSolutions = QueryPlanner::plan(*cq, params);
ASSERT_NOT_OK(statusWithSolutions.getStatus());
}
