public void Sort_TriggersOnReplaceDataEvent_ButNoRelationChangeEvents() { var eventReceiverMock = MockRepository.GenerateStrictMock <OrderCollection.ICollectionEventReceiver>(); eventReceiverMock.Expect(mock => mock.OnReplaceData()); eventReceiverMock.Replay(); var orderCollection = _owningCustomer.Orders; orderCollection.SetEventReceiver(eventReceiverMock); var eventListenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); try { eventListenerMock .Expect( mock => mock.VirtualRelationEndPointStateUpdated( TestableClientTransaction, RelationEndPointID.Resolve(_owningCustomer, c => c.Orders), null)); eventListenerMock.Replay(); orderCollection.Sort(_reversingComparison); eventReceiverMock.VerifyAllExpectations(); eventListenerMock.VerifyAllExpectations(); } finally { TestableClientTransaction.RemoveListener(eventListenerMock); } }
public void ChangesToDataState_CauseTransactionListenerNotifications() { var listener = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(_customerEndPoint.ClientTransaction); _customerEndPoint.Collection.Add(_order3); listener.AssertWasCalled(mock => mock.VirtualRelationEndPointStateUpdated(_customerEndPoint.ClientTransaction, _customerEndPoint.ID, null)); }
public void UnloadData_NonLoadedObject() { ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); UnloadService.UnloadData(TestableClientTransaction, DomainObjectIDs.Order1); Assert.That(TestableClientTransaction.GetEnlistedDomainObject(DomainObjectIDs.Order1), Is.Null); }
private void InstallUnlockWatcher(ClientTransaction clientTransaction) { var listener = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(clientTransaction); listener .Stub(stub => stub.ObjectMarkedInvalid(Arg <ClientTransaction> .Is.Anything, Arg <DomainObject> .Is.Anything)) .WhenCalled( mi => Assert.That(((ClientTransaction)mi.Arguments[0]).IsWriteable, Is.True, "MarkInvalid requires the transaction to be unlocked.")); }
public void CommitRoot() { var newObject = ClassWithAllDataTypes.NewObject(); newObject.DateTimeProperty = new DateTime(2012, 12, 12); newObject.DateProperty = new DateTime(2012, 12, 12); Assert.That(newObject.State, Is.EqualTo(StateType.New)); var changedObject = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> (); ++changedObject.Int32Property; Assert.That(changedObject.State, Is.EqualTo(StateType.Changed)); var unchangedObject = DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> (); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Unchanged)); newObject.RegisterForCommit(); changedObject.RegisterForCommit(); unchangedObject.RegisterForCommit(); Assert.That(newObject.State, Is.EqualTo(StateType.New)); CheckNotMarkedAsChanged(newObject); Assert.That(changedObject.State, Is.EqualTo(StateType.Changed)); CheckMarkedAsChanged(changedObject); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Changed)); CheckMarkedAsChanged(unchangedObject); var objectEventReceiverMock = MockRepository.GenerateMock <DomainObjectMockEventReceiver> (newObject); var transactionEventReceiverMock = MockRepository.GenerateMock <ClientTransactionMockEventReceiver> (TestableClientTransaction); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); SetDatabaseModifyable(); CommitTransactionAndCheckTimestamps(newObject, changedObject, unchangedObject); listenerMock.AssertWasCalled( mock => mock.TransactionCommitting( Arg.Is(TestableClientTransaction), Arg <ReadOnlyCollection <DomainObject> > .List.Equivalent(new[] { newObject, changedObject, unchangedObject }), Arg <ICommittingEventRegistrar> .Is.Anything)); listenerMock.AssertWasCalled( mock => mock.TransactionCommitValidate( Arg.Is(TestableClientTransaction), Arg <ReadOnlyCollection <PersistableData> > .Matches( x => x.Select(d => d.DomainObject).SetEquals(new[] { newObject, changedObject, unchangedObject })))); objectEventReceiverMock.AssertWasCalled(mock => mock.Committing()); objectEventReceiverMock.AssertWasCalled(mock => mock.Committed()); transactionEventReceiverMock.AssertWasCalled(mock => mock.Committing(newObject, changedObject, unchangedObject)); transactionEventReceiverMock.AssertWasCalled(mock => mock.Committed(newObject, changedObject, unchangedObject)); Assert.That(newObject.State, Is.EqualTo(StateType.Unchanged)); CheckNotMarkedAsChanged(newObject); Assert.That(changedObject.State, Is.EqualTo(StateType.Unchanged)); CheckNotMarkedAsChanged(changedObject); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Unchanged)); CheckNotMarkedAsChanged(unchangedObject); }
public void UnloadVirtualEndPoint_Collection_AlreadyUnloaded() { var customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var endPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(customer.Orders); UnloadService.UnloadVirtualEndPoint(TestableClientTransaction, endPoint.ID); ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); Assert.That(endPoint.IsDataComplete, Is.False); UnloadService.UnloadVirtualEndPoint(TestableClientTransaction, endPoint.ID); }
public void UnloadVirtualEndPointAndItemData_DoesNothing_IfEndPointNotLoaded() { var endPointID = RelationEndPointObjectMother.CreateRelationEndPointID(DomainObjectIDs.Customer1, "Orders"); Assert.That(TestableClientTransaction.DataManager.GetRelationEndPointWithoutLoading(endPointID), Is.Null); ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); UnloadService.UnloadVirtualEndPointAndItemData(TestableClientTransaction, endPointID); Assert.That(TestableClientTransaction.DataManager.GetRelationEndPointWithoutLoading(endPointID), Is.Null); }
public override void SetUp() { base.SetUp(); _loadedObject1 = DomainObjectMother.GetUnchangedObject(TestableClientTransaction, DomainObjectIDs.Order1); _loadedObject2 = DomainObjectMother.GetUnchangedObject(TestableClientTransaction, DomainObjectIDs.Order3); _notLoadedObject1 = DomainObjectMother.GetNotLoadedObject(TestableClientTransaction, DomainObjectIDs.Order4); _notLoadedObject2 = DomainObjectMother.GetNotLoadedObject(TestableClientTransaction, DomainObjectIDs.Order5); _invalidObject = DomainObjectMother.GetInvalidObject(TestableClientTransaction); _notLoadedNonExistingObject = DomainObjectMother.GetNotLoadedObject(TestableClientTransaction, new ObjectID(typeof(ClassWithAllDataTypes), Guid.NewGuid())); _listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); }
public void ReadingOppositeCollectionEndPoints_ReloadsObject() { var order1 = DomainObjectIDs.Order1.GetObject <Order> (); var customer = order1.Customer; UnloadService.UnloadData(TestableClientTransaction, order1.ID); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); Assert.That(order1.State, Is.EqualTo(StateType.NotLoadedYet)); Assert.That(customer.Orders, Has.Member(order1)); // enumerating reloads the relation contents because the foreign key is stored in order1 AssertObjectWasLoadedAmongOthers(listenerMock, order1); }
public void ChangingRealRelationEndPoints_ReloadsObject() { var order1 = DomainObjectIDs.Order1.GetObject <Order> (); UnloadService.UnloadData(TestableClientTransaction, order1.ID); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); Assert.That(order1.State, Is.EqualTo(StateType.NotLoadedYet)); order1.Customer = Customer.NewObject(); // reloads the object because the foreign key is stored in order1 AssertObjectWasLoaded(listenerMock, order1); Assert.That(order1.State, Is.EqualTo(StateType.Changed)); }
public void EnsureDataAvailable_ReloadsObject() { var order1 = DomainObjectIDs.Order1.GetObject <Order> (); UnloadService.UnloadData(TestableClientTransaction, order1.ID); Assert.That(order1.State, Is.EqualTo(StateType.NotLoadedYet)); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); order1.EnsureDataAvailable(); AssertObjectWasLoaded(listenerMock, order1); Assert.That(order1.State, Is.EqualTo(StateType.Unchanged)); }
public void WritingValueProperties_ReloadsObject() { var order1 = DomainObjectIDs.Order1.GetObject <Order> (); UnloadService.UnloadData(TestableClientTransaction, order1.ID); Assert.That(order1.State, Is.EqualTo(StateType.NotLoadedYet)); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); order1.OrderNumber = 4711; AssertObjectWasLoaded(listenerMock, order1); Assert.That(order1.State, Is.EqualTo(StateType.Changed)); }
public void UnloadData_AlreadyUnloaded() { var order1 = DomainObjectIDs.Order1.GetObject <Order> (); UnloadService.UnloadData(TestableClientTransaction, order1.ID); Assert.That(order1.State, Is.EqualTo(StateType.NotLoadedYet)); Assert.That(TestableClientTransaction.GetEnlistedDomainObject(DomainObjectIDs.Order1), Is.SameAs(order1)); ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); UnloadService.UnloadData(TestableClientTransaction, order1.ID); Assert.That(order1.State, Is.EqualTo(StateType.NotLoadedYet)); }
public void Reset_RaisesUnregisteringEvents() { var endPointID = RelationEndPointObjectMother.CreateRelationEndPointID(DomainObjectIDs.Customer1, "Orders"); var endPointStub = MockRepository.GenerateStub <IRelationEndPoint> (); endPointStub.Stub(stub => stub.ID).Return(endPointID); RelationEndPointManagerTestHelper.AddEndPoint(_relationEndPointManager, endPointStub); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(_relationEndPointManager.ClientTransaction); _relationEndPointManager.Reset(); listenerMock.AssertWasCalled(mock => mock.RelationEndPointMapUnregistering(_relationEndPointManager.ClientTransaction, endPointID)); }
public void GetValueWithoutEvents_NoEvents() { var clientTransactionMock = new TestableClientTransaction(); using (clientTransactionMock.EnterDiscardingScope()) { var dataContainer = Order.NewObject().InternalDataContainer; var propertyDefinition = GetPropertyDefinition(typeof(Order), "OrderNumber"); ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(clientTransactionMock); dataContainer.GetValueWithoutEvents(propertyDefinition, ValueAccess.Current); } }
public void UnloadVirtualEndPointAndItemData_Object_Events() { var order1 = DomainObjectIDs.Order1.GetObject <Order> (); var orderTicket = order1.OrderTicket; var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); using (listenerMock.GetMockRepository().Ordered()) { listenerMock .Expect(mock => mock.ObjectsUnloading( Arg.Is(TestableClientTransaction), Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { orderTicket }))) .WhenCalled( mi => { Assert.That(orderTicket.OnUnloadingCalled, Is.False, "items unloaded after this method is called"); Assert.That(orderTicket.OnUnloadedCalled, Is.False, "items unloaded after this method is called"); Assert.That(orderTicket.State, Is.EqualTo(StateType.Unchanged)); }); listenerMock .Expect(mock => mock.ObjectsUnloaded( Arg.Is(TestableClientTransaction), Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { orderTicket }))) .WhenCalled( mi => { Assert.That(orderTicket.OnUnloadingCalled, Is.True, "items unloaded before this method is called"); Assert.That(orderTicket.OnUnloadedCalled, Is.True, "items unloaded before this method is called"); Assert.That(orderTicket.State, Is.EqualTo(StateType.NotLoadedYet)); }); } listenerMock.Replay(); try { UnloadService.UnloadVirtualEndPointAndItemData(TestableClientTransaction, RelationEndPointID.Resolve(order1, o => o.OrderTicket)); listenerMock.VerifyAllExpectations(); } finally { listenerMock.BackToRecord(); // For Discarding } Assert.That(orderTicket.UnloadingState, Is.EqualTo(StateType.Unchanged), "OnUnloading before state change"); Assert.That(orderTicket.UnloadedState, Is.EqualTo(StateType.NotLoadedYet), "OnUnloaded after state change"); }
public void UnloadVirtualEndPoint_Object_AlreadyUnloaded() { var order = DomainObjectIDs.Order1.GetObject <Order> (); TestableClientTransaction.EnsureDataComplete(RelationEndPointID.Resolve(order, o => o.OrderTicket)); CheckVirtualEndPointExistsAndComplete(order, "OrderTicket", true, true); UnloadService.UnloadVirtualEndPoint(TestableClientTransaction, RelationEndPointID.Resolve(order, o => o.OrderTicket)); CheckVirtualEndPointExistsAndComplete(order, "OrderTicket", true, false); ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); UnloadService.UnloadVirtualEndPoint(TestableClientTransaction, RelationEndPointID.Resolve(order, o => o.OrderTicket)); }
public void SetValue_WithRelatedObject_Notifies() { var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); var order = DomainObjectIDs.Order1.GetObject <Order> (); var oldTicket = order.OrderTicket; var newTicket = OrderTicket.NewObject(); var propertyAccessor = CreateAccessor(order, "OrderTicket"); propertyAccessor.SetValue(newTicket); listenerMock.AssertWasCalled( mock => mock.RelationChanged(TestableClientTransaction, order, propertyAccessor.PropertyData.RelationEndPointDefinition, oldTicket, newTicket)); }
public void TryUnloadVirtualEndPointAndItemData_Success_IfDataNotComplete() { var customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var ordersEndPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(customer.Orders); UnloadService.UnloadVirtualEndPoint(TestableClientTransaction, ordersEndPoint.ID); Assert.That(ordersEndPoint.IsDataComplete, Is.False); ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); var result = UnloadService.TryUnloadVirtualEndPointAndItemData(TestableClientTransaction, ordersEndPoint.ID); Assert.That(result, Is.True); Assert.That(ordersEndPoint.IsDataComplete, Is.False); }
public void AddingToCollectionEndPoint_ReloadsObjectBeingAdded() { var customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var order3 = DomainObjectIDs.Order3.GetObject <Order> (); UnloadService.UnloadData(TestableClientTransaction, order3.ID); Assert.That(order3.State, Is.EqualTo(StateType.NotLoadedYet)); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); customer.Orders.Add(order3); // reloads order3 because order3's foreign key is changed AssertObjectWasLoaded(listenerMock, order3); Assert.That(order3.State, Is.EqualTo(StateType.Changed)); }
public void SetValue_WithObjectList_Notifies() { var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); IndustrialSector sector = IndustrialSector.NewObject(); var newCompanies = new ObjectList <Company> { Company.NewObject() }; var propertyAccessor = CreateAccessor(sector, "Companies"); propertyAccessor.SetValue(newCompanies); listenerMock.AssertWasCalled( mock => mock.RelationChanged(TestableClientTransaction, sector, propertyAccessor.PropertyData.RelationEndPointDefinition, null, newCompanies[0])); }
public void CopyCollectionEventHandlers_DoesNotLoadRelatedObjectsInOriginalTransaction() { Order order = DomainObjectIDs.Order1.GetObject <Order> (); int loadedObjectsBefore = TestableClientTransaction.DataManager.DataContainers.Count; ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope()) { ClientTransaction.Current.CopyCollectionEventHandlers(order, TestableClientTransaction); } int loadedObjectsAfter = TestableClientTransaction.DataManager.DataContainers.Count; Assert.That(loadedObjectsAfter, Is.EqualTo(loadedObjectsBefore)); }
public void Rollback() { var newObject = ClassWithAllDataTypes.NewObject(); Assert.That(newObject.State, Is.EqualTo(StateType.New)); var changedObject = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> (); ++changedObject.Int32Property; Assert.That(changedObject.State, Is.EqualTo(StateType.Changed)); var unchangedObject = DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> (); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Unchanged)); newObject.RegisterForCommit(); changedObject.RegisterForCommit(); unchangedObject.RegisterForCommit(); Assert.That(newObject.State, Is.EqualTo(StateType.New)); CheckNotMarkedAsChanged(newObject); Assert.That(changedObject.State, Is.EqualTo(StateType.Changed)); CheckMarkedAsChanged(changedObject); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Changed)); CheckMarkedAsChanged(unchangedObject); var objectEventReceiverMock = MockRepository.GenerateMock <DomainObjectMockEventReceiver> (unchangedObject); var transactionEventReceiverMock = MockRepository.GenerateMock <ClientTransactionMockEventReceiver> (TestableClientTransaction); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); TestableClientTransaction.Rollback(); listenerMock.AssertWasCalled( mock => mock.TransactionRollingBack( Arg.Is(TestableClientTransaction), Arg <ReadOnlyCollection <DomainObject> > .List.Equivalent(new[] { newObject, changedObject, unchangedObject }))); objectEventReceiverMock.AssertWasCalled(mock => mock.RollingBack()); objectEventReceiverMock.AssertWasCalled(mock => mock.RolledBack()); transactionEventReceiverMock.AssertWasCalled(mock => mock.RollingBack(newObject, changedObject, unchangedObject)); transactionEventReceiverMock.AssertWasCalled(mock => mock.RolledBack(changedObject, unchangedObject)); Assert.That(newObject.State, Is.EqualTo(StateType.Invalid)); Assert.That(changedObject.State, Is.EqualTo(StateType.Unchanged)); CheckNotMarkedAsChanged(changedObject); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Unchanged)); CheckNotMarkedAsChanged(unchangedObject); }
public void Compare_DoesNotTriggerEvents() { var domainObject1 = DomainObjectMother.CreateFakeObject <Order> (); var domainObject2 = DomainObjectMother.CreateFakeObject <Order> (); var dataContainer1 = PrepareDataContainer(_dataManagerStub, domainObject1, 1); var dataContainer2 = PrepareDataContainer(_dataManagerStub, domainObject2, 2); var transaction = ClientTransaction.CreateRootTransaction(); ClientTransactionTestHelper.RegisterDataContainer(transaction, dataContainer1); ClientTransactionTestHelper.RegisterDataContainer(transaction, dataContainer2); ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(transaction); var specification = new SortedPropertySpecification(_orderNumberPropertyDefinition, SortOrder.Descending); var comparer = new SortedPropertyComparer(specification, _dataManagerStub); Assert.That(comparer.Compare(domainObject1, domainObject1), Is.EqualTo(0)); }
public void ChangingCollectionEndPoint_ReloadsCollectionAndObject() { var order1 = DomainObjectIDs.Order1.GetObject <Order> (); var customer = order1.Customer; var customerOrders = customer.Orders; UnloadService.UnloadData(TestableClientTransaction, order1.ID); Assert.That(order1.State, Is.EqualTo(StateType.NotLoadedYet)); Assert.That(customerOrders.IsDataComplete, Is.False); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); customer.Orders.Add(Order.NewObject()); // reloads the relation contents and thus the object AssertObjectWasLoadedAmongOthers(listenerMock, order1); Assert.That(order1.State, Is.EqualTo(StateType.Unchanged)); Assert.That(customerOrders.IsDataComplete, Is.True); }
public void CommitSub() { ClassWithAllDataTypes newObject; ClassWithAllDataTypes changedObject; ClassWithAllDataTypes unchangedObject; using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope()) { newObject = ClassWithAllDataTypes.NewObject(); Assert.That(newObject.State, Is.EqualTo(StateType.New)); changedObject = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> (); ++changedObject.Int32Property; Assert.That(changedObject.State, Is.EqualTo(StateType.Changed)); unchangedObject = DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> (); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Unchanged)); newObject.RegisterForCommit(); changedObject.RegisterForCommit(); unchangedObject.RegisterForCommit(); Assert.That(newObject.State, Is.EqualTo(StateType.New)); CheckNotMarkedAsChanged(newObject); Assert.That(changedObject.State, Is.EqualTo(StateType.Changed)); CheckMarkedAsChanged(changedObject); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Changed)); CheckMarkedAsChanged(unchangedObject); var objectEventReceiverMock = MockRepository.GenerateMock <DomainObjectMockEventReceiver> (newObject); var transactionEventReceiverMock = MockRepository.GenerateMock <ClientTransactionMockEventReceiver> (ClientTransaction.Current); var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(ClientTransaction.Current); try { ClientTransaction.Current.Commit(); } finally { ClientTransactionTestHelper.RemoveListener(ClientTransaction.Current, listenerMock); } listenerMock.AssertWasCalled( mock => mock.TransactionCommitting( Arg.Is(ClientTransaction.Current), Arg <ReadOnlyCollection <DomainObject> > .List.Equivalent(new[] { newObject, changedObject, unchangedObject }), Arg <ICommittingEventRegistrar> .Is.Anything)); listenerMock.AssertWasCalled( mock => mock.TransactionCommitValidate( Arg.Is(ClientTransaction.Current), Arg <ReadOnlyCollection <PersistableData> > .Matches( x => x.Select(d => d.DomainObject).SetEquals(new[] { newObject, changedObject, unchangedObject })))); objectEventReceiverMock.AssertWasCalled(mock => mock.Committing()); objectEventReceiverMock.AssertWasCalled(mock => mock.Committed()); transactionEventReceiverMock.AssertWasCalled(mock => mock.Committing(newObject, changedObject, unchangedObject)); transactionEventReceiverMock.AssertWasCalled(mock => mock.Committed(newObject, changedObject, unchangedObject)); Assert.That(newObject.State, Is.EqualTo(StateType.Unchanged)); CheckNotMarkedAsChanged(newObject); Assert.That(changedObject.State, Is.EqualTo(StateType.Unchanged)); CheckNotMarkedAsChanged(changedObject); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Unchanged)); CheckNotMarkedAsChanged(unchangedObject); } Assert.That(newObject.State, Is.EqualTo(StateType.New)); CheckNotMarkedAsChanged(newObject); Assert.That(changedObject.State, Is.EqualTo(StateType.Changed)); CheckMarkedAsChanged(changedObject); Assert.That(unchangedObject.State, Is.EqualTo(StateType.Changed)); CheckMarkedAsChanged(unchangedObject); }
public void EnsureDataComplete_DoesNothing() { ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); _endPoint.EnsureDataComplete(); }
public override void SetUp() { base.SetUp(); _listenerDynamicMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction); }
public void End_DoesNothing() { ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(_transaction); _command.End(); }
protected void EnsureTransactionThrowsOnLoad() { ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvent( ClientTransaction.Current, mock => mock.ObjectsLoading(Arg <ClientTransaction> .Is.Anything, Arg <ReadOnlyCollection <ObjectID> > .Is.Anything)); }