public override void OnExecutionFail(WxeContext context, IWxeFunctionExecutionListener listener, Exception exception)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("listener", listener);
listener.OnExecutionFail(context, exception);
}
public override void OnExecutionFail(WxeContext context, IWxeFunctionExecutionListener listener, Exception exception)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("listener", listener);
if (_scope == null)
{
throw new InvalidOperationException("OnExecutionFail may not be invoked unless OnExecutionPlay was called first.");
}
Exception innerException = null;
try
{
_child.OnExecutionFail(context, listener, exception);
}
catch (Exception e)
{
innerException = e;
throw;
}
finally
{
LeaveScopeAndReleaseTransaction(innerException);
}
}
public override void OnExecutionStop(WxeContext context, IWxeFunctionExecutionListener listener)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("listener", listener);
if (_scope == null)
{
throw new InvalidOperationException("OnExecutionStop may not be invoked unless OnExecutionPlay was called first.");
}
_child.OnExecutionStop(context, listener);
if (_autoCommit)
{
CommitTransaction();
}
var outParameters = _executionContext.GetOutParameters();
try
{
_outerTransactionStrategy.EnsureCompatibility(outParameters);
}
catch (InvalidOperationException ex)
{
var message = "One or more of the output parameters returned from the WxeFunction are incompatible with the function's parent transaction. "
+ ex.Message;
throw new WxeException(message, ex);
}
LeaveScopeAndReleaseTransaction(null);
}
public override void OnExecutionStop(WxeContext context, IWxeFunctionExecutionListener listener)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("listener", listener);
listener.OnExecutionStop(context);
}
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 ChildTransactionExecutionListener(ChildTransactionStrategy transactionStrategy, IWxeFunctionExecutionListener innerListener)
{
ArgumentUtility.CheckNotNull("transactionStrategy", transactionStrategy);
ArgumentUtility.CheckNotNull("innerListener", innerListener);
_transactionStrategy = transactionStrategy;
_innerListener = innerListener;
}
public void CreateExecutionListener()
{
IWxeFunctionExecutionListener innerExecutionListenerStub = MockRepository.GenerateStub <IWxeFunctionExecutionListener> ();
IWxeFunctionExecutionListener executionListener = _strategy.CreateExecutionListener(innerExecutionListenerStub);
Assert.That(executionListener, Is.InstanceOf(typeof(ChildTransactionExecutionListener)));
Assert.That(((ChildTransactionExecutionListener)executionListener).InnerListener, Is.SameAs(innerExecutionListenerStub));
}
public void SetUp()
{
WxeContextFactory contextFactory = new WxeContextFactory();
_context = contextFactory.CreateContext(new TestFunction());
_executionListener = NullExecutionListener.Null;
}
public SecurityExecutionListener(WxeFunction function, IWxeFunctionExecutionListener innerListener, [CanBeNull] IWxeSecurityAdapter wxeSecurityAdapter)
{
ArgumentUtility.CheckNotNull("function", function);
ArgumentUtility.CheckNotNull("innerListener", innerListener);
_function = function;
_innerListener = innerListener;
_wxeSecurityAdapter = wxeSecurityAdapter;
}
public void SetUp()
{
TestFunction rootFunction = new TestFunction();
WxeContextFactory contextFactory = new WxeContextFactory();
_context = contextFactory.CreateContext(rootFunction);
_mockRepository = new MockRepository();
_executionListenerMock = _mockRepository.StrictMock <IWxeFunctionExecutionListener>();
}
public void SetUp()
{
WxeContextFactory wxeContextFactory = new WxeContextFactory();
_context = wxeContextFactory.CreateContext(new TestFunction());
_executionListenerMock = MockRepository.GenerateMock <IWxeFunctionExecutionListener> ();
_strategy = NullTransactionStrategy.Null;
}
protected void SetExecutionListener(IWxeFunctionExecutionListener executionListener)
{
ArgumentUtility.CheckNotNull("executionListener", executionListener);
if (_transactionStrategy != null)
{
throw new InvalidOperationException("The ExecutionListener cannot be set after the TransactionStrategy has been initialized.");
}
_executionListener = executionListener;
}
public void CreateExecutionListener()
{
var innerExecutionListenerStub = MockRepository.GenerateStub <IWxeFunctionExecutionListener>();
IWxeFunctionExecutionListener executionListener = _strategy.CreateExecutionListener(innerExecutionListenerStub);
Assert.That(executionListener, Is.InstanceOf(typeof(RootTransactionExecutionListener)));
var transactionExecutionListener = (RootTransactionExecutionListener)executionListener;
Assert.That(transactionExecutionListener.InnerListener, Is.SameAs(innerExecutionListenerStub));
Assert.That(transactionExecutionListener.TransactionStrategy, Is.SameAs(_strategy));
}
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 SetUp()
{
_mockRepository = new MockRepository();
WxeContextFactory wxeContextFactory = new WxeContextFactory();
_wxeContext = wxeContextFactory.CreateContext(new TestFunction());
_securityAdapterMock = _mockRepository.StrictMock <IWxeSecurityAdapter>();
_innerListenerMock = _mockRepository.StrictMock <IWxeFunctionExecutionListener>();
_function = new TestFunction();
}
public override void OnExecutionPlay(WxeContext context, IWxeFunctionExecutionListener listener)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("listener", listener);
if (_scope != null)
{
throw new InvalidOperationException(
"OnExecutionPlay may not be invoked twice without calling OnExecutionStop, OnExecutionPause, or OnExecutionFail in-between.");
}
ExecuteAndWrapInnerException(EnterScope, null);
_child.OnExecutionPlay(context, listener);
}
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 abstract void OnExecutionPause(WxeContext context, IWxeFunctionExecutionListener listener);
public override IWxeFunctionExecutionListener CreateExecutionListener(IWxeFunctionExecutionListener innerListener)
{
ArgumentUtility.CheckNotNull("innerListener", innerListener);
return(innerListener);
}
public override IWxeFunctionExecutionListener CreateExecutionListener(IWxeFunctionExecutionListener innerListener)
{
ArgumentUtility.CheckNotNull("innerListener", innerListener);
return(new ChildTransactionExecutionListener(this, innerListener));
}
public void SetUp()
{
_mockRepository = new MockRepository();
_executionListenerMock = _mockRepository.StrictMock <IWxeFunctionExecutionListener>();
}
public new void SetExecutionListener(IWxeFunctionExecutionListener value)
{
base.SetExecutionListener(value);
}
public abstract IWxeFunctionExecutionListener CreateExecutionListener(IWxeFunctionExecutionListener innerListener);
public abstract void OnExecutionFail(WxeContext context, IWxeFunctionExecutionListener listener, Exception exception);
