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