public void RuleTypeDeclarationOfInvalidRuleTypeShouldThrowException()
{
StringBuilder bldr = new StringBuilder();
bldr.Append(@"<?xml version=""1.0"" encoding=""utf-8"" ?>");
bldr.Append("<rules>");
bldr.Append(@"<rule type=""NonExistingRule, JDT.Calidus.CommonTest"">");
bldr.Append("<description>");
bldr.Append("<![CDATA[Description text]]>");
bldr.Append("</description>");
bldr.Append("<params>");
bldr.Append(@"<param name=""param1"" type=""String"">");
bldr.Append("theValue");
bldr.Append(@"</param>");
bldr.Append("</params>");
bldr.Append("</rule>");
bldr.Append("</rules>");
Stream stream = new MemoryStream(Encoding.Default.GetBytes(bldr.ToString()));
XmlReader reader = new XmlTextReader(stream);
FileRuleConfigurationFactory builder = new FileRuleConfigurationFactoryImpl(reader);
Assert.Throws <TypeLoadException>(
delegate
{
IRuleConfiguration config = builder.Get(GetType());
}
);
}
internal RuleOutputData(InstanceName instance, IRuleConfiguration ruleConfiguration, string ruleLanguage)
{
this.instanceName = instance.PlainName;
this.ruleName = ruleConfiguration.RuleName;
this.isDisabled = ruleConfiguration.IsDisabled;
this.isImpersonated = ruleConfiguration.Impersonate;
this.ruleLanguage = ruleLanguage;
}
public static void WriteConfiguration(this IRuleConfiguration config, Microsoft.Azure.Management.AppService.Fluent.IWebApp webApp)
{
var settings = new Dictionary <string, string>();
settings.AddRuleSettings(config);
webApp.ApplyWithAppSettings(settings);
}
public static void Delete(this IRuleConfiguration config, Microsoft.Azure.Management.AppService.Fluent.IWebApp webApp)
{
var settings = new Dictionary <string, string>();
settings.AddRuleSettings(config);
var update = webApp.Update();
foreach (var key in settings.Keys)
{
update.WithoutAppSetting(key);
}
update.Apply();
}
public void RuleConfigurationControllerShouldGetAndDisplayRuleConfigurationOnRuleSelectionChanged()
{
IRule rule = Mocker.DynamicMock <IRule>();
IRuleConfiguration ruleConfig = Mocker.DynamicMock <IRuleConfiguration>();
Expect.Call(_configFactory.GetRuleConfigurationFor(rule.GetType())).Return(ruleConfig).Repeat.Once();
Expect.Call(() => _view.DisplayRuleConfiguration(ruleConfig)).Repeat.Once();
Mocker.ReplayAll();
RuleConfigurationController controller = new RuleConfigurationController(_view, _provider, _configFactory);
_view.RuleTreeView.Raise(x => x.RuleSelectionChanged += null, this, new RuleEventArgs(rule));
Mocker.VerifyAll();
}
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();
}
private void RuleTreeView_RuleSelectionChanged(object sender, RuleEventArgs e)
{
if (e.SelectedRule != null)
{
IRuleConfiguration config = _configFactory.GetRuleConfigurationFor(e.SelectedRule.GetType());
_view.DisplayRuleConfiguration(config);
CurrentConfiguration = config;
}
else
{
_view.ClearRuleConfiguration();
CurrentConfiguration = null;
}
HasChanges = false;
}
public void ParsingStreamWithRegistrationShouldReturnInformation()
{
StringBuilder bldr = new StringBuilder();
bldr.Append(@"<?xml version=""1.0"" encoding=""utf-8"" ?>");
bldr.Append("<rules>");
bldr.Append(@"<rule type=""JDT.Calidus.CommonTest.Rules.UnCreatableRule, JDT.Calidus.CommonTest"">");
bldr.Append("<description>");
bldr.Append("Description text");
bldr.Append("</description>");
bldr.Append("<params>");
bldr.Append(@"<param name=""param1"" type=""String"">");
bldr.Append("theValue1");
bldr.Append(@"</param>");
bldr.Append(@"<param name=""param2"" type=""String"">");
bldr.Append("theValue2");
bldr.Append(@"</param>");
bldr.Append("</params>");
bldr.Append("</rule>");
bldr.Append("</rules>");
Stream stream = new MemoryStream(Encoding.Default.GetBytes(bldr.ToString()));
XmlReader reader = new XmlTextReader(stream);
FileRuleConfigurationFactory builder = new FileRuleConfigurationFactoryImpl(reader);
IRuleConfiguration actual = builder.Get(typeof(UnCreatableRule));
IList <IRuleConfigurationParameter> paramList = new List <IRuleConfigurationParameter>();
DefaultRuleConfigurationParameter param1 = new DefaultRuleConfigurationParameter();
param1.ParameterType = ParameterType.String;
param1.Name = "param1";
param1.Value = "theValue1";
paramList.Add(param1);
DefaultRuleConfigurationParameter param2 = new DefaultRuleConfigurationParameter();
param2.ParameterType = ParameterType.String;
param2.Name = "param2";
param2.Value = "theValue2";
paramList.Add(param2);
Assert.AreEqual("Description text", actual.Description);
Assert.AreEqual(Type.GetType("JDT.Calidus.CommonTest.Rules.UnCreatableRule, JDT.Calidus.CommonTest"), actual.Rule);
CollectionAssert.AreEquivalent(paramList, actual.Parameters);
}
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 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>
/// Displays the configuration for the rule
/// </summary>
/// <param name="ruleConfig">The rule configuration to display</param>
public void DisplayRuleConfiguration(IRuleConfiguration ruleConfig)
{
parameterLayoutPanel.Controls.Clear();
mainContainer.Panel2.Enabled = true;
//create parameter controls
_currentRuleParameterControl.Clear();
_currentParameters.Clear();
foreach (IRuleConfigurationParameter aParameter in ruleConfig.Parameters)
{
EditParameterControl paramControl = GetControlFor(aParameter);
paramControl.SetValue(aParameter.Value);
paramControl.ValueChanged += new EventHandler(paramControl_ValueChanged);
_currentRuleParameterControl.Add(aParameter.Name, paramControl);
_currentParameters.Add(aParameter.Name, aParameter);
}
txtDescription.Text = ruleConfig.Description;
lstParameters.DataSource = ruleConfig.Parameters;
lstParameters.DisplayMember = "Name";
}
public void ParsingStreamWithRegistrationShouldSupportMultipleRules()
{
StringBuilder bldr = new StringBuilder();
bldr.Append(@"<?xml version=""1.0"" encoding=""utf-8"" ?>");
bldr.Append("<rules>");
bldr.Append(@"<rule type=""JDT.Calidus.CommonTest.Rules.UnCreatableRule, JDT.Calidus.CommonTest"">");
bldr.Append("<description>");
bldr.Append("Description text");
bldr.Append("</description>");
bldr.Append("<params>");
bldr.Append(@"<param name=""param1"" type=""String"">");
bldr.Append("theValue1");
bldr.Append(@"</param>");
bldr.Append(@"<param name=""param2"" type=""String"">");
bldr.Append("theValue2");
bldr.Append(@"</param>");
bldr.Append("</params>");
bldr.Append("</rule>");
bldr.Append(@"<rule type=""JDT.Calidus.CommonTest.CreateableRule, JDT.Calidus.CommonTest"">");
bldr.Append("<description>");
bldr.Append("Description text");
bldr.Append("</description>");
bldr.Append("<params>");
bldr.Append("</params>");
bldr.Append("</rule>");
bldr.Append("</rules>");
Stream stream = new MemoryStream(Encoding.Default.GetBytes(bldr.ToString()));
XmlReader reader = new XmlTextReader(stream);
FileRuleConfigurationFactory builder = new FileRuleConfigurationFactoryImpl(reader);
IRuleConfiguration one = builder.Get(typeof(UnCreatableRule));
IRuleConfiguration two = builder.Get(typeof(CreateableRule));
Assert.IsNotNull(one);
Assert.IsNotNull(two);
}
/// <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);
}
public void BooleanTypeParameterShouldParseAsBoolean()
{
StringBuilder bldr = new StringBuilder();
bldr.Append(@"<?xml version=""1.0"" encoding=""utf-8"" ?>");
bldr.Append("<rules>");
bldr.Append(@"<rule type=""JDT.Calidus.CommonTest.Rules.UnCreatableRule, JDT.Calidus.CommonTest"">");
bldr.Append("<description>");
bldr.Append("Description text");
bldr.Append("</description>");
bldr.Append("<params>");
bldr.Append(@"<param name=""param1"" type=""Boolean"">");
bldr.Append("false");
bldr.Append(@"</param>");
bldr.Append("</params>");
bldr.Append("</rule>");
bldr.Append("</rules>");
Stream stream = new MemoryStream(Encoding.Default.GetBytes(bldr.ToString()));
XmlReader reader = new XmlTextReader(stream);
FileRuleConfigurationFactory builder = new FileRuleConfigurationFactoryImpl(reader);
IRuleConfiguration actual = builder.Get(typeof(UnCreatableRule));
IList <IRuleConfigurationParameter> paramList = new List <IRuleConfigurationParameter>();
DefaultRuleConfigurationParameter param = new DefaultRuleConfigurationParameter();
param.ParameterType = ParameterType.Boolean;
param.Name = "param1";
param.Value = false;
paramList.Add(param);
Assert.AreEqual("Description text", actual.Description);
Assert.AreEqual(Type.GetType("JDT.Calidus.CommonTest.Rules.UnCreatableRule, JDT.Calidus.CommonTest"), actual.Rule);
CollectionAssert.AreEquivalent(paramList, actual.Parameters);
}
public ValidatorSingleLong(IRuleConfiguration ruleConfig)
{
RulesConfig = ruleConfig;
RuleDetails = RulesConfig.GetRules();
}
private static void AddRuleSettings(this Dictionary <string, string> settings, IRuleConfiguration ruleSetting)
{
settings[$"{RULE_SETTINGS_PREFIX}{ruleSetting.RuleName}.Disabled"] = ruleSetting.IsDisabled.ToString();
settings[$"{RULE_SETTINGS_PREFIX}{ruleSetting.RuleName}.Impersonate"] = ruleSetting.Impersonate ? "onBehalfOfInitiator" : "false";
}
static void AssertRule(IRuleConfiguration rule)
{
rule.RuleType.Should().Be("Namespace.Rule, Assembly");
rule.Configuration.OuterXml.Should().Be(@"<rule property=""Property""><innerConfig property=""InnerProperty"" /></rule>");
}
public RuleRepository(IServiceLocator serviceLocator, IRuleConfiguration configuration)
{
_serviceLocator = serviceLocator;
_configuration = configuration;
}
public ValidatorCompareInt(IRuleConfiguration ruleConfig)
{
RulesConfig = ruleConfig;
RuleDetails = RulesConfig.GetRules();
}
public Validator()
{
RuleConfig = new RuleConfiguration();
}
