public void Should_handle_basic_CRUD_operations()
{
// arrange
var target = new TestTarget
{
Id = 0,
Data = new TestTargetData
{
TestString = "Test Target Data"
}
};
var dataProvider = new MssqlDataProvider();
var repository = new TargetRepository(dataProvider);
// act
var result = repository.Update(target);
// assert
Assert.That(result, Is.GreaterThan(0));
// now Get
var persistedTarget = repository.Get <TestTarget>(target.TableName, result);
Assert.That(persistedTarget.Id, Is.GreaterThan(0));
Assert.That(persistedTarget.Data, Is.Not.Null);
var targetData = (TestTargetData)persistedTarget.Data;
Assert.That(targetData.TestString, Is.EqualTo("Test Target Data"));
// remove the record
repository.Delete(persistedTarget);
}
public void Should_handle_basic_CRUD_operations()
{
// arrange
var target = new TestTarget
{
Id = 0,
Data = new TestTargetData
{
TestString = "Test Target Data"
}
};
var dataProvider = new MssqlDataProvider();
var repository = new TargetRepository(dataProvider);
// act
var result = repository.Update(target);
// assert
Assert.That(result, Is.GreaterThan(0));
// now Get
var persistedTarget = repository.Get<TestTarget>(target.TableName, result);
Assert.That(persistedTarget.Id, Is.GreaterThan(0));
Assert.That(persistedTarget.Data, Is.Not.Null);
var targetData = (TestTargetData) persistedTarget.Data;
Assert.That(targetData.TestString, Is.EqualTo("Test Target Data"));
// remove the record
repository.Delete(persistedTarget);
}
public void Should_handle_GetParent_operation_over_larger_hierarchy()
{
// build a sample hierarchy
var hierarchyEntry = new HierarchyEntry
{
Name = "Test Hierarchy",
SchemaName = "dbo",
TableName = "test"
};
// initialize the provider
var dataProvider = new MssqlDataProvider();
var provider = new MssqlHierarchyDataProvider(dataProvider);
// generate the complex hierarchy
TestHierarchy.BuildTestHierarchy(hierarchyEntry, provider);
var rootNode = provider.GetRootNode(hierarchyEntry);
var primaryChildren = provider.GetChildren(hierarchyEntry, rootNode);
var primaryChild1 = primaryChildren.First();
var secondaryChildren = provider.GetChildren(hierarchyEntry, primaryChild1);
var leafChild = secondaryChildren.First();
var parent = provider.GetParent(hierarchyEntry, leafChild);
Assert.That(parent.LeftId, Is.LessThan(leafChild.LeftId));
Assert.That(parent.RightId, Is.GreaterThan(leafChild.RightId));
// clean up
dataProvider.DropTable(hierarchyEntry.SchemaName, hierarchyEntry.TableName);
}
public static void Initialize()
{
// verify tables
var dataProvider = new MssqlDataProvider();
var hierarchyDataProvider = new MssqlHierarchyDataProvider(dataProvider);
var hierarchyEntryRepository = new HierarchyEntryRepository(dataProvider);
var targetEntryRepository = new TargetEntryRepository(dataProvider);
var targetRepository = new TargetRepository(dataProvider);
var assembly = Assembly.GetCallingAssembly();
var targetTypes = assembly.GetTypesOfType<ITarget>();
var hierarchyService = new HierarchyService(hierarchyDataProvider, hierarchyEntryRepository, targetEntryRepository, targetRepository, targetTypes);
// build missing tables
// register structureMap
}
public void Should_handle_GetDescendants_operation_over_larger_hierarchy()
{
// build a sample hierarchy
var hierarchyEntry = new HierarchyEntry
{
Name = "Test Hierarchy",
SchemaName = "dbo",
TableName = "test"
};
// initialize the provider
var dataProvider = new MssqlDataProvider();
var provider = new MssqlHierarchyDataProvider(dataProvider);
// generate the complex hierarchy
TestHierarchy.BuildTestHierarchy(hierarchyEntry, provider);
var rootNode = provider.GetRootNode(hierarchyEntry);
var descendants = provider.GetDescendants(hierarchyEntry, rootNode, true, true);
Assert.That(descendants.Count, Is.EqualTo(7));
Assert.That(descendants[0].LeftId, Is.EqualTo(1));
Assert.That(descendants[0].RightId, Is.EqualTo(14));
Assert.That(descendants[1].LeftId, Is.EqualTo(2));
Assert.That(descendants[1].RightId, Is.EqualTo(7));
Assert.That(descendants[2].LeftId, Is.EqualTo(3));
Assert.That(descendants[2].RightId, Is.EqualTo(4));
Assert.That(descendants[3].LeftId, Is.EqualTo(5));
Assert.That(descendants[3].RightId, Is.EqualTo(6));
Assert.That(descendants[4].LeftId, Is.EqualTo(8));
Assert.That(descendants[4].RightId, Is.EqualTo(13));
Assert.That(descendants[5].LeftId, Is.EqualTo(9));
Assert.That(descendants[5].RightId, Is.EqualTo(10));
Assert.That(descendants[6].LeftId, Is.EqualTo(11));
Assert.That(descendants[6].RightId, Is.EqualTo(12));
Assert.That(rootNode.LeftId, Is.EqualTo(1));
Assert.That(rootNode.RightId, Is.EqualTo(14));
// clean up
dataProvider.DropTable(hierarchyEntry.SchemaName, hierarchyEntry.TableName);
}
public void Should_handle_GetDescendants_operation_over_larger_hierarchy()
{
// build a sample hierarchy
var hierarchyEntry = new HierarchyEntry
{
Name = "Test Hierarchy",
SchemaName = "dbo",
TableName = "test"
};
// initialize the provider
var dataProvider = new MssqlDataProvider();
var provider = new MssqlHierarchyDataProvider(dataProvider);
// generate the complex hierarchy
TestHierarchy.BuildTestHierarchy(hierarchyEntry, provider);
var rootNode = provider.GetRootNode(hierarchyEntry);
var descendants = provider.GetDescendants(hierarchyEntry, rootNode, true, true);
Assert.That(descendants.Count, Is.EqualTo(7));
Assert.That(descendants[0].LeftId, Is.EqualTo(1));
Assert.That(descendants[0].RightId, Is.EqualTo(14));
Assert.That(descendants[1].LeftId, Is.EqualTo(2));
Assert.That(descendants[1].RightId, Is.EqualTo(7));
Assert.That(descendants[2].LeftId, Is.EqualTo(3));
Assert.That(descendants[2].RightId, Is.EqualTo(4));
Assert.That(descendants[3].LeftId, Is.EqualTo(5));
Assert.That(descendants[3].RightId, Is.EqualTo(6));
Assert.That(descendants[4].LeftId, Is.EqualTo(8));
Assert.That(descendants[4].RightId, Is.EqualTo(13));
Assert.That(descendants[5].LeftId, Is.EqualTo(9));
Assert.That(descendants[5].RightId, Is.EqualTo(10));
Assert.That(descendants[6].LeftId, Is.EqualTo(11));
Assert.That(descendants[6].RightId, Is.EqualTo(12));
Assert.That(rootNode.LeftId, Is.EqualTo(1));
Assert.That(rootNode.RightId, Is.EqualTo(14));
// clean up
dataProvider.DropTable(hierarchyEntry.SchemaName, hierarchyEntry.TableName);
}
public static void Initialize()
{
// verify tables
var dataProvider = new MssqlDataProvider();
var hierarchyDataProvider = new MssqlHierarchyDataProvider(dataProvider);
var hierarchyEntryRepository = new HierarchyEntryRepository(dataProvider);
var targetEntryRepository = new TargetEntryRepository(dataProvider);
var targetRepository = new TargetRepository(dataProvider);
var assembly = Assembly.GetCallingAssembly();
var targetTypes = assembly.GetTypesOfType <ITarget>();
var hierarchyService = new HierarchyService(hierarchyDataProvider, hierarchyEntryRepository, targetEntryRepository, targetRepository, targetTypes);
// build missing tables
// register structureMap
}
public void Should_handle_GetAncestors_operation_over_larger_hierarchy()
{
// build a sample hierarchy
var hierarchyEntry = new HierarchyEntry
{
Name = "Test Hierarchy",
SchemaName = "dbo",
TableName = "test"
};
// initialize the provider
var dataProvider = new MssqlDataProvider();
var provider = new MssqlHierarchyDataProvider(dataProvider);
// generate the complex hierarchy
TestHierarchy.BuildTestHierarchy(hierarchyEntry, provider);
var rootNode = provider.GetRootNode(hierarchyEntry);
var primaryChildren = provider.GetChildren(hierarchyEntry, rootNode);
var primaryChild1 = primaryChildren.First();
var secondaryChildren = provider.GetChildren(hierarchyEntry, primaryChild1);
var leafChild = secondaryChildren.First();
var ancestors = provider.GetAncestors(hierarchyEntry, leafChild, true, true);
Assert.That(ancestors.Count, Is.EqualTo(3));
Assert.That(ancestors[0].LeftId, Is.EqualTo(1));
Assert.That(ancestors[0].RightId, Is.EqualTo(14));
Assert.That(ancestors[1].LeftId, Is.EqualTo(2));
Assert.That(ancestors[1].RightId, Is.EqualTo(7));
Assert.That(ancestors[2].LeftId, Is.EqualTo(leafChild.LeftId));
Assert.That(ancestors[2].RightId, Is.EqualTo(leafChild.RightId));
// clean up
dataProvider.DropTable(hierarchyEntry.SchemaName, hierarchyEntry.TableName);
}
public void Should_handle_GetAncestors_operation_over_larger_hierarchy()
{
// build a sample hierarchy
var hierarchyEntry = new HierarchyEntry
{
Name = "Test Hierarchy",
SchemaName = "dbo",
TableName = "test"
};
// initialize the provider
var dataProvider = new MssqlDataProvider();
var provider = new MssqlHierarchyDataProvider(dataProvider);
// generate the complex hierarchy
TestHierarchy.BuildTestHierarchy(hierarchyEntry, provider);
var rootNode = provider.GetRootNode(hierarchyEntry);
var primaryChildren = provider.GetChildren(hierarchyEntry, rootNode);
var primaryChild1 = primaryChildren.First();
var secondaryChildren = provider.GetChildren(hierarchyEntry, primaryChild1);
var leafChild = secondaryChildren.First();
var ancestors = provider.GetAncestors(hierarchyEntry, leafChild, true, true);
Assert.That(ancestors.Count, Is.EqualTo(3));
Assert.That(ancestors[0].LeftId, Is.EqualTo(1));
Assert.That(ancestors[0].RightId, Is.EqualTo(14));
Assert.That(ancestors[1].LeftId, Is.EqualTo(2));
Assert.That(ancestors[1].RightId, Is.EqualTo(7));
Assert.That(ancestors[2].LeftId, Is.EqualTo(leafChild.LeftId));
Assert.That(ancestors[2].RightId, Is.EqualTo(leafChild.RightId));
// clean up
dataProvider.DropTable(hierarchyEntry.SchemaName, hierarchyEntry.TableName);
}
public void Should_properly_create_and_handle_simple_hierarchy_with_basic_operations()
{
// build a sample hierarchy
var hierarchyEntry = new HierarchyEntry
{
Name = "Test Hierarchy",
SchemaName = "dbo",
TableName = "test"
};
// initialize the provider
var dataProvider = new MssqlDataProvider();
var provider = new MssqlHierarchyDataProvider(dataProvider);
// initialize the hierarchy
var originalRootNode = new HierarchyNode
{
LeftId = 1,
RightId = 2
};
var rootId = provider.Add(hierarchyEntry, originalRootNode);
// test get root node
var persistedRootNode = provider.GetRootNode(hierarchyEntry);
Assert.That(persistedRootNode.Id, Is.EqualTo(rootId));
Assert.That(persistedRootNode.LeftId, Is.EqualTo(1));
Assert.That(persistedRootNode.RightId, Is.EqualTo(2));
// then insert first primary child
var firstChild = new HierarchyNode();
firstChild.LeftId = persistedRootNode.RightId;
provider.PrepareForInsertNode(hierarchyEntry, persistedRootNode);
firstChild.RightId = firstChild.LeftId + 1;
provider.Add(hierarchyEntry, firstChild);
// verify new hierarchy
persistedRootNode = provider.GetRootNode(hierarchyEntry);
var firstChildren = provider.GetChildren(hierarchyEntry, persistedRootNode);
Assert.That(firstChildren.Count, Is.EqualTo(1));
Assert.That(firstChildren[0].Id, Is.Not.EqualTo(0));
Assert.That(firstChildren[0].LeftId, Is.EqualTo(2));
Assert.That(firstChildren[0].RightId, Is.EqualTo(3));
Assert.That(persistedRootNode.LeftId, Is.EqualTo(1));
Assert.That(persistedRootNode.RightId, Is.EqualTo(4));
// insert second primary child
var secondChild = new HierarchyNode();
secondChild.LeftId = persistedRootNode.RightId;
provider.PrepareForInsertNode(hierarchyEntry, persistedRootNode);
secondChild.RightId = secondChild.LeftId + 1;
provider.Add(hierarchyEntry, secondChild);
// verify new hierarchy
persistedRootNode = provider.GetRootNode(hierarchyEntry);
var secondChildren = provider.GetChildren(hierarchyEntry, persistedRootNode);
Assert.That(secondChildren.Count, Is.EqualTo(2));
Assert.That(secondChildren[1].Id, Is.Not.EqualTo(0));
Assert.That(secondChildren[1].LeftId, Is.EqualTo(4));
Assert.That(secondChildren[1].RightId, Is.EqualTo(5));
Assert.That(secondChildren[0].LeftId, Is.EqualTo(2));
Assert.That(secondChildren[0].RightId, Is.EqualTo(3));
Assert.That(persistedRootNode.LeftId, Is.EqualTo(1));
Assert.That(persistedRootNode.RightId, Is.EqualTo(6));
// delete a node
var deleteNode = secondChildren[1];
provider.Delete(hierarchyEntry, deleteNode);
// verify revised hierarchy
persistedRootNode = provider.GetRootNode(hierarchyEntry);
var children = provider.GetChildren(hierarchyEntry, persistedRootNode);
Assert.That(children.Count, Is.EqualTo(1));
Assert.That(children[0].Id, Is.Not.EqualTo(0));
Assert.That(children[0].LeftId, Is.EqualTo(2));
Assert.That(children[0].RightId, Is.EqualTo(3));
Assert.That(persistedRootNode.LeftId, Is.EqualTo(1));
Assert.That(persistedRootNode.RightId, Is.EqualTo(4));
// clean up
dataProvider.DropTable(hierarchyEntry.SchemaName, hierarchyEntry.TableName);
}
public void Should_handle_basic_CRUD_for_any_table()
{
const string schemaName = "dbo";
const string tableName = "TestTable";
var provider = new MssqlDataProvider();
// check for the test table
if (provider.TableExists(schemaName, tableName))
{
provider.DropTable(schemaName, tableName);
}
// create table
var createSql = string.Format(@"CREATE TABLE [{0}].[{1}](
[id] [int] IDENTITY(1,1) NOT NULL,
[name] [nvarchar](50) NOT NULL
CONSTRAINT [PK_{1}] PRIMARY KEY CLUSTERED
([id] ASC)
WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]", schemaName, tableName);
provider.ExecuteSql(createSql);
// add to storage
var insertSql = string.Format("INSERT INTO [{0}].[{1}] (name) OUTPUT inserted.id VALUES (@Name)", schemaName, tableName);
var hierarchyId = provider.Update(insertSql, 0, new List <KeyValuePair <string, object> > {
new KeyValuePair <string, object>("@Name", "Test Name")
});
// retrieve from storage
var getSql = string.Format("SELECT id, name FROM [{0}].[{1}] WHERE id = @Id", schemaName, tableName);
var persistedRecord = provider.Get(getSql, hierarchyId, PopulateMethod);
Assert.That(persistedRecord, Is.Not.Null);
Assert.That(persistedRecord.Id, Is.EqualTo(hierarchyId));
Assert.That(persistedRecord.Name, Is.EqualTo("Test Name"));
// update, and save again
persistedRecord.Name = "New Name";
var updateSql = string.Format("UPDATE [{0}].[{1}] SET name=@Name WHERE id=@Id", schemaName, tableName);
var revisedId = provider.Update(updateSql, hierarchyId, new List <KeyValuePair <string, object> > {
new KeyValuePair <string, object>("@Name", "New Name")
});
Assert.That(revisedId, Is.EqualTo(hierarchyId));
// retrieve from storage
var revisedRecord = provider.Get(getSql, hierarchyId, PopulateMethod);
Assert.That(revisedRecord, Is.Not.Null);
Assert.That(revisedRecord.Id, Is.EqualTo(hierarchyId));
Assert.That(revisedRecord.Name, Is.EqualTo("New Name"));
// delete from storage
var deleteSuccessful = provider.Delete(schemaName, tableName, hierarchyId);
Assert.That(deleteSuccessful, Is.True);
// retrieve from storage
var deletedRecord = provider.Get(getSql, hierarchyId, PopulateMethod);
Assert.That(deletedRecord, Is.Null);
// drop the table
provider.DropTable(schemaName, tableName);
Assert.That(provider.TableExists(schemaName, tableName), Is.False);
}
public void Should_handle_GetParent_operation_over_larger_hierarchy()
{
// build a sample hierarchy
var hierarchyEntry = new HierarchyEntry
{
Name = "Test Hierarchy",
SchemaName = "dbo",
TableName = "test"
};
// initialize the provider
var dataProvider = new MssqlDataProvider();
var provider = new MssqlHierarchyDataProvider(dataProvider);
// generate the complex hierarchy
TestHierarchy.BuildTestHierarchy(hierarchyEntry, provider);
var rootNode = provider.GetRootNode(hierarchyEntry);
var primaryChildren = provider.GetChildren(hierarchyEntry, rootNode);
var primaryChild1 = primaryChildren.First();
var secondaryChildren = provider.GetChildren(hierarchyEntry, primaryChild1);
var leafChild = secondaryChildren.First();
var parent = provider.GetParent(hierarchyEntry, leafChild);
Assert.That(parent.LeftId, Is.LessThan(leafChild.LeftId));
Assert.That(parent.RightId, Is.GreaterThan(leafChild.RightId));
// clean up
dataProvider.DropTable(hierarchyEntry.SchemaName, hierarchyEntry.TableName);
}
public void Should_properly_create_and_handle_simple_hierarchy_with_basic_operations()
{
// build a sample hierarchy
var hierarchyEntry = new HierarchyEntry
{
Name = "Test Hierarchy",
SchemaName = "dbo",
TableName = "test"
};
// initialize the provider
var dataProvider = new MssqlDataProvider();
var provider = new MssqlHierarchyDataProvider(dataProvider);
// initialize the hierarchy
var originalRootNode = new HierarchyNode
{
LeftId = 1,
RightId = 2
};
var rootId = provider.Add(hierarchyEntry, originalRootNode);
// test get root node
var persistedRootNode = provider.GetRootNode(hierarchyEntry);
Assert.That(persistedRootNode.Id, Is.EqualTo(rootId));
Assert.That(persistedRootNode.LeftId, Is.EqualTo(1));
Assert.That(persistedRootNode.RightId, Is.EqualTo(2));
// then insert first primary child
var firstChild = new HierarchyNode();
firstChild.LeftId = persistedRootNode.RightId;
provider.PrepareForInsertNode(hierarchyEntry, persistedRootNode);
firstChild.RightId = firstChild.LeftId + 1;
provider.Add(hierarchyEntry, firstChild);
// verify new hierarchy
persistedRootNode = provider.GetRootNode(hierarchyEntry);
var firstChildren = provider.GetChildren(hierarchyEntry, persistedRootNode);
Assert.That(firstChildren.Count, Is.EqualTo(1));
Assert.That(firstChildren[0].Id, Is.Not.EqualTo(0));
Assert.That(firstChildren[0].LeftId, Is.EqualTo(2));
Assert.That(firstChildren[0].RightId, Is.EqualTo(3));
Assert.That(persistedRootNode.LeftId, Is.EqualTo(1));
Assert.That(persistedRootNode.RightId, Is.EqualTo(4));
// insert second primary child
var secondChild = new HierarchyNode();
secondChild.LeftId = persistedRootNode.RightId;
provider.PrepareForInsertNode(hierarchyEntry, persistedRootNode);
secondChild.RightId = secondChild.LeftId + 1;
provider.Add(hierarchyEntry, secondChild);
// verify new hierarchy
persistedRootNode = provider.GetRootNode(hierarchyEntry);
var secondChildren = provider.GetChildren(hierarchyEntry, persistedRootNode);
Assert.That(secondChildren.Count, Is.EqualTo(2));
Assert.That(secondChildren[1].Id, Is.Not.EqualTo(0));
Assert.That(secondChildren[1].LeftId, Is.EqualTo(4));
Assert.That(secondChildren[1].RightId, Is.EqualTo(5));
Assert.That(secondChildren[0].LeftId, Is.EqualTo(2));
Assert.That(secondChildren[0].RightId, Is.EqualTo(3));
Assert.That(persistedRootNode.LeftId, Is.EqualTo(1));
Assert.That(persistedRootNode.RightId, Is.EqualTo(6));
// delete a node
var deleteNode = secondChildren[1];
provider.Delete(hierarchyEntry, deleteNode);
// verify revised hierarchy
persistedRootNode = provider.GetRootNode(hierarchyEntry);
var children = provider.GetChildren(hierarchyEntry, persistedRootNode);
Assert.That(children.Count, Is.EqualTo(1));
Assert.That(children[0].Id, Is.Not.EqualTo(0));
Assert.That(children[0].LeftId, Is.EqualTo(2));
Assert.That(children[0].RightId, Is.EqualTo(3));
Assert.That(persistedRootNode.LeftId, Is.EqualTo(1));
Assert.That(persistedRootNode.RightId, Is.EqualTo(4));
// clean up
dataProvider.DropTable(hierarchyEntry.SchemaName, hierarchyEntry.TableName);
}
