public void shouldAddChildNodesToNode() { ExecutionNode node = ExecutionNode.CreateLevelOneNode(1); node.AddChild(100); Assert.AreEqual(1, node.Children.Count(), "Number of children"); node.AddChild(1); node.AddChild(1); Assert.AreEqual(3, node.Children.Count(), "Number of children"); foreach (var item in node.Children) { Assert.That(item.Level, Is.GreaterThan(1)); Console.WriteLine(item.Level); for (int i = 0; i < 3; i++) { item.AddChild(1); } foreach (var child in item.Children) { Assert.That(item.Level, Is.LessThan(child.Level)); } } }
public void shouldProduceUniqueIdentitiesForEachNodeAdded() { ExecutionNode node = ExecutionNode.CreateLevelOneNode(1); var node2 = node.AddChild(1); var node3 = node2.AddChild(1); var node4 = node2.AddChild(1); var node5 = node.AddChild(1); Assert.That(node, Is.Not.EqualTo(node2)); Assert.That(node3, Is.Not.EqualTo(node2)); Assert.That(node4, Is.Not.EqualTo(node2)); Assert.That(node5, Is.Not.EqualTo(node)); Assert.That(node, Is.EqualTo(node)); Assert.That(node2, Is.EqualTo(node2)); }
public void ShouldAddParentNodeToNode() { ExecutionNode root = ExecutionNode.CreateLevelOneNode(1, "Root"); var customer = root.AddChild(1, "Customer"); var order = customer.AddChild(10, "Order"); string expected = @"-Customer --Order"; Assert.That(customer.getDebugString(), Is.EqualTo(expected)); order.AddParent(1, "CustomerGroup"); expected = @"Root -Customer --CustomerGroup ---Order"; Assert.That(root.getDebugString(), Is.EqualTo(expected)); customer.AddParent(1, "Country"); expected = @"Root -Country --Customer ---CustomerGroup ----Order"; Assert.That(root.getDebugString(), Is.EqualTo(expected)); }
public void ShouldReturnTablesInCorrectOrder() { // Scenario: Make 2 customers, for each customer make two accounts and do one deposit and one withdraw for each account string[] requestedOrder = { "Customer", "Account", "Deposit", "Withdraw", "Account", "Deposit", "Withdraw", "Customer", "Account", "Deposit", "Withdraw", "Account", "Deposit", "Withdraw", }; // 2 Customers ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer"); customer.AddTable(new TableEntity("dbo", "Customer")); // Make 2 accounts var accounts = customer.AddChild(2, "Accounts"); accounts.AddTable(new TableEntity("dbo", "Account")); // make one one Deposit and one WithDraw var accountTransactions = accounts.AddChild(1, "AccountTransactions"); accountTransactions.AddTable(new TableEntity("dbo", "Deposit")); accountTransactions.AddTable(new TableEntity("dbo", "Withdraw")); NodeIterator it = new NodeIterator(customer); var actual = new List <TableEntity>(it.GetTablesRecursive().Select(x => x.Table)); for (int i = 0; i < requestedOrder.Length; i++) { Console.WriteLine(actual[i].TableName); Assert.That(requestedOrder[i], Is.EqualTo(actual[i].TableName)); } }
public void shouldIncreaseTheLevelOfEachChild() { ExecutionNode node = ExecutionNode.CreateLevelOneNode(1); var node2 = node.AddChild(100); var node3 = node2.AddChild(24); var node4 = node.AddChild(1); Assert.That(node2.Level, Is.GreaterThan(node.Level)); Assert.That(node2.Level, Is.EqualTo(node.Level + 1)); Assert.That(node3.Level, Is.GreaterThan(node2.Level)); Assert.That(node3.Level, Is.EqualTo(node2.Level + 1)); Assert.That(node4.Level, Is.GreaterThan(node.Level)); Assert.That(node4.Level, Is.EqualTo(node.Level + 1)); }
public void AddChildNode(ExecutionNode nodeToManipulate) { if (nodeToManipulate != null) { var newNode = nodeToManipulate.AddChild(1); _projectViewModel.SelectedExecutionNode = newNode; } }
public void ShouldNotBeAbleToRemoveRootNode() { ExecutionNode root = ExecutionNode.CreateLevelOneNode(1, "Root"); var customer = root.AddChild(1, "Customer"); var someNode = root.RemoveNode(); Assert.That(someNode, Is.EqualTo(root)); }
private static ExecutionNode BuildReleaseNode(RunContext context, ReleaseConfig release) { var node = new ExecutionNode(string.Format("Begin release {0}", release.Name), string.Format("End release {0}", release.Name)); foreach (var feature in release.Features) { node.AddChild(BuildFeatureNode(context, feature)); } return node; }
public void ShouldNotBeAbleToMergeRootNodeWithParent() { ExecutionNode root = ExecutionNode.CreateLevelOneNode(1, "Root"); var customer = root.AddChild(1, "Customer").AddTable(new TableEntity("dbo", "Customer")); var merged = root.MergeWithParent(); Assert.That(merged, Is.EqualTo(root)); Assert.That(merged.Tables, Is.Empty); }
public void ShouldHaveParentIfItIsChild() { ExecutionNode root = ExecutionNode.CreateLevelOneNode(1); Assert.That(root.HasChildren, Is.False); var child = root.AddChild(1); Assert.That(root.HasChildren, Is.True); Assert.That(child.Parent, Is.EqualTo(root)); }
public void ShouldRemoveNode() { ExecutionNode root = ExecutionNode.CreateLevelOneNode(1, "Root"); var customer = root.AddChild(1, "Customer"); var order = customer.AddChild(10, "Order"); var recall = order.AddChild(1, "Recall"); var someNode = order.RemoveNode(); Assert.That(someNode, Is.EqualTo(customer), "When removing a node, the parent node should be returned"); Assert.That(customer.Children.Contains(order), Is.Not.True); }
public void ShouldNotBeAbleToAddParentToRoot() { ExecutionNode root = ExecutionNode.CreateLevelOneNode(1, "Root"); var customer = root.AddChild(1, "Customer"); var order = customer.AddChild(10, "Order"); string beforeAddingParent = root.getDebugString(); var returnNode = root.AddParent(1, "Nono"); Assert.That(returnNode, Is.EqualTo(root)); Assert.That(root.getDebugString(), Is.EqualTo(beforeAddingParent)); }
public void ShouldCreateDebugString() { ExecutionNode root = ExecutionNode.CreateLevelOneNode(1, "Root"); var customer = root.AddChild(1, "Customer"); var order = customer.AddChild(10, "Order"); root.AddChild(1, "Invoice"); string expected = @"Root -Customer --Order -Invoice"; string actual = root.getDebugString(); Console.WriteLine("{" + actual + "}"); Console.WriteLine("{" + expected + "}"); Assert.That(actual, Is.EqualTo(expected)); Assert.That(order.getDebugString(), Is.EqualTo("--Order")); Assert.That(customer.getDebugString(), Is.EqualTo("-Customer" + Environment.NewLine + "--Order")); }
private static ExecutionNode BuildFeatureNode(string featureName, DeployContext context) { FeatureConfig feature; if (!context.FeaturesConfig.TryGet(featureName, out feature)) throw new SoftFailureException(string.Format("Cannot find feature {0}", featureName)); var node = new ExecutionNode(string.Format("Begin feature {0}", featureName), string.Format("End feature {0}", featureName)); foreach (var taskConfig in feature.Recipe) { var task = context.TaskManager.CreateTask(taskConfig); var replacer = new VariableReplacer(context.ApplicationContext, feature, taskConfig); node.AddChild(new ExecutionNode(task, new TaskExecutionContext(context.RunContext, feature, taskConfig, replacer))); } return node; }
public void ShouldRestartNodeCounterWhenNodeIsRestarted() { // 2 Customers ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer"); customer.AddTable(new TableEntity("dbo", "Customer")); // Make 2 accounts var accounts = customer.AddChild(2, "Accounts"); accounts.AddTable(new TableEntity("dbo", "Account")); // make one one Deposit and one WithDraw var accountTransactions = accounts.AddChild(1, "AccountTransactions"); accountTransactions.AddTable(new TableEntity("dbo", "Deposit")); accountTransactions.AddTable(new TableEntity("dbo", "Withdraw")); NodeIterator it = new NodeIterator(customer); var et = it.GetTablesRecursive().ToList(); int rowCounter = 0; et[rowCounter++].AssertNAndTable(1, "Customer"); et[rowCounter++].AssertNAndTable(1, "Account"); et[rowCounter++].AssertNAndTable(1, "Deposit"); et[rowCounter++].AssertNAndTable(1, "Withdraw"); // first customer, second account et[rowCounter++].AssertNAndTable(2, "Account"); et[rowCounter++].AssertNAndTable(1, "Deposit"); et[rowCounter++].AssertNAndTable(1, "Withdraw"); // second customer et[rowCounter++].AssertNAndTable(2, "Customer"); et[rowCounter++].AssertNAndTable(1, "Account"); et[rowCounter++].AssertNAndTable(1, "Deposit"); et[rowCounter++].AssertNAndTable(1, "Withdraw"); et[rowCounter++].AssertNAndTable(2, "Account"); et[rowCounter++].AssertNAndTable(1, "Deposit"); et[rowCounter++].AssertNAndTable(1, "Withdraw"); }
public void ShouldMergeNodeWithParent() { ExecutionNode root = ExecutionNode.CreateLevelOneNode(1, "Root"); var customer = root.AddChild(1, "Customer"); var order = customer.AddChild(10, "Order"); var recall = order.AddChild(1, "Recall"); customer.AddTable(new TableEntity("dbo", "Customer")).AddTable(new TableEntity("dbo", "Account")); order.AddTable(new TableEntity("dbo", "Order")).AddTable(new TableEntity("dbo", "OrderLine")).AddTable(new TableEntity("dbo", "Invoice")); var tablesBeforeMerge = new List <TableEntity>(customer.Tables); var tablesToBeMerged = new List <TableEntity>(order.Tables); var mergedInto = order.MergeWithParent(); Assert.That(mergedInto, Is.EqualTo(customer)); CollectionAssert.IsSubsetOf(tablesBeforeMerge, customer.Tables); CollectionAssert.IsSubsetOf(tablesToBeMerged, customer.Tables); Assert.That(customer.Tables.Count(), Is.EqualTo(tablesBeforeMerge.Count + tablesToBeMerged.Count)); Assert.That(customer.Children.Contains(recall)); }
public void ShouldBeAbleToRemoveOneTableFromExecutionNode() { // 2 Customers ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer"); customer.AddTable(_CustomerTable); // Make 2 accounts per customer ExecutionNode accounts = customer.AddChild(2, "Accounts"); accounts.AddTable(_AccountTable); NodeIterator it = new NodeIterator(customer); Assert.That(it.GetExpectedInsertCount(), Is.EqualTo(6)); AssertOrder(it.GetTablesRecursive().Select(x => x.Table), "Customer", "Accounts", "Accounts", "Customer", "Accounts", "Accounts"); accounts.RemoveTable(_AccountTable); Assert.That(it.GetExpectedInsertCount(), Is.EqualTo(2)); AssertOrder(it.GetTablesRecursive().Select(x => x.Table), "Customer", "Customer"); }
public void ShouldGetAllExecutionItems() { ExecutionNode node = ExecutionNode.CreateLevelOneNode(1); node.AddTable(new TableEntity("", "")); node.AddTable(new TableEntity("", "")); var child = node.AddChild(1); node.AddTable(new TableEntity("", "")); node.AddTable(new TableEntity("", "")); node.AddTable(new TableEntity("", "")); NodeIterator it = new NodeIterator(node); int counter = 0; foreach (var ei in it.GetTablesRecursive()) { Console.WriteLine(ei); counter++; } Assert.That(counter, Is.EqualTo(5)); }
public void ShouldCountTheTotalExpectedInsertedRowsInOrderToPredictProgress() { // 2 Customers ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer"); customer.AddTable(new TableEntity("dbo", "Customer")); // Make 2 accounts var accounts = customer.AddChild(2, "Accounts"); accounts.AddTable(new TableEntity("dbo", "Account")); // make one one Deposit and one WithDraw var accountTransactions = accounts.AddChild(1, "AccountTransactions"); accountTransactions.AddTable(new TableEntity("dbo", "Deposit")); accountTransactions.AddTable(new TableEntity("dbo", "Withdraw")); NodeIterator it = new NodeIterator(customer); long actualExpectedCount = it.GetExpectedInsertCount(); Assert.That(actualExpectedCount, Is.EqualTo(14)); }
private static ExecutionNode BuildRestoreDatabasesNode(DatabaseBackupInfo[] databases, DeployContext context) { var node = new ExecutionNode("Restoring databases...", "All databases restored!"); node.AddChild(new ExecutionNode(new RestoreDatabasesTransform(context.ApplicationContext.UserConfig.Databases.Connection, databases))); return node; }
public Tuple<ExecutionNode, StateHash, bool, StateHash> Calculate(DeployContext context, StateHash hash, StateHash startingHash, ICacheManager cacheManager) { if (mTransform != null) { hash = mTransform.CalculateTransform(hash); if (hash == startingHash) return Tuple.Create((ExecutionNode)null, hash, true, (StateHash)null); var backups = GetCachedBackups(cacheManager, hash, context.ApplicationContext.ProjectConfig.Databases); if (backups != null) { var node = new ExecutionNode("Restoring state from cache...", "Cache restored"); node.AddChild(new ExecutionNode(new RestoreDatabasesTransform(context.ApplicationContext.UserConfig.Databases.Connection, backups, hash))); return Tuple.Create(node, hash, true, hash); } } else if (mChildren.Count > 0) { var result = new ExecutionNode(mLogPre, mLogPost); var changed = false; StateHash cacheHash = null; foreach (var child in mChildren) { var calc = child.Calculate(context, hash, startingHash, cacheManager); if (calc.Item3) { changed = true; result.mChildren.Clear(); } if (calc.Item1 != null) result.mChildren.Add(calc.Item1); hash = calc.Item2; if (calc.Item4 != null) cacheHash = calc.Item4; } if (result.mChildren.Count == 0) result = null; return Tuple.Create(result, hash, changed, cacheHash); } return Tuple.Create(this, hash, false, (StateHash)null); }
private static void RunCore(DeployContext context) { Beep(context, "start"); var plan = ActionPlan.Build(context.RunContext); var root = new ExecutionNode("Begin deploy", "Deploy completed"); root.AddChild(BuildRestoreDatabasesNode(plan.Databases, context)); foreach (var release in plan.Releases) { var releaseNode = BuildReleaseNode(release, context); root.AddChild(releaseNode); } var hash = StateHash.Empty; try { StateHash startingHash = null; if (context.Resume) { startingHash = LoadResumeHash(context); } var improved = root.Calculate(context, hash, startingHash, context.CacheManager); if (improved.Item3) { root = improved.Item1; if (improved.Item4 != null) { context.CacheManager.UpdateHits(context.ApplicationContext.ProjectConfig.Databases.Select(x => Tuple.Create(x, improved.Item4))); } } var sink = new CheckingRequirementSink(context.ApplicationContext.Log); root.GetRequirements(sink); if (sink.Finish()) throw new SoftFailureException("Command aborted due to unmet requirements."); root.Run(context, startingHash ?? hash, context.CacheManager); if (!context.DryRun) CleanResumeHash(context); } catch (SoftFailureException ex) { Beep(context, "error"); throw new SoftFailureException("Blocking error detected", ex); } Beep(context, "success"); }
private static void RunCore(RunContext context) { var plan = ActionPlan.Build(context); var root = new ExecutionNode(string.Format("Running '{0}' action", context.Action), "Success!"); foreach (var release in plan.Releases) { root.AddChild(BuildReleaseNode(context, release)); } var sink = new CheckingRequirementSink(context.ApplicationContext.Log); root.GetRequirements(sink); if (sink.Finish()) throw new SoftFailureException("Command aborted due to unmet requirements."); root.Run(context); }