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