protected ScopedTransactionStrategyBase(
bool autoCommit,
Func <ITransaction> transactionFactory,
TransactionStrategyBase outerTransactionStrategy,
IWxeFunctionExecutionContext executionContext)
{
ArgumentUtility.CheckNotNull("transactionFactory", transactionFactory);
ArgumentUtility.CheckNotNull("outerTransactionStrategy", outerTransactionStrategy);
ArgumentUtility.CheckNotNull("executionContext", executionContext);
_autoCommit = autoCommit;
_transactionFactory = transactionFactory;
_outerTransactionStrategy = outerTransactionStrategy;
_executionContext = executionContext;
_child = NullTransactionStrategy.Null;
_transaction = CreateTransaction();
var inParameters = _executionContext.GetInParameters();
try
{
EnsureCompatibility(inParameters);
}
catch (InvalidOperationException ex)
{
var message = "One or more of the input parameters passed to the WxeFunction are incompatible with the function's transaction. " + ex.Message;
throw new WxeException(message, ex);
}
}
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>();
_executionContextMock = MockRepository.GenerateMock <IWxeFunctionExecutionContext>();
_outerTransactionStrategyMock = MockRepository.GenerateMock <TransactionStrategyBase>();
_strategy = new NoneTransactionStrategy(_outerTransactionStrategyMock);
}
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 override TransactionStrategyBase CreateChildTransactionStrategy(bool autoCommit, IWxeFunctionExecutionContext executionContext, WxeContext wxeContext)
{
ArgumentUtility.CheckNotNull("executionContext", executionContext);
return(null);
}
public override sealed TransactionStrategyBase CreateChildTransactionStrategy(bool autoCommit, IWxeFunctionExecutionContext executionContext, WxeContext wxeContext)
{
ArgumentUtility.CheckNotNull("executionContext", executionContext);
ArgumentUtility.CheckNotNull("wxeContext", wxeContext);
if (!_child.IsNull)
{
throw new InvalidOperationException(
"The transaction strategy already has an active child transaction strategy. "
+ "This child transaction strategy must first be unregistered before invoking CreateChildTransactionStrategy again.");
}
var childTransactionStrategy = new ChildTransactionStrategy(autoCommit, this, Transaction, executionContext);
_child = childTransactionStrategy;
if (_scope != null)
{
_child.OnExecutionPlay(wxeContext, NullExecutionListener.Null);
}
return(childTransactionStrategy);
}
public abstract TransactionStrategyBase CreateChildTransactionStrategy(bool autoCommit, IWxeFunctionExecutionContext executionContext, WxeContext wxeContext);
public ChildTransactionStrategy(
bool autoCommit, TransactionStrategyBase outerTransactionStrategy, ITransaction parentTransaction, IWxeFunctionExecutionContext executionContext)
: base(autoCommit, parentTransaction.CreateChild, outerTransactionStrategy, executionContext)
{
}
public RootTransactionStrategy(
bool autoCommit, Func <ITransaction> transactionFactory, TransactionStrategyBase outerTransactionStrategy, IWxeFunctionExecutionContext executionContext)
: base(autoCommit, transactionFactory, outerTransactionStrategy, executionContext)
{
}
