public void ShouldSimulateCompleteWorkflow()
{
DataAccess.TableEntityDataAccess tda = new DataAccess.TableEntityDataAccess(Connection());
var person = tda.GetTableAndColumns("Person", "NewPerson");
var personDetail = tda.GetTableAndColumns("Person", "AnotherTable");
personDetail.Columns.First().Generator = new ValueFromOtherColumnIntGenerator(personDetail.Columns.First().ColumnDataType);
personDetail.Columns.First().Generator.GeneratorParameters.ValueFromOtherColumn.Value = person.Columns.First();
ExecutionNode node = ExecutionNode.CreateLevelOneNode(100, "Root");
node.AddTable(person);
node.AddTable(personDetail);
var consumerMeta = PluginLoader.GetMetaDataOfType(typeof(InsertConsumer));
var wrapper = new DataConsumerPluginWrapper(consumerMeta.ConsumerName, typeof(InsertConsumer), consumerMeta.OptionsTemplate);
ExecutionResultBuilder builder = new ExecutionResultBuilder();
WorkflowManager manager = new WorkflowManager();
manager.RunWorkFlow(Connection(), wrapper, builder, options, node);
var result = builder.Build();
Assert.That(result.InsertCount, Is.EqualTo(200));
Assert.That(result.Errors.Count, Is.EqualTo(0));
Assert.That(result.Duration, Is.GreaterThan(new TimeSpan(1)));
}
public void ShouldNotBeAbleToAddSameTableTwice()
{
ExecutionNode node1 = ExecutionNode.CreateLevelOneNode(1);
TableEntity customerTable = new TableEntity("dbo", "Customer");
node1.AddTable(customerTable);
node1.AddTable(customerTable);
node1.AddTable(customerTable);
Assert.That(node1.Tables.Count(), Is.EqualTo(1));
}
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 ShouldBeAbleToRemoveSeveralTablesFromExecutionNode()
{
// 2 Customers
ExecutionNode customer = ExecutionNode.CreateLevelOneNode(2, "Customer");
customer.AddTable(_CustomerTable);
customer.AddTable(_AccountTable);
NodeIterator it = new NodeIterator(customer);
Assert.That(it.GetExpectedInsertCount(), Is.EqualTo(4));
AssertOrder(it.GetTablesRecursive().Select(x => x.Table), "Customer", "Accounts", "Customer", "Accounts");
customer.RemoveTables(_AccountTable, _CustomerTable);
Assert.That(it.GetExpectedInsertCount(), Is.EqualTo(0));
// AssertOrder(it.GetTablesRecursive(), "Customer", "Customer");
}
public void ShouldMoveTableDownInTheListOfTables()
{
ExecutionNode node1 = ExecutionNode.CreateLevelOneNode(1);
TableEntity customerTable = new TableEntity("dbo", "Customer");
var orderTable = new TableEntity("dbo", "Order");
node1.AddTable(orderTable);
node1.AddTable(customerTable);
Assert.That(node1.Tables.Last(), Is.EqualTo(customerTable));
node1.MoveTableDown(orderTable);
Assert.That(node1.Tables.Count(), Is.EqualTo(2));
Assert.That(node1.Tables.Last(), Is.EqualTo(orderTable));
node1.MoveTableUp(customerTable);
Assert.That(node1.Tables.Last(), Is.EqualTo(orderTable), "moving a table below the bottom should leave it where it is");
}
public void ShouldRunWorkflowAsync()
{
builder = new ExecutionResultBuilder().Begin();
ExecutionNode rootNode = ExecutionNode.CreateLevelOneNode(1, "Root");
rootNode.AddTable(new TableEntity("dbo", "Customer"));
manager.RunWorkFlowAsync(connectionString, wrapper, builder, options, rootNode);
Thread.Sleep(10); // give some time for the async method to complete
var result = builder.Build();
Assert.That(result.Errors.Count, Is.EqualTo(0));
Assert.That(result.InsertCount, Is.EqualTo(1));
}
public void ShouldConsumeOneRow()
{
builder = new ExecutionResultBuilder();
builder.Begin();
ExecutionNode rootNode = ExecutionNode.CreateLevelOneNode(1, "Root");
rootNode.AddTable(new TableEntity("dbo", "Customer"));
manager.RunWorkFlow(connectionString, wrapper, builder, options, rootNode);
var result = builder.Build();
Assert.That(result.Errors.Count, Is.EqualTo(0));
Assert.That(result.InsertCount, Is.EqualTo(1));
}
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 ShouldNotMoveATableThatIsNotPartOfTheNode()
{
ExecutionNode node1 = ExecutionNode.CreateLevelOneNode(1);
var customerTable = new TableEntity("dbo", "Customer");
var orderTable = new TableEntity("dbo", "Order");
node1.AddTable(customerTable);
node1.MoveTableUp(orderTable);
node1.MoveTableUp(orderTable);
node1.MoveTableDown(orderTable);
node1.MoveTableDown(orderTable);
Assert.That(node1.Tables.Count(), Is.EqualTo(1));
}
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 ShouldStopWhenAskedToBeCancled()
{
ExecutionNode node = ExecutionNode.CreateLevelOneNode(1000000);
node.AddTable(new TableEntity("", ""));
var tables = new List <ExecutionTable>();
NodeIterator iterator = new NodeIterator(node);
Action a = new Action(() =>
{
tables.AddRange(iterator.GetTablesRecursive());
});
a.BeginInvoke(null, null);
Thread.Sleep(10);
iterator.Cancel();
Console.WriteLine(tables.Count);
Assert.That(tables.Count, Is.LessThan(1000000));
Assert.That(tables.Count, Is.GreaterThan(0));
}
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 shouldReturnOnlyTheNodeIfOnlyOne()
{
ExecutionNode node = ExecutionNode.CreateLevelOneNode(1);
node.AddTable(new TableEntity("", ""));
int counter = 0;
NodeIterator it = new NodeIterator(node);
Assert.That(node.Children.Count(), Is.EqualTo(0));
HashSet <TableEntity> nodes = new HashSet <TableEntity>();
foreach (var item in it.GetTablesRecursive())
{
nodes.Add(item.Table);
counter++;
}
Assert.That(counter, Is.EqualTo(1));
Assert.That(nodes.Count, Is.EqualTo(1));
}
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));
}
