TEST(InclusionProjectionExecutionTest, ComputedFieldReplacingExistingShouldAppearAfterInclusions) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("b" << wrapInLiteral("NEW") << "a" << true));
auto result = inclusion.applyProjection(Document{{"b", 1}, {"a", 1}});
auto expectedResult = Document{{"a", 1}, {"b", "NEW"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
result = inclusion.applyProjection(Document{{"a", 1}, {"b", 4}});
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldAddComputedTopLevelField) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("newField" << wrapInLiteral("computedVal")));
auto result = inclusion.applyProjection(Document{});
auto expectedResult = Document{{"newField", "computedVal"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Computed field should replace existing field.
result = inclusion.applyProjection(Document{{"newField", "preExisting"_sd}});
expectedResult = Document{{"newField", "computedVal"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldImplicitlyIncludeId) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << true));
auto result = inclusion.applyProjection(Document{{"_id", "ID"_sd}, {"a", 1}, {"b", 2}});
auto expectedResult = Document{{"_id", "ID"_sd}, {"a", 1}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Should leave the "_id" in the same place as in the original document.
result = inclusion.applyProjection(Document{{"a", 1}, {"b", 2}, {"_id", "ID"_sd}});
expectedResult = Document{{"a", 1}, {"_id", "ID"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldCreateSubDocIfDottedComputedFieldDoesntExist) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("sub.target" << wrapInLiteral("computedVal")));
// Should add the path if it doesn't exist.
auto result = inclusion.applyProjection(Document{});
auto expectedResult = Document{{"sub", Document{{"target", "computedVal"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Should replace non-documents with documents.
result = inclusion.applyProjection(Document{{"sub", "notADocument"_sd}});
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldNotCreateSubDocIfDottedIncludedFieldDoesNotExist) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("sub.target" << true));
// Should not add the path if it doesn't exist.
auto result = inclusion.applyProjection(Document{});
auto expectedResult = Document{};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Should not replace the first part of the path if that part exists.
result = inclusion.applyProjection(Document{{"sub", "notADocument"_sd}});
expectedResult = Document{};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldCreateNestedSubDocumentsAllTheWayToComputedField) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a.b.c.d" << wrapInLiteral("computedVal")));
// Should add the path if it doesn't exist.
auto result = inclusion.applyProjection(Document{});
auto expectedResult =
Document{{"a", Document{{"b", Document{{"c", Document{{"d", "computedVal"_sd}}}}}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Should replace non-documents with documents.
result = inclusion.applyProjection(Document{{"a", Document{{"b", "other"_sd}}}});
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST_F(DocumentSourceFacetTest, SingleFacetShouldReceiveAllDocuments) {
auto ctx = getExpCtx();
auto dummy = DocumentSourcePassthrough::create();
auto statusWithPipeline = Pipeline::create({dummy}, ctx);
ASSERT_OK(statusWithPipeline.getStatus());
auto pipeline = std::move(statusWithPipeline.getValue());
auto facetStage = DocumentSourceFacet::create({{"results", pipeline}}, ctx);
deque<DocumentSource::GetNextResult> inputs = {
Document{{"_id", 0}}, Document{{"_id", 1}}, Document{{"_id", 2}}};
auto mock = DocumentSourceMock::create(inputs);
facetStage->setSource(mock.get());
auto output = facetStage->getNext();
ASSERT(output.isAdvanced());
ASSERT_DOCUMENT_EQ(output.getDocument(),
Document(fromjson("{results: [{_id: 0}, {_id: 1}, {_id: 2}]}")));
// Should be exhausted now.
ASSERT(facetStage->getNext().isEOF());
ASSERT(facetStage->getNext().isEOF());
ASSERT(facetStage->getNext().isEOF());
}
TEST(InclusionProjectionExecutionTest, ShouldExcludeIdIfExplicitlyExcluded) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << true << "_id" << false));
auto result = inclusion.applyProjection(Document{{"a", 1}, {"b", 2}, {"_id", "ID"_sd}});
auto expectedResult = Document{{"a", 1}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldImplicitlyIncludeIdWithComputedFields) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("newField" << wrapInLiteral("computedVal")));
auto result = inclusion.applyProjection(Document{{"_id", "ID"_sd}, {"a", 1}});
auto expectedResult = Document{{"_id", "ID"_sd}, {"newField", "computedVal"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldIncludeFieldsInOrderOfInputDoc) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("first" << true << "second" << true << "third" << true));
auto inputDoc = Document{{"second", 1}, {"first", 0}, {"third", 2}};
auto result = inclusion.applyProjection(inputDoc);
ASSERT_DOCUMENT_EQ(result, inputDoc);
}
TEST(InclusionProjectionExecutionTest, ComputedFieldShouldReplaceNestedArrayForNoRecursePolicy) {
auto inclusion = makeInclusionProjectionWithNoArrayRecursion();
inclusion.parse(BSON("a.b" << wrapInLiteral("COMPUTED")));
// For kRecurseNestedArrays, the computed field (1) replaces any scalar values in the array with
// a subdocument containing the new field, and (2) is added to each element of the array and all
// nested arrays individually. With kDoNotRecurseNestedArrays, the nested arrays are replaced
// rather than being traversed, in exactly the same way as scalar values.
vector<Value> nestedValues = {Value(1),
Value(Document{}),
Value(Document{{"b", 1}}),
Value(Document{{"b", 1}, {"c", 2}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(1), Value(Document{{"c", 1}})})};
vector<Value> expectedNestedValues = {Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}})};
auto result = inclusion.applyProjection(Document{{"a", nestedValues}});
auto expectedResult = Document{{"a", expectedNestedValues}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldReplaceIdWithComputedId) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("_id" << wrapInLiteral("newId")));
auto result = inclusion.applyProjection(Document{{"a", 1}, {"b", 2}, {"_id", "ID"_sd}});
auto expectedResult = Document{{"_id", "newId"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldApplyNestedComputedFieldsInOrderSpecified) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << wrapInLiteral("FIRST") << "b.c" << wrapInLiteral("SECOND")));
auto result = inclusion.applyProjection(Document{});
auto expectedResult = Document{{"a", "FIRST"_sd}, {"b", Document{{"c", "SECOND"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldApplyInclusionsAndAdditionsToEachElementInArray) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a.inc" << true << "a.comp" << wrapInLiteral("COMPUTED")));
vector<Value> nestedValues = {Value(1),
Value(Document{}),
Value(Document{{"inc", 1}}),
Value(Document{{"inc", 1}, {"c", 2}}),
Value(Document{{"c", 2}, {"inc", 1}}),
Value(Document{{"inc", 1}, {"c", 2}, {"comp", "original"_sd}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(1), Value(Document{{"inc", 1}})})};
vector<Value> expectedNestedValues = {
Value(Document{{"comp", "COMPUTED"_sd}}),
Value(Document{{"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(Document{{"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}})})};
auto result = inclusion.applyProjection(Document{{"a", nestedValues}});
auto expectedResult = Document{{"a", expectedNestedValues}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldAddOrIncludeSubFieldsOfId) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("_id.X" << true << "_id.Z" << wrapInLiteral("NEW")));
auto result = inclusion.applyProjection(Document{{"_id", Document{{"X", 1}, {"Y", 2}}}});
auto expectedResult = Document{{"_id", Document{{"X", 1}, {"Z", "NEW"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldSerializeExplicitExclusionOfId) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("_id" << false << "a" << true));
// Adds implicit "_id" inclusion, converts numbers to bools, serializes expressions.
auto expectedSerialization = Document{{"_id", false}, {"a", true}};
// Should be the same if we're serializing for explain or for internal use.
ASSERT_DOCUMENT_EQ(expectedSerialization, inclusion.serializeTransformation(boost::none));
ASSERT_DOCUMENT_EQ(expectedSerialization,
inclusion.serializeTransformation(ExplainOptions::Verbosity::kQueryPlanner));
ASSERT_DOCUMENT_EQ(expectedSerialization,
inclusion.serializeTransformation(ExplainOptions::Verbosity::kExecStats));
ASSERT_DOCUMENT_EQ(expectedSerialization,
inclusion.serializeTransformation(ExplainOptions::Verbosity::kExecAllPlans));
}
TEST(InclusionProjectionExecutionTest, ShouldOptimizeTopLevelExpressions) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << BSON("$add" << BSON_ARRAY(1 << 2))));
inclusion.optimize();
auto expectedSerialization = Document{{"_id", true}, {"a", Document{{"$const", 3}}}};
// Should be the same if we're serializing for explain or for internal use.
ASSERT_DOCUMENT_EQ(expectedSerialization, inclusion.serializeTransformation(boost::none));
ASSERT_DOCUMENT_EQ(expectedSerialization,
inclusion.serializeTransformation(ExplainOptions::Verbosity::kQueryPlanner));
ASSERT_DOCUMENT_EQ(expectedSerialization,
inclusion.serializeTransformation(ExplainOptions::Verbosity::kExecStats));
ASSERT_DOCUMENT_EQ(expectedSerialization,
inclusion.serializeTransformation(ExplainOptions::Verbosity::kExecAllPlans));
}
TEST(InclusionProjectionExecutionTest, ShouldApplyComputedFieldsInOrderSpecified) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("firstComputed" << wrapInLiteral("FIRST") << "secondComputed"
<< wrapInLiteral("SECOND")));
auto result = inclusion.applyProjection(Document{{"first", 0}, {"second", 1}, {"third", 2}});
auto expectedResult = Document{{"firstComputed", "FIRST"_sd}, {"secondComputed", "SECOND"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldSerializeToEquivalentProjection) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(fromjson("{a: {$add: ['$a', 2]}, b: {d: 3}, 'x.y': {$literal: 4}}"));
// Adds implicit "_id" inclusion, converts numbers to bools, serializes expressions.
auto expectedSerialization = Document(fromjson(
"{_id: true, a: {$add: [\"$a\", {$const: 2}]}, b: {d: true}, x: {y: {$const: 4}}}"));
// Should be the same if we're serializing for explain or for internal use.
ASSERT_DOCUMENT_EQ(expectedSerialization, inclusion.serializeTransformation(boost::none));
ASSERT_DOCUMENT_EQ(expectedSerialization,
inclusion.serializeTransformation(ExplainOptions::Verbosity::kQueryPlanner));
ASSERT_DOCUMENT_EQ(expectedSerialization,
inclusion.serializeTransformation(ExplainOptions::Verbosity::kExecStats));
ASSERT_DOCUMENT_EQ(expectedSerialization,
inclusion.serializeTransformation(ExplainOptions::Verbosity::kExecAllPlans));
}
TEST(InclusionProjectionExecutionTest, ShouldOverrideExcludePolicyWithExplicitIncludeIdSpec) {
auto inclusion = makeInclusionProjectionWithDefaultIdExclusion();
inclusion.parse(BSON("_id" << true << "a" << true));
auto result = inclusion.applyProjection(Document{{"_id", 2}, {"a", 3}});
auto expectedResult = Document{{"_id", 2}, {"a", 3}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldIncludeIdWithIncludePolicy) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << true));
auto result = inclusion.applyProjection(Document{{"_id", 2}, {"a", 3}});
auto expectedResult = Document{{"_id", 2}, {"a", 3}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldApplyComputedFieldsAfterAllInclusions) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("b.c" << wrapInLiteral("NEW") << "a" << true));
auto result = inclusion.applyProjection(Document{{"a", 1}});
auto expectedResult = Document{{"a", 1}, {"b", Document{{"c", "NEW"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
result = inclusion.applyProjection(Document{{"a", 1}, {"b", 4}});
ASSERT_DOCUMENT_EQ(result, expectedResult);
// In this case, the field 'b' shows up first and has a nested inclusion or computed field. Even
// though it is a computed field, it will appear first in the output document. This is
// inconsistent, but the expected behavior, and a consequence of applying the projection
// recursively to each sub-document.
result = inclusion.applyProjection(Document{{"b", 4}, {"a", 1}});
expectedResult = Document{{"b", Document{{"c", "NEW"_sd}}}, {"a", 1}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldAddComputedDottedFieldToSubDocument) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("sub.target" << wrapInLiteral("computedVal")));
// Other fields exist in sub document, one of which is the specified field.
auto result = inclusion.applyProjection(Document{{"sub", Document{{"target", 1}, {"c", 2}}}});
auto expectedResult = Document{{"sub", Document{{"target", "computedVal"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Specified field is not present in the sub document.
result = inclusion.applyProjection(Document{{"sub", Document{{"c", 1}}}});
expectedResult = Document{{"sub", Document{{"target", "computedVal"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// There are no fields in sub document.
result = inclusion.applyProjection(Document{{"sub", Document{}}});
expectedResult = Document{{"sub", Document{{"target", "computedVal"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldAllowInclusionOfIdSubfieldWithDefaultExcludePolicy) {
auto inclusion = makeInclusionProjectionWithDefaultIdExclusion();
inclusion.parse(BSON("_id.id1" << true << "a" << true));
auto result = inclusion.applyProjection(
Document{{"_id", Document{{"id1", 1}, {"id2", 2}}}, {"a", 3}, {"b", 4}});
auto expectedResult = Document{{"_id", Document{{"id1", 1}}}, {"a", 3}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldIncludeSimpleDottedFieldFromSubDoc) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a.b" << true));
// More than one field in sub document.
auto result = inclusion.applyProjection(Document{{"a", Document{{"b", 1}, {"c", 2}}}});
auto expectedResult = Document{{"a", Document{{"b", 1}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Specified field is the only field in the sub document.
result = inclusion.applyProjection(Document{{"a", Document{{"b", 1}}}});
expectedResult = Document{{"a", Document{{"b", 1}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Specified field is not present in the sub document.
result = inclusion.applyProjection(Document{{"a", Document{{"c", 1}}}});
expectedResult = Document{{"a", Document{}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// There are no fields in sub document.
result = inclusion.applyProjection(Document{{"a", Document{}}});
expectedResult = Document{{"a", Document{}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldAlwaysKeepMetadataFromOriginalDoc) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << true));
MutableDocument inputDocBuilder(Document{{"a", 1}});
inputDocBuilder.setRandMetaField(1.0);
inputDocBuilder.setTextScore(10.0);
Document inputDoc = inputDocBuilder.freeze();
auto result = inclusion.applyProjection(inputDoc);
MutableDocument expectedDoc(inputDoc);
expectedDoc.copyMetaDataFrom(inputDoc);
ASSERT_DOCUMENT_EQ(result, expectedDoc.freeze());
}
TEST_F(DocumentSourceFacetTest, ShouldBeAbleToEvaluateMultipleStagesWithinOneSubPipeline) {
auto ctx = getExpCtx();
auto firstDummy = DocumentSourcePassthrough::create();
auto secondDummy = DocumentSourcePassthrough::create();
auto pipeline = uassertStatusOK(Pipeline::create({firstDummy, secondDummy}, ctx));
auto facetStage = DocumentSourceFacet::create({{"subPipe", pipeline}}, ctx);
deque<DocumentSource::GetNextResult> inputs = {Document{{"_id", 0}}, Document{{"_id", 1}}};
auto mock = DocumentSourceMock::create(inputs);
facetStage->setSource(mock.get());
auto output = facetStage->getNext();
ASSERT(output.isAdvanced());
ASSERT_DOCUMENT_EQ(output.getDocument(), Document(fromjson("{subPipe: [{_id: 0}, {_id: 1}]}")));
}
TEST(InclusionProjectionExecutionTest, ShouldRetainNestedArraysIfNoRecursionNeeded) {
auto inclusion = makeInclusionProjectionWithNoArrayRecursion();
inclusion.parse(BSON("a" << true));
// {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => [output doc identical to input]
const auto inputDoc =
Document{{"a",
vector<Value>{Value(1),
Value(Document{{"b", 2}, {"c", 3}}),
Value(vector<Value>{Value(Document{{"b", 4}, {"c", 5}})}),
Value(Document{{"d", 6}})}}};
auto result = inclusion.applyProjection(inputDoc);
const auto& expectedResult = inputDoc;
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldNotRecurseNestedArraysForNoRecursePolicy) {
auto inclusion = makeInclusionProjectionWithNoArrayRecursion();
inclusion.parse(BSON("a.b" << true));
// {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => {a: [{b: 2}, {}]}
auto result = inclusion.applyProjection(
Document{{"a",
vector<Value>{Value(1),
Value(Document{{"b", 2}, {"c", 3}}),
Value(vector<Value>{Value(Document{{"b", 4}, {"c", 5}})}),
Value(Document{{"d", 6}})}}});
auto expectedResult = Document{
{"a", vector<Value>{Value(), Value(Document{{"b", 2}}), Value(), Value(Document{})}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ComputedFieldIsAddedToNestedArrayElementsForRecursePolicy) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a.b" << wrapInLiteral("COMPUTED")));
vector<Value> nestedValues = {Value(1),
Value(Document{}),
Value(Document{{"b", 1}}),
Value(Document{{"b", 1}, {"c", 2}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(1), Value(Document{{"c", 1}})})};
vector<Value> expectedNestedValues = {
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}})})};
auto result = inclusion.applyProjection(Document{{"a", nestedValues}});
auto expectedResult = Document{{"a", expectedNestedValues}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
