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 ToBsonDocument_should_return_expected_result(ReadConcernLevel? level, string json)
        {
            var subject = new ReadConcern(level);
            var result = subject.ToBsonDocument();

            result.Should().Be(json);
        }
        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);
        }
Esempio n. 4
0
        public void ReadConcern_get_and_set_should_work(
            [Values(ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
            ReadConcernLevel level)
        {
            var subject = new GeoNearOperation <BsonDocument>(_collectionNamespace, _near, _resultSerializer, _messageEncoderSettings);
            var value   = new ReadConcern(level);

            subject.ReadConcern = value;
            var result = subject.ReadConcern;

            result.Should().Be(value);
        }
        public void CreateAggregateOperation_should_return_expected_result(
            int?batchSize,
            string locale,
            ChangeStreamFullDocumentOption fullDocument,
            int?maxAwaitTimeMS,
            ReadConcernLevel level,
            string resumeAferJson,
            string startAfterJson,
            string expectedChangeStreamStageJson)
        {
            var collation    = locale == null ? null : new Collation(locale);
            var maxAwaitTime = maxAwaitTimeMS == null ? (TimeSpan?)null : TimeSpan.FromMilliseconds(maxAwaitTimeMS.Value);
            var readConcern  = new ReadConcern(level);
            var resumeAfter  = resumeAferJson == null ? null : BsonDocument.Parse(resumeAferJson);
            var startAfter   = startAfterJson == null ? null : BsonDocument.Parse(startAfterJson);
            var expectedChangeStreamStage = BsonDocument.Parse(expectedChangeStreamStageJson);
            var collectionNamespace       = new CollectionNamespace(new DatabaseNamespace("foo"), "bar");
            var pipeline = new List <BsonDocument> {
                BsonDocument.Parse("{ $match : { operationType : \"insert\" } }")
            };
            var resultSerializer       = BsonDocumentSerializer.Instance;
            var messageEncoderSettings = new MessageEncoderSettings();
            var subject = new ChangeStreamOperation <BsonDocument>(collectionNamespace, pipeline, resultSerializer, messageEncoderSettings)
            {
                BatchSize    = batchSize,
                Collation    = collation,
                FullDocument = fullDocument,
                MaxAwaitTime = maxAwaitTime,
                ReadConcern  = readConcern,
                ResumeAfter  = resumeAfter,
                StartAfter   = startAfter
            };
            var expectedPipeline = new BsonDocument[]
            {
                expectedChangeStreamStage,
                pipeline[0]
            };

            var result = subject.CreateAggregateOperation();

            result.AllowDiskUse.Should().NotHaveValue();
            result.BatchSize.Should().Be(batchSize);
            result.Collation.Should().Be(collation);
            result.CollectionNamespace.Should().Be(collectionNamespace);
            result.MaxAwaitTime.Should().Be(maxAwaitTime);
            result.MaxTime.Should().NotHaveValue();
            result.MessageEncoderSettings.Should().BeSameAs(messageEncoderSettings);
            result.Pipeline.Should().Equal(expectedPipeline);
            result.ReadConcern.Should().Be(readConcern);
            result.ResultSerializer.Should().Be(RawBsonDocumentSerializer.Instance);
            result.RetryRequested.Should().BeFalse();
        }
Esempio n. 6
0
        public void ReadConcern_get_and_set_should_work(
            [Values(ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
            ReadConcernLevel level)
        {
#pragma warning disable CS0618 // Type or member is obsolete
            var subject = new MapReduceOperation <BsonDocument>(_collectionNamespace, _mapFunction, _reduceFunction, _resultSerializer, _messageEncoderSettings);
#pragma warning restore CS0618 // Type or member is obsolete
            var value = new ReadConcern(level);

            subject.ReadConcern = value;
            var result = subject.ReadConcern;

            result.Should().Be(value);
        }
        public void TestReadConcernLevel(string connectionString, ReadConcernLevel readConcernLevel)
        {
            var built = new MongoUrlBuilder { ReadConcernLevel = readConcernLevel };

            foreach (var builder in EnumerateBuiltAndParsedBuilders(built, connectionString))
            {
                Assert.AreEqual(readConcernLevel, builder.ReadConcernLevel);
                Assert.AreEqual(connectionString, builder.ToString());
            }
        }
        public void When_readConcernLevel_is_specified(string connectionString, ReadConcernLevel readConcernLevel)
        {
            var subject = new ConnectionString(connectionString);

            subject.ReadConcernLevel.Should().Be(readConcernLevel);
        }
        public void When_readConcernLevel_is_specified(string connectionString, ReadConcernLevel readConcernLevel)
        {
            var subject = new ConnectionString(connectionString);

            subject.ReadConcernLevel.Should().Be(readConcernLevel);
        }