public void MatchingRuleHasTransientLifetime()
{
MethodSignatureMatchingRuleData ruleData = new MethodSignatureMatchingRuleData("ruleName", "Foo");
TypeRegistration registration = ruleData.GetRegistrations("").First();
Assert.AreEqual(TypeRegistrationLifetime.Transient, registration.Lifetime);
}
/// <summary>
/// Returs the represented <see cref="MethodSignatureMatchingRuleData"/> instance.
/// </summary>
/// <returns>A newly created <see cref="MethodSignatureMatchingRuleData"/> instance.</returns>
public override MatchingRuleData GetConfigurationData()
{
MethodSignatureMatchingRuleData ruleData = new MethodSignatureMatchingRuleData(Name, Match);
ruleData.IgnoreCase = IgnoreCase;
foreach (ParameterType parameterType in ParameterTypes)
{
ruleData.Parameters.Add(new ParameterTypeElement(parameterType.Name, parameterType.Type));
}
return(ruleData);
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodSignatureMatchingRuleNode"/> class for representing a <see cref="MethodSignatureMatchingRuleData"/> instance.
/// </summary>
/// <param name="ruleData">The <see cref="MethodSignatureMatchingRuleData"/> to represent.</param>
public MethodSignatureMatchingRuleNode(MethodSignatureMatchingRuleData ruleData)
: base(ruleData)
{
ignoreCase = ruleData.IgnoreCase;
match = ruleData.Match;
parameterTypes = new List <ParameterType>();
foreach (ParameterTypeElement parameterType in ruleData.Parameters)
{
parameterTypes.Add(new ParameterType(parameterType.Name, parameterType.ParameterTypeName));
}
}
public void MatchingRuleHasTransientLifetime()
{
MethodSignatureMatchingRuleData ruleData = new MethodSignatureMatchingRuleData("ruleName", "Foo");
using (var container = new UnityContainer())
{
ruleData.ConfigureContainer(container, "-test");
var registration = container.Registrations.Single(r => r.Name == "ruleName-test");
Assert.AreSame(typeof(IMatchingRule), registration.RegisteredType);
Assert.AreSame(typeof(MethodSignatureMatchingRule), registration.MappedToType);
Assert.AreSame(typeof(TransientLifetimeManager), registration.LifetimeManagerType);
}
}
public void CanSerializeMethodSignatureContainingDuplicatedTypes()
{
MethodSignatureMatchingRuleData ruleData =
new MethodSignatureMatchingRuleData("ruleName", "Foo");
ruleData.Parameters.Add(new ParameterTypeElement("p1", "System.String"));
ruleData.Parameters.Add(new ParameterTypeElement("p2", "System.Int"));
ruleData.Parameters.Add(new ParameterTypeElement("p3", "System.String"));
Assert.AreEqual(3, ruleData.Parameters.Count);
MethodSignatureMatchingRuleData deserializedRule = SerializeAndDeserializeMatchingRule(ruleData) as MethodSignatureMatchingRuleData;
Assert.IsNotNull(deserializedRule);
AssertAreSame(ruleData, deserializedRule);
}
public void CanSerializeTypeMatchingRule()
{
MethodSignatureMatchingRuleData sigMatchingRule = new MethodSignatureMatchingRuleData("RuleName", "Contains");
sigMatchingRule.IgnoreCase = true;
sigMatchingRule.Parameters.Add(new ParameterTypeElement("p1", "String"));
MethodSignatureMatchingRuleData deserializedRule = SerializeAndDeserializeMatchingRule(sigMatchingRule) as MethodSignatureMatchingRuleData;
Assert.IsNotNull(deserializedRule);
AssertAreSame(sigMatchingRule, deserializedRule);
ParameterTypeElement param = deserializedRule.Parameters.Get(0);
Assert.IsNotNull(param);
Assert.AreEqual("String", param.ParameterTypeName);
}
private void AssertAreSame(MethodSignatureMatchingRuleData expected, MethodSignatureMatchingRuleData actual)
{
Assert.AreEqual(expected.Name, actual.Name);
Assert.AreEqual(expected.Match, actual.Match);
Assert.AreEqual(expected.IgnoreCase, actual.IgnoreCase);
Assert.AreEqual(expected.Parameters.Count, actual.Parameters.Count);
for (int i = 0; i < expected.Parameters.Count; ++i)
{
ParameterTypeElement expectedElement = expected.Parameters.Get(i);
ParameterTypeElement actualElement = actual.Parameters.Get(i);
Assert.AreEqual(expectedElement.ParameterTypeName, actualElement.ParameterTypeName,
"Parameter type mismatch at element {0}", i);
}
}
public void CanCreateRuleDataFromMethodSignatureMatchingRuleNode()
{
MethodSignatureMatchingRuleNode ruleNode = new MethodSignatureMatchingRuleNode();
ruleNode.Name = "RuleName";
ruleNode.Match = "MethodName";
ruleNode.IgnoreCase = true;
ruleNode.ParameterTypes.Add(new ParameterType("p1", "ParamType1"));
ruleNode.ParameterTypes.Add(new ParameterType("p2", "ParamType2"));
MethodSignatureMatchingRuleData ruleData = ruleNode.GetConfigurationData() as MethodSignatureMatchingRuleData;
Assert.IsNotNull(ruleData);
Assert.AreEqual(ruleNode.Name, ruleData.Name);
Assert.AreEqual(ruleNode.Match, ruleData.Match);
Assert.AreEqual(ruleNode.IgnoreCase, ruleData.IgnoreCase);
Assert.AreEqual(ruleNode.ParameterTypes[0].Type, ruleData.Parameters.Get(0).ParameterTypeName);
Assert.AreEqual(ruleNode.ParameterTypes[1].Type, ruleData.Parameters.Get(1).ParameterTypeName);
}
public void CanCreateMethodSignatureMatchingRuleNodeFromData()
{
MethodSignatureMatchingRuleData ruleData = new MethodSignatureMatchingRuleData();
ruleData.Name = "rule name";
ruleData.IgnoreCase = false;
ruleData.Match = "MemberName";
ruleData.Parameters.Add(new ParameterTypeElement("p1", "ParameterType1"));
ruleData.Parameters.Add(new ParameterTypeElement("p2", "ParameterType2"));
MethodSignatureMatchingRuleNode ruleNode = new MethodSignatureMatchingRuleNode(ruleData);
Assert.AreEqual(ruleData.Name, ruleNode.Name);
Assert.AreEqual(ruleData.Match, ruleNode.Match);
Assert.AreEqual(ruleData.IgnoreCase, ruleNode.IgnoreCase);
Assert.AreEqual(ruleData.Parameters.Count, ruleNode.ParameterTypes.Count);
Assert.AreEqual(ruleData.Parameters.Get(0).ParameterTypeName, ruleNode.ParameterTypes[0].Type);
Assert.AreEqual(ruleData.Parameters.Get(1).ParameterTypeName, ruleNode.ParameterTypes[1].Type);
}
