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