public void The_Rule_Fails()
{
var mappingSet = new MappingSetImpl();
var parent = new EntityImpl("Parent");
var child = new EntityImpl("Child");
child.Parent = parent;
var idProperty = new PropertyImpl("ID")
{
IsKeyProperty = true
};
parent.AddProperty(idProperty);
mappingSet.EntitySet.AddEntity(parent);
mappingSet.EntitySet.AddEntity(child);
var rule = new CheckEntityInheritanceForTablePerSubclassRule();
var result = rule.Run(mappingSet);
Assert.That(result.Issues, Has.Count(1));
var issue = result.Issues[0];
Assert.That(issue.Object, Is.SameAs(child));
Assert.That(issue.ErrorLevel, Is.EqualTo(ValidationErrorLevel.Error));
StringAssert.Contains("ID", issue.Description);
}
/// <summary>
/// Creates one Entity per database table, and one Reference per database relationship.
/// It then looks for association tables and maps them correctly.
/// </summary>
/// <param name="database"></param>
/// <returns></returns>
public MappingSet CreateOneToOneMapping(IDatabase database, List <string> tablePrefixes, List <string> columnPrefixes, List <string> tableSuffixes, List <string> columnSuffixes)
{
EntitySet entitySet = new EntitySetImpl();
MappingSet set = new MappingSetImpl(database, entitySet);
set.TablePrefixes = tablePrefixes;
set.ColumnPrefixes = columnPrefixes;
set.TableSuffixes = tableSuffixes;
set.ColumnSuffixes = columnSuffixes;
entitySet.MappingSet = set;
ArchAngel.Interfaces.ProjectOptions.ModelScripts.Scripts.ExistingEntityNames = new List <string>();
ArchAngel.Interfaces.ProjectOptions.ModelScripts.Scripts.TablePrefixes = (List <string>)tablePrefixes;
ArchAngel.Interfaces.ProjectOptions.ModelScripts.Scripts.ColumnPrefixes = (List <string>)columnPrefixes;
ArchAngel.Interfaces.ProjectOptions.ModelScripts.Scripts.TableSuffixes = (List <string>)tableSuffixes;
ArchAngel.Interfaces.ProjectOptions.ModelScripts.Scripts.ColumnSuffixes = (List <string>)columnSuffixes;
foreach (var table in database.Tables)
{
ProcessTable(set, table);
}
foreach (var view in database.Views)
{
ProcessTable(set, view);
}
foreach (var relationship in database.Relationships)
{
ProcessRelationship(set, relationship);
}
CreateManyToManyMappings(entitySet.Entities.ToList(), entitySet);
return(set);
}
public void The_Rule_Fails_But_Only_For_The_Parent()
{
var set = new MappingSetImpl();
var parentEntity = new EntityImpl("Parent");
var childEntity = new EntityImpl("Child");
childEntity.Parent = parentEntity;
var property = new PropertyImpl("Property1");
parentEntity.AddProperty(property);
set.EntitySet.AddEntity(parentEntity);
set.EntitySet.AddEntity(childEntity);
var table = new Table("Table1");
var column = new Column("Column1");
table.AddColumn(column);
set.Database.AddTable(table);
var rule = new CheckAllPropertiesMappedRule();
var result = rule.Run(set);
Assert.That(result.HasIssues);
Assert.That(result.Issues, Has.Count(1));
var issue = result.Issues[0];
Assert.That(issue.ErrorLevel, Is.EqualTo(ValidationErrorLevel.Warning));
Assert.That(issue.Object, Is.SameAs(property));
StringAssert.Contains("Property1", issue.Description);
StringAssert.Contains("Parent", issue.Description);
}
public void The_Presenter_Fills_In_The_Form()
{
IMainPanel mainPanel = MockRepository.GenerateStub <IMainPanel>();
IEntityForm form = MockRepository.GenerateMock <IEntityForm>();
form.Expect(f => f.Mappings = null)
.IgnoreArguments()
.WhenCalled(action => Assert.That(((IEnumerable <Mapping>)action.Arguments[0]).Count(), Is.EqualTo(0)));
form.Expect(f => f.SetAvailableTables(null))
.IgnoreArguments()
.WhenCalled(action => Assert.That(((IEnumerable <ITable>)action.Arguments[0]).Count(), Is.EqualTo(0)));
form.Expect(f => f.SetProperties(null))
.IgnoreArguments()
.WhenCalled(action => Assert.That(((IEnumerable <Property>)action.Arguments[0]).Count(), Is.EqualTo(1)));
form.Expect(f => f.SetAvailableEntities(null))
.IgnoreArguments()
.WhenCalled(action => Assert.That(((IEnumerable <Entity>)action.Arguments[0]).Count(), Is.EqualTo(2)));
form.Expect(f => f.SetChildEntities(null))
.IgnoreArguments()
.WhenCalled(action => Assert.That(((IEnumerable <Entity>)action.Arguments[0]).Count(), Is.EqualTo(1)));
Entity parentEntity = new EntityImpl("Parent");
Entity childEntity = new EntityImpl("Child");
Property property = new PropertyImpl("Prop1");
EntityKey key = new EntityKeyImpl();
Entity entity = new EntityImpl("Entity1")
{
Key = key
};
entity.Parent = parentEntity;
entity.AddChild(childEntity);
entity.AddProperty(property);
key.AddProperty(property);
EntitySet es = new EntitySetImpl();
es.AddEntity(parentEntity);
es.AddEntity(entity);
es.AddEntity(childEntity);
MappingSet ms = new MappingSetImpl();
ms.EntitySet = es;
var presenter = new EntityPresenter(mainPanel, form);
presenter.AttachToModel(entity);
form.AssertWasCalled(f => f.EntityName = entity.Name);
form.AssertWasCalled(f => f.Discriminator = entity.Discriminator);
form.AssertWasCalled(f => f.ParentEntity = entity.Parent);
form.AssertWasCalled(f => f.SetVirtualProperties(entity.Ex));
form.VerifyAllExpectations();
}
public void The_Rule_Fails()
{
var mappingSet = new MappingSetImpl();
var rule = new CheckEntityInheritanceForTablePerSubclassRule();
var result = rule.Run(mappingSet);
Assert.That(result.HasWarnings, Is.True);
Assert.That(result.Issues[0].ErrorLevel, Is.EqualTo(ValidationErrorLevel.Warning));
}
public void The_Rule_Passes()
{
var mappingSet = new MappingSetImpl();
mappingSet.EntitySet.AddEntity(new EntityImpl("Entity1"));
var rule = new CheckEntityInheritanceForTablePerSubclassRule();
var result = rule.Run(mappingSet);
Assert.That(result.HasIssues, Is.False);
}
public static MappingSet SetupModel()
{
MappingSet ms = new MappingSetImpl();
SetupDatabase(ms.Database);
SetupEntities(ms.EntitySet);
SetupMappings(ms);
return(ms);
}
public void It_Should_Serialise_To_This()
{
var set = new MappingSetImpl();
set.AddMapping(When_Serialising_A_Mapping_With_All_Fields_Set.GetMapping());
set.AddMapping(When_Serialising_A_ReferenceMapping_With_All_Fields_Set.GetMapping());
string outputXML = new MappingSetSerialisationScheme().SerialiseMappingSet(set);
outputXML = XmlSqueezer.RemoveWhitespaceBetweenElements(outputXML);
Assert.That(outputXML, Is.EqualTo(FullMappingSetXml));
}
public static Reference GetReference()
{
Reference reference = new ReferenceImpl();
var mappingSet = new MappingSetImpl();
var entitySet = new EntitySetImpl();
entitySet.AddReference(reference);
mappingSet.EntitySet = entitySet;
return(reference);
}
public void Form_Is_Set_Up()
{
IComponentSpecificationForm form = MockRepository.GenerateMock <IComponentSpecificationForm>();
IMainPanel panel = MockRepository.GenerateMock <IMainPanel>();
var mappingSet = new MappingSetImpl();
var entity = new EntityImpl("Entity1");
entity.AddProperty(new PropertyImpl("Property1"));
var table = new Table("Table1");
table.AddColumn(new Column("Column1"));
table.AddColumn(new Column("Street"));
mappingSet.EntitySet.AddEntity(entity);
mappingSet.ChangeMappedColumnFor(entity.Properties.First()).To(table.Columns[0]);
ComponentSpecification spec = new ComponentSpecificationImpl("Address");
spec.AddProperty(new ComponentPropertyImpl("Street"));
Component component = spec.CreateImplementedComponentFor(entity, "Street");
mappingSet.EntitySet.AddComponentSpecification(spec);
var mapping = new ComponentMappingImpl {
ToComponent = component, FromTable = table
};
mapping.AddPropertyAndColumn(component.Properties[0], table.Columns[0]);
mappingSet.AddMapping(mapping);
form.Expect(f => f.SetProperties(null))
.IgnoreArguments()
.WhenCalled(action => Assert.That(((IEnumerable <ComponentProperty>)action.Arguments[0]).Count(), Is.EqualTo(1)));
form.Expect(f => f.SetUsages(null))
.IgnoreArguments()
.WhenCalled(action => Assert.That(((IEnumerable <Entity>)action.Arguments[0]).Count(), Is.EqualTo(1)));
form.Expect(f => f.SetFullEntityList(null))
.IgnoreArguments()
.WhenCalled(action => Assert.That(((IEnumerable <Entity>)action.Arguments[0]).Count(), Is.EqualTo(1)));
ComponentSpecificationPresenter presenter = new ComponentSpecificationPresenter(panel, form);
presenter.AttachToModel(spec);
form.AssertWasCalled(f => f.Clear());
form.AssertWasCalled(f => f.SpecName = spec.Name);
form.AssertWasCalled(f => f.SetVirtualProperties(spec.Ex));
form.VerifyAllExpectations();
}
public void It_Is_Deleted()
{
MappingSet ms = new MappingSetImpl();
Mapping m = new MappingImpl();
ms.AddMapping(m);
Assert.That(ms.Mappings.Contains(m));
m.Delete();
Assert.That(ms.Mappings.Contains(m) == false);
}
public void The_Mapping_Should_Be_Deleted()
{
var m = new MappingImpl();
var ms = new MappingSetImpl();
ms.AddMapping(m);
Assert.That(ms.Mappings.Contains(m), Is.True);
//presenter.AttachToModel(m);
form.Raise(f => f.RemoveMapping += null, form, new EventArgs());
Assert.That(ms.Mappings.Contains(m), Is.False);
}
public void SetUp()
{
mappingSet = new MappingSetImpl();
engine = new ValidationRulesEngine(mappingSet);
rule1 = MockRepository.GenerateMock <IValidationRule>();
rule2 = MockRepository.GenerateMock <IValidationRule>();
result1 = new ValidationResult(rule1);
result2 = new ValidationResult(rule2);
rule1.Stub(r => r.Run(mappingSet)).Return(result1);
rule2.Stub(r => r.Run(mappingSet)).Return(result2);
engine.AddRule(rule1);
engine.AddRule(rule2);
}
public void The_Rule_Fails()
{
var set = new MappingSetImpl();
var emptyEntity = new Table("");
set.Database.AddTable(emptyEntity);
DatabaseNamingRule rule = new DatabaseNamingRule();
var result = rule.Run(set);
Assert.That(result.Issues, Has.Count(1));
var issue = result.Issues[0];
Assert.That(issue.ErrorLevel, Is.EqualTo(ValidationErrorLevel.Error));
Assert.That(issue.Object, Is.SameAs(emptyEntity));
StringAssert.Contains("name", issue.Description);
}
public void The_Rule_Fails()
{
var set = new MappingSetImpl();
set.EntitySet.AddEntity(new EntityImpl("Entity1"));
var duplicate = new EntityImpl("Entity1");
set.EntitySet.AddEntity(duplicate);
EntityNamingRule rule = new EntityNamingRule();
var result = rule.Run(set);
Assert.That(result.Issues, Has.Count(1));
var issue = result.Issues[0];
Assert.That(issue.ErrorLevel, Is.EqualTo(ValidationErrorLevel.Error));
Assert.That(issue.Object, Is.SameAs(duplicate));
StringAssert.Contains("Entity1", issue.Description);
}
public void The_Rule_Does_Not_Identify_It_As_A_Duplicate_Property()
{
var set = new MappingSetImpl();
var parent = new EntityImpl("Entity1");
var child = new EntityImpl("Entity2");
set.EntitySet.AddEntity(parent);
set.EntitySet.AddEntity(child);
var property = new PropertyImpl("Property1");
parent.AddProperty(property);
child.Parent = parent;
child.CopyPropertyFromParent(property);
EntityNamingRule rule = new EntityNamingRule();
var result = rule.Run(set);
Assert.That(result.HasIssues, Is.False);
}
public void The_Rule_Fails()
{
var set = new MappingSetImpl();
set.Database.AddTable(new Table("Table1"));
set.Database.AddTable(new Table("Table2"));
set.Database.Tables[0].AddKey(new Key("Key1"));
var duplicate = new Key("Key1");
set.Database.Tables[1].AddKey(duplicate);
DatabaseNamingRule rule = new DatabaseNamingRule();
var result = rule.Run(set);
Assert.That(result.Issues, Has.Count(1));
var issue = result.Issues[0];
Assert.That(issue.ErrorLevel, Is.EqualTo(ValidationErrorLevel.Error));
Assert.That(issue.Object, Is.SameAs(duplicate));
StringAssert.Contains("Key1", issue.Description);
}
public void The_Rule_Passes()
{
var set = new MappingSetImpl();
var entity = new EntityImpl("Entity1");
var property = new PropertyImpl("Property1");
entity.AddProperty(property);
set.EntitySet.AddEntity(entity);
var table = new Table("Table1");
var column = new Column("Column1");
table.AddColumn(column);
set.Database.AddTable(table);
set.ChangeMappedColumnFor(property).To(column);
var rule = new CheckAllPropertiesMappedRule();
var result = rule.Run(set);
Assert.That(result.HasIssues, Is.False);
}
public void The_Rule_Passes()
{
var mappingSet = new MappingSetImpl();
var parent = new EntityImpl("Parent");
var child = new EntityImpl("Child");
child.Parent = parent;
var idProperty = new PropertyImpl("ID")
{
IsKeyProperty = true
};
parent.AddProperty(idProperty);
child.CopyPropertyFromParent(idProperty);
mappingSet.EntitySet.AddEntity(parent);
mappingSet.EntitySet.AddEntity(child);
var rule = new CheckEntityInheritanceForTablePerSubclassRule();
var result = rule.Run(mappingSet);
Assert.That(result.HasIssues, Is.False);
}
public void The_Rule_Fails()
{
var set = new MappingSetImpl();
var entity1 = new EntityImpl("Entity1");
var entity2 = new EntityImpl("Entity2");
set.EntitySet.AddEntity(entity1);
set.EntitySet.AddEntity(entity2);
entity1.AddProperty(new PropertyImpl("Property1"));
var reference = entity1.CreateReferenceTo(entity2);
reference.End1Name = "Property1";
EntityNamingRule rule = new EntityNamingRule();
var result = rule.Run(set);
Assert.That(result.Issues, Has.Count(1));
var issue = result.Issues[0];
Assert.That(issue.ErrorLevel, Is.EqualTo(ValidationErrorLevel.Error));
Assert.That(issue.Object, Is.SameAs(reference));
StringAssert.Contains("Property1", issue.Description);
}
public MappingSet CreateOneToOneMapping(EntitySet entitySet)
{
IDatabase database = new Database("Database", ArchAngel.Providers.EntityModel.Controller.DatabaseLayer.DatabaseTypes.SQLServer2005);
MappingSet set = new MappingSetImpl(database, entitySet);
database.MappingSet = set;
foreach (var entity in entitySet.Entities)
{
ProcessEntity(set, entity);
}
foreach (var entity in entitySet.Entities)
{
PostProcessEntity(set, entity);
}
foreach (var reference in entitySet.References)
{
ProcessReference(set, reference);
}
return(set);
}
public void Setup()
{
EntitySet entitySet = new EntitySetImpl();
entity = new EntityImpl("Entity1");
entity.AddProperty(new PropertyImpl {
Name = "Property1"
});
entitySet.AddEntity(entity);
IDatabase database = new Database("DB1");
table = new Table("Table");
table.AddColumn(new Column("Column1"));
database.AddEntity(table);
Mapping mapping = new MappingImpl();
mapping.AddPropertyAndColumn(entity.Properties.ElementAt(0), table.Columns[0]);
MappingSet mappingSet = new MappingSetImpl(database, entitySet);
mappingSet.AddMapping(mapping);
}
