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);