public void ConfigurationFactoryShouldReturnConfigurationFromConfigurationFactoryProvider()
{
IRule rule = Mocker.DynamicMock <IRule>();
IRuleConfiguration config = Mocker.DynamicMock <IRuleConfiguration>();
IRuleConfigurationFactory factory = Mocker.DynamicMock <IRuleConfigurationFactory>();
Expect.Call(_provider.GetRuleConfigurationFactoryFor(rule.GetType())).Return(factory).Repeat.Once();
Expect.Call(factory.Get(rule.GetType())).Return(config).Repeat.Once();
Expect.Call(_project.GetProjectRuleConfigurationOverrides()).Return(new IRuleConfigurationOverride[] {}).Repeat.Once();
Mocker.ReplayAll();
Assert.AreEqual(config, _configFactory.GetRuleConfigurationFor(rule.GetType()));
Mocker.VerifyAll();
}
public void ConfigurationFactoryShouldReturnOverriddenRulesIfAvailable()
{
//TODO: this test was difficult to write, is difficult to read and therefore can use some refactoring
String name = "parameterName";
ParameterType type = ParameterType.MultilineString;
String value = "parameterValue";
IRule rule = Mocker.DynamicMock <IRule>();
IRuleConfiguration config = Mocker.DynamicMock <IRuleConfiguration>();
IRuleConfigurationFactory factory = Mocker.DynamicMock <IRuleConfigurationFactory>();
IRuleConfigurationOverride ruleOverride = Mocker.DynamicMock <IRuleConfigurationOverride>();
IRuleConfigurationParameter defaultParameter = Mocker.DynamicMock <IRuleConfigurationParameter>();
IRuleConfigurationParameter ruleOverrideParameter = Mocker.DynamicMock <IRuleConfigurationParameter>();
IList <IRuleConfigurationOverride> overrides = new[] { ruleOverride };
IList <IRuleConfigurationParameter> parameters = new[] { ruleOverrideParameter };
IList <IRuleConfigurationParameter> actuals = new[] { defaultParameter };
Expect.Call(_provider.GetRuleConfigurationFactoryFor(rule.GetType())).Return(factory).Repeat.Once();
Expect.Call(factory.Get(rule.GetType())).Return(config).Repeat.Once();
Expect.Call(config.Parameters).Return(actuals).Repeat.Once();
Expect.Call(_project.GetProjectRuleConfigurationOverrides()).Return(overrides).Repeat.Once();
Expect.Call(ruleOverride.Parameters).Return(parameters).Repeat.Once();
Expect.Call(defaultParameter.Name).Return(name).Repeat.Twice();
Expect.Call(defaultParameter.ParameterType).Return(type).Repeat.Once();
Expect.Call(ruleOverride.Rule).Return(rule.GetType()).Repeat.Once();
Expect.Call(ruleOverrideParameter.Name).Return(name).Repeat.Once();
Expect.Call(ruleOverrideParameter.Value).Return(value).Repeat.Once();
Mocker.ReplayAll();
IRuleConfiguration actual = _configFactory.GetRuleConfigurationFor(rule.GetType());
Assert.AreEqual(name, actual.Parameters[0].Name);
Assert.AreEqual(type, actual.Parameters[0].ParameterType);
Assert.AreEqual(value, actual.Parameters[0].Value);
Mocker.VerifyAll();
}
/// <summary>
/// Gets the configuration for the specified rule type
/// </summary>
/// <param name="aType">The rule type</param>
/// <returns>The rule configuration</returns>
public IRuleConfiguration GetRuleConfigurationFor(Type aType)
{
IRuleConfigurationFactory factory = _provider.GetRuleConfigurationFactoryFor(aType);
if (factory == null)
{
throw new CalidusException("No default configuration could be loaded for rule " + aType.FullName);
}
//determine default and overridden configuration
IRuleConfiguration defaultConfig = factory.Get(aType);
IRuleConfigurationOverride overrideConfig = _project.GetProjectRuleConfigurationOverrides().FirstOrDefault <IRuleConfigurationOverride>(p => p.Rule.FullName.Equals(aType.FullName));
IRuleConfiguration actualConfig = defaultConfig;
if (overrideConfig != null)
{
IList <IRuleConfigurationParameter> parameters = new List <IRuleConfigurationParameter>();
foreach (IRuleConfigurationParameter aParam in overrideConfig.Parameters)
{
//get the default value
IRuleConfigurationParameter defaultConfigParameter = defaultConfig.Parameters.FirstOrDefault <IRuleConfigurationParameter>(p => p.Name.Equals(aParam.Name));
//create an overridden parameter with the overridden value
DefaultRuleConfigurationParameter overriddenParam = new DefaultRuleConfigurationParameter();
overriddenParam.Name = defaultConfigParameter.Name;
overriddenParam.ParameterType = defaultConfigParameter.ParameterType;
overriddenParam.Value = aParam.Value;
//add the overridden parameter
parameters.Add(overriddenParam);
}
actualConfig = new DefaultRuleConfiguration(aType, defaultConfig.Description, parameters);
}
return(actualConfig);
}
/// <summary>
/// Create a new instance of this class
/// </summary>
/// <param name="parsedTypes">The parsed types</param>
/// <param name="instanceCreator">The instance creator to use</param>
/// <param name="factory">The factory to use for rule configurations</param>
public RuleFactory(IEnumerable <Type> parsedTypes, IInstanceCreator instanceCreator, IRuleConfigurationFactory factory)
{
_parsed = parsedTypes;
_factory = factory;
_instanceCreator = instanceCreator;
}
/// <summary>
/// Create a new instance of this class
/// </summary>
/// <param name="toParse">The assembly to parse for rules</param>
/// <param name="factory">The factory to use for rule configurations</param>
public RuleFactory(Assembly toParse, IRuleConfigurationFactory factory)
: this(toParse.GetTypes(), ObjectFactory.Get <IInstanceCreator>(), factory)
{
}
