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 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_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); }