public void Execute_should_return_expected_result_when_Collation_is_set(
[Values(false, true)]
bool caseSensitive,
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.AggregateOut, Feature.Collation);
EnsureTestData();
var pipeline = new[]
{
BsonDocument.Parse("{ $match : { x : \"x\" } }"),
BsonDocument.Parse("{ $out : \"awesome\" }")
};
var collation = new Collation("en_US", caseLevel: caseSensitive, strength: CollationStrength.Primary);
var subject = new AggregateToCollectionOperation(_collectionNamespace, pipeline, _messageEncoderSettings)
{
Collation = collation
};
ExecuteOperation(subject, async);
var result = ReadAllFromCollection(new CollectionNamespace(_databaseNamespace, "awesome"), async);
result.Should().NotBeNull();
result.Should().HaveCount(caseSensitive ? 1 : 2);
}
public void CreateCommand_should_create_the_correct_command(
[Values(null, false, true)] bool?allowDiskUse,
[Values(null, false, true)] bool?bypassDocumentValidation,
[Values(null, 2000)] int?maxTime,
[Values("3.0.0", "3.1.3")] string serverVersionString)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, _pipeline, _messageEncoderSettings)
{
AllowDiskUse = allowDiskUse,
BypassDocumentValidation = bypassDocumentValidation,
MaxTime = maxTime.HasValue ? TimeSpan.FromMilliseconds(maxTime.Value) : (TimeSpan?)null,
};
var serverVersion = SemanticVersion.Parse(serverVersionString);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(subject.Pipeline) },
{ "allowDiskUse", () => allowDiskUse.Value, allowDiskUse.HasValue },
{ "bypassDocumentValidation", () => bypassDocumentValidation.Value, bypassDocumentValidation.HasValue&& SupportedFeatures.IsBypassDocumentValidationSupported(serverVersion) },
{ "maxTimeMS", () => maxTime.Value, maxTime.HasValue }
};
var result = subject.CreateCommand(serverVersion);
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_WriteConcern_is_set(
[Values(null, 1, 2)]
int?w,
[Values(false, true)]
bool isWriteConcernSupported)
{
var writeConcern = w.HasValue ? new WriteConcern(w.Value) : null;
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
WriteConcern = writeConcern
};
var session = OperationTestHelper.CreateSession();
var connectionDescription = OperationTestHelper.CreateConnectionDescription(serverVersion: Feature.CommandsThatWriteAcceptWriteConcern.SupportedOrNotSupportedVersion(isWriteConcernSupported));
var result = subject.CreateCommand(session, connectionDescription);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "writeConcern", () => writeConcern.ToBsonDocument(), writeConcern != null && isWriteConcernSupported }
};
result.Should().Be(expectedResult);
}
public void Execute_should_return_expected_result_when_Comment_is_set(
[Values(false, true)]
bool async)
{
RequireServer.Check()
.ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet)
.Supports(Feature.AggregateOut, Feature.AggregateComment);
EnsureTestData();
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
Comment = "test"
};
using (var profile = Profile(_collectionNamespace.DatabaseNamespace))
{
ExecuteOperation(subject, async);
var result = ReadAllFromCollection(new CollectionNamespace(_databaseNamespace, "awesome"), async);
result.Should().NotBeNull();
var profileEntries = profile.Find(new BsonDocument("command.aggregate", new BsonDocument("$exists", true)));
profileEntries.Should().HaveCount(1);
profileEntries[0]["command"]["comment"].AsString.Should().Be(subject.Comment);
}
}
public void CreateCommand_should_return_expected_result_when_BypassDocumentValidation_is_set(
[Values(null, false, true)]
bool?bypassDocumentValidation,
[Values(false, true)]
bool useServerVersionSupportingBypassDocumentValidation)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
BypassDocumentValidation = bypassDocumentValidation
};
var serverVersion = Feature.BypassDocumentValidation.SupportedOrNotSupportedVersion(useServerVersionSupportingBypassDocumentValidation);
var session = OperationTestHelper.CreateSession();
var connectionDescription = OperationTestHelper.CreateConnectionDescription(serverVersion: serverVersion);
var result = subject.CreateCommand(session, connectionDescription);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "bypassDocumentValidation", () => bypassDocumentValidation.Value, bypassDocumentValidation != null && Feature.BypassDocumentValidation.IsSupported(serverVersion) },
{ "cursor", new BsonDocument(), serverVersion >= new SemanticVersion(3, 5, 0) }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_ReadConcern_is_set(
[Values(ReadConcernLevel.Majority)] ReadConcernLevel readConcernLevel,
[Values(false, true)] bool withReadConcern)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
if (withReadConcern)
{
subject.ReadConcern = new ReadConcern(readConcernLevel);
}
;
var session = OperationTestHelper.CreateSession();
var connectionDescription = OperationTestHelper.CreateConnectionDescription();
var result = subject.CreateCommand(session, connectionDescription);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "readConcern", () => subject.ReadConcern.ToBsonDocument(), withReadConcern },
{ "cursor", new BsonDocument() }
};
result.Should().Be(expectedResult);
}
public void Execute_should_return_expected_result_when_Let_is_set_with_project(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.AggregateOptionsLet);
EnsureTestData();
var pipeline = new[]
{
BsonDocument.Parse("{ $project : { y : '$$z' } }"),
BsonDocument.Parse("{ $out : \"awesome\" }")
};
var subject = new AggregateToCollectionOperation(_collectionNamespace, pipeline, _messageEncoderSettings)
{
Let = new BsonDocument("z", "x")
};
ExecuteOperation(subject, async);
var result = ReadAllFromCollection(new CollectionNamespace(_databaseNamespace, "awesome"), async);
result.Should().BeEquivalentTo(new[]
{
new BsonDocument {
{ "_id", 1 }, { "y", "x" }
},
new BsonDocument {
{ "_id", 2 }, { "y", "x" }
}
});
}
public void Constructor_should_create_a_valid_instance()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, _pipeline, _messageEncoderSettings);
subject.CollectionNamespace.Should().Be(_collectionNamespace);
subject.Pipeline.Should().HaveCount(2);
subject.MessageEncoderSettings.Should().BeEquivalentTo(_messageEncoderSettings);
}
public void Execute_should_return_expected_result(
[Values("$out", "$merge")] string lastStageName,
[Values(false, true)] bool usingDifferentOutputDatabase,
[Values(false, true)] bool async)
{
RequireServer.Check();
var pipeline = new List <BsonDocument> {
BsonDocument.Parse("{ $match : { _id : 1 } }")
};
var inputDatabaseName = _databaseNamespace.DatabaseName;
var inputCollectionName = _collectionNamespace.CollectionName;
var outputDatabaseName = usingDifferentOutputDatabase ? $"{inputDatabaseName}-outputdatabase" : inputDatabaseName;
var outputCollectionName = $"{inputCollectionName}-outputcollection";
switch (lastStageName)
{
case "$out":
RequireServer.Check().Supports(Feature.AggregateOut);
if (usingDifferentOutputDatabase)
{
RequireServer.Check().Supports(Feature.AggregateOutToDifferentDatabase);
pipeline.Add(BsonDocument.Parse($"{{ $out : {{ db : '{outputDatabaseName}', coll : '{outputCollectionName}' }} }}"));
}
else
{
pipeline.Add(BsonDocument.Parse($"{{ $out : '{outputCollectionName}' }}"));
}
break;
case "$merge":
RequireServer.Check().Supports(Feature.AggregateMerge);
if (usingDifferentOutputDatabase)
{
pipeline.Add(BsonDocument.Parse($"{{ $merge : {{ into : {{ db : '{outputDatabaseName}', coll : '{outputCollectionName}' }} }} }}"));
}
else
{
pipeline.Add(BsonDocument.Parse($"{{ $merge : {{ into : '{outputDatabaseName}' }} }}"));
}
break;
default:
throw new Exception($"Unexpected lastStageName: \"{lastStageName}\".");
}
EnsureTestData();
if (usingDifferentOutputDatabase)
{
EnsureDatabaseExists(outputDatabaseName);
}
var subject = new AggregateToCollectionOperation(_collectionNamespace, pipeline, _messageEncoderSettings);
ExecuteOperation(subject, async);
var result = ReadAllFromCollection(new CollectionNamespace(new DatabaseNamespace(outputDatabaseName), outputCollectionName), async);
result.Should().NotBeNull();
result.Should().HaveCount(1);
}
public void Execute_should_send_session_id_when_supported(
[Values(false, true)] bool async)
{
RequireServer.Check().Supports(Feature.AggregateOut);
EnsureTestData();
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
VerifySessionIdWasSentWhenSupported(subject, "aggregate", async);
}
public void ReadConcern_get_and_set_should_work([Values(ReadConcernLevel.Local, ReadConcernLevel.Majority)] ReadConcernLevel level)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = new ReadConcern(new Optional <ReadConcernLevel?>(level));
subject.ReadConcern = value;
var result = subject.ReadConcern;
result.Should().BeSameAs(value);
}
public void Constructor_should_simplify_out_stage_when_possible(string outStageJson, string expectedOutStageJson)
{
var databaseNamespace = new DatabaseNamespace("database");
var pipeline = new[] { BsonDocument.Parse(outStageJson) };
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new AggregateToCollectionOperation(databaseNamespace, pipeline, messageEncoderSettings);
subject.Pipeline.Last().Should().Be(BsonDocument.Parse(expectedOutStageJson));
}
public void ReadPreference_get_and_set_should_work()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = new ReadPreference(ReadPreferenceMode.Primary);
subject.ReadPreference = value;
var result = subject.ReadPreference;
result.Should().BeSameAs(value);
}
public void Hint_get_and_set_should_work()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = new BsonDocument("x", 1);
subject.Hint = value;
var result = subject.Hint;
result.Should().BeSameAs(value);
}
public void AllowDiskUse_should_have_the_correct_value()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, _pipeline, _messageEncoderSettings);
subject.AllowDiskUse.Should().Be(null);
subject.AllowDiskUse = true;
subject.AllowDiskUse.Should().Be(true);
}
public void MaxTime_should_have_the_correct_value()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, _pipeline, _messageEncoderSettings);
subject.MaxTime.Should().Be(null);
subject.MaxTime = TimeSpan.FromSeconds(2);
subject.MaxTime.Should().Be(TimeSpan.FromSeconds(2));
}
public void BypassDocumentValidation_should_have_the_correct_value()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, _pipeline, _messageEncoderSettings);
subject.BypassDocumentValidation.Should().Be(null);
subject.BypassDocumentValidation = true;
subject.BypassDocumentValidation.Should().Be(true);
}
public void Comment_get_and_set_should_work()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = (BsonValue)"test";
subject.Comment = value;
var result = subject.Comment;
result.Should().BeSameAs(value);
}
public void BypassDocumentValidation_get_and_set_should_work(
[Values(null, false, true)]
bool?value)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
subject.BypassDocumentValidation = value;
var result = subject.BypassDocumentValidation;
result.Should().Be(value);
}
public void AllowDiskUse_get_and_set_should_work(
[Values(null, false, true)]
bool?value)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
subject.AllowDiskUse = value;
var result = subject.AllowDiskUse;
result.Should().Be(value);
}
public void MaxTime_get_and_set_should_work(
[Values(-10000, 0, 1, 10000, 99999)] long maxTimeTicks)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = TimeSpan.FromTicks(maxTimeTicks);
subject.MaxTime = value;
var result = subject.MaxTime;
result.Should().Be(value);
}
public void CreateCommand_should_throw_when_Collation_is_set_but_not_supported()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
Collation = new Collation("en_US")
};
var exception = Record.Exception(() => subject.CreateCommand(Feature.Collation.LastNotSupportedVersion));
exception.Should().BeOfType <NotSupportedException>();
}
public void Collation_get_and_set_should_work(
[Values(null, "en_US")]
string locale)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = locale == null ? null : new Collation(locale);
subject.Collation = value;
var result = subject.Collation;
result.Should().BeSameAs(value);
}
public void MaxTime_set_should_throw_when_value_is_invalid(
[Values(-10001, -9999, -1)] long maxTimeTicks)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = TimeSpan.FromTicks(maxTimeTicks);
var exception = Record.Exception(() => subject.MaxTime = value);
var e = exception.Should().BeOfType <ArgumentOutOfRangeException>().Subject;
e.ParamName.Should().Be("value");
}
public void WriteConcern_get_and_set_should_work(
[Values(1, 2)]
int w)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = new WriteConcern(w);
subject.WriteConcern = value;
var result = subject.WriteConcern;
result.Should().BeSameAs(value);
}
public void MaxTime_get_and_set_should_work(
[Values(null, 1L)]
long?milliseconds)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var value = milliseconds == null ? (TimeSpan?)null : TimeSpan.FromMilliseconds(milliseconds.Value);
subject.MaxTime = value;
var result = subject.MaxTime;
result.Should().Be(value);
}
public void CreateCommand_should_return_expected_result()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) }
};
result.Should().Be(expectedResult);
}
public void Execute_should_return_expected_result(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.AggregateOut);
EnsureTestData();
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
ExecuteOperation(subject, async);
var result = ReadAllFromCollection(new CollectionNamespace(_databaseNamespace, "awesome"), async);
result.Should().NotBeNull();
result.Should().HaveCount(1);
}
public void Constructor_should_create_a_valid_instance()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings);
subject.CollectionNamespace.Should().BeSameAs(_collectionNamespace);
subject.Pipeline.Should().Equal(__pipeline);
subject.MessageEncoderSettings.Should().BeSameAs(_messageEncoderSettings);
subject.AllowDiskUse.Should().NotHaveValue();
subject.BypassDocumentValidation.Should().NotHaveValue();
subject.Collation.Should().BeNull();
subject.MaxTime.Should().NotHaveValue();
subject.WriteConcern.Should().BeNull();
}
public void Execute_should_throw_when_Collation_is_set(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.AggregateOut).DoesNotSupport(Feature.Collation);
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
Collation = new Collation("en_US")
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
exception.Should().BeOfType <NotSupportedException>();
}
