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