public void GetViolatingOccurrences_Success_CanNotRelate()
{
var architectureRule = new ArchitecturalRule()
{
OriginLayer = "Origin",
TargetLayer = "Target",
RuleOperator = RuleOperator.CanNotRelate
};
var targetNamespace = "Test.Target";
var targetStructureName = "TargetTestStructure";
var originStructure = new Structure()
{
Name = "OriginTestStructure",
Type = StructureType.Class,
Namespace = "Test.Origin",
References = new List <string>()
{
{ targetNamespace }
},
Relations = new List <Relation>()
{
new Relation(RelationType.Inheritance,
targetNamespace, true, targetStructureName)
}
};
var layersNamespaces = new Dictionary <string, IEnumerable <string> >()
{
{ "Origin", new List <string>()
{
originStructure.Namespace
} },
{ "Target", new List <string>()
{
targetNamespace
} }
};
var structures = new List <Structure>()
{
originStructure,
new Structure()
{
Name = targetStructureName,
Type = StructureType.Class,
Namespace = targetNamespace
}
};
var violatingOccurrences = ArchitecturalRuleHelper.GetViolatingOccurrences(
architectureRule, layersNamespaces, structures);
AssertViolatingOccurrences(violatingOccurrences, originStructure,
$"{targetNamespace}.{targetStructureName}");
}
public void GetViolatingOccurrences_Success_NeedToRelate()
{
var architectureRule = new ArchitecturalRule()
{
OriginLayer = "Origin",
TargetLayer = "Target",
RuleOperator = RuleOperator.NeedToRelate
};
var targetNamespace = "Test.Target";
var targetStructureName = "TargetTestStructure";
var originStructure = new Structure()
{
Name = "OriginTestStructure",
Type = StructureType.Class,
Namespace = "Test.Origin"
};
var layersNamespaces = new Dictionary <string, IEnumerable <string> >()
{
{ "Origin", new List <string>()
{
originStructure.Namespace
} },
{ "Target", new List <string>()
{
targetNamespace
} }
};
var structures = new List <Structure>()
{
originStructure,
new Structure()
{
Name = targetStructureName,
Type = StructureType.Class,
Namespace = targetNamespace
}
};
var violatingOccurrences = ArchitecturalRuleHelper.GetViolatingOccurrences(
architectureRule, layersNamespaces, structures);
Assert.NotNull(violatingOccurrences);
Assert.Single(violatingOccurrences);
Assert.Equal($"{originStructure.Namespace}.{originStructure.Name}",
violatingOccurrences.Single().Structure);
Assert.Empty(violatingOccurrences.Single().NonConformingRelations);
}
public void GetViolatingOccurrences_Success_OnlyCanRelate_Empty()
{
var architectureRule = new ArchitecturalRule()
{
OriginLayer = "Origin",
TargetLayer = "Target",
RuleOperator = RuleOperator.OnlyCanRelate
};
var targetNamespace = "Test.Target";
var layersNamespaces = new Dictionary <string, IEnumerable <string> >()
{
{ "Origin", new List <string>()
{
"Test.Origin"
} },
{ "Target", new List <string>()
{
targetNamespace
} }
};
var structures = new List <Structure>()
{
new Structure()
{
Name = "TargetStructure",
Type = StructureType.Class,
Namespace = targetNamespace,
References = new List <string>()
{
{ targetNamespace }
},
Relations = new List <Relation>()
{
new Relation(RelationType.Inheritance,
targetNamespace, true, "AnotherTargetStructure")
}
}
};
var violatingOccurrences = ArchitecturalRuleHelper.GetViolatingOccurrences(
architectureRule, layersNamespaces, structures);
Assert.NotNull(violatingOccurrences);
Assert.Empty(violatingOccurrences);
}
private static IEnumerable <TransgressedRule> GetTransgressedRulesByConstraintsAndCodeFiles(
ArchitecturalConstraints constraints, ICollection <CodeFile> codeFiles)
{
var structures = codeFiles.SelectMany(c => c.Structures);
var namespaces = structures.Select(s => s.Namespace).Distinct();
var layersNamespaces = NamespacesGroupingMethodHelper
.GetLayersNamespaces(constraints.Layers, namespaces);
foreach (var rule in constraints.Rules)
{
var violatingOccurrences = ArchitecturalRuleHelper
.GetViolatingOccurrences(rule, layersNamespaces, structures);
if (violatingOccurrences.Any())
{
yield return(new TransgressedRule()
{
Rule = rule,
Violations = violatingOccurrences
});
}
}
}
public void GetViolatingOccurrences_Success_Empty()
{
var architecturalRules = new ArchitecturalRule[]
{
new ArchitecturalRule()
{
OriginLayer = "X",
TargetLayer = "Y",
RuleOperator = RuleOperator.CanNotRelate,
RelationTypes = new List <RelationType>()
{
RelationType.Declarate
}
},
new ArchitecturalRule()
{
OriginLayer = "X",
TargetLayer = "Z",
RuleOperator = RuleOperator.OnlyCanRelate,
RelationTypes = new List <RelationType>()
{
RelationType.Inheritance
}
},
new ArchitecturalRule()
{
OriginLayer = "W",
TargetLayer = "Z",
RuleOperator = RuleOperator.OnlyNeedToRelate,
RelationTypes = new List <RelationType>()
{
RelationType.ReceiptByConstructorArgument
}
}
};
var structures = new List <Structure>()
{
new Structure()
{
Name = "XStructure",
Type = StructureType.Class,
Namespace = "X",
Relations = new List <Relation>()
{
new Relation(RelationType.Inheritance,
"Y", true, "YStructure")
}
},
new Structure()
{
Name = "YStructure",
Type = StructureType.Class,
Namespace = "Y",
Relations = new List <Relation>()
{
new Relation(RelationType.Indirect,
"Z", true, "ZStructure")
}
}
};
var layersNamespaces = new Dictionary <string, IEnumerable <string> >()
{
{ "X", new List <string>()
{
"X"
} },
{ "Y", new List <string>()
{
"Y"
} },
{ "W", new List <string>()
{
"W"
} },
{ "Z", new List <string>()
{
"Z"
} }
};
foreach (var rule in architecturalRules)
{
var violatingOccurrences = ArchitecturalRuleHelper
.GetViolatingOccurrences(rule, layersNamespaces, structures);
Assert.Empty(violatingOccurrences);
}
}
