public void ShouldCreateCorrectMatchingRule()
{
PolicyData policyData = new PolicyData("Validate Parameters");
policyData.Handlers.Add(new ValidationCallHandlerData());
ParameterTypeMatchingRuleData matchingRuleData = GetParameterTypeMatchingRuleData();
policyData.MatchingRules.Add(matchingRuleData);
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(policyData);
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
configSource.Add(PolicyInjectionSettings.SectionName, settings);
PolicySetFactory factory = new PolicySetFactory(configSource);
PolicySet policies = factory.Create();
Policy policy = policies[1];
Assert.IsTrue(policy is RuleDrivenPolicy);
RuleDrivenPolicy validateRule = (RuleDrivenPolicy)policy;
Assert.IsTrue(validateRule.RuleSet[0] is ParameterTypeMatchingRule);
ParameterTypeMatchingRule rule = (ParameterTypeMatchingRule)(validateRule.RuleSet[0]);
Assert.AreEqual(3, rule.ParameterMatches.Count);
for (int i = 0; i < matchingRuleData.Matches.Count; ++i)
{
AssertMatchDataEqual(matchingRuleData.Matches[i], rule.ParameterMatches[i], "Mismatch at element {0}", i);
}
}
public void MatchingRuleHasTransientLifetime()
{
ParameterTypeMatchingRuleData ruleData = GetParameterTypeMatchingRuleData();
TypeRegistration registration = ruleData.GetRegistrations("").First();
Assert.AreEqual(TypeRegistrationLifetime.Transient, registration.Lifetime);
}
/// <summary>
/// Get the configuration node data from the design time node.
/// </summary>
/// <returns>Configuration data that this node represents.</returns>
public override MatchingRuleData GetConfigurationData()
{
ParameterTypeMatchingRuleData ruleData = new ParameterTypeMatchingRuleData(
Name,
ConvertRuleNodeToDataMatches(matches));
return(ruleData);
}
public void MatchingRuleHasTransientLifetime()
{
ParameterTypeMatchingRuleData ruleData = GetParameterTypeMatchingRuleData();
using (var container = new UnityContainer())
{
ruleData.ConfigureContainer(container, "-test");
var registration = container.Registrations.Single(r => r.Name == "Parameter Matching Rule-test");
Assert.AreSame(typeof(IMatchingRule), registration.RegisteredType);
Assert.AreSame(typeof(ParameterTypeMatchingRule), registration.MappedToType);
Assert.AreSame(typeof(TransientLifetimeManager), registration.LifetimeManagerType);
}
}
public void ShouldSerializeAndDeserializeCorrectly()
{
ParameterTypeMatchingRuleData original = GetParameterTypeMatchingRuleData();
Assert.AreEqual(3, original.Matches.Count);
ParameterTypeMatchingRuleData rehydrated =
(ParameterTypeMatchingRuleData)SerializeAndDeserializeMatchingRule(original);
Assert.AreEqual(original.Name, rehydrated.Name);
Assert.AreEqual(original.Matches.Count, rehydrated.Matches.Count);
for (int i = 0; i < original.Matches.Count; ++i)
{
AssertMatchDataEqual(original.Matches[i], rehydrated.Matches[i], "Match data different at index {0}", i);
}
}
public void ShouldBeAbleToConstructFromConfigData()
{
ParameterTypeMatchingRuleData ruleData = new ParameterTypeMatchingRuleData("RuleName");
ruleData.Matches.Add(new ParameterTypeMatchData("System.Double", ParameterKind.InputOrOutput));
ruleData.Matches.Add(new ParameterTypeMatchData("ParameterTypeMatchingRuleNodeFixture"));
ParameterTypeMatchingRuleNode node = new ParameterTypeMatchingRuleNode(ruleData);
Assert.AreEqual(ruleData.Name, node.Name);
Assert.AreEqual(ruleData.Matches.Count, node.Matches.Count);
for (int i = 0; i < ruleData.Matches.Count; ++i)
{
AssertAreEquivalent(ruleData.Matches[i], node.Matches[i], "Mismatch at element {0}", i);
}
}
public void ShouldBeAbleToGetConfigDataFromNode()
{
ParameterTypeMatchingRuleNode node = new ParameterTypeMatchingRuleNode();
node.Matches.Add(new ParameterTypeMatch("Foo", true, ParameterKind.InputOrOutput));
node.Matches.Add(new ParameterTypeMatch("String", false, ParameterKind.ReturnValue));
node.Matches.Add(new ParameterTypeMatch("System.Decimal", false, ParameterKind.Output));
ParameterTypeMatchingRuleData ruleData = (ParameterTypeMatchingRuleData)node.GetConfigurationData();
Assert.AreEqual(node.Name, ruleData.Name);
Assert.AreEqual(node.Matches.Count, ruleData.Matches.Count);
for (int i = 0; i < node.Matches.Count; ++i)
{
AssertAreEquivalent(ruleData.Matches[i], node.Matches[i], "Mismatch at element {0}", i);
}
}
public void ShouldCreateCorrectMatchingRule()
{
ValidationFactory.SetDefaultConfigurationValidatorFactory(new ConfigurationValidatorFactory(new DictionaryConfigurationSource()));
PolicyData policyData = new PolicyData("Validate Parameters");
policyData.Handlers.Add(new ValidationCallHandlerData());
ParameterTypeMatchingRuleData matchingRuleData = GetParameterTypeMatchingRuleData();
policyData.MatchingRules.Add(matchingRuleData);
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(policyData);
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
configSource.Add(PolicyInjectionSettings.SectionName, settings);
IUnityContainer container = new UnityContainer().AddNewExtension <Interception>();
settings.ConfigureContainer(container);
RuleDrivenPolicy policy = container.Resolve <RuleDrivenPolicy>("Validate Parameters");
List <IMatchingRule> rules = RuleCreationFixture.GetRules(policy);
Assert.IsNotNull(policy);
Assert.IsTrue(rules[0] is ParameterTypeMatchingRule);
ParameterTypeMatchingRule rule = (ParameterTypeMatchingRule)(rules[0]);
Assert.AreEqual(3, rule.ParameterMatches.Count());
for (int i = 0; i < matchingRuleData.Matches.Count; ++i)
{
AssertMatchDataEqual(
matchingRuleData.Matches[i],
rule.ParameterMatches.ElementAt(i),
"Mismatch at element {0}",
i);
}
}
/// <summary>
/// Construct a new ParameterTypeMatchingRuleNode, given data from the configuration
/// file.
/// </summary>
/// <param name="ruleData">Data configuring this matching rule.</param>
public ParameterTypeMatchingRuleNode(ParameterTypeMatchingRuleData ruleData)
: base(ruleData)
{
matches = new List <ParameterTypeMatch>(ConvertRuleDataToNodeMatches(ruleData.Matches));
}
