public void DtoRegexRulePatternAtAttributeScopeWithOneExclusion()
{
var dtoRules = new DTO.CustomizationRule()
{
RegexRules = new DTO.RegexRule[]
{
new DTO.RegexRule()
{
pattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
scope = DTO.RuleScope.Attribute,
Exclude = new string[] { "new_incorrect_Naming.my_field" }
}
}
};
var rules = RuleRepository.GetRules(dtoRules);
var rule = rules.Single() as RegexRule;
Assert.Equal(@"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
rule.Pattern.ToString());
Assert.Equal(RuleScope.Attribute, rule.Scope);
var excluded = GetInstanceField(rule.GetType(),
rule,
"_excludedSchemaNames") as ICollection <string>;
Assert.Single(excluded);
Assert.Contains("new_incorrect_Naming.my_field", excluded);
}
public void DtoRegexRulePatternAtEntityScopeWithManyExclusions()
{
var dtoRules = new DTO.CustomizationRule()
{
RegexRules = new DTO.RegexRule[]
{
new DTO.RegexRule()
{
pattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
scope = DTO.RuleScope.Entity,
Exclude = new string[] {
"new_incorrect_Naming", "new_INcorrect", "not_SoGood"
}
}
}
};
var rules = RuleRepository.GetRules(dtoRules);
var rule = rules.Single() as RegexRule;
Assert.Equal(@"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
rule.Pattern.ToString());
Assert.Equal(RuleScope.Entity, rule.Scope);
var excluded = GetInstanceField(rule.GetType(),
rule,
"_excludedSchemaNames") as ICollection <string>;
Assert.Equal(3, excluded.Count);
Assert.Contains("new_incorrect_Naming", excluded);
Assert.Contains("new_INcorrect", excluded);
Assert.Contains("not_SoGood", excluded);
}
/// <summary>
/// Gets the customization rules persisted on given file location.
/// </summary>
/// <param name="rulesFileLocation">
/// Location of the file containing rules.
/// </param>
/// <returns>
/// List of rules from <paramref name="rulesFileLocation"/>.
/// </returns>
public List <CustomizationRuleBase> GetRules(string rulesFileLocation)
{
var serializer = new XmlSerializer(typeof(DTO.CustomizationRule));
var filename = Environment.CurrentDirectory + "\\" + rulesFileLocation;
DTO.CustomizationRule rules = null;
using (var stream = new FileStream(filename,
FileMode.Open,
FileAccess.Read)) {
rules = serializer.Deserialize(stream) as DTO.CustomizationRule;
}
return(GetRules(rules));
}
public void DtoDisallowSolutionToOwnManagedEntitiesRuleImplicitFalse()
{
var dtoRules = new DTO.CustomizationRule()
{
DisallowSolutionToOwnManagedEntitiesRule = new DTO.DisallowSolutionToOwnManagedEntitiesRule()
};
var rules = RuleRepository.GetRules(dtoRules);
var rule = rules.Single() as DisallowSolutionToOwnManagedEntitiesRule;
bool allowed = (bool)GetInstanceField(rule.GetType(),
rule,
"_allowSolutionToOwnManagedEntities");
Assert.False(allowed);
}
public void DtoAttributePrefixRuleIllegalValues(string prefix)
{
var dtoRules = new DTO.CustomizationRule()
{
AttributePrefixRule = new DTO.AttributePrefixRule()
{
schemaPrefix = prefix
}
};
var ex = Assert.Throws <ArgumentException>(
() => RuleRepository.GetRules(dtoRules));
Assert.StartsWith("Schema prefix isn't allowed to be null, empty or whitespace.",
ex.Message);
Assert.Equal("schemaPrefix", ex.ParamName);
}
public void DtoEntityPrefixRuleSet()
{
var dtoRules = new DTO.CustomizationRule()
{
EntityPrefixRule = new DTO.EntityPrefixRule()
{
schemaPrefix = "sar"
}
};
var rules = RuleRepository.GetRules(dtoRules);
var rule = rules.Single() as EntityPrefixRule;
string prefix = GetInstanceField(rule.GetType(),
rule,
"_schemaPrefix") as string;
Assert.Equal("sar", prefix);
}
public void DtoRegexRulePatternAtAttributeScope()
{
var dtoRules = new DTO.CustomizationRule()
{
RegexRules = new DTO.RegexRule[]
{
new DTO.RegexRule()
{
pattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
scope = DTO.RuleScope.Attribute
}
}
};
var rules = RuleRepository.GetRules(dtoRules);
var rule = rules.Single() as RegexRule;
Assert.Equal(@"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$",
rule.Pattern.ToString());
Assert.Equal(RuleScope.Attribute, rule.Scope);
}
/// <summary>
/// Get rules from deserialized rules object.
/// This is internal so we can get unit tests to run nicely.
/// </summary>
/// <param name="rules">
/// Deserialized rules object.
/// </param>
/// <returns>
/// List of rules from <paramref name="rules"/>.
/// </returns>
internal static List <CustomizationRuleBase> GetRules(
DTO.CustomizationRule rules)
{
if (rules is null)
{
throw new ArgumentNullException(nameof(rules));
}
var retval = new List <CustomizationRuleBase>();
var ruleFactory = new RuleFactory();
if (rules.DisallowSolutionToOwnManagedEntitiesRule != null)
{
var rule = ruleFactory.CreateFrom(rules.DisallowSolutionToOwnManagedEntitiesRule);
retval.Add(rule);
}
if (rules.EntityPrefixRule != null)
{
var rule = ruleFactory.CreateFrom(rules.EntityPrefixRule);
retval.Add(rule);
}
if (rules.AttributePrefixRule != null)
{
var rule = ruleFactory.CreateFrom(rules.AttributePrefixRule);
retval.Add(rule);
}
if (rules.RegexRules != null)
{
foreach (var dtoRule in rules.RegexRules)
{
var rule = ruleFactory.CreateFrom(dtoRule);
retval.Add(rule);
}
}
return(retval);
}
