public void CreateCommand_should_return_expected_result_when_MaxTime_is_set(
[Values(null, 1, 2)]
int?seconds)
{
var maxTime = seconds.HasValue ? TimeSpan.FromSeconds(seconds.Value) : (TimeSpan?)null;
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings)
{
MaxTime = maxTime
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "group", new BsonDocument
{
{ "ns", _collectionNamespace.CollectionName },
{ "key", _key },
{ "$reduce", _reduceFunction },
{ "initial", _initial }
} },
{ "maxTimeMS", () => seconds.Value * 1000, seconds.HasValue }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_Collation_is_set(
[Values(null, "en_US", "fr_CA")]
string locale)
{
var collation = locale == null ? null : new Collation(locale);
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings)
{
Collation = collation
};
var result = subject.CreateCommand(Feature.Collation.FirstSupportedVersion);
var expectedResult = new BsonDocument
{
{ "group", new BsonDocument
{
{ "ns", _collectionNamespace.CollectionName },
{ "key", _key },
{ "$reduce", _reduceFunction },
{ "initial", _initial },
{ "collation", () => collation.ToBsonDocument(), collation != null }
} }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_finalizeFunction_is_set(
[Values(false, true)]
bool isFinalizeFunctionNull)
{
var finalizeFunction = isFinalizeFunctionNull ? null : _finalizeFunction;
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings)
{
FinalizeFunction = finalizeFunction
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "group", new BsonDocument
{
{ "ns", _collectionNamespace.CollectionName },
{ "key", _key },
{ "$reduce", _reduceFunction },
{ "initial", _initial },
{ "finalize", finalizeFunction, finalizeFunction != null }
} }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_maxTime_was_provided()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation <BsonDocument>(collectionNamespace, key, initial, reduceFunction, null, messageEncoderSettings);
subject.MaxTime = TimeSpan.FromSeconds(1);
var expectedResult = new BsonDocument
{
{ "group", new BsonDocument
{
{ "ns", collectionNamespace.CollectionName },
{ "key", key },
{ "$reduce", reduceFunction },
{ "initial", initial }
} },
{ "maxTimeMS", 1000 }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
public void Execute_should_send_session_id_when_supported(
[Values(false, true)] bool async)
{
RequireServer.Check();
EnsureTestData();
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings);
VerifySessionIdWasSentWhenSupported(subject, "group", async);
}
// constructors
public Builder(GroupOperation other)
{
_collectionName = other.CollectionName;
_databaseName = other.DatabaseName;
_finalizeFunction = other.FinalizeFunction;
_initial = other.Initial;
_key = other.Key;
_keyFunction = other.KeyFunction;
_query = other.Query;
_reduceFunction = other.ReduceFunction;
}
public void MaxTime_get_and_set_should_work(
[Values(-10000, 0, 1, 10000, 99999)] long maxTimeTicks)
{
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, _filter, _messageEncoderSettings);
var value = TimeSpan.FromTicks(maxTimeTicks);
subject.MaxTime = value;
var result = subject.MaxTime;
result.Should().Be(value);
}
public void MaxTime_set_should_throw_when_value_is_invalid(
[Values(-10001, -9999, -1)] long maxTimeTicks)
{
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, _filter, _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 FinalizeFunction_get_and_set_should_work(
[Values(null, "x", "y")]
string code)
{
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, _filter, _messageEncoderSettings);
var value = code == null ? null : new BsonJavaScript(code);
subject.FinalizeFunction = value;
var result = subject.FinalizeFunction;
result.Should().BeSameAs(value);
}
public void Collation_get_and_set_should_work(
[Values(null, "en_US", "fr_CA")]
string locale)
{
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, _filter, _messageEncoderSettings);
var value = locale == null ? null : new Collation(locale);
subject.Collation = value;
var result = subject.Collation;
result.Should().BeSameAs(value);
}
public void MaxTime_get_and_set_should_work(
[Values(null, 1, 2)]
int?seconds)
{
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, _filter, _messageEncoderSettings);
var value = seconds.HasValue ? TimeSpan.FromSeconds(seconds.Value) : (TimeSpan?)null;
subject.MaxTime = value;
var result = subject.MaxTime;
result.Should().Be(value);
}
public void ResultSerializer_get_and_set_should_work(
[Values(false, true)]
bool isNull)
{
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, _filter, _messageEncoderSettings);
var value = isNull ? null : new BsonDocumentSerializer();
subject.ResultSerializer = value;
var result = subject.ResultSerializer;
result.Should().Be(value);
}
public void MaxTime_should_work()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var criteria = new BsonDocument("y", 1);
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation <BsonDocument>(collectionNamespace, key, initial, reduceFunction, criteria, messageEncoderSettings);
var maxTime = TimeSpan.FromSeconds(1);
subject.MaxTime = maxTime;
subject.MaxTime.Should().Be(maxTime);
}
public void FinalizeFunction_should_work()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var criteria = new BsonDocument("y", 1);
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation <BsonDocument>(collectionNamespace, key, initial, reduceFunction, criteria, messageEncoderSettings);
var finalizeFunction = new BsonJavaScript("finalizeFunction");
subject.FinalizeFunction = finalizeFunction;
subject.FinalizeFunction.Should().Be(finalizeFunction);
}
public void Execute_should_throw_when_maxTime_is_exceeded(
[Values(false, true)] bool async)
{
RequireServer.Check().Supports(Feature.FailPoints).ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet);
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings);
subject.MaxTime = TimeSpan.FromSeconds(9001);
using (var failPoint = FailPoint.ConfigureAlwaysOn(CoreTestConfiguration.Cluster, _session, FailPointName.MaxTimeAlwaysTimeout))
{
var exception = Record.Exception(() => ExecuteOperation(subject, failPoint.Binding, async));
exception.Should().BeOfType <MongoExecutionTimeoutException>();
}
}
public void Execute_should_return_expected_result_when_keyFunction_is_used(
[Values(false, true)]
bool async)
{
RequireServer.Check();
EnsureTestData();
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _keyFunction, _initial, _reduceFunction, null, _messageEncoderSettings);
var result = ExecuteOperation(subject, async);
result.Should().Equal(
BsonDocument.Parse("{ x : 1, count : 2 }"),
BsonDocument.Parse("{ x : 2, count : 1 }"),
BsonDocument.Parse("{ x : 3, count : 3 }"));
}
public void Execute_should_throw_when_Collation_is_set_but_not_supported(
[Values(false, true)]
bool async)
{
RequireServer.Check().DoesNotSupport(Feature.Collation);
EnsureTestData();
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings)
{
Collation = new Collation("en_US")
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
exception.Should().BeOfType <NotSupportedException>();
}
public void ResultSerializer_should_work()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var criteria = new BsonDocument("y", 1);
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation <BsonDocument>(collectionNamespace, key, initial, reduceFunction, criteria, messageEncoderSettings);
var resultSerializer = Substitute.For <IBsonSerializer <BsonDocument> >();
subject.ResultSerializer = resultSerializer;
subject.ResultSerializer.Should().BeSameAs(resultSerializer);
}
public void Execute_should_return_expected_result_when_ResultSerializer_is_used(
[Values(false, true)]
bool async)
{
RequireServer.Check();
EnsureTestData();
var resultSerializer = new ElementDeserializer <int>("x", new Int32Serializer());
var subject = new GroupOperation <int>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings)
{
ResultSerializer = resultSerializer
};
var result = ExecuteOperation(subject, async);
result.Should().Equal(1, 2, 3);
}
public void constructor_with_keyFunction_should_initialize_subject()
{
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _keyFunction, _initial, _reduceFunction, _filter, _messageEncoderSettings);
subject.CollectionNamespace.Should().Be(_collectionNamespace);
subject.KeyFunction.Should().Be(_keyFunction);
subject.Initial.Should().Be(_initial);
subject.ReduceFunction.Should().Be(_reduceFunction);
subject.Filter.Should().Be(_filter);
subject.MessageEncoderSettings.Should().BeSameAs(_messageEncoderSettings);
subject.Collation.Should().BeNull();
subject.FinalizeFunction.Should().BeNull();
subject.Key.Should().BeNull();
subject.MaxTime.Should().Be(default(TimeSpan?));
subject.ResultSerializer.Should().BeNull();
}
public void Execute_should_return_expected_result_when_FinalizeFunction_is_set(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.GroupCommand);
EnsureTestData();
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings)
{
FinalizeFunction = _finalizeFunction
};
var result = ExecuteOperation(subject, async);
result.Should().Equal(
BsonDocument.Parse("{ x : 1, count : -2 }"),
BsonDocument.Parse("{ x : 2, count : -1 }"),
BsonDocument.Parse("{ x : 3, count : -3 }"));
}
public void constructor_with_key_should_initialize_subject()
{
var collectionNamespace = new CollectionNamespace("databaseName", "collectionName");
var key = new BsonDocument("key", 1);
var initial = new BsonDocument("x", 1);
var reduceFunction = new BsonJavaScript("reduceFunction");
var criteria = new BsonDocument("y", 1);
var messageEncoderSettings = new MessageEncoderSettings();
var subject = new GroupOperation <BsonDocument>(collectionNamespace, key, initial, reduceFunction, criteria, messageEncoderSettings);
subject.CollectionNamespace.Should().Be(collectionNamespace);
subject.Criteria.Should().Be(criteria);
subject.FinalizeFunction.Should().BeNull();
subject.Initial.Should().Be(initial);
subject.Key.Should().Be(key);
subject.KeyFunction.Should().BeNull();
subject.MaxTime.Should().Be(default(TimeSpan?));
Assert.That(subject.MessageEncoderSettings, Is.EqualTo(messageEncoderSettings));
subject.ReduceFunction.Should().Be(reduceFunction);
subject.ResultSerializer.Should().BeNull();
}
public void Execute_should_throw_when_binding_is_null(
[Values(false, true)]
bool async)
{
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, _filter, _messageEncoderSettings);
var exception = Record.Exception(() =>
{
if (async)
{
subject.ExecuteAsync(null, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
subject.Execute(null, CancellationToken.None);
}
});
var argumentNullException = exception.Should().BeOfType <ArgumentNullException>().Subject;
argumentNullException.ParamName.Should().Be("binding");
}
public void Execute_should_return_expected_result_when_MaxTime_is_used(
[Values(null, 1000)]
int?seconds,
[Values(false, true)]
bool async)
{
RequireServer.Check();
EnsureTestData();
var maxTime = seconds.HasValue ? TimeSpan.FromSeconds(seconds.Value) : (TimeSpan?)null;
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings)
{
MaxTime = maxTime
};
// TODO: force a timeout on the server? for now we're just smoke testing
var result = ExecuteOperation(subject, async);
result.Should().Equal(
BsonDocument.Parse("{ x : 1, count : 2 }"),
BsonDocument.Parse("{ x : 2, count : 1 }"),
BsonDocument.Parse("{ x : 3, count : 3 }"));
}
public void CreateCommand_should_return_expected_result_when_keyFunction_is_used(
[Values(false, true)]
bool isFilterNull)
{
var filter = isFilterNull ? _filter : null;
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _keyFunction, _initial, _reduceFunction, filter, _messageEncoderSettings);
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "group", new BsonDocument
{
{ "ns", _collectionNamespace.CollectionName },
{ "$keyf", _keyFunction },
{ "$reduce", _reduceFunction },
{ "initial", _initial },
{ "cond", filter, filter != null }
} }
};
result.Should().Be(expectedResult);
}
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.Collation);
EnsureTestData();
var collation = new Collation("en_US", caseLevel: caseSensitive, strength: CollationStrength.Primary);
var filter = BsonDocument.Parse("{ y : 'a' }");
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, filter, _messageEncoderSettings)
{
Collation = collation
};
var result = ExecuteOperation(subject, async);
BsonDocument[] expectedResult;
if (caseSensitive)
{
expectedResult = new[]
{
BsonDocument.Parse("{ x : 1, count : 2 }"),
BsonDocument.Parse("{ x : 3, count : 2 }")
};
}
else
{
expectedResult = new[]
{
BsonDocument.Parse("{ x : 1, count : 2 }"),
BsonDocument.Parse("{ x : 2, count : 1 }"),
BsonDocument.Parse("{ x : 3, count : 3 }")
};
}
result.Should().Equal(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_MaxTime_is_set(long maxTimeTicks, int expectedMaxTimeMS)
{
var subject = new GroupOperation <BsonDocument>(_collectionNamespace, _key, _initial, _reduceFunction, null, _messageEncoderSettings)
{
MaxTime = TimeSpan.FromTicks(maxTimeTicks)
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "group", new BsonDocument
{
{ "ns", _collectionNamespace.CollectionName },
{ "key", _key },
{ "$reduce", _reduceFunction },
{ "initial", _initial }
} },
{ "maxTimeMS", expectedMaxTimeMS }
};
result.Should().Be(expectedResult);
result["maxTimeMS"].BsonType.Should().Be(BsonType.Int32);
}