public void MultidatabaseMappingResolverOnSharedSchemaTest()
{
Require.AllFeaturesSupported(ProviderFeatures.Multidatabase);
var domainConfiguration = DomainConfigurationFactory.Create();
domainConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
domainConfiguration.Types.Register(typeof(model.Part1.TestEntity1).Assembly, typeof(model.Part1.TestEntity1).Namespace);
domainConfiguration.Types.Register(typeof(model.Part2.TestEntity2).Assembly, typeof(model.Part2.TestEntity2).Namespace);
domainConfiguration.Types.Register(typeof(model.Part3.TestEntity3).Assembly, typeof(model.Part3.TestEntity3).Namespace);
domainConfiguration.Types.Register(typeof(model.Part4.TestEntity4).Assembly, typeof(model.Part4.TestEntity4).Namespace);
domainConfiguration.Databases.Add("DO-Tests-1");
domainConfiguration.Databases.Add("DO-Tests-2");
domainConfiguration.MappingRules.Map(typeof(model.Part1.TestEntity1).Assembly, typeof(model.Part1.TestEntity1).Namespace).To("DO-Tests-1", "Model1");
domainConfiguration.MappingRules.Map(typeof(model.Part2.TestEntity2).Assembly, typeof(model.Part2.TestEntity2).Namespace).To("DO-Tests-1", "Model2");
domainConfiguration.MappingRules.Map(typeof(model.Part3.TestEntity3).Assembly, typeof(model.Part3.TestEntity3).Namespace).To("DO-Tests-2", "Model1");
domainConfiguration.MappingRules.Map(typeof(model.Part4.TestEntity4).Assembly, typeof(model.Part4.TestEntity4).Namespace).To("DO-Tests-2", "Model2");
domainConfiguration.DefaultDatabase = "DO-Tests-1";
domainConfiguration.DefaultSchema = "Model1";
var nodeConfiguration = new NodeConfiguration("Additional");
nodeConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
nodeConfiguration.DatabaseMapping.Add("DO-Tests-1", "DO-Tests-3");
nodeConfiguration.DatabaseMapping.Add("DO-Tests-2", "DO-Tests-4");
nodeConfiguration.SchemaMapping.Add("Model1", "Model3");
nodeConfiguration.SchemaMapping.Add("Model2", "Model4");
using (var domain = Domain.Build(domainConfiguration)) {
domain.StorageNodeManager.AddNode(nodeConfiguration);
var defaultNodeConfig = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId).Configuration;
var additionalNodeConfig = domain.StorageNodeManager.GetNode("Additional").Configuration;
DefaultSchemaInfo defaultSchemaInfo;
using (var connection = driver.CreateConnection()) {
connection.Open();
defaultSchemaInfo = driver.GetDefaultSchema(connection);
}
var defaultMappingResolver = MappingResolver.Create(domainConfiguration, defaultNodeConfig, defaultSchemaInfo);
Assert.That(defaultMappingResolver, Is.InstanceOf <MultidatabaseMappingResolver>());
var additionalMappingResolver = MappingResolver.Create(domainConfiguration, additionalNodeConfig, defaultSchemaInfo);
Assert.That(additionalMappingResolver, Is.InstanceOf <MultidatabaseMappingResolver>());
SchemaExtractionResult extractionResult;
using (var connection = driver.CreateConnection()) {
connection.Open();
extractionResult = new SchemaExtractionResult(driver.Extract(connection, defaultMappingResolver.GetSchemaTasks()));
}
extractionResult.MakeShared();
var resolverPerNodeMap = new Dictionary <NodeConfiguration, MappingResolver> {
{ defaultNodeConfig, defaultMappingResolver }, { additionalNodeConfig, additionalMappingResolver }
};
var baseDb1 = "DO-Tests-1";
var baseDb2 = "DO-Tests-2";
var baseSch1 = "Model1";
var baseSch2 = "Model2";
foreach (var pair in resolverPerNodeMap)
{
var nodeConfig = pair.Key;
var resolver = pair.Value;
var tasks = resolver.GetSchemaTasks();
Assert.That(tasks.Count(), Is.EqualTo(4));
Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply("DO-Tests-1") && t.Schema == nodeConfig.SchemaMapping.Apply("Model1")), Is.True);
Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply("DO-Tests-1") && t.Schema == nodeConfig.SchemaMapping.Apply("Model2")), Is.True);
Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply("DO-Tests-2") && t.Schema == nodeConfig.SchemaMapping.Apply("Model1")), Is.True);
Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply("DO-Tests-2") && t.Schema == nodeConfig.SchemaMapping.Apply("Model2")), Is.True);
tasks = resolver.GetMetadataTasks();
Assert.That(tasks.Count(), Is.EqualTo(2));
Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply("DO-Tests-1") && t.Schema == nodeConfig.SchemaMapping.Apply("Model1")), Is.True);
Assert.That(tasks.Any(t => t.Catalog == nodeConfig.DatabaseMapping.Apply("DO-Tests-2") && t.Schema == nodeConfig.SchemaMapping.Apply("Model1")), Is.True);
var fullName = resolver.GetNodeName("TestDb", "TestSchema", "TestEntity1");
Assert.That(fullName, Is.EqualTo("TestDb:TestSchema:TestEntity1"));
var expectedDatabase = nodeConfig.DatabaseMapping.Apply(baseDb1);
var expectedSchema = nodeConfig.SchemaMapping.Apply(baseSch1);
fullName = resolver.GetNodeName("DO-Tests-1", "Model1", "TestEntity1");
Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity1", expectedDatabase, expectedSchema)));
var table = extractionResult
.Catalogs[baseDb1]
.Schemas[baseSch1]
.Tables["TestEntity1"];
fullName = resolver.GetNodeName(table);
expectedDatabase = baseDb1;
expectedSchema = baseSch1;
Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity1", expectedDatabase, expectedSchema)));
table = extractionResult
.Catalogs[baseDb1]
.Schemas[baseSch2]
.Tables["TestEntity2"];
fullName = resolver.GetNodeName(table);
expectedDatabase = baseDb1;
expectedSchema = baseSch2;
Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity2", expectedDatabase, expectedSchema)));
table = extractionResult
.Catalogs[baseDb2]
.Schemas[baseSch1]
.Tables["TestEntity3"];
expectedDatabase = baseDb2;
expectedSchema = baseSch1;
fullName = resolver.GetNodeName(table);
Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity3", expectedDatabase, expectedSchema)));
var typeinfo = domain.Model.Types[typeof(model.Part1.TestEntity1)];
expectedDatabase = nodeConfig.DatabaseMapping.Apply(baseDb1);
expectedSchema = nodeConfig.SchemaMapping.Apply(baseSch1);
fullName = resolver.GetNodeName(typeinfo);
Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity1", expectedDatabase, expectedSchema)));
var resolveResult = resolver.Resolve(extractionResult, fullName);
expectedDatabase = baseDb1;
expectedSchema = baseSch1;
Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo(expectedSchema));
Assert.That(resolveResult.Schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));
var schema = resolver.ResolveSchema(extractionResult, typeinfo.MappingDatabase, typeinfo.MappingSchema);
Assert.That(schema.GetNameInternal(), Is.EqualTo(expectedSchema));
Assert.That(schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));
typeinfo = domain.Model.Types[typeof(model.Part2.TestEntity2)];
expectedDatabase = nodeConfig.DatabaseMapping.Apply(baseDb1);
expectedSchema = nodeConfig.SchemaMapping.Apply(baseSch2);
fullName = resolver.GetNodeName(typeinfo);
Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity2", expectedDatabase, expectedSchema)));
resolveResult = resolver.Resolve(extractionResult, fullName);
expectedDatabase = baseDb1;
expectedSchema = baseSch2;
Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo(expectedSchema));
Assert.That(resolveResult.Schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));
schema = resolver.ResolveSchema(extractionResult, typeinfo.MappingDatabase, typeinfo.MappingSchema);
Assert.That(schema.GetNameInternal(), Is.EqualTo(expectedSchema));
Assert.That(schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));
typeinfo = domain.Model.Types[typeof(model.Part3.TestEntity3)];
expectedDatabase = nodeConfig.DatabaseMapping.Apply(baseDb2);
expectedSchema = nodeConfig.SchemaMapping.Apply(baseSch1);
fullName = resolver.GetNodeName(typeinfo);
Assert.That(fullName, Is.EqualTo(string.Format("{0}:{1}:TestEntity3", expectedDatabase, expectedSchema)));
resolveResult = resolver.Resolve(extractionResult, fullName);
expectedDatabase = baseDb2;
expectedSchema = baseSch1;
Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo(expectedSchema));
Assert.That(resolveResult.Schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));
schema = resolver.ResolveSchema(extractionResult, typeinfo.MappingDatabase, typeinfo.MappingSchema);
Assert.That(schema.GetNameInternal(), Is.EqualTo(expectedSchema));
Assert.That(schema.Catalog.GetNameInternal(), Is.EqualTo(expectedDatabase));
}
}
}
public void TestFixtureSetUp()
{
driver = TestSqlDriver.Create(DomainConfigurationFactory.Create().ConnectionInfo);
}
public void MainTest()
{
// Creatign new Domain configuration
var config = DomainConfigurationFactory.CreateWithoutSessionConfigurations();
config.UpgradeMode = DomainUpgradeMode.Recreate;
// Modifying it by registering the persistent types
config.Types.Register(typeof(User).Assembly, typeof(User).Namespace);
// And finally building the domain
var domain = Domain.Build(config);
Key dmitriKey;
int dmitriId;
string dmitriKeyString;
// Opening Session
using (var session = domain.OpenSession()) {
// Opening transaction
using (var transactionScope = session.OpenTransaction()) {
// Creating user
var dmitri = new User(session)
{
Name = "Dmitri"
};
// Storing entity key
dmitriKey = dmitri.Key;
dmitriKeyString = dmitriKey.Format();
dmitriId = dmitri.Id;
Console.WriteLine("Dmitri's Key (human readable): {0}", dmitriKey);
Console.WriteLine("Dmitri's Key (serializable): {0}", dmitriKeyString);
Console.WriteLine("Dmitri's Id: {0}", dmitriId);
// Marking the transaction scope as completed to commit it
transactionScope.Complete();
}
// Opening another transaction
using (var transactionScope = session.OpenTransaction()) {
// Parses the serialized key
var anotherDimtriKey = Key.Parse(session.Domain, dmitriKeyString);
// Keys are equal
Assert.AreEqual(dmitriKey, anotherDimtriKey);
// Materialization on fetch
var dmitri = session.Query.Single <User>(dmitriKey);
// Alternative way to do the same
var anotherDmitri = session.Query.SingleOrDefault <User>(dmitriKey);
Assert.AreSame(dmitri, anotherDmitri);
// Fetching by key value(s)
anotherDmitri = session.Query.Single <User>(dmitriId);
Assert.AreSame(dmitri, anotherDmitri);
// Querying the storage using regular LINQ query
var query =
from user in session.Query.All <User>()
where user.Name == "Dmitri"
select user;
Assert.AreSame(dmitri, query.First());
// Querying the storage using compiled query
anotherDmitri = session.Query.Execute(qe => // Default caching key is methodof( () => ... )
from user in session.Query.All <User>()
where user.Name == "Dmitri"
select user).First();
Assert.AreSame(dmitri, anotherDmitri);
// Querying the storage using compiled future scalar query
var delayedDmitry1 = session.Query.CreateDelayedQuery(qe => (
from user in qe.All <User>()
where user.Name == "Dmitri"
select user
).FirstOrDefault());
var delayedDmitry2 = session.Query.CreateDelayedQuery(qe => (
from user in qe.All <User>()
where user.Id == dmitriId
select user
).First());
Assert.AreSame(dmitri, delayedDmitry1.Value); // Both queries are executed at once here
Assert.AreSame(dmitri, delayedDmitry2.Value);
// Modifying the entity
dmitri.Name = "Dmitri Maximov";
// Opening new nested transaction
using (var nestedScope = session.OpenTransaction(TransactionOpenMode.New)) {
// Removing the entity
dmitri.Remove();
Assert.IsTrue(dmitri.IsRemoved);
AssertEx.Throws <InvalidOperationException>(() => {
var dmitryName = dmitri.Name;
});
// No nestedScope.Complete(), so nested transaction will be rolled back
}
// Transparent Entity state update
Assert.IsFalse(dmitri.IsRemoved);
Assert.AreEqual("Dmitri Maximov", dmitri.Name);
// Creating few more objects
var xtensiveWebPage = new WebPage(session)
{
Title = "Xtensive Web Site",
Url = "http://www.x-tensive.com"
};
var alexYakuninBlogPage = new WebPage(session)
{
Title = "Alex Yakunin's Blog",
Url = "http://blog.alexyakunin.com"
};
var subsonicPage = new WebPage(session)
{
Title = "SubSonic project page",
Url = "http://www.subsonicproject.com/"
};
// Adding the items to EntitySet
dmitri.FavoritePages.Add(xtensiveWebPage);
dmitri.FavoritePages.Add(alexYakuninBlogPage);
dmitri.FavoritePages.Add(subsonicPage);
// Removing the item from EntitySet
dmitri.FavoritePages.Remove(subsonicPage);
// Getting count of items in EntitySet
Console.WriteLine("Dmitri's favorite page count: {0}", dmitri.FavoritePages.Count);
Assert.AreEqual(2, dmitri.FavoritePages.Count);
Assert.AreEqual(2, dmitri.FavoritePages.Count()); // The same, but by LINQ query
// Enumerating EntitySet
foreach (var page in dmitri.FavoritePages)
{
Console.WriteLine("Dmitri's favorite page: {0} ({1})", page.Title, page.Url);
}
// Checking for the containment
Assert.IsTrue(dmitri.FavoritePages.Contains(xtensiveWebPage));
Assert.IsTrue(dmitri.FavoritePages.Contains(alexYakuninBlogPage));
Assert.IsFalse(dmitri.FavoritePages.Contains(subsonicPage));
// Opening new nested transaction
using (var nestedScope = session.OpenTransaction(TransactionOpenMode.New)) {
// Clearing the EntitySet
dmitri.FavoritePages.Clear();
Assert.IsFalse(dmitri.FavoritePages.Contains(xtensiveWebPage));
Assert.IsFalse(dmitri.FavoritePages.Contains(alexYakuninBlogPage));
Assert.IsFalse(dmitri.FavoritePages.Contains(subsonicPage));
Assert.AreEqual(0, dmitri.FavoritePages.Count);
Assert.AreEqual(0, dmitri.FavoritePages.Count()); // By query
// No nestedScope.Complete(), so nested transaction will be rolled back
}
// Transparent EntitySet state update
Assert.IsTrue(dmitri.FavoritePages.Contains(xtensiveWebPage));
Assert.IsTrue(dmitri.FavoritePages.Contains(alexYakuninBlogPage));
Assert.IsFalse(dmitri.FavoritePages.Contains(subsonicPage));
Assert.AreEqual(2, dmitri.FavoritePages.Count);
Assert.AreEqual(2, dmitri.FavoritePages.Count()); // The same, but by LINQ query
// Finally, let's query the EntitySet:
// Query construction
var dmitryFavoriteBlogs =
from page in dmitri.FavoritePages
where page.Url.ToLower().Contains("blog")
select page;
// Query execution
var dmitryFavoriteBlogList = dmitryFavoriteBlogs.ToList();
// Printing the results
Console.WriteLine("Dmitri's favorite blog count: {0}", dmitryFavoriteBlogList.Count);
foreach (var page in dmitryFavoriteBlogList)
{
Console.WriteLine("Dmitri's favorite blog: {0} ({1})", page.Title, page.Url);
}
Assert.IsTrue(dmitryFavoriteBlogList.Contains(alexYakuninBlogPage));
Assert.IsFalse(dmitryFavoriteBlogList.Contains(xtensiveWebPage));
Assert.AreEqual(1, dmitryFavoriteBlogList.Count);
// Marking the transaction scope as completed to commit it
transactionScope.Complete();
}
}
}
public void MultischemaMappingResolverOnSharedSchemaTest()
{
Require.AllFeaturesSupported(ProviderFeatures.Multischema);
var domainConfiguration = DomainConfigurationFactory.Create();
domainConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
domainConfiguration.Types.Register(typeof(model.Part1.TestEntity1).Assembly, typeof(model.Part1.TestEntity1).Namespace);
domainConfiguration.Types.Register(typeof(model.Part2.TestEntity2).Assembly, typeof(model.Part2.TestEntity2).Namespace);
domainConfiguration.Types.Register(typeof(model.Part3.TestEntity3).Assembly, typeof(model.Part3.TestEntity3).Namespace);
domainConfiguration.Types.Register(typeof(model.Part4.TestEntity4).Assembly, typeof(model.Part4.TestEntity4).Namespace);
domainConfiguration.MappingRules.Map(typeof(model.Part1.TestEntity1).Assembly, typeof(model.Part1.TestEntity1).Namespace).ToSchema("Model1");
domainConfiguration.MappingRules.Map(typeof(model.Part2.TestEntity2).Assembly, typeof(model.Part2.TestEntity2).Namespace).ToSchema("Model1");
domainConfiguration.MappingRules.Map(typeof(model.Part3.TestEntity3).Assembly, typeof(model.Part3.TestEntity3).Namespace).ToSchema("Model2");
domainConfiguration.MappingRules.Map(typeof(model.Part4.TestEntity4).Assembly, typeof(model.Part4.TestEntity4).Namespace).ToSchema("Model2");
domainConfiguration.DefaultSchema = "Model1";
var nodeConfiguration = new NodeConfiguration("Additional");
nodeConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
nodeConfiguration.SchemaMapping.Add("Model1", "Model3");
nodeConfiguration.SchemaMapping.Add("Model2", "Model4");
using (var domain = Domain.Build(domainConfiguration)) {
domain.StorageNodeManager.AddNode(nodeConfiguration);
var defaultNodeConfig = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId).Configuration;
var additionalNodeConfig = domain.StorageNodeManager.GetNode("Additional").Configuration;
DefaultSchemaInfo defaultSchemaInfo;
using (var connection = driver.CreateConnection()) {
connection.Open();
defaultSchemaInfo = driver.GetDefaultSchema(connection);
}
var defaultMappingResolver = MappingResolver.Create(domainConfiguration, defaultNodeConfig, defaultSchemaInfo);
Assert.That(defaultMappingResolver, Is.InstanceOf <MultischemaMappingResolver>());
var additionalMappingResolver = MappingResolver.Create(domainConfiguration, additionalNodeConfig, defaultSchemaInfo);
Assert.That(additionalMappingResolver, Is.InstanceOf <MultischemaMappingResolver>());
SchemaExtractionResult extractionResult;
using (var connection = driver.CreateConnection()) {
connection.Open();
extractionResult = new SchemaExtractionResult(driver.Extract(connection, defaultMappingResolver.GetSchemaTasks()));
}
extractionResult.MakeShared();
var resolverPerNodeMap = new Dictionary <NodeConfiguration, MappingResolver> {
{ defaultNodeConfig, defaultMappingResolver }, { additionalNodeConfig, additionalMappingResolver }
};
foreach (var pair in resolverPerNodeMap)
{
var nodeConfig = pair.Key;
var mappingResolver = pair.Value;
Assert.That(mappingResolver, Is.InstanceOf <MultischemaMappingResolver>());
var metadataExtactionTasks = mappingResolver.GetMetadataTasks();
Assert.That(metadataExtactionTasks.Count(), Is.EqualTo(1));
Assert.That(metadataExtactionTasks.First().Catalog, Is.EqualTo(defaultSchemaInfo.Database));
Assert.That(metadataExtactionTasks.First().Schema, Is.EqualTo(nodeConfig.SchemaMapping.Apply("Model1")));
var schemaExtractionTasks = mappingResolver.GetSchemaTasks();
Assert.That(schemaExtractionTasks.Count(), Is.EqualTo(2));
Assert.That(schemaExtractionTasks.Any(t => t.Catalog == defaultSchemaInfo.Database && t.Schema == nodeConfig.SchemaMapping.Apply("Model1")), Is.True);
Assert.That(schemaExtractionTasks.Any(t => t.Catalog == defaultSchemaInfo.Database && t.Schema == nodeConfig.SchemaMapping.Apply("Model2")), Is.True);
var fullName = mappingResolver.GetNodeName("dummy", "SchemaName", "Table1");
Assert.That(fullName, Is.EqualTo("SchemaName:Table1"));
fullName = mappingResolver.GetNodeName("dummy", "Model1", "Table1");
Assert.That(fullName, Is.EqualTo(nodeConfig.SchemaMapping.Apply("Model1") + ":" + "Table1"));
var table = extractionResult.Catalogs.First().Schemas["Model1"].Tables["TestEntity1"];
fullName = mappingResolver.GetNodeName(table);
Assert.That(fullName, Is.EqualTo("Model1" + ":" + "TestEntity1"));
table = extractionResult.Catalogs.First().Schemas["Model2"].Tables["TestEntity4"];
fullName = mappingResolver.GetNodeName(table);
Assert.That(fullName, Is.EqualTo("Model2" + ":" + "TestEntity4"));
var typeInfo = domain.Model.Types[typeof(model.Part1.TestEntity1)];
fullName = mappingResolver.GetNodeName(typeInfo);
Assert.That(fullName, Is.EqualTo(nodeConfig.SchemaMapping.Apply("Model1") + ":" + "TestEntity1"));
var resolveResult = mappingResolver.Resolve(extractionResult, fullName);
Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo("Model1"));
var schema = mappingResolver.ResolveSchema(extractionResult, typeInfo.MappingDatabase, typeInfo.MappingSchema);
Assert.That(schema.GetNameInternal(), Is.EqualTo("Model1"));
typeInfo = domain.Model.Types[typeof(model.Part4.TestEntity4)];
fullName = mappingResolver.GetNodeName(typeInfo);
Assert.That(fullName, Is.EqualTo(nodeConfig.SchemaMapping.Apply("Model2") + ":" + "TestEntity4"));
resolveResult = mappingResolver.Resolve(extractionResult, fullName);
Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo("Model2"));
schema = mappingResolver.ResolveSchema(extractionResult, typeInfo.MappingDatabase, typeInfo.MappingSchema);
Assert.That(schema.GetNameInternal(), Is.EqualTo("Model2"));
var sequence = typeInfo.Hierarchy.Key.Sequence;
fullName = mappingResolver.GetNodeName(sequence);
Assert.That(fullName, Is.EqualTo(nodeConfig.SchemaMapping.Apply("Model1") + ":" + sequence.MappingName));
resolveResult = mappingResolver.Resolve(extractionResult, fullName);
Assert.That(resolveResult.Schema.GetNameInternal(), Is.EqualTo("Model1"));
}
}
}
public void CurrentSessionTest()
{
#region Session sample
// Creating new Domain configuration
var config = DomainConfigurationFactory.CreateWithoutSessionConfigurations();
config.UpgradeMode = DomainUpgradeMode.Recreate;
// Registering all types in the specified assembly and namespace
config.Types.Register(typeof(Person).Assembly, typeof(Person).Namespace);
// And finally building the domain
var domain = Domain.Build(config);
int personId;
using (var session = domain.OpenSession()) {
using (var transactionScope = session.OpenTransaction()) {
personId = new Person(session).Id;
transactionScope.Complete();
}
}
// Opens the session with default configuration - ServerProfile. Auto actiovation option is disabled.
using (var session = domain.OpenSession()) {
using (var transactionScope = session.OpenTransaction()) {
// you need to provide session explicitly
var newPerson = new Person(session);
var fetchedPerson = session.Query.Single <Person>(personId);
Console.WriteLine("Current session is null: {0}", Session.Current == null);
Console.WriteLine("New entity is bound to our session: {0}", newPerson.Session == session);
Console.WriteLine("Fetched entity is bound to our session: {0}", fetchedPerson.Session == session);
transactionScope.Complete();
}
}
// New session configuration with actiovation option enabled.
var sessionConfiguration = new SessionConfiguration(SessionOptions.AutoActivation | SessionOptions.AutoSaveChanges);
using (var session = domain.OpenSession(sessionConfiguration)) {
using (var transactionScope = session.OpenTransaction()) {
// you don't need to provide session explicitly. Active session will be used instead.
var newPerson = new Person();
var fetchedPerson = session.Query.Single <Person>(personId);
Console.WriteLine("Our session is current: {0}", Session.Current == session);
Console.WriteLine("New entity is bound to our session: {0}", newPerson.Session == session);
Console.WriteLine("Fetched entity is bound to our session: {0}", fetchedPerson.Session == session);
transactionScope.Complete();
}
}
#endregion
using (var session = domain.OpenSession()) {
using (var transactionScope = session.OpenTransaction()) {
var person = new Person(session);
person.Name = "Barack Obama";
transactionScope.Complete();
}
}
}
public void MultischemaWithDatabaseSwitchingTest()
{
Require.ProviderIs(StorageProvider.SqlServer);
var masterConnection = BuildConnectionToMaster(DomainConfigurationFactory.Create().ConnectionInfo);
var configuration = new DomainConfiguration(masterConnection)
{
UpgradeMode = DomainUpgradeMode.Recreate,
DefaultSchema = dbo,
ConnectionInitializationSql = $"USE [{DOTests1Db}]"
};
configuration.Types.Register(typeof(part1.TestEntity1));
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1")
{
ConnectionInfo = masterConnection,
ConnectionInitializationSql = $"USE [{DOTests1Db}]",
UpgradeMode = DomainUpgradeMode.Recreate
};
domainCopyNode.SchemaMapping.Add(dbo, dbo);
_ = domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2")
{
ConnectionInfo = masterConnection,
ConnectionInitializationSql = $"USE [{DOTests2Db}]",
UpgradeMode = DomainUpgradeMode.Recreate
};
anotherDatabaseNode.SchemaMapping.Add(dbo, dbo);
_ = domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var thirdDatabaseNode = new NodeConfiguration("3")
{
ConnectionInfo = masterConnection,
ConnectionInitializationSql = $"USE [{DOTests3Db}]",
UpgradeMode = DomainUpgradeMode.Recreate
};
thirdDatabaseNode.SchemaMapping.Add(dbo, Schema1);
_ = domain.StorageNodeManager.AddNode(thirdDatabaseNode);
}
configuration = new DomainConfiguration(masterConnection)
{
DefaultSchema = dbo,
UpgradeMode = DomainUpgradeMode.Skip,
ConnectionInitializationSql = $"USE [{DOTests1Db}]"
};
configuration.Types.Register(typeof(part1.TestEntity1));
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1")
{
ConnectionInfo = masterConnection,
UpgradeMode = DomainUpgradeMode.Skip,
ConnectionInitializationSql = $"USE [{DOTests1Db}]"
};
domainCopyNode.SchemaMapping.Add(dbo, dbo);
_ = domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2")
{
ConnectionInfo = masterConnection,
UpgradeMode = DomainUpgradeMode.Skip,
ConnectionInitializationSql = $"USE [{DOTests2Db}]"
};
anotherDatabaseNode.SchemaMapping.Add(dbo, dbo);
_ = domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var thirdDatabaseNode = new NodeConfiguration("3")
{
ConnectionInfo = masterConnection,
UpgradeMode = DomainUpgradeMode.Skip,
ConnectionInitializationSql = $"USE [{DOTests3Db}]"
};
thirdDatabaseNode.SchemaMapping.Add(dbo, Schema1);
_ = domain.StorageNodeManager.AddNode(thirdDatabaseNode);
var testEntity1Type = domain.Model.Types[typeof(part1.TestEntity1)];
var defaultNode = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var table = defaultNode.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests1Db));
var node1 = domain.StorageNodeManager.GetNode("1");
table = node1.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests1Db));
var node2 = domain.StorageNodeManager.GetNode("2");
table = node2.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests2Db));
var node3 = domain.StorageNodeManager.GetNode("3");
table = node3.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(Schema1));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests3Db));
}
}
public void AutoTest()
{
var config = DomainConfigurationFactory.Create();
config.Types.Register(typeof(Base));
config.Types.Register(typeof(Auto));
config.Types.Register(typeof(AutoInheritor));
var domain = Domain.Build(config);
var autoTypeInfo = domain.Model.Types[typeof(Auto)];
var autoInheritorTypeInfo = domain.Model.Types[typeof(AutoInheritor)];
Assert.AreEqual(1, autoTypeInfo.GetVersionColumns().Count);
Assert.AreEqual(2, autoInheritorTypeInfo.GetVersionColumns().Count);
using (var session = domain.OpenSession()) {
var versions = new VersionSet();
var updatedVersions = new VersionSet();
Auto auto;
AutoInheritor autoInheritor;
using (VersionCapturer.Attach(session, versions))
using (var t = session.OpenTransaction()) {
auto = new Auto()
{
Content = "Content", Tag = "Tag"
};
autoInheritor = new AutoInheritor()
{
Content = "Content", Tag = "Tag"
};
t.Complete();
}
using (VersionCapturer.Attach(session, updatedVersions))
using (VersionValidator.Attach(session, versions))
using (var t = session.OpenTransaction()) {
auto.Content = "AnotherContent";
auto.Content = "AnotherContetnCorrect";
autoInheritor.Content = "AnotherContent";
autoInheritor.Content = "AnotherContetnCorrect";
t.Complete();
}
AssertEx.Throws <VersionConflictException>(() => {
using (VersionValidator.Attach(session, versions))
using (var t = session.OpenTransaction()) {
auto.Tag = "AnotherTag";
autoInheritor.Tag = "AnotherTag";
t.Complete();
}
});
using (VersionValidator.Attach(session, updatedVersions))
using (var t = session.OpenTransaction()) {
auto.Tag = "AnotherTag";
autoInheritor.Tag = "AnotherTag";
t.Complete();
}
}
var allVersions = new VersionSet();
using (var session = domain.OpenSession())
using (VersionCapturer.Attach(session, allVersions))
using (VersionValidator.Attach(session, allVersions)) {
Auto auto;
AutoInheritor autoInheritor;
using (var t = session.OpenTransaction()) {
auto = new Auto()
{
Content = "Content", Tag = "Tag"
};
autoInheritor = new AutoInheritor()
{
Content = "Content", Tag = "Tag"
};
t.Complete();
}
using (var t = session.OpenTransaction()) {
auto.Content = "AnotherContent";
auto.Content = "AnotherContetnCorrect";
autoInheritor.Content = "AnotherContent";
autoInheritor.Content = "AnotherContetnCorrect";
t.Complete();
}
using (var t = session.OpenTransaction()) {
auto.Tag = "AnotherTag";
autoInheritor.Tag = "AnotherTag";
t.Complete();
}
}
}
public void MultischemaWithDatabaseSwitchingTest()
{
Require.ProviderIs(StorageProvider.SqlServer);
var masterConnection = BuildConnectionToMaster(DomainConfigurationFactory.Create().ConnectionInfo);
var configuration = new DomainConfiguration(masterConnection);
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.UpgradeMode = DomainUpgradeMode.Recreate;
configuration.DefaultSchema = "dbo";
configuration.ConnectionInitializationSql = "USE [DO-Tests-1]";
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1");
domainCopyNode.ConnectionInfo = masterConnection;
domainCopyNode.ConnectionInitializationSql = "USE [DO-Tests-1]";
domainCopyNode.SchemaMapping.Add("dbo", "dbo");
domainCopyNode.UpgradeMode = DomainUpgradeMode.Recreate;
_ = domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2");
anotherDatabaseNode.ConnectionInfo = masterConnection;
anotherDatabaseNode.ConnectionInitializationSql = "USE [DO-Tests-2]";
anotherDatabaseNode.SchemaMapping.Add("dbo", "dbo");
anotherDatabaseNode.UpgradeMode = DomainUpgradeMode.Recreate;
_ = domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var thirdDatabaseNode = new NodeConfiguration("3");
thirdDatabaseNode.ConnectionInfo = masterConnection;
thirdDatabaseNode.ConnectionInitializationSql = "USE [DO-Tests-3]";
thirdDatabaseNode.SchemaMapping.Add("dbo", "Model1");
thirdDatabaseNode.UpgradeMode = DomainUpgradeMode.Recreate;
_ = domain.StorageNodeManager.AddNode(thirdDatabaseNode);
}
configuration = new DomainConfiguration(masterConnection);
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.DefaultSchema = "dbo";
configuration.UpgradeMode = DomainUpgradeMode.Skip;
configuration.ConnectionInitializationSql = "USE [DO-Tests-1]";
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1");
domainCopyNode.ConnectionInfo = masterConnection;
domainCopyNode.ConnectionInitializationSql = "USE [DO-Tests-1]";
domainCopyNode.SchemaMapping.Add("dbo", "dbo");
domainCopyNode.UpgradeMode = DomainUpgradeMode.Skip;
_ = domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2");
anotherDatabaseNode.ConnectionInfo = masterConnection;
anotherDatabaseNode.ConnectionInitializationSql = "USE [DO-Tests-2]";
anotherDatabaseNode.SchemaMapping.Add("dbo", "dbo");
anotherDatabaseNode.UpgradeMode = DomainUpgradeMode.Skip;
_ = domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var thirdDatabaseNode = new NodeConfiguration("3");
thirdDatabaseNode.ConnectionInfo = masterConnection;
thirdDatabaseNode.ConnectionInitializationSql = "USE [DO-Tests-3]";
thirdDatabaseNode.SchemaMapping.Add("dbo", "Model1");
thirdDatabaseNode.UpgradeMode = DomainUpgradeMode.Skip;
_ = domain.StorageNodeManager.AddNode(thirdDatabaseNode);
var testEntity1Type = domain.Model.Types[typeof(part1.TestEntity1)];
var defaultNode = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var table = defaultNode.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
var node1 = domain.StorageNodeManager.GetNode("1");
table = node1.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
var node2 = domain.StorageNodeManager.GetNode("2");
table = node2.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node3 = domain.StorageNodeManager.GetNode("3");
table = node3.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("Model1"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-3"));
}
}
public void DefaultTest()
{
var config = DomainConfigurationFactory.Create();
config.Types.Register(typeof(Base));
config.Types.Register(typeof(Default));
config.Types.Register(typeof(DefaultInheritor));
var domain = Domain.Build(config);
var defaultTypeInfo = domain.Model.Types[typeof(Default)];
var defaultInheritorTypeInfo = domain.Model.Types[typeof(DefaultInheritor)];
Assert.AreEqual(3, defaultTypeInfo.GetVersionColumns().Count);
Assert.AreEqual(4, defaultInheritorTypeInfo.GetVersionColumns().Count);
using (var session = domain.OpenSession()) {
var versions = new VersionSet();
var updatedVersions = new VersionSet();
Default @default;
using (VersionCapturer.Attach(session, versions))
using (var t = session.OpenTransaction()) {
@default = new Default()
{
Name = "Name", Tag = "Tag", Version = 1
};
t.Complete();
}
using (VersionCapturer.Attach(session, updatedVersions))
using (VersionValidator.Attach(session, versions))
using (var t = session.OpenTransaction()) {
@default.Version = 2;
@default.Name = "AnotherName";
@default.Name = "AnotherNameCorrect";
t.Complete();
}
AssertEx.Throws <VersionConflictException>(() => {
using (VersionValidator.Attach(session, versions))
using (var t = session.OpenTransaction()) {
@default.Tag = "AnotherTag";
t.Complete();
}
});
using (VersionValidator.Attach(session, updatedVersions))
using (var t = session.OpenTransaction()) {
@default.Tag = "AnotherTag";
t.Complete();
}
}
var allVersions = new VersionSet();
using (var session = domain.OpenSession())
using (VersionCapturer.Attach(session, allVersions))
using (VersionValidator.Attach(session, allVersions)) {
Default @default;
using (var t = session.OpenTransaction()) {
@default = new Default()
{
Name = "Name", Tag = "Tag", Version = 1
};
t.Complete();
}
using (var t = session.OpenTransaction()) {
@default.Version = 2;
@default.Name = "AnotherName";
@default.Name = "AnotherNameCorrect";
t.Complete();
}
using (var t = session.OpenTransaction()) {
@default.Tag = "AnotherTag";
t.Complete();
}
}
}
public void ManualTest()
{
var config = DomainConfigurationFactory.Create();
config.Types.Register(typeof(Base));
config.Types.Register(typeof(Manual));
config.Types.Register(typeof(AnotherManual));
config.Types.Register(typeof(ManualInheritor));
config.Types.Register(typeof(AnotherManualInheritor));
var domain = Domain.Build(config);
var manualTypeInfo = domain.Model.Types[typeof(Manual)];
var anotherManualTypeInfo = domain.Model.Types[typeof(AnotherManual)];
var manualInheritorTypeInfo = domain.Model.Types[typeof(ManualInheritor)];
var anotherManualInheritorTypeInfo = domain.Model.Types[typeof(AnotherManualInheritor)];
Assert.AreEqual(1, manualTypeInfo.GetVersionColumns().Count);
Assert.AreEqual(2, anotherManualTypeInfo.GetVersionColumns().Count);
Assert.AreEqual(1, manualInheritorTypeInfo.GetVersionColumns().Count);
Assert.AreEqual(2, anotherManualInheritorTypeInfo.GetVersionColumns().Count);
using (var session = domain.OpenSession()) {
var versions = new VersionSet();
var updatedVersions = new VersionSet();
Manual manual;
ManualInheritor manualInheritor;
AnotherManual anotherManual;
AnotherManualInheritor anotherManualInheritor;
using (VersionCapturer.Attach(session, versions))
using (var t = session.OpenTransaction()) {
manual = new Manual()
{
Tag = "Tag", Content = "Content", Version = 1
};
manualInheritor = new ManualInheritor()
{
Tag = "Tag", Content = "Content", Version = 1, Name = "Name"
};
anotherManual = new AnotherManual()
{
Tag = "Tag", Content = "Content", Version = 1, SubVersion = 100
};
anotherManualInheritor = new AnotherManualInheritor()
{
Tag = "Tag", Content = "Content", Version = 1, SubVersion = 100, Name = "Name"
};
t.Complete();
}
using (VersionCapturer.Attach(session, updatedVersions))
using (VersionValidator.Attach(session, versions))
using (var t = session.OpenTransaction()) {
manual.Version = 2;
manual.Tag = "AnotherTag";
manual.Tag = "AnotherTagCorrect";
manualInheritor.Name = "AnotherName";
manualInheritor.Version = 2;
anotherManual.Tag = "AnotherTag";
anotherManual.SubVersion = 200;
anotherManualInheritor.Name = "AnotherName";
anotherManualInheritor.SubVersion = 200;
t.Complete();
}
AssertEx.Throws <VersionConflictException>(() => {
using (VersionValidator.Attach(session, versions))
using (var t = session.OpenTransaction()) {
manual.Tag = "YetAnotherTag";
anotherManual.Tag = "YetAnotherTag";
anotherManual.Version = 2;
manualInheritor.Name = "YetAnotherName";
anotherManualInheritor.Name = "YetAnotherName";
t.Complete();
}
});
using (VersionValidator.Attach(session, updatedVersions))
using (var t = session.OpenTransaction()) {
manual.Tag = "YetAnotherTag";
anotherManual.Tag = "YetAnotherTag";
anotherManual.Version = 2;
manualInheritor.Name = "YetAnotherName";
anotherManualInheritor.Name = "YetAnotherName";
t.Complete();
}
}
}
public async Task MultidatabaseAsyncTest()
{
Require.AllFeaturesSupported(ProviderFeatures.Multidatabase);
var db1DefaultSchemaType = typeof(Database1.Default.TestEntity1);
var db1Model1SchemaType = typeof(Database1.Model1.TestEntity2);
var db1Model2SchemaType = typeof(Database1.Model2.TestEntity3);
var db2DefaultSchemaType = typeof(Database2.Default.TestEntity4);
var db2Model1SchemaType = typeof(Database2.Model1.TestEntity5);
var db2Model2SchemaType = typeof(Database2.Model2.TestEntity6);
var configuragtion = DomainConfigurationFactory.Create();
configuragtion.Types.Register(db1DefaultSchemaType);
configuragtion.Types.Register(db1Model1SchemaType);
configuragtion.Types.Register(db1Model2SchemaType);
configuragtion.Types.Register(db2DefaultSchemaType);
configuragtion.Types.Register(db2Model1SchemaType);
configuragtion.Types.Register(db2Model2SchemaType);
configuragtion.Types.Register(typeof(CustomUpgradeHandler));
configuragtion.Types.Register(typeof(CustomFullTextCatalogNameBuilder));
configuragtion.DefaultDatabase = "DO-Tests";
configuragtion.DefaultSchema = "dbo";
configuragtion.MappingRules.Map(db1DefaultSchemaType.Assembly, db1DefaultSchemaType.Namespace).To("DO-Tests", "dbo");
configuragtion.MappingRules.Map(db1Model1SchemaType.Assembly, db1Model1SchemaType.Namespace).To("DO-Tests", "Model1");
configuragtion.MappingRules.Map(db1Model2SchemaType.Assembly, db1Model2SchemaType.Namespace).To("DO-Tests", "Model2");
configuragtion.MappingRules.Map(db2DefaultSchemaType.Assembly, db2DefaultSchemaType.Namespace).To("DO-Tests-1", "dbo");
configuragtion.MappingRules.Map(db2Model1SchemaType.Assembly, db2Model1SchemaType.Namespace).To("DO-Tests-1", "Model1");
configuragtion.MappingRules.Map(db2Model2SchemaType.Assembly, db2Model2SchemaType.Namespace).To("DO-Tests-1", "Model2");
configuragtion.UpgradeMode = DomainUpgradeMode.Recreate;
using (var domain = await Domain.BuildAsync(configuragtion)) {
var targetStorageModel = domain.Extensions.Get <StorageModel>();
var db1DefaultSchemaTable = targetStorageModel.Tables["DO-Tests:dbo:TestEntity1"];
Assert.That(db1DefaultSchemaTable, Is.Not.Null);
var ftIndex = db1DefaultSchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo("DO-Tests_dbo"));
var db1Model1SchemaTable = targetStorageModel.Tables["DO-Tests:Model1:TestEntity2"];
ftIndex = db1Model1SchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo("DO-Tests_Model1"));
var db1Model2SchemaTable = targetStorageModel.Tables["DO-Tests:Model2:TestEntity3"];
ftIndex = db1Model2SchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo("DO-Tests_Model2"));
var db2DefaultSchemaTable = targetStorageModel.Tables["DO-Tests-1:dbo:TestEntity4"];
ftIndex = db2DefaultSchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo("DO-Tests-1_dbo"));
var db2Model1SchemaTable = targetStorageModel.Tables["DO-Tests-1:Model1:TestEntity5"];
ftIndex = db2Model1SchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo("DO-Tests-1_Model1"));
var db2Model2SchemaTable = targetStorageModel.Tables["DO-Tests-1:Model2:TestEntity6"];
ftIndex = db2Model2SchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo("DO-Tests-1_Model2"));
}
}
public async Task MultidatabaseAsyncTest()
{
Require.AllFeaturesSupported(ProviderFeatures.Multidatabase);
var db1DefaultSchemaType = typeof(Database1.Default.TestEntity1);
var db1Model1SchemaType = typeof(Database1.Model1.TestEntity2);
var db1Model2SchemaType = typeof(Database1.Model2.TestEntity3);
var db2DefaultSchemaType = typeof(Database2.Default.TestEntity4);
var db2Model1SchemaType = typeof(Database2.Model1.TestEntity5);
var db2Model2SchemaType = typeof(Database2.Model2.TestEntity6);
var configuragtion = DomainConfigurationFactory.Create();
configuragtion.Types.Register(db1DefaultSchemaType);
configuragtion.Types.Register(db1Model1SchemaType);
configuragtion.Types.Register(db1Model2SchemaType);
configuragtion.Types.Register(db2DefaultSchemaType);
configuragtion.Types.Register(db2Model1SchemaType);
configuragtion.Types.Register(db2Model2SchemaType);
configuragtion.Types.Register(typeof(CustomUpgradeHandler));
configuragtion.Types.Register(typeof(CustomFullTextCatalogNameBuilder));
configuragtion.DefaultDatabase = DOTestsDb;
configuragtion.DefaultSchema = dbo;
configuragtion.MappingRules.Map(db1DefaultSchemaType.Assembly, db1DefaultSchemaType.Namespace)
.To(DOTestsDb, dbo);
configuragtion.MappingRules.Map(db1Model1SchemaType.Assembly, db1Model1SchemaType.Namespace)
.To(DOTestsDb, WellKnownSchemas.Schema1);
configuragtion.MappingRules.Map(db1Model2SchemaType.Assembly, db1Model2SchemaType.Namespace)
.To(DOTestsDb, WellKnownSchemas.Schema2);
configuragtion.MappingRules.Map(db2DefaultSchemaType.Assembly, db2DefaultSchemaType.Namespace)
.To(DOTests1Db, dbo);
configuragtion.MappingRules.Map(db2Model1SchemaType.Assembly, db2Model1SchemaType.Namespace)
.To(DOTests1Db, WellKnownSchemas.Schema1);
configuragtion.MappingRules.Map(db2Model2SchemaType.Assembly, db2Model2SchemaType.Namespace)
.To(DOTests1Db, WellKnownSchemas.Schema2);
configuragtion.UpgradeMode = DomainUpgradeMode.Recreate;
using (var domain = await Domain.BuildAsync(configuragtion)) {
var targetStorageModel = domain.Extensions.Get <StorageModel>();
var db1DefaultSchemaTable = targetStorageModel.Tables[$"{DOTestsDb}:{dbo}:TestEntity1"];
Assert.That(db1DefaultSchemaTable, Is.Not.Null);
var ftIndex = db1DefaultSchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo($"{DOTestsDb}_{dbo}"));
var db1Model1SchemaTable = targetStorageModel.Tables[$"{DOTestsDb}:{Schema1}:TestEntity2"];
ftIndex = db1Model1SchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo($"{DOTestsDb}_{Schema1}"));
var db1Model2SchemaTable = targetStorageModel.Tables[$"{DOTestsDb}:{Schema2}:TestEntity3"];
ftIndex = db1Model2SchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo($"{DOTestsDb}_{Schema2}"));
var db2DefaultSchemaTable = targetStorageModel.Tables[$"{DOTests1Db}:{dbo}:TestEntity4"];
ftIndex = db2DefaultSchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo($"{DOTests1Db}_{dbo}"));
var db2Model1SchemaTable = targetStorageModel.Tables[$"{DOTests1Db}:{Schema1}:TestEntity5"];
ftIndex = db2Model1SchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo($"{DOTests1Db}_{Schema1}"));
var db2Model2SchemaTable = targetStorageModel.Tables[$"{DOTests1Db}:{Schema2}:TestEntity6"];
ftIndex = db2Model2SchemaTable.FullTextIndexes[0];
Assert.That(ftIndex, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.Not.Null);
Assert.That(ftIndex.FullTextCatalog, Is.EqualTo($"{DOTests1Db}_{Schema2}"));
}
}
private ConnectionInfo GetAlternativeConnectionInfo()
{
return(DomainConfigurationFactory.CreateForConnectionStringTest().ConnectionInfo);
}
public void MainTest()
{
var config = DomainConfigurationFactory.CreateWithoutSessionConfigurations();
config.UpgradeMode = DomainUpgradeMode.Recreate;
config.Types.Register(typeof(Person).Assembly, typeof(Person).Namespace);
var domain = Domain.Build(config);
using (var session = domain.OpenSession())
using (var transactionScope = session.OpenTransaction()) {
var employee = new Person(session)
{
Name = "Employee", Photo = new byte[] { 8, 0 }
};
var manager = new Person(session)
{
Name = "Manager", Photo = new byte[] { 8, 0 }
};
manager.Employees.Add(employee);
transactionScope.Complete();
}
using (var session = domain.OpenSession())
using (var transactionScope = session.OpenTransaction()) {
var persons = session.Query.All <Person>()
.Prefetch(p => p.Photo) // Lazy load field
.Prefetch(p => p.Employees // EntitySet Employees
.Prefetch(e => e.Photo)) // and lazy load field of each of its items
.Prefetch(p => p.Manager); // Referenced entity
foreach (var person in persons)
{
// some code here...
}
transactionScope.Complete();
}
using (var session = domain.OpenSession())
using (var transactionScope = session.OpenTransaction()) {
var personIds = session.Query.All <Person>().Select(p => p.Id);
var prefetchedPersons = session.Query.Many <Person, int>(personIds)
.Prefetch(p => new { p.Photo, p.Manager }) // Lazy load field and Referenced entity
.Prefetch(p => p.Employees // EntitySet Employees
.Prefetch(e => new { e.Photo, e.Manager })); // and lazy load field and referenced entity of each of its items
foreach (var person in prefetchedPersons)
{
// some code here...
}
transactionScope.Complete();
}
using (var session = domain.OpenSession())
using (var transactionScope = session.OpenTransaction()) {
var persons = session.Query.All <Person>()
.Prefetch(p => p.Photo) // Lazy load field
.Prefetch(p => p.Employees.Prefetch(e => e.Photo)) // EntitySet Employees and lazy load field of each of its items with the limit on number of items to be loaded
.Prefetch(p => p.Manager.Photo); // Referenced entity and lazy load field for each of them
foreach (var person in persons)
{
Assert.IsTrue(DirectStateAccessor.Get(person).GetFieldState("Photo") == PersistentFieldState.Loaded);
Assert.IsTrue(DirectStateAccessor.Get(person).GetFieldState("Manager") == PersistentFieldState.Loaded);
if (person.ManagerKey != null)
{
Assert.IsNotNull(DirectStateAccessor.Get(session)[person.ManagerKey]);
Assert.IsTrue(DirectStateAccessor.Get(person.Manager).GetFieldState("Photo") == PersistentFieldState.Loaded);
}
// some code here...
}
transactionScope.Complete();
}
}
public void SkipTest()
{
var config = DomainConfigurationFactory.Create();
config.Types.Register(typeof(Base));
config.Types.Register(typeof(Skip));
config.Types.Register(typeof(VersionBehavior.Model.Version));
config.Types.Register(typeof(HasVersion));
config.Types.Register(typeof(HasSkipVersion));
var domain = Domain.Build(config);
var skipTypeInfo = domain.Model.Types[typeof(Skip)];
var hasVersionTypeInfo = domain.Model.Types[typeof(HasVersion)];
var hasSkipVersionTypeInfo = domain.Model.Types[typeof(HasSkipVersion)];
Assert.AreEqual(2, skipTypeInfo.GetVersionColumns().Count);
Assert.AreEqual(2, hasVersionTypeInfo.GetVersionColumns().Count);
Assert.AreEqual(2, hasSkipVersionTypeInfo.GetVersionColumns().Count);
using (var session = domain.OpenSession()) {
var versions = new VersionSet();
var updatedVersions = new VersionSet();
Skip skip;
HasVersion hasVersion;
using (VersionCapturer.Attach(session, versions))
using (var t = session.OpenTransaction()) {
skip = new Skip()
{
Content = "Content", Tag = "Tag", Description = "Desription", NotVersion = "NotVersion"
};
hasVersion = new HasVersion {
Content = "Content",
Tag = "Tag",
Version = { Major = 10, Minor = 100, Meta = 1000 }
};
t.Complete();
}
using (VersionCapturer.Attach(session, updatedVersions))
using (VersionValidator.Attach(session, versions))
using (var t = session.OpenTransaction()) {
skip.Content = "AnotherContent";
skip.Content = "AnotherContetnCorrect";
hasVersion.Content = "AnotherContent";
hasVersion.Content = "AnotherContetnCorrect";
t.Complete();
}
AssertEx.Throws <VersionConflictException>(() => {
using (VersionValidator.Attach(session, versions))
using (var t = session.OpenTransaction()) {
skip.Tag = "AnotherTag";
hasVersion.Tag = "AnotherTag";
t.Complete();
}
});
using (VersionValidator.Attach(session, updatedVersions))
using (var t = session.OpenTransaction()) {
skip.Tag = "AnotherTag";
hasVersion.Tag = "AnotherTag";
t.Complete();
}
}
var allVersions = new VersionSet();
using (var session = domain.OpenSession())
using (VersionCapturer.Attach(session, allVersions))
using (VersionValidator.Attach(session, allVersions)) {
Skip skip;
HasVersion hasVersion;
using (var t = session.OpenTransaction()) {
skip = new Skip()
{
Content = "Content", Tag = "Tag", Description = "Desription", NotVersion = "NotVersion"
};
hasVersion = new HasVersion {
Content = "Content",
Tag = "Tag",
Version = { Major = 10, Minor = 100, Meta = 1000 }
};
t.Complete();
}
using (var t = session.OpenTransaction()) {
skip.Content = "AnotherContent";
skip.Content = "AnotherContetnCorrect";
hasVersion.Content = "AnotherContent";
hasVersion.Content = "AnotherContetnCorrect";
t.Complete();
}
using (var t = session.OpenTransaction()) {
skip.Tag = "AnotherTag";
hasVersion.Tag = "AnotherTag";
t.Complete();
}
}
}
protected virtual DomainConfiguration BuildConfiguration()
{
return(DomainConfigurationFactory.Create());
}
private void InitializeSchemas()
{
var connectionInfo = DomainConfigurationFactory.Create().ConnectionInfo;
StorageTestHelper.DemandSchemas(connectionInfo, DefaultSchema, AlternativeSchema);
}
public async Task MultidatabaseNodesToDifferentDatabaseSetAsyncTest()
{
Require.ProviderIs(StorageProvider.SqlServer);
var masterConnectionInfo = BuildConnectionToMaster(DomainConfigurationFactory.Create().ConnectionInfo);
var configuration = new DomainConfiguration(masterConnectionInfo);
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.Types.Register(typeof(part2.TestEntity2));
configuration.UpgradeMode = DomainUpgradeMode.Recreate;
configuration.DefaultSchema = "dbo";
configuration.DefaultDatabase = "DO-Tests-1";
configuration.MappingRules.Map(typeof(part1.TestEntity1).Namespace).ToDatabase("DO-Tests-1");
configuration.MappingRules.Map(typeof(part2.TestEntity2).Namespace).ToDatabase("DO-Tests-2");
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1");
domainCopyNode.ConnectionInfo = masterConnectionInfo;
domainCopyNode.SchemaMapping.Add("dbo", "dbo");
domainCopyNode.DatabaseMapping.Add("DO-Tests-1", "DO-Tests-1");
domainCopyNode.DatabaseMapping.Add("DO-Tests-2", "DO-Tests-2");
domainCopyNode.UpgradeMode = DomainUpgradeMode.Recreate;
_ = domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2");
anotherDatabaseNode.ConnectionInfo = masterConnectionInfo;
anotherDatabaseNode.SchemaMapping.Add("dbo", "dbo");
anotherDatabaseNode.DatabaseMapping.Add("DO-Tests-1", "DO-Tests-3");
anotherDatabaseNode.DatabaseMapping.Add("DO-Tests-2", "DO-Tests-4");
anotherDatabaseNode.UpgradeMode = DomainUpgradeMode.Recreate;
_ = domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var testEntity1Type = domain.Model.Types[typeof(part1.TestEntity1)];
var testEntity2Type = domain.Model.Types[typeof(part2.TestEntity2)];
var defaultNode = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var table = defaultNode.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
table = defaultNode.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node1 = domain.StorageNodeManager.GetNode("1");
table = node1.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
table = node1.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node2 = domain.StorageNodeManager.GetNode("2");
table = node2.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-3"));
table = node2.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-4"));
}
configuration = new DomainConfiguration(masterConnectionInfo);
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.Types.Register(typeof(part2.TestEntity2));
configuration.UpgradeMode = DomainUpgradeMode.Skip;
configuration.DefaultSchema = "dbo";
configuration.DefaultDatabase = "DO-Tests-1";
configuration.MappingRules.Map(typeof(part1.TestEntity1).Namespace).ToDatabase("DO-Tests-1");
configuration.MappingRules.Map(typeof(part2.TestEntity2).Namespace).ToDatabase("DO-Tests-2");
using (var domain = await Domain.BuildAsync(configuration)) {
var domainCopyNode = new NodeConfiguration("1");
domainCopyNode.ConnectionInfo = masterConnectionInfo;
domainCopyNode.SchemaMapping.Add("dbo", "dbo");
domainCopyNode.DatabaseMapping.Add("DO-Tests-1", "DO-Tests-1");
domainCopyNode.DatabaseMapping.Add("DO-Tests-2", "DO-Tests-2");
domainCopyNode.UpgradeMode = DomainUpgradeMode.Skip;
_ = domain.StorageNodeManager.AddNodeAsync(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2");
anotherDatabaseNode.ConnectionInfo = masterConnectionInfo;
anotherDatabaseNode.SchemaMapping.Add("dbo", "dbo");
anotherDatabaseNode.DatabaseMapping.Add("DO-Tests-1", "DO-Tests-3");
anotherDatabaseNode.DatabaseMapping.Add("DO-Tests-2", "DO-Tests-4");
anotherDatabaseNode.UpgradeMode = DomainUpgradeMode.Skip;
_ = await domain.StorageNodeManager.AddNodeAsync(anotherDatabaseNode);
var testEntity1Type = domain.Model.Types[typeof(part1.TestEntity1)];
var testEntity2Type = domain.Model.Types[typeof(part2.TestEntity2)];
var defaultNode = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var table = defaultNode.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
table = defaultNode.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node1 = domain.StorageNodeManager.GetNode("1");
table = node1.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-1"));
table = node1.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-2"));
var node2 = domain.StorageNodeManager.GetNode("2");
table = node2.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-3"));
table = node2.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo("dbo"));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo("DO-Tests-4"));
}
}
public override void TestFixtureSetUp()
{
ProviderInfo = StorageProviderInfo.Instance.Info;
driver = TestSqlDriver.Create(DomainConfigurationFactory.Create().ConnectionInfo);
nodeToSchemaMap = BuildNodeToSchemaMap();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
driver = TestSqlDriver.Create(DomainConfigurationFactory.Create().ConnectionInfo);
}
public void MultidatabaseNodesToDifferentDatabaseSetTest()
{
Require.ProviderIs(StorageProvider.SqlServer);
var masterConnectionInfo = BuildConnectionToMaster(DomainConfigurationFactory.Create().ConnectionInfo);
var configuration = new DomainConfiguration(masterConnectionInfo)
{
UpgradeMode = DomainUpgradeMode.Recreate,
DefaultSchema = dbo,
DefaultDatabase = DOTests1Db
};
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.Types.Register(typeof(part2.TestEntity2));
configuration.MappingRules.Map(typeof(part1.TestEntity1).Namespace).ToDatabase(DOTests1Db);
configuration.MappingRules.Map(typeof(part2.TestEntity2).Namespace).ToDatabase(DOTests2Db);
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1")
{
ConnectionInfo = masterConnectionInfo,
UpgradeMode = DomainUpgradeMode.Recreate
};
domainCopyNode.SchemaMapping.Add(dbo, dbo);
domainCopyNode.DatabaseMapping.Add(DOTests1Db, DOTests1Db);
domainCopyNode.DatabaseMapping.Add(DOTests2Db, DOTests2Db);
_ = domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2")
{
ConnectionInfo = masterConnectionInfo,
UpgradeMode = DomainUpgradeMode.Recreate
};
anotherDatabaseNode.SchemaMapping.Add(dbo, dbo);
anotherDatabaseNode.DatabaseMapping.Add(DOTests1Db, DOTests3Db);
anotherDatabaseNode.DatabaseMapping.Add(DOTests2Db, DOTests4Db);
_ = domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var testEntity1Type = domain.Model.Types[typeof(part1.TestEntity1)];
var testEntity2Type = domain.Model.Types[typeof(part2.TestEntity2)];
var defaultNode = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var table = defaultNode.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests1Db));
table = defaultNode.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests2Db));
var node1 = domain.StorageNodeManager.GetNode("1");
table = node1.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests1Db));
table = node1.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests2Db));
var node2 = domain.StorageNodeManager.GetNode("2");
table = node2.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests3Db));
table = node2.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests4Db));
}
configuration = new DomainConfiguration(masterConnectionInfo)
{
UpgradeMode = DomainUpgradeMode.Skip,
DefaultSchema = dbo,
DefaultDatabase = DOTests1Db
};
configuration.Types.Register(typeof(part1.TestEntity1));
configuration.Types.Register(typeof(part2.TestEntity2));
configuration.MappingRules.Map(typeof(part1.TestEntity1).Namespace).ToDatabase(DOTests1Db);
configuration.MappingRules.Map(typeof(part2.TestEntity2).Namespace).ToDatabase(DOTests2Db);
using (var domain = Domain.Build(configuration)) {
var domainCopyNode = new NodeConfiguration("1")
{
ConnectionInfo = masterConnectionInfo,
UpgradeMode = DomainUpgradeMode.Skip
};
domainCopyNode.SchemaMapping.Add(dbo, dbo);
domainCopyNode.DatabaseMapping.Add(DOTests1Db, DOTests1Db);
domainCopyNode.DatabaseMapping.Add(DOTests2Db, DOTests2Db);
_ = domain.StorageNodeManager.AddNode(domainCopyNode);
var anotherDatabaseNode = new NodeConfiguration("2")
{
ConnectionInfo = masterConnectionInfo,
UpgradeMode = DomainUpgradeMode.Skip
};
anotherDatabaseNode.SchemaMapping.Add(dbo, dbo);
anotherDatabaseNode.DatabaseMapping.Add(DOTests1Db, DOTests3Db);
anotherDatabaseNode.DatabaseMapping.Add(DOTests2Db, DOTests4Db);
_ = domain.StorageNodeManager.AddNode(anotherDatabaseNode);
var testEntity1Type = domain.Model.Types[typeof(part1.TestEntity1)];
var testEntity2Type = domain.Model.Types[typeof(part2.TestEntity2)];
var defaultNode = domain.StorageNodeManager.GetNode(WellKnown.DefaultNodeId);
var table = defaultNode.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests1Db));
table = defaultNode.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests2Db));
var node1 = domain.StorageNodeManager.GetNode("1");
table = node1.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests1Db));
table = node1.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests2Db));
var node2 = domain.StorageNodeManager.GetNode("2");
table = node2.Mapping[testEntity1Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests3Db));
table = node2.Mapping[testEntity2Type];
Assert.That(table.Schema.Name, Is.EqualTo(dbo));
Assert.That(table.Schema.Catalog.Name, Is.EqualTo(DOTests4Db));
}
}
