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