public void DefaultRuleConfigurationOverridesShouldBeEqual()
{
IRuleConfigurationParameter parameter = Mocker.DynamicMock <IRuleConfigurationParameter>();
IList <IRuleConfigurationParameter> parameters = new[] { parameter };
DefaultRuleConfigurationOverride alpha = new DefaultRuleConfigurationOverride(typeof(String), parameters);
DefaultRuleConfigurationOverride beta = new DefaultRuleConfigurationOverride(typeof(String), parameters);
Assert.AreEqual(alpha, beta);
}
public void RuleConfigurationControllerShouldNotDisplayRuleConfigurationParameterOnSelectedRuleParameterChangedIfParameterIsNull()
{
IRuleConfigurationParameter config = Mocker.DynamicMock <IRuleConfigurationParameter>();
Expect.Call(() => _view.DisplayRuleConfigurationParameter(config)).Repeat.Never();
Mocker.ReplayAll();
RuleConfigurationController controller = new RuleConfigurationController(_view, _provider, _configFactory);
_view.Raise(x => x.SelectedRuleParameterChanged += null, this, new RuleConfigurationParameterEventArgs(null));
Mocker.VerifyAll();
}
private EditParameterControl GetControlFor(IRuleConfigurationParameter param)
{
if (param.ParameterType == ParameterType.MultilineString)
{
return(new MultilineParameterControl());
}
else if (param.ParameterType == ParameterType.Boolean)
{
return(new BooleanParameterControl());
}
else
{
return(new BasicParameterControl());
}
}
public void RulesSectionManagerShouldWriteRulesSectionFromOverrideList()
{
IRule rule = Mocker.DynamicMock <IRule>();
String paramOneName = "paramOne";
String paramTwoName = "paramTwo";
String paramOneValue = "one";
String paramTwoValue = "two";
StringBuilder bldr = new StringBuilder();
bldr.Append(@"<root>");
bldr.Append(@"<rules>");
bldr.Append(@"<rule type=""" + rule.GetType().AssemblyQualifiedName + @""">");
bldr.Append(@"<param name=""" + paramOneName + @""" type=""String"">" + paramOneValue + "</param>");
bldr.Append(@"<param name=""" + paramTwoName + @""" type=""String"">" + paramTwoValue + "</param>");
bldr.Append(@"</rule>");
bldr.Append(@"</rules>");
bldr.Append(@"</root>");
IRuleConfigurationOverride overrideConfig = Mocker.DynamicMock <IRuleConfigurationOverride>();
IRuleConfigurationParameter overrideParamOne = Mocker.DynamicMock <IRuleConfigurationParameter>();
IRuleConfigurationParameter overrideParamTwo = Mocker.DynamicMock <IRuleConfigurationParameter>();
IList <IRuleConfigurationOverride> overrides = new List <IRuleConfigurationOverride>();
overrides.Add(overrideConfig);
Expect.Call(overrideConfig.Rule).Return(rule.GetType()).Repeat.Once();
Expect.Call(overrideConfig.Parameters).Return(new[] { overrideParamOne, overrideParamTwo }).Repeat.Once();
Expect.Call(overrideParamOne.Name).Return(paramOneName).Repeat.Once();
Expect.Call(overrideParamOne.Value).Return(paramOneValue).Repeat.Once();
Expect.Call(overrideParamOne.ParameterType).Return(ParameterType.String).Repeat.Once();
Expect.Call(overrideParamTwo.Name).Return(paramTwoName).Repeat.Once();
Expect.Call(overrideParamTwo.Value).Return(paramTwoValue).Repeat.Once();
Expect.Call(overrideParamTwo.ParameterType).Return(ParameterType.String).Repeat.Once();
Mocker.ReplayAll();
XElement parent = new XElement(XName.Get("root"));
_sectionManager.WriteTo(overrides, parent);
Assert.AreEqual(bldr.ToString(), parent.ToString(SaveOptions.DisableFormatting));
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="param">The parameter in the event</param>
public RuleConfigurationParameterEventArgs(IRuleConfigurationParameter param)
{
Parameter = param;
}
/// <summary>
/// Displays the rule configuration parameter
/// </summary>
/// <param name="parameter">The parameter to display</param>
public void DisplayRuleConfigurationParameter(IRuleConfigurationParameter parameter)
{
parameterLayoutPanel.Controls.Clear();
parameterLayoutPanel.Controls.Add(_currentRuleParameterControl[parameter.Name]);
}
