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 SetUp()
{
WxeContextFactory contextFactory = new WxeContextFactory();
_context = contextFactory.CreateContext(new TestFunction());
_executionListener = NullExecutionListener.Null;
}
public void SetUp()
{
WxeContextFactory wxeContextFactory = new WxeContextFactory();
_context = wxeContextFactory.CreateContext(new TestFunction());
_executionListenerMock = MockRepository.GenerateMock <IWxeFunctionExecutionListener> ();
_strategy = NullTransactionStrategy.Null;
}
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>();
_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 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 void SetUp()
{
TestFunction rootFunction = new TestFunction();
WxeContextFactory contextFactory = new WxeContextFactory();
_wxeContext = contextFactory.CreateContext(rootFunction);
_mockRepository = new MockRepository();
_mockWxeSecurityAdapter = _mockRepository.StrictMock <IWxeSecurityAdapter> ();
var serviceLocator = DefaultServiceLocator.Create();
serviceLocator.RegisterMultiple <IWxeSecurityAdapter> (() => _mockWxeSecurityAdapter);
_serviceLocatorScope = new ServiceLocatorScope(serviceLocator);
}
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 SetTransactionMode_AfterExecutionHasStarted_ThrowsInvalidOperationException()
{
TestFunction2 function = new TestFunction2();
function.Add(
new WxeDelegateStep(
() => Assert.That(
() => function.SetTransactionMode(WxeTransactionMode <TestTransactionFactory> .CreateRoot),
Throws.InvalidOperationException
.With.Message.EqualTo("The TransactionMode cannot be set after the TransactionStrategy has been initialized."))));
WxeContextFactory contextFactory = new WxeContextFactory();
var context = contextFactory.CreateContext(function);
function.Execute(context);
}
public void SetTransactionMode()
{
TestFunction2 function = new TestFunction2();
ITransactionStrategy actualTransaction = null;
function.Add(new WxeDelegateStep(() => actualTransaction = function.Transaction));
function.SetTransactionMode(WxeTransactionMode <TestTransactionFactory> .CreateRoot);
WxeContextFactory contextFactory = new WxeContextFactory();
var context = contextFactory.CreateContext(function);
Assert.That(function.Transaction, Is.InstanceOf <NullTransactionStrategy>());
function.Execute(context);
Assert.That(actualTransaction, Is.InstanceOf <RootTransactionStrategy>());
}
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();
}
