public void ConstructorRegistersWithTheControl()
{
var control = PipelineTestHelper.TransactionControlMock();
var sut = new DeferredPipelineTransaction(control.Object);
control.Verify(mock => mock.Register(It.Is <DeferredPipelineTransaction>(a => a == sut)), Times.Once);
}
public void InitialNodeHasTheInputAsOutput()
{
var stage = PipelineTestHelper.Assignable(PipelineSuspensionState.Resume);
var sut = new HierarchicalSuspenderNode(stage);
Assert.AreSame(stage, sut.Output);
}
public void TransactionCannotBeUsedAfterBeingCommitted()
{
var control = PipelineTestHelper.TransactionControlMock();
var sut = new DeferredPipelineTransaction(control.Object);
sut.Commit();
Assert.Throws <InvalidOperationException>(() => sut.Update(1.AsPipelineConstant(), () => true));
Assert.Throws <InvalidOperationException>(() => sut.Commit());
Assert.Throws <InvalidOperationException>(() => sut.Cancel());
}
public void ControlIsCalledOnCommitWithTheExpectedStage()
{
var value = PipelineTestHelper.Assignable(1);
var control = PipelineTestHelper.TransactionControlMock();
var sut = new DeferredPipelineTransaction(control.Object)
.Update(value, 2);
control.Setup(mock => mock.Commit(
It.IsAny <DeferredPipelineTransaction>(),
It.IsAny <IEnumerable <DeferredTransactionPart> >()))
.Callback <DeferredPipelineTransaction, IEnumerable <DeferredTransactionPart> >((a, b) => Assert.IsTrue(a == sut && b.Count() == 1 && b.First().Stage == value));
sut.Commit();
}
public void CreatingSuspenderStageFromHierarchyWillGetHierarchySuspensionState(PipelineSuspensionState state, bool expectInvalidation)
{
var hierarchy = new HierarchicalSuspenderNode(state.AsPipelineConstant());
var input = PipelineTestHelper.Assignable(1);
var sut = hierarchy.WithSuspender(input);
var test = sut.AttachTestStage();
input.SetValue(10);
if (expectInvalidation)
{
test.AssertInvalidations(1);
}
else
{
test.AssertInvalidations(0);
}
}
public void CanceledTransactionDoesNotInvokeAnyOfTheUpdates()
{
var value = PipelineTestHelper.Assignable(1);
var other = PipelineTestHelper.Assignable("hello");
var test1 = value.AttachTestStage();
var test2 = other.AttachTestStage();
var control = PipelineTestHelper.TransactionControlMock();
var sut = new DeferredPipelineTransaction(control.Object)
.Update(value, 2)
.Update(other, "hello 2");
sut.Cancel();
test1.AssertNotInvalidatedNorRetrieved();
test2.AssertNotInvalidatedNorRetrieved();
PipelineAssert.Value(value, 1);
PipelineAssert.Value(other, "hello");
}
public void TransactionDoesNothingBeforeCommit()
{
var value = PipelineTestHelper.Assignable(1);
var test = value.AttachTestStage();
var control = PipelineTestHelper.TransactionControlMock();
control.Setup(mock => mock.Commit(It.IsAny <DeferredPipelineTransaction>(), It.IsAny <IEnumerable <DeferredTransactionPart> >()))
.Callback(new Action <DeferredPipelineTransaction, IEnumerable <DeferredTransactionPart> >((a, b) => { var c = new AggregatingTransactionControl(); c.Register(a); c.Commit(a, b); }));
var sut = new DeferredPipelineTransaction(control.Object)
.Update(value, 2);
control.Verify(mock => mock.Commit(It.IsAny <DeferredPipelineTransaction>(), It.IsAny <IEnumerable <DeferredTransactionPart> >()), Times.Never);
PipelineAssert.Value(value, 1);
test.AssertNotInvalidatedNorRetrieved();
sut.Commit();
control.Verify(mock => mock.Commit(It.IsAny <DeferredPipelineTransaction>(), It.IsAny <IEnumerable <DeferredTransactionPart> >()), Times.Once);
PipelineAssert.Value(value, 2);
test.AssertInvalidations(1);
}
public void ConcurrentTransactionsWhichCollideCausesTheLastOneToRollback(int[] totalOrder, int[] transaction1, int[] transaction2)
{
var stages = Enumerable.Repeat(1, totalOrder.Length).Select(_ => PipelineTestHelper.Assignable(1)).ToList();
var tests = stages.Select(stage => stage.AttachTestStage()).ToList();
var control = new AggregatingTransactionControl();
var t1 = control.CreateTransaction();
var t2 = control.CreateTransaction();
foreach (var i in totalOrder)
{
if (transaction1.Contains(i))
{
t1.Update(stages[i], 2);
}
if (transaction2.Contains(i))
{
t2.Update(stages[i], 2);
}
}
AssertExpectedTransactionOutcome(t1, t2, stages, tests, transaction1, PipelineTransactionResult.PendingSuccess, PipelineTransactionResult.Failed);
}
public void InvalidationPropagatesThroughEntireHierarchy(int size)
{
var inputs = Enumerable.Repeat(PipelineSuspensionState.Resume, size + 1).Select(r => PipelineTestHelper.Assignable(r)).ToList();
var stages = new List <HierarchicalSuspenderNode> {
new HierarchicalSuspenderNode(inputs[0])
};
for (int i = 0; i < size; ++i)
{
stages.Add(stages[i].CreateChild(inputs[i + 1], HierarchicalBehavior.WeakenSuspensionState));
}
var tests = stages.Select(s => s.Output.AttachTestStage()).ToList();
for (int i = 0; i < size; ++i)
{
inputs[i].SetValue(PipelineSuspensionState.Suspend);
foreach (var test in tests.Skip(i))
{
test.AssertInvalidations(i + 1);
}
PipelineAssert.Value(stages.Last().Output, PipelineSuspensionState.Suspend);
}
}
