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 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 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 ReadingRealRelationEndPoints_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(order1.Customer, Is.SameAs(customer)); // reloads the object because the foreign key is stored in order1
AssertObjectWasLoaded(listenerMock, order1);
Assert.That(order1.State, Is.EqualTo(StateType.Unchanged));
}
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 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 override void SetUp()
{
base.SetUp();
_listenerDynamicMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction);
}
public void UnloadVirtualEndPointAndItemData_Collection_Events()
{
var order1 = DomainObjectIDs.Order1.GetObject <Order> ();
var orderItemA = order1.OrderItems[0];
var orderItemB = order1.OrderItems[1];
var listenerMock = ClientTransactionTestHelperWithMocks.CreateAndAddListenerMock(TestableClientTransaction);
using (listenerMock.GetMockRepository().Ordered())
{
listenerMock
.Expect(mock => mock.ObjectsUnloading(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { orderItemA, orderItemB })))
.WhenCalled(
mi =>
{
Assert.That(orderItemA.OnUnloadingCalled, Is.False, "items unloaded after this method is called");
Assert.That(orderItemB.OnUnloadingCalled, Is.False, "items unloaded after this method is called");
Assert.That(orderItemA.OnUnloadedCalled, Is.False, "items unloaded after this method is called");
Assert.That(orderItemB.OnUnloadedCalled, Is.False, "items unloaded after this method is called");
Assert.That(orderItemA.State, Is.EqualTo(StateType.Unchanged));
Assert.That(orderItemB.State, Is.EqualTo(StateType.Unchanged));
});
listenerMock
.Expect(mock => mock.ObjectsUnloaded(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { orderItemA, orderItemB })))
.WhenCalled(
mi =>
{
Assert.That(orderItemA.OnUnloadingCalled, Is.True, "items unloaded before this method is called");
Assert.That(orderItemB.OnUnloadingCalled, Is.True, "items unloaded before this method is called");
Assert.That(orderItemA.OnUnloadedCalled, Is.True, "items unloaded before this method is called");
Assert.That(orderItemB.OnUnloadedCalled, Is.True, "items unloaded before this method is called");
Assert.That(orderItemA.State, Is.EqualTo(StateType.NotLoadedYet));
Assert.That(orderItemB.State, Is.EqualTo(StateType.NotLoadedYet));
});
}
listenerMock.Replay();
try
{
UnloadService.UnloadVirtualEndPointAndItemData(TestableClientTransaction, order1.OrderItems.AssociatedEndPointID);
listenerMock.VerifyAllExpectations();
}
finally
{
listenerMock.BackToRecord(); // For Discarding
}
Assert.That(orderItemA.UnloadingState, Is.EqualTo(StateType.Unchanged), "OnUnloading before state change");
Assert.That(orderItemB.UnloadingState, Is.EqualTo(StateType.Unchanged), "OnUnloading before state change");
Assert.That(orderItemA.OnUnloadingDateTime, Is.LessThan(orderItemB.OnUnloadingDateTime), "orderItemA.OnUnloading before orderItemB.OnUnloading");
Assert.That(orderItemA.UnloadedState, Is.EqualTo(StateType.NotLoadedYet), "OnUnloaded after state change");
Assert.That(orderItemB.UnloadedState, Is.EqualTo(StateType.NotLoadedYet), "OnUnloaded after state change");
Assert.That(orderItemA.OnUnloadedDateTime, Is.GreaterThan(orderItemB.OnUnloadedDateTime), "orderItemA.OnUnloaded after orderItemB.OnUnloaded");
}