public void CreateChildTransactionStrategy_AfterPlay()
{
InvokeOnExecutionPlay(_strategy);
var childTransaction = MockRepository.GenerateStub <ITransaction> ();
TransactionMock.Expect(mock => mock.CreateChild()).Return(childTransaction);
ITransactionScope childScope = MockRepository.GenerateStub <ITransactionScope>();
childTransaction.Expect(mock => mock.EnterScope()).Return(childScope);
var childExecutionContextStub = MockRepository.GenerateStub <IWxeFunctionExecutionContext> ();
childExecutionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]);
MockRepository.ReplayAll();
TransactionStrategyBase childTransactionStrategy = _strategy.CreateChildTransactionStrategy(true, childExecutionContextStub, Context);
MockRepository.VerifyAll();
Assert.That(childTransactionStrategy, Is.InstanceOf(typeof(ChildTransactionStrategy)));
Assert.That(((ChildTransactionStrategy)childTransactionStrategy).AutoCommit, Is.True);
Assert.That(((ChildTransactionStrategy)childTransactionStrategy).Transaction, Is.SameAs(childTransaction));
Assert.That(childTransactionStrategy.OuterTransactionStrategy, Is.SameAs(_strategy));
Assert.That(((ChildTransactionStrategy)childTransactionStrategy).ExecutionContext, Is.SameAs(childExecutionContextStub));
Assert.That(((ChildTransactionStrategy)childTransactionStrategy).Scope, Is.SameAs(childScope));
Assert.That(_strategy.Child, Is.SameAs(childTransactionStrategy));
}
public void Test_WithParentTransactionStrategy()
{
var strategy = CreateScopedTransactionStrategy(true, OuterTransactionStrategyMock);
var expectedObjects = new[] { new object() };
InvokeOnExecutionPlay(strategy);
using (MockRepository.Ordered())
{
ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionStop(Context, ExecutionListenerStub));
TransactionMock.Expect(mock => mock.Commit());
ExecutionContextMock.Expect(mock => mock.GetOutParameters()).Return(expectedObjects);
OuterTransactionStrategyMock.Expect(mock => mock.EnsureCompatibility(expectedObjects));
ScopeMock.Expect(mock => mock.Leave());
TransactionMock.Expect(mock => mock.Release());
}
MockRepository.ReplayAll();
strategy.OnExecutionStop(Context, ExecutionListenerStub);
MockRepository.VerifyAll();
Assert.That(strategy.Scope, Is.Null);
}
public void Test_WithoutScope_And_CreateThrows()
{
var exception = new ApplicationException("Reset Exception");
TransactionMock.BackToRecord();
TransactionMock.Expect(mock => mock.Release());
TransactionFactoryMock.BackToRecord();
TransactionFactoryMock.Expect(mock => mock.Create()).Throw(exception);
Assert.That(_strategy.Scope, Is.Null);
MockRepository.ReplayAll();
try
{
_strategy.Reset();
Assert.Fail("Expected Exception");
}
catch (ApplicationException actualException)
{
Assert.That(actualException, Is.SameAs(exception));
}
MockRepository.VerifyAll();
Assert.That(_strategy.Scope, Is.Null);
Assert.That(_strategy.Transaction, Is.SameAs(TransactionMock), "Transaction just released is retained.");
}
public void Test_WithScope()
{
var object1 = new object();
var object2 = new object();
InvokeOnExecutionPlay(_strategy);
TransactionMock.BackToRecord();
TransactionFactoryMock.BackToRecord();
var newScopeMock = MockRepository.StrictMock <ITransactionScope>();
using (MockRepository.Ordered())
{
ScopeMock.Expect(mock => mock.Leave());
TransactionMock.Expect(mock => mock.Release());
TransactionFactoryMock.Expect(mock => mock.Create()).Return(_newTransactionMock);
_newTransactionMock.Expect(mock => mock.EnterScope()).Return(newScopeMock);
ExecutionContextMock.Expect(mock => mock.GetVariables()).Return(new[] { object1, object2 });
_newTransactionMock.Expect(mock => mock.EnsureCompatibility(Arg <IEnumerable> .List.ContainsAll(new[] { object1, object2 })));
}
Assert.That(_strategy.Scope, Is.SameAs(ScopeMock));
MockRepository.ReplayAll();
_strategy.Reset();
MockRepository.VerifyAll();
Assert.That(_strategy.Scope, Is.SameAs(newScopeMock));
}
public void Test_WithScope_And_ResetThrows()
{
InvokeOnExecutionPlay(_strategy);
var exception = new ApplicationException("Reset Exception");
TransactionFactoryMock.BackToRecord();
TransactionMock.BackToRecord();
using (MockRepository.Ordered())
{
ScopeMock.Expect(mock => mock.Leave());
TransactionMock.Expect(mock => mock.Release());
TransactionFactoryMock.Expect(mock => mock.Create()).Throw(exception);
}
Assert.That(_strategy.Scope, Is.SameAs(ScopeMock));
MockRepository.ReplayAll();
try
{
_strategy.Reset();
Assert.Fail("Expected Exception");
}
catch (ApplicationException actualException)
{
Assert.That(actualException, Is.SameAs(exception));
}
MockRepository.VerifyAll();
Assert.That(_strategy.Scope, Is.SameAs(ScopeMock));
Assert.That(_strategy.Transaction, Is.SameAs(TransactionMock), "Transaction just released is retained.");
}
public void Test_ReleaseThrows()
{
var strategy = CreateScopedTransactionStrategy(false, NullTransactionStrategy.Null);
var innerException = new Exception("Release Exception");
InvokeOnExecutionPlay(strategy);
ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionStop(Context, ExecutionListenerStub));
ExecutionContextMock.Expect(mock => mock.GetOutParameters()).Return(new object[0]);
ScopeMock.Expect(mock => mock.Leave());
TransactionMock.Expect(mock => mock.Release()).Throw(innerException);
MockRepository.ReplayAll();
try
{
strategy.OnExecutionStop(Context, ExecutionListenerStub);
Assert.Fail("Expected Exception");
}
catch (WxeFatalExecutionException actualException)
{
Assert.That(actualException.InnerException, Is.SameAs(innerException));
}
MockRepository.VerifyAll();
Assert.That(strategy.Scope, Is.Null);
}
public void Test_ChildStrategyThrows()
{
var innerException = new ApplicationException("InnerListener Exception");
using (MockRepository.Ordered())
{
TransactionMock.Expect(mock => mock.EnterScope()).Return(ScopeMock);
ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionPlay(Context, ExecutionListenerStub)).Throw(innerException);
}
MockRepository.ReplayAll();
try
{
_strategy.OnExecutionPlay(Context, ExecutionListenerStub);
Assert.Fail("Expected Exception");
}
catch (ApplicationException actualException)
{
Assert.That(actualException, Is.SameAs(innerException));
}
MockRepository.VerifyAll();
Assert.That(_strategy.Scope, Is.Not.Null);
}
public void CreateChildTransactionStrategy_AfterPlay_Throws()
{
InvokeOnExecutionPlay(_strategy);
var childTransaction = MockRepository.GenerateStub <ITransaction> ();
TransactionMock.Expect(mock => mock.CreateChild()).Return(childTransaction);
ApplicationException innerException = new ApplicationException("EnterScope Exception");
childTransaction.Expect(mock => mock.EnterScope()).Throw(innerException);
var childExecutionContextStub = MockRepository.GenerateStub <IWxeFunctionExecutionContext> ();
childExecutionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]);
MockRepository.ReplayAll();
try
{
_strategy.CreateChildTransactionStrategy(true, childExecutionContextStub, Context);
Assert.Fail("Expected Exception");
}
catch (WxeFatalExecutionException e)
{
MockRepository.VerifyAll();
Assert.That(e.InnerException, Is.SameAs(innerException));
Assert.That(_strategy.Child, Is.InstanceOf(typeof(ChildTransactionStrategy)));
}
}
public void Test_ChildStrategyThrows_And_ReleaseThrows()
{
var innerException = new Exception("InnerListener Exception");
var outerException = new Exception("Release Exception");
InvokeOnExecutionPlay(_strategy);
using (MockRepository.Ordered())
{
ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionFail(Context, ExecutionListenerStub, _failException)).Throw(innerException);
ScopeMock.Expect(mock => mock.Leave());
TransactionMock.Expect(mock => mock.Release()).Throw(outerException);
}
MockRepository.ReplayAll();
try
{
_strategy.OnExecutionFail(Context, ExecutionListenerStub, _failException);
Assert.Fail("Expected Exception");
}
catch (WxeFatalExecutionException actualException)
{
Assert.That(actualException.InnerException, Is.SameAs(innerException));
Assert.That(actualException.OuterException, Is.SameAs(outerException));
}
MockRepository.VerifyAll();
Assert.That(_strategy.Scope, Is.Null);
}
public void Commit()
{
TransactionMock.Expect(mock => mock.Commit());
MockRepository.ReplayAll();
_strategy.Commit();
MockRepository.VerifyAll();
}
public void Rollback()
{
TransactionMock.Expect(mock => mock.Rollback());
MockRepository.ReplayAll();
_strategy.Rollback();
MockRepository.VerifyAll();
}
public void CreateChildTransactionStrategy_TwiceWithoutUnregister()
{
var childTransaction = MockRepository.GenerateStub <ITransaction>();
TransactionMock.Expect(mock => mock.CreateChild()).Return(childTransaction);
var childExecutionContextStub = MockRepository.GenerateStub <IWxeFunctionExecutionContext>();
childExecutionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]);
MockRepository.ReplayAll();
_strategy.CreateChildTransactionStrategy(true, childExecutionContextStub, Context);
_strategy.CreateChildTransactionStrategy(true, childExecutionContextStub, Context);
}
public void Test()
{
using (MockRepository.Ordered())
{
TransactionMock.Expect(mock => mock.EnterScope()).Return(ScopeMock);
ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionPlay(Context, ExecutionListenerStub));
}
MockRepository.ReplayAll();
_strategy.OnExecutionPlay(Context, ExecutionListenerStub);
MockRepository.VerifyAll();
Assert.That(_strategy.Scope, Is.SameAs(ScopeMock));
}
public void Test_WithNullValue()
{
var object1 = new object();
var object2 = new object();
using (MockRepository.Ordered())
{
ExecutionContextMock.Expect(mock => mock.GetInParameters()).Return(new[] { object1, null, object2 });
TransactionMock.Expect(mock => mock.EnsureCompatibility(Arg <IEnumerable> .List.ContainsAll(new[] { object1, object2 })));
}
MockRepository.ReplayAll();
new RootTransactionStrategy(false, () => TransactionMock, NullTransactionStrategy.Null, ExecutionContextMock);
MockRepository.VerifyAll();
}
public void Test()
{
InvokeOnExecutionPlay(_strategy);
using (MockRepository.Ordered())
{
ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionFail(Context, ExecutionListenerStub, _failException));
ScopeMock.Expect(mock => mock.Leave());
TransactionMock.Expect(mock => mock.Release());
}
MockRepository.ReplayAll();
_strategy.OnExecutionFail(Context, ExecutionListenerStub, _failException);
MockRepository.VerifyAll();
Assert.That(_strategy.Scope, Is.Null);
}
public void Test_EnterScopeThrows()
{
var innerException = new Exception("Enter Scope Exception");
TransactionMock.Expect(mock => mock.EnterScope()).Throw(innerException);
MockRepository.ReplayAll();
try
{
_strategy.OnExecutionPlay(Context, ExecutionListenerStub);
Assert.Fail("Expected Exception");
}
catch (WxeFatalExecutionException actualException)
{
Assert.That(actualException.InnerException, Is.SameAs(innerException));
}
Assert.That(_strategy.Scope, Is.Null);
}
public void Test_WithoutAutoCommit()
{
var strategy = CreateScopedTransactionStrategy(false, NullTransactionStrategy.Null);
InvokeOnExecutionPlay(strategy);
using (MockRepository.Ordered())
{
ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionStop(Context, ExecutionListenerStub));
ExecutionContextMock.Expect(mock => mock.GetOutParameters()).Return(new object[0]);
ScopeMock.Expect(mock => mock.Leave());
TransactionMock.Expect(mock => mock.Release());
}
MockRepository.ReplayAll();
strategy.OnExecutionStop(Context, ExecutionListenerStub);
MockRepository.VerifyAll();
Assert.That(strategy.Scope, Is.Null);
}
public void Test_CommitThrows()
{
var strategy = CreateScopedTransactionStrategy(true, NullTransactionStrategy.Null);
var innerException = new ApplicationException("Commit Exception");
InvokeOnExecutionPlay(strategy);
ChildTransactionStrategyMock.Expect(mock => mock.OnExecutionStop(Context, ExecutionListenerStub));
TransactionMock.Expect(mock => mock.Commit()).Throw(innerException);
MockRepository.ReplayAll();
try
{
strategy.OnExecutionStop(Context, ExecutionListenerStub);
Assert.Fail("Expected Exception");
}
catch (ApplicationException actualException)
{
Assert.That(actualException, Is.SameAs(innerException));
}
MockRepository.VerifyAll();
Assert.That(strategy.Scope, Is.SameAs(ScopeMock));
}
public void GetTransaction()
{
TransactionMock.Expect(mock => mock.To <ITransaction>()).Return(TransactionMock);
TransactionMock.Replay();
Assert.That(_strategy.GetNativeTransaction <ITransaction>(), Is.SameAs(TransactionMock));
}