public void CreateTransactionStrategy_WithParentTransaction()
{
ITransactionMode transactionMode = new CreateChildIfParentTransactionMode(true, new TestTransactionFactory());
WxeFunction parentFunction = new TestFunction2(new CreateRootTransactionMode(true, new TestTransactionFactory()));
WxeFunction childFunction = new TestFunction2(transactionMode);
parentFunction.Add(childFunction);
WxeStep stepMock = MockRepository.GenerateMock <WxeStep>();
childFunction.Add(stepMock);
WxeContextFactory wxeContextFactory = new WxeContextFactory();
WxeContext context = wxeContextFactory.CreateContext(new TestFunction());
stepMock.Expect(mock => mock.Execute(context)).WhenCalled(
invocation =>
{
TransactionStrategyBase strategy = ((TestFunction2)childFunction).TransactionStrategy;
Assert.That(strategy, Is.InstanceOf(typeof(ChildTransactionStrategy)));
Assert.That(((ChildTransactionStrategy)strategy).AutoCommit, Is.True);
Assert.That(strategy.OuterTransactionStrategy, Is.SameAs(((TestFunction2)parentFunction).TransactionStrategy));
});
parentFunction.Execute(context);
}
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 override void Execute(WxeContext context)
{
ArgumentUtility.CheckNotNull("context", context);
Assertion.IsNotNull(_executionListener);
if (!IsExecutionStarted)
{
_variablesContainer.EnsureParametersInitialized(null);
var wxeSecurityAdapter = GetWxeSecurityAdapter();
_executionListener = new SecurityExecutionListener(this, _executionListener, wxeSecurityAdapter);
_transactionStrategy = _transactionMode.CreateTransactionStrategy(this, context);
Assertion.IsNotNull(_transactionStrategy);
_executionListener = _transactionStrategy.CreateExecutionListener(_executionListener);
Assertion.IsNotNull(_executionListener);
}
try
{
_executionListener.OnExecutionPlay(context);
base.Execute(context);
_executionListener.OnExecutionStop(context);
}
catch (WxeFatalExecutionException)
{
// bubble up
throw;
}
catch (ThreadAbortException)
{
_executionListener.OnExecutionPause(context);
throw;
}
catch (Exception stepException)
{
try
{
_executionListener.OnExecutionFail(context, stepException);
}
catch (Exception listenerException)
{
throw new WxeFatalExecutionException(stepException, listenerException);
}
var unwrappedException = WxeHttpExceptionPreservingException.GetUnwrappedException(stepException) ?? stepException;
if (!_exceptionHandler.Catch(unwrappedException))
{
throw new WxeUnhandledException(
string.Format("An exception ocured while executing WxeFunction '{0}'.", GetType().FullName),
stepException);
}
}
if (_exceptionHandler.Exception == null && ParentStep != null)
{
_variablesContainer.ReturnParametersToCaller();
}
}
public void SetUp()
{
_transactionMock = MockRepository.GenerateMock <ITransaction>();
_outerTransactionStrategyStub = MockRepository.GenerateStub <TransactionStrategyBase>();
_executionContextStub = MockRepository.GenerateStub <IWxeFunctionExecutionContext>();
_executionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]);
_strategy = new RootTransactionStrategy(true, () => _transactionMock, _outerTransactionStrategyStub, _executionContextStub);
}
public void SetUp()
{
WxeContextFactory wxeContextFactory = new WxeContextFactory();
_context = wxeContextFactory.CreateContext(new TestFunction());
_executionListenerMock = MockRepository.GenerateMock <IWxeFunctionExecutionListener> ();
_strategy = NullTransactionStrategy.Null;
}
public void SetUp()
{
WxeContextFactory wxeContextFactory = new WxeContextFactory();
_context = wxeContextFactory.CreateContext(new TestFunction());
_executionListenerMock = MockRepository.GenerateMock <IWxeFunctionExecutionListener>();
_executionContextMock = MockRepository.GenerateMock <IWxeFunctionExecutionContext>();
_outerTransactionStrategyMock = MockRepository.GenerateMock <TransactionStrategyBase>();
_strategy = new NoneTransactionStrategy(_outerTransactionStrategyMock);
}
public void CreateTransactionStrategy_WithoutParentFunction()
{
WxeContextFactory wxeContextFactory = new WxeContextFactory();
WxeContext context = wxeContextFactory.CreateContext(new TestFunction());
ITransactionMode transactionMode = new NoneTransactionMode();
TransactionStrategyBase strategy = transactionMode.CreateTransactionStrategy(new TestFunction2(transactionMode), context);
Assert.That(strategy, Is.InstanceOf(typeof(NoneTransactionStrategy)));
Assert.That(strategy.OuterTransactionStrategy, Is.SameAs(NullTransactionStrategy.Null));
}
public void CreateTransactionStrategy_WithoutParentFunction_And_WithoutParentTransaction()
{
WxeContextFactory wxeContextFactory = new WxeContextFactory();
WxeContext context = wxeContextFactory.CreateContext(new TestFunction());
ITransactionMode transactionMode = new CreateChildIfParentTransactionMode(true, new TestTransactionFactory());
TransactionStrategyBase strategy = transactionMode.CreateTransactionStrategy(new TestFunction2(transactionMode), context);
Assert.That(strategy, Is.InstanceOf(typeof(RootTransactionStrategy)));
Assert.That(strategy.GetNativeTransaction <TestTransaction>(), Is.InstanceOf(typeof(TestTransaction)));
Assert.That(((RootTransactionStrategy)strategy).AutoCommit, Is.True);
Assert.That(((RootTransactionStrategy)strategy).Transaction, Is.InstanceOf(typeof(TestTransaction)));
Assert.That(strategy.OuterTransactionStrategy, Is.InstanceOf(typeof(NullTransactionStrategy)));
}
public void SetUp()
{
WxeContextFactory wxeContextFactory = new WxeContextFactory();
_wxeContext = wxeContextFactory.CreateContext(new TestFunction());
ITransaction transactionMock = MockRepository.GenerateMock <ITransaction>();
TransactionStrategyBase outerTransactionStrategyStub = MockRepository.GenerateStub <TransactionStrategyBase>();
IWxeFunctionExecutionContext executionContextStub = MockRepository.GenerateStub <IWxeFunctionExecutionContext>();
executionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]);
_transactionStrategyMock = MockRepository.GenerateMock <RootTransactionStrategy> (
false, (Func <ITransaction>)(() => transactionMock), outerTransactionStrategyStub, executionContextStub);
_innerListenerStub = MockRepository.GenerateStub <IWxeFunctionExecutionListener>();
_transactionListener = new RootTransactionExecutionListener(_transactionStrategyMock, _innerListenerStub);
}
public virtual void SetUp()
{
WxeContextFactory wxeContextFactory = new WxeContextFactory();
_context = wxeContextFactory.CreateContext(new TestFunction());
_mockRepository = new MockRepository();
_executionListenerStub = MockRepository.Stub <IWxeFunctionExecutionListener>();
_transactionFactoryMock = MockRepository.StrictMock <ITransactionFactory>();
_transactionMock = MockRepository.StrictMock <ITransaction>();
_transactionFactoryMock.Stub(stub => stub.Create()).Return(_transactionMock);
_scopeMock = MockRepository.StrictMock <ITransactionScope> ();
_executionContextMock = MockRepository.StrictMock <IWxeFunctionExecutionContext>();
_outerTransactionStrategyMock = MockRepository.StrictMock <TransactionStrategyBase>();
_childTransactionStrategyMock = MockRepository.StrictMock <TransactionStrategyBase> ();
}
public void SetUp()
{
_mockRepository = new MockRepository();
WxeContextFactory wxeContextFactory = new WxeContextFactory();
_context = wxeContextFactory.CreateContext(new TestFunction());
_outerTransactionStrategyMock = _mockRepository.StrictMock <TransactionStrategyBase> ();
_parentTransactionMock = _mockRepository.StrictMock <ITransaction>();
_childTransactionMock = _mockRepository.StrictMock <ITransaction> ();
_executionContextStub = _mockRepository.Stub <IWxeFunctionExecutionContext> ();
_executionListenerStub = _mockRepository.Stub <IWxeFunctionExecutionListener> ();
_executionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]);
_parentTransactionMock.Stub(stub => stub.CreateChild()).Return(_childTransactionMock);
_childTransactionMock.Stub(stub => stub.EnsureCompatibility(Arg <IEnumerable> .Is.NotNull));
_mockRepository.ReplayAll();
_strategy = new ChildTransactionStrategy(true, _outerTransactionStrategyMock, _parentTransactionMock, _executionContextStub);
_mockRepository.BackToRecordAll();
}
public void Test_WithTransactionStrategy()
{
ITransactionMode transactionModeMock = _mockRepository.StrictMock <ITransactionMode>();
TestFunction2 function = new TestFunction2(transactionModeMock);
TransactionStrategyBase transactionStrategyMock = MockRepository.GenerateMock <TransactionStrategyBase>();
transactionModeMock.Expect(mock => mock.CreateTransactionStrategy(function, _context)).Return(transactionStrategyMock);
transactionStrategyMock.Expect(mock => mock.CreateExecutionListener(Arg <IWxeFunctionExecutionListener> .Is.NotNull))
.Return(_executionListenerMock);
using (_mockRepository.Ordered())
{
_executionListenerMock.Expect(mock => mock.OnExecutionPlay(_context));
_executionListenerMock.Expect(mock => mock.OnExecutionStop(_context));
}
_mockRepository.ReplayAll();
function.Execute(_context);
_mockRepository.VerifyAll();
Assert.That(function.ExecutionListener, Is.SameAs(_executionListenerMock));
}
public void CreateChildTransactionStrategy()
{
var grandParentTransactionStrategyMock = MockRepository.GenerateMock <TransactionStrategyBase> ();
var noneTransactionStrategy = new NoneTransactionStrategy(grandParentTransactionStrategyMock);
var childExecutionContextStub = MockRepository.GenerateStub <IWxeFunctionExecutionContext>();
childExecutionContextStub.Stub(stub => stub.GetInParameters()).Return(new object[0]);
var fakeParentTransaction = MockRepository.GenerateStub <ITransaction>();
fakeParentTransaction.Stub(stub => stub.CreateChild()).Return(MockRepository.GenerateStub <ITransaction>());
var fakeChildTransactionStrategy = new ChildTransactionStrategy(
false, grandParentTransactionStrategyMock, fakeParentTransaction, childExecutionContextStub);
grandParentTransactionStrategyMock
.Expect(mock => mock.CreateChildTransactionStrategy(true, childExecutionContextStub, _context))
.Return(fakeChildTransactionStrategy);
TransactionStrategyBase actual = noneTransactionStrategy.CreateChildTransactionStrategy(true, childExecutionContextStub, _context);
Assert.That(actual, Is.SameAs(fakeChildTransactionStrategy));
}
protected ScopedTransactionStrategyBase CreateScopedTransactionStrategy(bool autoCommit, TransactionStrategyBase parentTransactionStrategy)
{
_executionContextMock.BackToRecord();
_executionContextMock.Stub(stub => stub.GetInParameters()).Return(new object[0]).Repeat.Any();
_executionContextMock.Replay();
_transactionMock.BackToRecord();
_transactionMock.Stub(stub => stub.EnsureCompatibility(Arg <IEnumerable> .Is.NotNull));
_transactionMock.Replay();
_transactionFactoryMock.Replay();
var strategy = MockRepository.PartialMock <ScopedTransactionStrategyBase> (
autoCommit, (Func <ITransaction>)_transactionFactoryMock.Create, parentTransactionStrategy, _executionContextMock);
strategy.Replay();
SetChild(strategy, ChildTransactionStrategyMock);
_executionContextMock.BackToRecord();
_transactionMock.BackToRecord();
return(strategy);
}
protected void SetChild(ScopedTransactionStrategyBase strategy, TransactionStrategyBase childStrategy)
{
PrivateInvoke.SetNonPublicField(strategy, "_child", childStrategy);
}
