public void NullTransaction_ForCloneTransaction()
{
using (ClientTransactionScope.EnterNullScope())
{
_cloner.CreateValueClone(_boundSource);
}
}
public void SearchAvailableObjects_NoTransaction()
{
using (ClientTransactionScope.EnterNullScope())
{
_service.Search(null, _property, new DefaultSearchArguments(_stubbedQueryID));
}
}
public void ExecuteSingle_NoActiveClientTransaction()
{
using (ClientTransactionScope.EnterNullScope())
{
_queryExecutor.ExecuteSingle <Order> (_someQueryModel, false);
}
}
public override void SetUp()
{
base.SetUp();
ClientTransactionScope.ResetActiveScope();
_outermostScope = ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope();
}
public void ExecuteScalar_NoActiveClientTransaction()
{
using (ClientTransactionScope.EnterNullScope())
{
_queryExecutor.ExecuteScalar <int> (_someQueryModel);
}
}
public void LeaveAndDisposeThrows()
{
using (ClientTransactionScope scope = ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
scope.Leave();
}
}
public void CommitAndRollbackOnScope()
{
ClientTransaction transaction = ClientTransaction.CreateRootTransaction();
var eventCounter = new TransactionEventCounter(transaction);
using (ClientTransactionScope scope = transaction.EnterNonDiscardingScope())
{
Assert.That(eventCounter.Commits, Is.EqualTo(0));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(0));
scope.Commit();
Assert.That(eventCounter.Commits, Is.EqualTo(1));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(0));
scope.Rollback();
Assert.That(eventCounter.Commits, Is.EqualTo(1));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(1));
transaction.Commit();
Assert.That(eventCounter.Commits, Is.EqualTo(2));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(1));
transaction.Rollback();
Assert.That(eventCounter.Commits, Is.EqualTo(2));
Assert.That(eventCounter.Rollbacks, Is.EqualTo(2));
}
}
public override void SetUp()
{
base.SetUp();
_owningOrder = DomainObjectIDs.Order1.GetObject <Order> ();
_endPointID = RelationEndPointID.Resolve(_owningOrder, o => o.OrderItems);
_collectionEndPointMock = MockRepository.GenerateStrictMock <ICollectionEndPoint>();
StubCollectionEndPoint(_collectionEndPointMock, TestableClientTransaction, _owningOrder);
_virtualEndPointProviderStub = MockRepository.GenerateStub <IVirtualEndPointProvider> ();
_virtualEndPointProviderStub
.Stub(stub => stub.GetOrCreateVirtualEndPoint(_endPointID))
.Return(_collectionEndPointMock);
_endPointDataStub = MockRepository.GenerateStub <IDomainObjectCollectionData>();
_endPointDataDecorator = new ReadOnlyCollectionDataDecorator(_endPointDataStub);
_commandStub = MockRepository.GenerateStub <IDataManagementCommand>();
_nestedCommandMock = MockRepository.GenerateMock <IDataManagementCommand> ();
_nestedCommandMock.Stub(stub => stub.GetAllExceptions()).Return(new Exception[0]);
_expandedCommandFake = new ExpandedCommand(_nestedCommandMock);
_delegatingData = new EndPointDelegatingCollectionData(_endPointID, _virtualEndPointProviderStub);
_orderItem1 = DomainObjectIDs.OrderItem1.GetObject <OrderItem>();
_orderItem2 = DomainObjectIDs.OrderItem2.GetObject <OrderItem>();
ClientTransactionScope.EnterNullScope(); // no active transaction
}
public void NoAutoRollbackWhenNoneBehavior()
{
var mock = new TestableClientTransaction();
var eventCounter = new TransactionEventCounter(mock);
using (mock.EnterScope(AutoRollbackBehavior.None))
{
Order order = new DomainObjectIDs(MappingConfiguration.Current).Order1.GetObject <Order> ();
order.OrderNumber = 0xbadf00d;
order.OrderTicket = OrderTicket.NewObject();
order.OrderItems.Add(OrderItem.NewObject());
}
Assert.That(eventCounter.Rollbacks, Is.EqualTo(0));
using (mock.EnterScope(AutoRollbackBehavior.None))
{
}
Assert.That(eventCounter.Rollbacks, Is.EqualTo(0));
using (ClientTransactionScope scope = mock.EnterScope(AutoRollbackBehavior.None))
{
Order order = new DomainObjectIDs(MappingConfiguration.Current).Order1.GetObject <Order> ();
order.OrderNumber = 0xbadf00d;
scope.ScopedTransaction.Rollback();
}
Assert.That(eventCounter.Rollbacks, Is.EqualTo(1));
}
public void ExecuteCollection_NoActiveClientTransaction()
{
using (ClientTransactionScope.EnterNullScope())
{
_queryExecutor.ExecuteCollection <Order> (_someQueryModel);
}
}
public void TearDown()
{
BusinessObjectProvider.SetProvider(typeof(BindableDomainObjectProviderAttribute), null);
ClientTransactionScope.ResetActiveScope();
_serviceLocatorScope.Dispose();
}
public void ExpectFunctionalSecurityStrategyHasAccessWithMatchingScope(ClientTransactionScope expectedScope)
{
Expect.Call(_mockFunctionalSecurityStrategy.HasAccess(null, null, null, null))
.IgnoreArguments()
.WhenCalled(mi => CheckScope(expectedScope))
.Return(true);
}
public void ThreadAbortExceptionInNestedFunction()
{
var nestedFunction = new ThreadAbortTestTransactedFunction();
ClientTransactionScope originalScope = ClientTransaction.CreateRootTransaction().EnterDiscardingScope();
var parentFunction =
new CreateRootWithChildTestTransactedFunction(ClientTransactionScope.CurrentTransaction, nestedFunction);
try
{
parentFunction.Execute(Context);
Assert.Fail("Expected ThreadAbortException");
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(originalScope));
Assert.That(nestedFunction.FirstStepExecuted, Is.True);
Assert.That(nestedFunction.SecondStepExecuted, Is.False);
Assert.That(nestedFunction.ThreadAborted, Is.True);
parentFunction.Execute(Context);
Assert.That(nestedFunction.FirstStepExecuted, Is.True);
Assert.That(nestedFunction.SecondStepExecuted, Is.True);
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(originalScope));
originalScope.Leave();
}
public void HasCurrentFalseViaNullTransaction()
{
using (ClientTransactionScope.EnterNullScope())
{
Assert.That(ClientTransactionScope.HasCurrentTransaction, Is.False);
}
}
public override void TearDown()
{
ClientTransactionScope.ResetActiveScope();
_serviceLocatorScope.Dispose();
base.TearDown();
}
public void NestedScopes()
{
ClientTransaction clientTransaction1 = ClientTransaction.CreateRootTransaction();
ClientTransaction clientTransaction2 = ClientTransaction.CreateRootTransaction();
ClientTransactionScope originalScope = ClientTransactionScope.ActiveScope;
ClientTransaction original = ClientTransactionScope.CurrentTransaction;
Assert.That(original, Is.Not.SameAs(clientTransaction1));
Assert.That(original, Is.Not.SameAs(clientTransaction2));
Assert.That(original, Is.Not.Null);
using (ClientTransactionScope scope1 = clientTransaction1.EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(clientTransaction1));
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(scope1));
using (ClientTransactionScope scope2 = clientTransaction2.EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(scope2));
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(clientTransaction2));
}
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(scope1));
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(clientTransaction1));
}
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(originalScope));
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(original));
}
public void LeaveTwiceThrows()
{
ClientTransactionScope scope = ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope();
scope.Leave();
scope.Leave();
}
public void NoAutoInitializationOfCurrent()
{
using (ClientTransactionScope.EnterNullScope())
{
Assert.That(ClientTransactionScope.HasCurrentTransaction, Is.False);
Dev.Null = ClientTransactionScope.CurrentTransaction;
}
}
public override void SetUp()
{
base.SetUp();
DomainObjectsConfiguration.SetCurrent(TableInheritanceConfiguration.Instance.GetDomainObjectsConfiguration());
MappingConfiguration.SetCurrent(TableInheritanceConfiguration.Instance.GetMappingConfiguration());
ConfigurationWrapper.SetCurrent(null);
_transactionScope = ClientTransaction.CreateRootTransaction().EnterDiscardingScope();
}
public void Search_NoCurrentTransaction()
{
using (ClientTransactionScope.EnterNullScope())
{
var property = GetBusinessObjectProperty(typeof(OppositeBidirectionalBindableDomainObject), "OppositeSampleObject");
_service.Search(null, property, null);
}
}
// methods and properties
private void Step1()
{
Assert.That(FirstStepExecuted, Is.False);
Assert.That(SecondStepExecuted, Is.False);
Assert.That(ThreadAborted, Is.False);
FirstStepExecuted = true;
TransactionScopeInFirstStep = ClientTransactionScope.ActiveScope;
}
public void TearDown()
{
BusinessObjectProvider.SetProvider(typeof(BindableDomainObjectProviderAttribute), null);
ClientTransactionScope.ResetActiveScope();
SecurityConfiguration.Current.DisableAccessChecks = _disableAccessChecksBackup;
_serviceLocatorScope.Dispose();
}
public void WxeTransactedFunctionNone()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
ClientTransactionScope originalScope = ClientTransactionScope.ActiveScope;
new CreateNoneTestTransactedFunction(originalScope).Execute(Context);
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(originalScope));
}
}
public void ToCustomCollection_WithoutTransaction()
{
using (ClientTransactionScope.EnterNullScope())
{
var collection = _resultWithCustomType.ToCustomCollection();
Assert.That(collection, Is.InstanceOf(typeof(OrderCollection)));
Assert.That(collection, Is.EqualTo(new[] { _order1, _order3, _order4 }));
}
}
public void ResetScope()
{
ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope();
Assert.That(ClientTransactionScope.ActiveScope, Is.Not.Null);
Assert.That(ClientTransactionScope.HasCurrentTransaction, Is.True);
ClientTransactionScope.ResetActiveScope();
Assert.That(ClientTransactionScope.ActiveScope, Is.Null);
Assert.That(ClientTransactionScope.HasCurrentTransaction, Is.False);
}
public void WxeTransactedFunctionCreateChildIfParent()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
ClientTransactionScope originalScope = ClientTransactionScope.ActiveScope;
new CreateRootWithChildTestTransactedFunction(originalScope.ScopedTransaction, new CreateChildIfParentTestTransactedFunction()).Execute(
Context);
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(originalScope));
}
}
public void ActiveScope()
{
_outermostScope.Leave();
Assert.That(ClientTransactionScope.ActiveScope, Is.Null);
using (ClientTransactionScope scope = ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.ActiveScope, Is.Not.Null);
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(scope));
}
}
public void EnterNonDiscardingScope()
{
ClientTransactionScope outerScope = ClientTransactionScope.ActiveScope;
ClientTransaction newTransaction = ClientTransaction.CreateRootTransaction();
using (newTransaction.EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.ActiveScope, Is.Not.SameAs(outerScope));
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(newTransaction));
Assert.That(ClientTransactionScope.ActiveScope.AutoRollbackBehavior, Is.EqualTo(AutoRollbackBehavior.None));
}
}
public void EnterNullScopeSetsNullTransaction()
{
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
Assert.That(ClientTransactionScope.HasCurrentTransaction, Is.True);
using (ClientTransactionScope.EnterNullScope())
{
Assert.That(ClientTransactionScope.HasCurrentTransaction, Is.False);
}
Assert.That(ClientTransactionScope.HasCurrentTransaction, Is.True);
}
}
public void EnterScope()
{
ITransaction transaction = ClientTransaction.CreateRootTransaction().ToITransaction();
ClientTransactionScope.ResetActiveScope();
Assert.That(ClientTransactionScope.ActiveScope, Is.Null);
ITransactionScope transactionScope = transaction.EnterScope();
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(transactionScope));
Assert.That(ClientTransactionScope.ActiveScope.ScopedTransaction, Is.SameAs(((ClientTransactionWrapper)transaction).WrappedInstance));
Assert.That(ClientTransactionScope.ActiveScope.AutoRollbackBehavior, Is.EqualTo(AutoRollbackBehavior.None));
ClientTransactionScope.ResetActiveScope();
}
