public void It_Should_Be_Reconstructed_Correctly()
{
const string xml = @"<LogicalSchema Version = ""1""><DatabaseName>Database1</DatabaseName></LogicalSchema>";
IDatabase db = new DatabaseDeserialisationScheme().Deserialise(xml);
Assert.That(db.Name, Is.EqualTo("Database1"));
}
public void It_Should_Be_Reconstructed_Correctly()
{
const string xml = When_Serialising_An_Empty_Table.BasicTableXml;
XmlDocument document = new XmlDocument();
document.LoadXml(xml);
ITable table = new DatabaseDeserialisationScheme().ProcessTableNode(document.DocumentElement);
// All of the table stuff is tested in the tests for IScriptObject
Assert.That(table.Name, Is.EqualTo("Entity1"));
}
public void It_Should_Be_Reconstructed_Correctly()
{
const string xml = When_Serialising_An_Empty_Key.BasicKeyXml;
XmlDocument document = new XmlDocument();
document.LoadXml(xml);
IKey key = new DatabaseDeserialisationScheme().ProcessKeyNode(document.DocumentElement, new Table(), new Database(""));
// All of the other key stuff is tested in the tests for IScriptObject
Assert.That(key.Keytype, Is.EqualTo(DatabaseKeyType.Primary));
}
public void Outputs_This()
{
IDatabaseLoader loader = new DatabaseDeserialisationScheme().DeserialiseConnectionInformation(
Specs_For_Serialisation_Of_Database_Connection_Information.When_Given_A_SQL_CE_Connector.ExpectedXml.GetXmlDocRoot());
Assert.That(loader, Is.Not.Null);
Assert.That(loader, Is.TypeOf(typeof(SQLCEDatabaseLoader)));
Assert.That(loader.DatabaseConnector, Is.Not.Null);
var connector = (SQLCEDatabaseConnector)loader.DatabaseConnector;
Assert.That(connector.Filename, Is.EqualTo("database.sdf"));
}
public void It_Should_Be_Reconstructed_Correctly()
{
const string xml = When_Serialising_Index_With_All_Information_Set.FullIndexXml;
XmlDocument document = new XmlDocument();
document.LoadXml(xml);
IIndex index = new DatabaseDeserialisationScheme().ProcessIndexNode(document.DocumentElement, new Table(), new Database(""));
// All of the other key stuff is tested in the tests for IScriptObject
Assert.That(index.Datatype, Is.EqualTo(DatabaseIndexType.PrimaryKey));
Assert.That(index.IsClustered, Is.True);
Assert.That(index.IsUnique, Is.True);
}
public void It_Should_Be_Reconstructed_Correctly()
{
const string xml = When_Serialising_Key_With_Columns.KeyWithColumnsXml;
XmlDocument document = new XmlDocument();
document.LoadXml(xml);
Table table1 = new Table("Table1");
table1.AddColumn(new Column("Column1"));
IKey key = new DatabaseDeserialisationScheme().ProcessKeyNode(document.DocumentElement, table1, new Database(""));
Assert.That(key.Columns, Has.Count(1));
Assert.That(key.Columns[0], Is.SameAs(table1.Columns[0]));
}
private static TimeSpan RunDeserialisationTest(int numTables, int numColumns)
{
IDatabase db = new Database("Test Database", ArchAngel.Providers.EntityModel.Controller.DatabaseLayer.DatabaseTypes.SQLServer2005);
SetupDatabase(db, numTables, numColumns);
string xml = db.Serialise(new DatabaseSerialisationScheme());
var scheme = new DatabaseDeserialisationScheme();
DateTime start = DateTime.Now;
scheme.Deserialise(xml);
return DateTime.Now - start;
}
public void Outputs_This()
{
IDatabaseLoader loader = new DatabaseDeserialisationScheme().DeserialiseConnectionInformation(
Specs_For_Serialisation_Of_Database_Connection_Information.When_Given_A_SQL_Server_2005_Connector.ExpectedXml.GetXmlDocRoot());
Assert.That(loader, Is.Not.Null);
Assert.That(loader, Is.TypeOf(typeof(SQLServer2005DatabaseLoader)));
Assert.That(loader.DatabaseConnector, Is.Not.Null);
var connector = (SQLServer2005DatabaseConnector)loader.DatabaseConnector;
var helper = connector.ConnectionInformation;
Assert.That(helper.ServerName, Is.EqualTo("server"));
Assert.That(helper.DatabaseName, Is.EqualTo("database"));
Assert.That(helper.UserName, Is.EqualTo("username"));
Assert.That(helper.UseIntegratedSecurity, Is.False);
}
public void It_Should_Be_Reconstructed_Correctly()
{
const string xml = When_Serialising_Key_With_A_Referenced_Key.KeyWithReferencedKeyXml;
XmlDocument document = new XmlDocument();
document.LoadXml(xml);
Database db = new Database("Database1");
Table table1 = new Table("Table1");
Table table2 = new Table("Table2");
db.AddTable(table1);
db.AddTable(table2);
IKey key2 = new Key("ForeignKey") { Parent = table2 };
table2.AddKey(key2);
var scheme = new DatabaseDeserialisationScheme();
IKey key = scheme.ProcessKeyNode(document.DocumentElement, table1, db);
scheme.ProcessReferencedKey(key, document.DocumentElement, db);
Assert.That(key.ReferencedKey, Is.SameAs(key2));
}
public void It_Should_Be_Reconstructed_Correctly()
{
IDatabase database = new Database("DB1");
var table1 = new Table("Table1");
var table2 = new Table("Table2");
var key1 = new Key("K1", DatabaseKeyType.Primary);
var key2 = new Key("ForeignKey", DatabaseKeyType.Foreign);
table1.AddKey(key1);
table2.AddKey(key2);
database.AddTable(table1);
database.AddTable(table2);
Relationship rel = new DatabaseDeserialisationScheme().DeserialiseRelationship(FullRelationshipXml.GetXmlDocRoot(), database);
Assert.That(rel.Identifier, Is.EqualTo(new Guid("11111111-1111-1111-1111-111111111111")));
Assert.That(rel.Name, Is.EqualTo("Relation1"));
Assert.That(rel.PrimaryTable, Is.SameAs(table1));
Assert.That(rel.ForeignTable, Is.SameAs(table2));
Assert.That(rel.PrimaryKey, Is.SameAs(key1));
Assert.That(rel.ForeignKey, Is.SameAs(key2));
}
public void It_Should_Be_Reconstructed_Correctly()
{
#region Xml
const string xml =
@"<LogicalSchema Version = ""1"">
<DatabaseName>Database1</DatabaseName>
<Table>
<Name>Table1</Name>
<NamePlural />
<Description />
<Enabled>False</Enabled>
<IsUserDefined>False</IsUserDefined>
<UID>00000000-0000-0000-0000-000000000000</UID>
<Keys>
<Key>
<Name>FK_Table1</Name>
<NamePlural />
<Description />
<Enabled>False</Enabled>
<IsUserDefined>False</IsUserDefined>
<UID>00000000-0000-0000-0000-000000000000</UID>
<IsUnique>False</IsUnique>
<Keytype>Foreign</Keytype>
<ReferencedKey>
<TableName>Table2</TableName>
<KeyName>PK_Table2</KeyName>
</ReferencedKey>
<Columns>
<ColumnName>ColumnT11</ColumnName>
</Columns>
</Key>
</Keys>
<Columns>
<Column>
<Name>ColumnT11</Name>
<NamePlural />
<Description />
<Enabled>False</Enabled>
<IsUserDefined>False</IsUserDefined>
<UID>00000000-0000-0000-0000-000000000000</UID>
<Datatype>int</Datatype>
<Default />
<InPrimaryKey>False</InPrimaryKey>
<IsCalculated>False</IsCalculated>
<IsComputed>False</IsComputed>
<IsIdentity>False</IsIdentity>
<IsNullable>True</IsNullable>
<IsReadOnly>False</IsReadOnly>
<IsUnique>True</IsUnique>
<OrdinalPosition>3</OrdinalPosition>
<Precision>10</Precision>
<Scale>0</Scale>
<Size>0</Size>
</Column>
</Columns>
</Table>
<Table>
<Name>Table2</Name>
<NamePlural />
<Description />
<Enabled>False</Enabled>
<IsUserDefined>False</IsUserDefined>
<UID>00000000-0000-0000-0000-000000000000</UID>
<Keys>
<Key>
<Name>PK_Table2</Name>
<NamePlural />
<Description />
<Enabled>False</Enabled>
<IsUserDefined>False</IsUserDefined>
<UID>00000000-0000-0000-0000-000000000000</UID>
<IsUnique>True</IsUnique>
<Keytype>Primary</Keytype>
<Columns>
<ColumnName>Column1</ColumnName>
</Columns>
</Key>
</Keys>
<Columns>
<Column>
<Name>Column1</Name>
<NamePlural />
<Description />
<Enabled>False</Enabled>
<IsUserDefined>False</IsUserDefined>
<UID>00000000-0000-0000-0000-000000000000</UID>
<Datatype>int</Datatype>
<Default />
<InPrimaryKey>True</InPrimaryKey>
<IsCalculated>False</IsCalculated>
<IsComputed>False</IsComputed>
<IsIdentity>False</IsIdentity>
<IsNullable>False</IsNullable>
<IsReadOnly>False</IsReadOnly>
<IsUnique>True</IsUnique>
<OrdinalPosition>1</OrdinalPosition>
<Precision>10</Precision>
<Scale>0</Scale>
<Size>0</Size>
</Column>
</Columns>
</Table>
</LogicalSchema>";
#endregion
IDatabase db = new DatabaseDeserialisationScheme().Deserialise(xml);
Assert.That(db.Tables, Has.Count(2));
ITable table1 = db.Tables[0];
Assert.That(table1.Name, Is.EqualTo("Table1"));
Assert.That(table1.Keys, Has.Count(1));
Assert.That(table1.Keys[0].Name, Is.EqualTo("FK_Table1"));
Assert.That(table1.Keys[0].Keytype, Is.EqualTo(DatabaseKeyType.Foreign));
ITable table2 = db.Tables[1];
Assert.That(table2.Name, Is.EqualTo("Table2"));
Assert.That(table2.Keys, Has.Count(1));
Assert.That(table2.Keys[0].Name, Is.EqualTo("PK_Table2"));
Assert.That(table2.Keys[0].Keytype, Is.EqualTo(DatabaseKeyType.Primary));
Assert.That(table1.Keys[0].ReferencedKey, Is.SameAs(table2.Keys[0]));
}
public void It_Should_Be_Reconstructed_Correctly()
{
const string xml =
@"<LogicalSchema Version = ""1"">" +
"<DatabaseName>Database1</DatabaseName>" +
"<Table>" + When_Serialising_An_Empty_Table.ScriptBaseXml +
"<Keys>" + When_Serialising_An_Empty_Key.BasicKeyXml + "</Keys>" +
"<Indexes>" + When_Serialising_An_Empty_Index.BasicIndexXml + "</Indexes>" +
"</Table>"+
"</LogicalSchema>";
IDatabase db = new DatabaseDeserialisationScheme().Deserialise(xml);
Assert.That(db.Tables, Has.Count(1));
ITable table = db.Tables[0];
Assert.That(table.Name, Is.EqualTo("Entity1"));
Assert.That(table.Keys, Has.Count(1));
Assert.That(table.Keys[0].Name, Is.EqualTo("PrimaryKey"));
Assert.That(table.Keys[0].Parent, Is.SameAs(table));
Assert.That(table.Indexes, Has.Count(1));
Assert.That(table.Indexes, Has.Count(1));
Assert.That(table.Indexes[0].Name, Is.EqualTo("Index1"));
Assert.That(table.Indexes[0].Parent, Is.SameAs(table));
}
public void It_Should_Be_Reconstructed_Correctly()
{
const string xml = @"<LogicalSchema Version = ""1""><DatabaseName>Database1</DatabaseName>" +
When_Serialising_An_Empty_Table.BasicTableXml +
"</LogicalSchema>";
IDatabase db = new DatabaseDeserialisationScheme().Deserialise(xml);
Assert.That(db.Tables, Has.Count(1));
// Make sure the correct table was loaded up.
Assert.That(db.Tables[0].Name, Is.EqualTo("Entity1"));
}
public override void Open(string folder)
{
string databaseFilePath = Path.Combine(folder, DatabaseFilename);
string entityFilePath = Path.Combine(folder, EntitiesFilename);
string mappingsFilePath = Path.Combine(folder, MappingsFilename);
if (File.Exists(databaseFilePath) == false)
throw new ArgumentException("Database definition file missing.");
if (File.Exists(entityFilePath) == false)
throw new ArgumentException("Entity definition file missing.");
if (File.Exists(mappingsFilePath) == false)
throw new ArgumentException("Mapping definition file missing.");
string databaseXml = File.ReadAllText(databaseFilePath);
string entitiesXml = File.ReadAllText(entityFilePath);
string mappingsXml = File.ReadAllText(mappingsFilePath);
try
{
var database = new DatabaseDeserialisationScheme().Deserialise(databaseXml);
var entitySet = new EntitySetDeserialisationScheme().DeserialiseEntitySet(entitiesXml, database);
MappingSet = new MappingSetDeserialisationScheme().DeserialiseMappingSet(mappingsXml, database, entitySet);
// If everything loaded correctly, copy the database file away so we can use it to figure out what the user has changed
// in this session.
loadedDatabaseXML = databaseXml;
}
catch (Exception e)
{
log.ErrorFormat("Error opening Entity Model Provider files on disk");
log.Error(e.Message);
#if DEBUG
if (MessageBox.Show("An error occurred while opening the project files.\nDo you want to ignore the invalid model on disk? See logs for exception", "Error",
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.Yes)
{
Clear();
}
else
{
throw;
}
#endif
}
}
