private static void TestMapReduce()
{
const string map = @"function () {
emit(this.identifier, this.count);
}";
const string reduce = @"function (gender, count) {
return Array.sum(count);
}";
var client = new MongoClient("mongodb://*****:*****@ds047782.mongolab.com:47782/testcrud");
var database = client.GetDatabase("testcrud");
var collection = database.GetCollection<BsonDocument>("aggregates");
var bsonMap = new BsonJavaScript(map);
var bsonReduce = new BsonJavaScript(reduce);
//collection.MapReduceAsync(bsonMap, bsonReduce, )
var x = new MapReduceOutputToCollectionOperation(new CollectionNamespace("testcrud", "aggregates"),
new CollectionNamespace("testcrud", "reduced2"), bsonMap, bsonReduce, new MessageEncoderSettings());
//x.ExecuteAsync();
}
public void BypassDocumentValidation_should_get_and_set_value()
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
var value = true;
subject.BypassDocumentValidation = value;
var result = subject.BypassDocumentValidation;
result.Should().Be(value);
}
public void BypassDocumentValidation_get_and_set_should_work(
[Values(null, false, true)]
bool? value)
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
subject.BypassDocumentValidation = value;
var result = subject.BypassDocumentValidation;
result.Should().Be(value);
}
public void constructor_should_initialize_instance()
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
subject.CollectionNamespace.Should().BeSameAs(_collectionNamespace);
subject.OutputCollectionNamespace.Should().BeSameAs(_outputCollectionNamespace);
subject.MapFunction.Should().BeSameAs(_mapFunction);
subject.MessageEncoderSettings.Should().BeSameAs(_messageEncoderSettings);
subject.Filter.Should().BeNull();
subject.ReduceFunction.Should().BeSameAs(_reduceFunction);
subject.OutputMode.Should().Be(MapReduceOutputMode.Replace);
}
public void CreateOutputOptions_should_return_expected_result()
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
var subjectReflector = new Reflector(subject);
var expectedResult = new BsonDocument
{
{ "replace", _outputCollectionNamespace.CollectionName },
{ "db", _outputCollectionNamespace.DatabaseNamespace.DatabaseName }
};
var result = subjectReflector.CreateOutputOptions();
result.Should().Be(expectedResult);
}
public void constructor_should_initialize_instance()
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
subject.CollectionNamespace.Should().BeSameAs(_collectionNamespace);
subject.OutputCollectionNamespace.Should().BeSameAs(_outputCollectionNamespace);
subject.MapFunction.Should().BeSameAs(_mapFunction);
subject.ReduceFunction.Should().BeSameAs(_reduceFunction);
subject.MessageEncoderSettings.Should().BeSameAs(_messageEncoderSettings);
subject.BypassDocumentValidation.Should().NotHaveValue();
subject.Collation.Should().BeNull();
subject.Filter.Should().BeNull();
subject.FinalizeFunction.Should().BeNull();
subject.JavaScriptMode.Should().NotHaveValue();
subject.Limit.Should().NotHaveValue();
subject.MaxTime.Should().NotHaveValue();
subject.NonAtomicOutput.Should().NotHaveValue();
subject.OutputMode.Should().Be(MapReduceOutputMode.Replace);
subject.Scope.Should().BeNull();
subject.Sort.Should().BeNull();
subject.Verbose.Should().NotHaveValue();
}
public void Execute_should_throw_when_a_write_concern_error_occurs(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.CommandsThatWriteAcceptWriteConcern).ClusterType(ClusterType.ReplicaSet);
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
WriteConcern = new WriteConcern(9)
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
exception.Should().BeOfType<MongoWriteConcernException>();
}
public void CreateOutputOptions_should_return_expected_result_when_NonAtomicOutput_is_provided(
[Values(null, false, true)]
bool? nonAtomicOutput)
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
NonAtomicOutput = nonAtomicOutput
};
var subjectReflector = new Reflector(subject);
var expectedResult = new BsonDocument
{
{ "replace", _outputCollectionNamespace.CollectionName },
{ "db", _outputCollectionNamespace.DatabaseNamespace.DatabaseName },
{ "nonAtomic", () => nonAtomicOutput.Value, nonAtomicOutput.HasValue }
};
var result = subjectReflector.CreateOutputOptions();
result.Should().Be(expectedResult);
}
public void Execute_should_return_expected_results_when_Scope_is_set(
[Values(false, true)]
bool async)
{
RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet);
EnsureTestData();
var finalizeFunction = new BsonJavaScript("function(key, reduced) { return reduced + zeroFromScope; }");
var scope = new BsonDocument("zeroFromScope", 0);
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
FinalizeFunction = finalizeFunction,
Scope = scope
};
ExecuteOperation(subject, async);
ReadAllFromCollection(_outputCollectionNamespace).Should().Equal(
BsonDocument.Parse("{ _id : 1, value : 3 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }"));
}
public void Execute_should_return_expected_results_when_Sort_is_set(
[Values(1, -1)]
int direction,
[Values(false, true)]
bool async)
{
RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet);
EnsureTestData();
var sort = new BsonDocument("_id", direction);
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
Limit = 2,
Sort = sort
};
ExecuteOperation(subject, async);
BsonDocument[] expectedResults;
if (direction == 1)
{
expectedResults = new[]
{
BsonDocument.Parse("{ _id : 1, value : 3 }")
};
}
else
{
expectedResults = new[]
{
BsonDocument.Parse("{ _id : 1, value : 2 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }")
};
}
ReadAllFromCollection(_outputCollectionNamespace).Should().Equal(expectedResults);
}
public void OutputCollectionNamespace_get_and_set_should_work(
[Values("a", "b")]
string collectionName)
{
var outputCollectionNamespace = new CollectionNamespace(_databaseNamespace, collectionName);
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
var result = subject.OutputCollectionNamespace;
result.Should().BeSameAs(outputCollectionNamespace);
}
public void ExecuteAsync_should_throw_when_binding_is_null()
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
Action action = () => subject.ExecuteAsync(null, CancellationToken.None);
action.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("binding");
}
public void NonAtomicOutput_should_get_and_set_value()
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
var value = true;
subject.NonAtomicOutput = value;
var result = subject.NonAtomicOutput;
result.Should().Be(value);
}
public void OutputMode_should_get_and_set_value()
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
var value = MapReduceOutputMode.Merge;
subject.OutputMode = value;
var result = subject.OutputMode;
result.Should().Be(value);
}
public void Execute_should_throw_when_binding_is_null(
[Values(false, true)]
bool async)
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
Action action = () => ExecuteOperation(subject, null, async);
action.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("binding");
}
public void Filter_should_get_and_set_value(
[Values(null, "{ x : 1 }", "{ x : 2 }")]
string valueString)
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
var value = valueString == null ? null : BsonDocument.Parse(valueString);
subject.Filter = value;
var result = subject.Filter;
result.Should().Be(value);
}
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 MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
WriteConcern = writeConcern
};
var subjectReflector = new Reflector(subject);
var serverVersion = Feature.CommandsThatWriteAcceptWriteConcern.SupportedOrNotSupportedVersion(isWriteConcernSupported);
var result = subjectReflector.CreateCommand(serverVersion);
var expectedResult = new BsonDocument
{
{ "mapreduce", _collectionNamespace.CollectionName },
{ "map", _mapFunction },
{ "reduce", _reduceFunction },
{ "out", new BsonDocument { {"replace", _outputCollectionNamespace.CollectionName }, { "db", _databaseNamespace.DatabaseName } } },
{ "writeConcern", () => writeConcern.ToBsonDocument(), writeConcern != null && isWriteConcernSupported }
};
result.Should().Be(expectedResult);
}
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 MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
BypassDocumentValidation = bypassDocumentValidation
};
var subjectReflector = new Reflector(subject);
var serverVersion = Feature.BypassDocumentValidation.SupportedOrNotSupportedVersion(useServerVersionSupportingBypassDocumentValidation);
var result = subjectReflector.CreateCommand(serverVersion);
var expectedResult = new BsonDocument
{
{ "mapreduce", _collectionNamespace.CollectionName },
{ "map", _mapFunction },
{ "reduce", _reduceFunction },
{ "out", new BsonDocument { {"replace", _outputCollectionNamespace.CollectionName }, { "db", _databaseNamespace.DatabaseName } } },
{ "bypassDocumentValidation", () => bypassDocumentValidation.Value, bypassDocumentValidation.HasValue && Feature.BypassDocumentValidation.IsSupported(serverVersion) }
};
result.Should().Be(expectedResult);
}
public void WriteConcern_get_and_set_should_work(
[Values(null, 1, 2)]
int? w)
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
var value = w.HasValue ? new WriteConcern(w.Value) : null;
subject.WriteConcern = value;
var result = subject.WriteConcern;
result.Should().BeSameAs(value);
}
public void Execute_should_return_expected_result(
[Values(false, true)]
bool async)
{
EnsureTestData();
var mapFunction = "function() { emit(this.x, this.v); }";
var reduceFunction = "function(key, values) { var sum = 0; for (var i = 0; i < values.length; i++) { sum += values[i]; }; return sum; }";
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, mapFunction, reduceFunction, _messageEncoderSettings)
{
BypassDocumentValidation = true
};
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { {"_id", 1 }, { "value", 3 } },
new BsonDocument { {"_id", 2 }, { "value", 4 } },
};
var response = ExecuteOperation(subject, async);
response["ok"].ToBoolean().Should().BeTrue();
var documents = ReadAllFromCollection(_outputCollectionNamespace, async);
documents.Should().BeEquivalentTo(expectedDocuments);
}
public void Execute_should_return_expected_results_when_Collation_is_set(
[Values(false, true)]
bool caseSensitive,
[Values(false, true)]
bool async)
{
RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet).Supports(Feature.Collation);
EnsureTestData();
var collation = new Collation("en_US", caseLevel: caseSensitive, strength: CollationStrength.Primary);
var filter = BsonDocument.Parse("{ y : 'a' }");
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
Collation = collation,
Filter = filter
};
ExecuteOperation(subject, async);
BsonDocument[] expectedResults;
if (caseSensitive)
{
expectedResults = new[]
{
BsonDocument.Parse("{ _id : 1, value : 1 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }")
};
}
else
{
expectedResults = new[]
{
BsonDocument.Parse("{ _id : 1, value : 3 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }")
};
}
ReadAllFromCollection(_outputCollectionNamespace).Should().Equal(expectedResults);
}
public void Filter_should_get_and_set_value()
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
var value = new BsonDocument("_id", 1);
subject.Filter = value;
var result = subject.Filter;
result.Should().Be(value);
}
public void Execute_should_return_expected_results_when_Filter_is_set(
[Values(false, true)]
bool async)
{
RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet);
EnsureTestData();
var filter = BsonDocument.Parse("{ y : 'a' }");
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
Filter = filter
};
ExecuteOperation(subject, async);
ReadAllFromCollection(_outputCollectionNamespace).Should().Equal(
BsonDocument.Parse("{ _id : 1, value : 1 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }"));
}
public void OutputCollectionNamespace_should_get__value()
{
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings);
var result = subject.OutputCollectionNamespace;
result.Should().BeSameAs(_outputCollectionNamespace);
}
public void Execute_should_return_expected_results_when_Limit_is_set(
[Values(1, 2)]
long limit,
[Values(false, true)]
bool async)
{
RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet);
EnsureTestData();
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
Limit = limit
};
ExecuteOperation(subject, async);
var expectedResults = new[]
{
new BsonDocument { { "_id", 1 }, { "value", limit == 1 ? 1 : 3 } }
};
ReadAllFromCollection(_outputCollectionNamespace).Should().Equal(expectedResults);
}
// constructor
public Reflector(MapReduceOutputToCollectionOperation instance)
{
_instance = instance;
}
public void Execute_should_return_expected_results_when_MaxTime_is_set(
[Values(null, 1000)]
int? seconds,
[Values(false, true)]
bool async)
{
RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet).Supports(Feature.MaxTime);
EnsureTestData();
var maxTime = seconds.HasValue ? TimeSpan.FromSeconds(seconds.Value) : (TimeSpan?)null;
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings)
{
MaxTime = maxTime
};
ExecuteOperation(subject, async);
// results should be the same whether MaxTime was used or not
ReadAllFromCollection(_outputCollectionNamespace).Should().Equal(
BsonDocument.Parse("{ _id : 1, value : 3 }"),
BsonDocument.Parse("{ _id : 2, value : 4 }"));
}
public override async Task <IAsyncCursor <TResult> > MapReduceAsync <TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions <TDocument, TResult> options = null, CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(map, "map");
Ensure.IsNotNull(reduce, "reduce");
options = options ?? new MapReduceOptions <TDocument, TResult>();
var outputOptions = options.OutputOptions ?? MapReduceOutputOptions.Inline;
var resultSerializer = ResolveResultSerializer <TResult>(options.ResultSerializer);
if (outputOptions == MapReduceOutputOptions.Inline)
{
var operation = new MapReduceOperation <TResult>(
_collectionNamespace,
map,
reduce,
resultSerializer,
_messageEncoderSettings)
{
Filter = options.Filter == null ? null : options.Filter.Render(_documentSerializer, _settings.SerializerRegistry),
FinalizeFunction = options.Finalize,
JavaScriptMode = options.JavaScriptMode,
Limit = options.Limit,
MaxTime = options.MaxTime,
Scope = options.Scope,
Sort = options.Sort == null ? null : options.Sort.Render(_documentSerializer, _settings.SerializerRegistry),
Verbose = options.Verbose
};
return(await ExecuteReadOperation(operation, cancellationToken).ConfigureAwait(false));
}
else
{
var collectionOutputOptions = (MapReduceOutputOptions.CollectionOutput)outputOptions;
var databaseNamespace = collectionOutputOptions.DatabaseName == null ?
_collectionNamespace.DatabaseNamespace :
new DatabaseNamespace(collectionOutputOptions.DatabaseName);
var outputCollectionNamespace = new CollectionNamespace(databaseNamespace, collectionOutputOptions.CollectionName);
var operation = new MapReduceOutputToCollectionOperation(
_collectionNamespace,
outputCollectionNamespace,
map,
reduce,
_messageEncoderSettings)
{
Filter = options.Filter == null ? null : options.Filter.Render(_documentSerializer, _settings.SerializerRegistry),
FinalizeFunction = options.Finalize,
JavaScriptMode = options.JavaScriptMode,
Limit = options.Limit,
MaxTime = options.MaxTime,
NonAtomicOutput = collectionOutputOptions.NonAtomic,
Scope = options.Scope,
OutputMode = collectionOutputOptions.OutputMode,
ShardedOutput = collectionOutputOptions.Sharded,
Sort = options.Sort == null ? null : options.Sort.Render(_documentSerializer, _settings.SerializerRegistry),
Verbose = options.Verbose
};
await ExecuteWriteOperation(operation, cancellationToken).ConfigureAwait(false);
var findOperation = new FindOperation <TResult>(
outputCollectionNamespace,
resultSerializer,
_messageEncoderSettings)
{
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));
return(await Task.FromResult(deferredCursor).ConfigureAwait(false));
}
}
public async Task ExecuteAsync_should_return_expected_result()
{
await EnsureTestDataAsync();
var mapFunction = "function() { emit(this.x, this.v); }";
var reduceFunction = "function(key, values) { var sum = 0; for (var i = 0; i < values.length; i++) { sum += values[i]; }; return sum; }";
var subject = new MapReduceOutputToCollectionOperation(_collectionNamespace, _outputCollectionNamespace, mapFunction, reduceFunction, _messageEncoderSettings);
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { {"_id", 1 }, { "value", 3 } },
new BsonDocument { {"_id", 2 }, { "value", 4 } },
};
var response = await ExecuteOperationAsync(subject);
response["ok"].ToBoolean().Should().BeTrue();
var documents = await ReadAllFromCollectionAsync(_outputCollectionNamespace);
documents.Should().BeEquivalentTo(expectedDocuments);
}
