/// <summary>
/// Sets a rule configuration override
/// </summary>
/// <param name="overrideConfig">The override config</param>
public void SetProjectRuleConfigurationOverrideTo(IRuleConfigurationOverride overrideConfig)
{
IRuleConfigurationOverride exisitingConfig = _ruleConfigurations.FirstOrDefault <IRuleConfigurationOverride>(p => p.Rule.AssemblyQualifiedName.Equals(overrideConfig.Rule.AssemblyQualifiedName));
if (exisitingConfig != null)
{
_ruleConfigurations.Remove(exisitingConfig);
}
_ruleConfigurations.Add(overrideConfig);
}
public void ConfigurationFactoryShouldSetOverrideToProject()
{
IRuleConfigurationOverride overrideConfig = Mocker.DynamicMock <IRuleConfigurationOverride>();
Expect.Call(() => _project.SetProjectRuleConfigurationOverrideTo(overrideConfig)).Repeat.Once();
Expect.Call(() => _manager.Write(_project)).Repeat.Once();
Mocker.ReplayAll();
_configFactory.SetRuleConfiguration(overrideConfig);
Mocker.VerifyAll();
}
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 RuleConfigurationControllerShouldSetConfigurationForCurrentRuleToRuleConfigurationFactory()
{
IRule rule = Mocker.DynamicMock <IRule>();
IRuleConfiguration ruleConfig = Mocker.DynamicMock <IRuleConfiguration>();
IRuleConfigurationOverride overrideConfig = Mocker.DynamicMock <IRuleConfigurationOverride>();
Expect.Call(_configFactory.GetRuleConfigurationFor(rule.GetType())).Return(ruleConfig).Repeat.Once();
Expect.Call(() => _configFactory.SetRuleConfiguration(overrideConfig)).IgnoreArguments().Repeat.Once();
Mocker.ReplayAll();
RuleConfigurationController controller = new RuleConfigurationController(_view, _provider, _configFactory);
_view.RuleTreeView.Raise(x => x.RuleSelectionChanged += null, this, new RuleEventArgs(rule));
_view.Raise(x => x.Save += null, this, new RuleConfigurationChangeCommandEventArgs(new Dictionary <IRuleConfigurationParameter, object>()));
Mocker.VerifyAll();
}
public void ProjectSetProjectRuleConfigurationOverrideShouldReplaceExisting()
{
_project = new CalidusProject(@"C:\src\test.project", _provider);
IRule rule = Mocker.DynamicMock <IRule>();
IRuleConfigurationOverride one = Mocker.DynamicMock <IRuleConfigurationOverride>();
Expect.Call(one.Rule).Return(rule.GetType()).Repeat.Twice();
Mocker.ReplayAll();
_project.SetProjectRuleConfigurationOverrideTo(one);
Assert.AreEqual(1, _project.GetProjectRuleConfigurationOverrides().Count());
_project.SetProjectRuleConfigurationOverrideTo(one);
Assert.AreEqual(1, _project.GetProjectRuleConfigurationOverrides().Count());
Mocker.VerifyAll();
}
public void WriteShouldCallRulesSectionManagerToWriteRuleOverrides()
{
ICalidusProject project = Mocker.DynamicMock <ICalidusProject>();
IRuleConfigurationOverride config = Mocker.DynamicMock <IRuleConfigurationOverride>();
Expect.Call(project.IgnoredFiles).Return(new String[] {}).Repeat.Once();
Expect.Call(project.GetProjectRuleConfigurationOverrides()).Return(new[] { config }).Repeat.Once();
Expect.Call(() => _rulesSectionManager.WriteTo(new[] { config }, null)).IgnoreArguments().Repeat.Once();
Mocker.ReplayAll();
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlTextWriter.Create(stream);
_manager.WriteTo(project, writer);
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();
}
public void ProjectSetProjectRuleConfigurationOverrideShouldAddOverrides()
{
_project = new CalidusProject(@"C:\src\test.project", _provider);
//need to make sure to have different rule types
StatementRuleBase ruleOne = Mocker.DynamicMock <StatementRuleBase>("test");
BlockRuleBase ruleTwo = Mocker.DynamicMock <BlockRuleBase>("test");
IRuleConfigurationOverride one = Mocker.DynamicMock <IRuleConfigurationOverride>();
IRuleConfigurationOverride two = Mocker.DynamicMock <IRuleConfigurationOverride>();
Expect.Call(one.Rule).Return(ruleOne.GetType()).Repeat.Once();
Expect.Call(two.Rule).Return(ruleTwo.GetType()).Repeat.Once();
Mocker.ReplayAll();
Assert.AreEqual(0, _project.GetProjectRuleConfigurationOverrides().Count());
_project.SetProjectRuleConfigurationOverrideTo(one);
Assert.AreEqual(1, _project.GetProjectRuleConfigurationOverrides().Count());
_project.SetProjectRuleConfigurationOverrideTo(two);
Assert.AreEqual(2, _project.GetProjectRuleConfigurationOverrides().Count());
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>
/// Sets the configuration override
/// </summary>
/// <param name="overrideConfig">The configuration to set</param>
public void SetRuleConfiguration(IRuleConfigurationOverride overrideConfig)
{
_project.SetProjectRuleConfigurationOverrideTo(overrideConfig);
_manager.Write(_project);
}
/// <summary>
/// Sets a rule configuration override
/// </summary>
/// <param name="overrideConfig">The override config</param>
public void SetProjectRuleConfigurationOverrideTo(IRuleConfigurationOverride overrideConfig)
{
_project.SetProjectRuleConfigurationOverrideTo(overrideConfig);
}
