public void ShouldNotAllowAnEmptyName()
{
RepositoryItemBuilder item = DefaultItem.WithName(string.Empty);
ExpectConstraintViolation(item);
Validate(item, "Empty name not detected.");
}
protected static RepositoryItem AddChild(RepositoryItem parent, RepositoryItemBuilder itemBuilder)
{
RepositoryItem newItem = itemBuilder.Build();
parent.AddOrReplaceChild(newItem);
return(newItem);
}
public void ShouldNotAllowAnySubpackages()
{
RepositoryItemBuilder aPackage = APackage;
RepositoryItemBuilder elementLibrary = DefaultItem.WithChild(aPackage);
VerifyConstraintViolations(elementLibrary, aPackage);
}
public void ShouldNotAllowElements()
{
RepositoryItemBuilder element1 = AnElement;
RepositoryItemBuilder element2 = AnElement;
RepositoryItemBuilder bLibrary = DefaultItem.WithChild(element1).WithChild(element2);
VerifyConstraintViolations(bLibrary, element1, element2);
}
protected void VerifyConstraintViolations(RepositoryItemBuilder validatedItem, params RepositoryItemBuilder[] offendingItems)
{
foreach (RepositoryItemBuilder item in offendingItems)
{
ExpectConstraintViolation(item);
}
Validate(validatedItem);
}
public void ShouldDetectEmptyTaggedValues()
{
foreach (TaggedValues taggedValue in requiredTaggedValues)
{
RepositoryItemBuilder item = DefaultItem.WithTaggedValue(taggedValue, string.Empty);
ExpectConstraintViolation(item);
Validate(item, "Empty required Tagged Value '" + taggedValue + "' not detected.");
}
}
public void ShouldDetectUndefinedTaggedValues()
{
foreach (TaggedValues taggedValue in definedTaggedValues)
{
RepositoryItemBuilder item = DefaultItem.WithoutTaggedValue(taggedValue);
ExpectConstraintViolation(item);
Validate(item, "Undefined Tagged Value '" + taggedValue + "' not detected.");
}
}
public void ShouldOnlyAllowElementsWithTheProperStereotype()
{
RepositoryItemBuilder element1 = AnElement.WithStereotype(elementStereotype);
RepositoryItemBuilder element2 = AnElement.WithStereotype("other than " + elementStereotype);
RepositoryItemBuilder elementLibrary = DefaultItem.WithChild(element1).WithChild(element2);
ExpectConstraintViolation(element2);
Validate(elementLibrary);
}
public void ShouldOnlyAllowBusinessLibrariesAsSubpackages()
{
RepositoryItemBuilder invalidSubPackage = APackage.WithStereotype("other-that-a-business-library-stereotype");
RepositoryItemBuilder bLibrary = DefaultItem
.WithChild(APackage.WithStereotype(Stereotype.bLibrary))
.WithChild(APackage.WithStereotype(Stereotype.PRIMLibrary))
.WithChild(APackage.WithStereotype(Stereotype.ENUMLibrary))
.WithChild(APackage.WithStereotype(Stereotype.CDTLibrary))
.WithChild(APackage.WithStereotype(Stereotype.CCLibrary))
.WithChild(APackage.WithStereotype(Stereotype.BDTLibrary))
.WithChild(APackage.WithStereotype(Stereotype.BIELibrary))
.WithChild(APackage.WithStereotype(Stereotype.DOCLibrary))
.WithChild(invalidSubPackage);
VerifyConstraintViolations(bLibrary, invalidSubPackage);
}
private void Validate(RepositoryItemBuilder validatedItemBuilder, string message)
{
RepositoryItem validatedItem = validatedItemBuilder.Build();
IValidator validator = Validator();
Assert.That(validator.Matches(validatedItem), "validator does not match validated item");
var constraintViolations = new List <ConstraintViolation>(validator.Validate(validatedItem));
foreach (ConstraintViolation constraintViolation in constraintViolations)
{
Console.WriteLine(constraintViolation);
}
var actualOffendingItemIds = new List <ItemId>(validator.Validate(validatedItem).Select(constraintViolation => constraintViolation.OffendingItemId));
Assert.That(actualOffendingItemIds, Is.EquivalentTo(expectedOffendingItemIds), message);
expectedOffendingItemIds.Clear();
}
protected void ExpectConstraintViolation(RepositoryItemBuilder offendingItemBuilder)
{
RepositoryItem offendingItem = offendingItemBuilder.Build();
expectedOffendingItemIds.Add(offendingItem.Id);
}
public ExpectedViolation(RepositoryItemBuilder validatedItem, params RepositoryItemBuilder[] offendingItems)
{
ValidatedItem = validatedItem;
OffendingItems = offendingItems;
}
public void ShouldNotAllowAnInvalidParent()
{
RepositoryItemBuilder bLibrary = DefaultItem.WithParent(APackage.WithStereotype("SOME-OTHER-KIND-OF-PACKAGE").WithParent(APackage));
VerifyConstraintViolations(bLibrary, bLibrary);
}
public void ShouldOnlyAllowABLibraryAsParent()
{
RepositoryItemBuilder elementLibrary = DefaultItem.WithParent(APackage.WithStereotype("other than bLibrary"));
VerifyConstraintViolations(elementLibrary, elementLibrary);
}
private void AssertValidatorDoesNotMatch(RepositoryItemBuilder repositoryItemBuilder)
{
RepositoryItem repositoryItem = repositoryItemBuilder.Build();
Assert.IsFalse(Validator().Matches(repositoryItem), libraryStereotype + " validator wrongly matches a " + repositoryItem.Id.Type + " with stereotype " + repositoryItem.Stereotype + ".");
}
protected void Validate(RepositoryItemBuilder validatedItemBuilder)
{
Validate(validatedItemBuilder, "");
}
public void ShouldOnlyAllowAPRIMLibraryAsParent()
{
RepositoryItemBuilder prim = DefaultItem.WithParent(APackage.WithStereotype("other than " + LibraryStereotype));
VerifyConstraintViolations(prim, prim);
}
