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);
}
// methods
public override async Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken)
{
var renderedPipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).Render(_documentSerializer, _settings.SerializerRegistry);
options = options ?? new AggregateOptions();
var last = renderedPipeline.Documents.LastOrDefault();
if (last != null && last.GetElement(0).Name == "$out")
{
var operation = new AggregateToCollectionOperation(
_collectionNamespace,
renderedPipeline.Documents,
_messageEncoderSettings)
{
AllowDiskUse = options.AllowDiskUse,
BypassDocumentValidation = options.BypassDocumentValidation,
MaxTime = options.MaxTime
};
await ExecuteWriteOperationAsync(operation, cancellationToken).ConfigureAwait(false);
var outputCollectionName = last.GetElement(0).Value.AsString;
var findOperation = new FindOperation <TResult>(
new CollectionNamespace(_collectionNamespace.DatabaseNamespace, outputCollectionName),
renderedPipeline.OutputSerializer,
_messageEncoderSettings)
{
BatchSize = options.BatchSize,
MaxTime = options.MaxTime
};
// we want to delay execution of the find because the user may
// not want to iterate the results at all...
var deferredCursor = new DeferredAsyncCursor <TResult>(
ct => ExecuteReadOperation(findOperation, ReadPreference.Primary, ct),
ct => ExecuteReadOperationAsync(findOperation, ReadPreference.Primary, ct));
return(await Task.FromResult <IAsyncCursor <TResult> >(deferredCursor).ConfigureAwait(false));
}
else
{
var aggregateOperation = new AggregateOperation <TResult>(
_collectionNamespace,
renderedPipeline.Documents,
renderedPipeline.OutputSerializer,
_messageEncoderSettings)
{
AllowDiskUse = options.AllowDiskUse,
BatchSize = options.BatchSize,
MaxTime = options.MaxTime,
ReadConcern = _settings.ReadConcern,
UseCursor = options.UseCursor
};
return(await ExecuteReadOperationAsync(aggregateOperation, cancellationToken).ConfigureAwait(false));
}
}
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 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 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();
}
// methods
public async Task <IAsyncEnumerable <TResult> > AggregateAsync <TResult>(AggregateModel <TResult> model, TimeSpan?timeout, CancellationToken cancellationToken)
{
Ensure.IsNotNull(model, "model");
var pipeline = model.Pipeline.Select(x => ConvertToBsonDocument(x)).ToList();
var last = pipeline.LastOrDefault();
if (last != null && last.GetElement(0).Name == "$out")
{
var operation = new AggregateToCollectionOperation(
_collectionNamespace,
pipeline,
_messageEncoderSettings)
{
AllowDiskUse = model.AllowDiskUse,
MaxTime = model.MaxTime
};
await ExecuteWriteOperation(operation, timeout, cancellationToken);
var outputCollectionName = last.GetElement(0).Value.AsString;
var findOperation = new FindOperation <TResult>(
new CollectionNamespace(_collectionNamespace.DatabaseNamespace, outputCollectionName),
model.ResultSerializer ?? _settings.SerializerRegistry.GetSerializer <TResult>(),
_messageEncoderSettings)
{
BatchSize = model.BatchSize,
MaxTime = model.MaxTime
};
return(await Task.FromResult <IAsyncEnumerable <TResult> >(new AsyncCursorAsyncEnumerable <TResult>(
() => ExecuteReadOperation(findOperation, timeout, cancellationToken),
null)));
}
else
{
var operation = CreateAggregateOperation <TResult>(model, pipeline);
return(await Task.FromResult <IAsyncEnumerable <TResult> >(new AsyncCursorAsyncEnumerable <TResult>(
() => ExecuteReadOperation(operation, timeout, cancellationToken),
null)));
}
}
public async Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(IEnumerable <object> pipeline, AggregateOptions <TResult> options, CancellationToken cancellationToken)
{
Ensure.IsNotNull(pipeline, "pipeline");
options = options ?? new AggregateOptions <TResult>();
var pipelineDocuments = pipeline.Select(x => ConvertToBsonDocument(x)).ToList();
var last = pipelineDocuments.LastOrDefault();
if (last != null && last.GetElement(0).Name == "$out")
{
var operation = new AggregateToCollectionOperation(
_collectionNamespace,
pipelineDocuments,
_messageEncoderSettings)
{
AllowDiskUse = options.AllowDiskUse,
MaxTime = options.MaxTime
};
await ExecuteWriteOperation(operation, cancellationToken).ConfigureAwait(false);
var outputCollectionName = last.GetElement(0).Value.AsString;
var resultSerializer = ResolveResultSerializer(options.ResultSerializer);
var findOperation = new FindOperation <TResult>(
new CollectionNamespace(_collectionNamespace.DatabaseNamespace, outputCollectionName),
resultSerializer,
_messageEncoderSettings)
{
BatchSize = options.BatchSize,
MaxTime = options.MaxTime
};
// we want to delay execution of the find because the user may
// not want to iterate the results at all...
return(await Task.FromResult <IAsyncCursor <TResult> >(new DeferredAsyncCursor <TResult>(ct => ExecuteReadOperation(findOperation, ReadPreference.Primary, ct))).ConfigureAwait(false));
}
else
{
var operation = CreateAggregateOperation <TResult>(options, pipelineDocuments);
return(await ExecuteReadOperation(operation, cancellationToken).ConfigureAwait(false));
}
}
protected override void Given()
{
Require.MinimumServerVersion("2.6.0");
_subject = new AggregateToCollectionOperation(
CollectionNamespace,
new[]
{
BsonDocument.Parse("{$match: {x: { $gt: 3}}}"),
BsonDocument.Parse("{$out: \"awesome\"}")
},
MessageEncoderSettings);
Insert(new[]
{
BsonDocument.Parse("{_id: 1, x: 1}"),
BsonDocument.Parse("{_id: 2, x: 2}"),
BsonDocument.Parse("{_id: 3, x: 3}"),
BsonDocument.Parse("{_id: 4, x: 4}"),
BsonDocument.Parse("{_id: 5, x: 5}"),
BsonDocument.Parse("{_id: 6, x: 6}"),
});
}
public async Task Executing_with_matching_documents_using_all_options()
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, _pipeline, _messageEncoderSettings)
{
AllowDiskUse = true,
MaxTime = TimeSpan.FromSeconds(20)
};
await ExecuteOperationAsync(subject);
var result = await ReadAllFromCollectionAsync(new CollectionNamespace(_databaseNamespace, "awesome"));
result.Should().NotBeNull();
result.Should().HaveCount(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()
{
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_throw_when_a_write_concern_error_occurs(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.AggregateOut, Feature.CommandsThatWriteAcceptWriteConcern).ClusterType(ClusterType.ReplicaSet);
EnsureTestData();
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
WriteConcern = new WriteConcern(9)
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
exception.Should().BeOfType<MongoWriteConcernException>();
}
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 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 result = subject.CreateCommand(serverVersion);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "bypassDocumentValidation", () => bypassDocumentValidation.Value, bypassDocumentValidation != null && Feature.BypassDocumentValidation.IsSupported(serverVersion) }
};
result.Should().Be(expectedResult);
}
public void Execute_should_return_expected_result_when_MaxTime_is_set(
[Values(null, 1000)]
int? milliseconds,
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.AggregateOut);
EnsureTestData();
var maxTime = milliseconds == null ? (TimeSpan?)null : TimeSpan.FromMilliseconds(milliseconds.Value);
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
MaxTime = maxTime
};
ExecuteOperation(subject, async);
var result = ReadAllFromCollection(new CollectionNamespace(_databaseNamespace, "awesome"), async);
result.Should().NotBeNull();
result.Should().HaveCount(1);
}
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_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 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 serverVersion = Feature.CommandsThatWriteAcceptWriteConcern.SupportedOrNotSupportedVersion(isWriteConcernSupported);
var result = subject.CreateCommand(serverVersion);
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_BypassDocumentValidation_is_set(
[Values(null, false, true)]
bool? bypassDocumentValidation,
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.AggregateOut);
EnsureTestData();
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
BypassDocumentValidation = bypassDocumentValidation
};
ExecuteOperation(subject, async);
var result = ReadAllFromCollection(new CollectionNamespace(_databaseNamespace, "awesome"), async);
result.Should().NotBeNull();
result.Should().HaveCount(1);
}
public void CreateCommand_should_return_expected_result_when_MaxTime_is_set(
[Values(null, 1, 2)]
int? milliseconds)
{
var maxTime = milliseconds == null ? (TimeSpan?)null : TimeSpan.FromMilliseconds(milliseconds.Value);
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
MaxTime = maxTime
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "maxTimeMS", () => milliseconds.Value, milliseconds != null }
};
result.Should().Be(expectedResult);
}
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 CreateCommand_should_return_expected_result_when_Collation_is_set(
[Values(null, "en_US")]
string locale)
{
var collation = locale == null ? null : new Collation(locale);
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
Collation = collation
};
var result = subject.CreateCommand(Feature.Collation.FirstSupportedVersion);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "collation", () => collation.ToBsonDocument(), collation != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_create_the_correct_command(
[Values(null, false, true)] bool? allowDiskUse,
[Values(null, 2000)] int? maxTime)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, _pipeline, _messageEncoderSettings)
{
AllowDiskUse = allowDiskUse,
MaxTime = maxTime.HasValue ? TimeSpan.FromMilliseconds(maxTime.Value) : (TimeSpan?)null,
};
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(subject.Pipeline) },
{ "allowDiskUse", () => allowDiskUse.Value, allowDiskUse.HasValue },
{ "maxTimeMS", () => maxTime.Value, maxTime.HasValue }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
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 Executing_with_matching_documents_using_all_options(
[Values(false, true)]
bool async)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, _pipeline, _messageEncoderSettings)
{
AllowDiskUse = true,
MaxTime = TimeSpan.FromSeconds(20)
};
ExecuteOperation(subject, async);
var result = ReadAllFromCollection(new CollectionNamespace(_databaseNamespace, "awesome"), async);
result.Should().NotBeNull();
result.Should().HaveCount(2);
}
public void CreateCommand_should_return_expected_result_when_AllowDiskUse_is_set(
[Values(null, false, true)]
bool? allowDiskUse)
{
var subject = new AggregateToCollectionOperation(_collectionNamespace, __pipeline, _messageEncoderSettings)
{
AllowDiskUse = allowDiskUse
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "allowDiskUse", () => allowDiskUse.Value, allowDiskUse != null }
};
result.Should().Be(expectedResult);
}
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 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 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>();
}
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);
}
