public void LinqCustomQuery_CallsFilterCustomQueryResult()
{
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener>();
listenerMock
.Expect(
mock => mock.FilterCustomQueryResult(
Arg.Is(TestableClientTransaction),
Arg <IQuery> .Is.Anything,
Arg <IEnumerable <int> > .List.Equal(new[] { 1, 2, 3, 4, 5 })))
.Return(new[] { 1, 2, 3 });
TestableClientTransaction.AddListener(listenerMock);
try
{
var query = from o in QueryFactory.CreateLinqQuery <Order>() where o.OrderNumber <= 5 orderby o.OrderNumber select o.OrderNumber;
var result = query.ToArray();
listenerMock.VerifyAllExpectations();
Assert.That(result, Is.EqualTo(new[] { 1, 2, 3 }));
}
finally
{
TestableClientTransaction.RemoveListener(listenerMock);
}
}
public void Events_New_WithHierarchy()
{
Order newObject;
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
var middleTopTransaction = ClientTransaction.Current;
newObject = Order.NewObject();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
var middleBottomTransaction = ClientTransaction.Current;
newObject.EnsureDataAvailable();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
var subSubTransaction = ClientTransaction.Current;
Assert.That(newObject.TransactionContext[TestableClientTransaction].State, Is.EqualTo(StateType.Invalid));
Assert.That(newObject.TransactionContext[middleTopTransaction].State, Is.EqualTo(StateType.New));
Assert.That(newObject.TransactionContext[middleBottomTransaction].State, Is.EqualTo(StateType.Unchanged));
Assert.That(newObject.TransactionContext[subSubTransaction].State, Is.EqualTo(StateType.NotLoadedYet));
var clientTransactionListener = MockRepository.GenerateMock <IClientTransactionListener>();
TestableClientTransaction.AddListener(clientTransactionListener);
ClientTransactionTestHelper.AddListener(middleTopTransaction, clientTransactionListener);
ClientTransactionTestHelper.AddListener(middleBottomTransaction, clientTransactionListener);
ClientTransactionTestHelper.AddListener(subSubTransaction, clientTransactionListener);
try
{
UnloadService.UnloadAll(ClientTransaction.Current);
}
finally
{
TestableClientTransaction.RemoveListener(clientTransactionListener);
ClientTransactionTestHelper.RemoveListener(middleTopTransaction, clientTransactionListener);
ClientTransactionTestHelper.RemoveListener(middleBottomTransaction, clientTransactionListener);
ClientTransactionTestHelper.RemoveListener(subSubTransaction, clientTransactionListener);
}
clientTransactionListener.AssertWasCalled(mock => mock.ObjectMarkedInvalid(middleTopTransaction, newObject));
clientTransactionListener.AssertWasCalled(
mock => mock.DataContainerMapUnregistering(Arg.Is(middleTopTransaction), Arg <DataContainer> .Matches(dc => dc.ID == newObject.ID)));
clientTransactionListener.AssertWasCalled(
mock =>
mock.DataContainerMapUnregistering(Arg.Is(middleBottomTransaction), Arg <DataContainer> .Matches(dc => dc.ID == newObject.ID)));
clientTransactionListener.AssertWasCalled(mock => mock.ObjectMarkedInvalid(subSubTransaction, newObject));
}
}
}
}
public void Events_New()
{
var order = Order.NewObject();
var mockRepository = new MockRepository();
var clientTransactionListener = mockRepository.DynamicMock <IClientTransactionListener> ();
var unloadEventReceiver = mockRepository.StrictMock <IUnloadEventReceiver> ();
order.SetUnloadEventReceiver(unloadEventReceiver);
using (mockRepository.Ordered())
{
clientTransactionListener
.Expect(
mock =>
mock.ObjectsUnloading(
Arg.Is(TestableClientTransaction), Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { order })));
unloadEventReceiver.Expect(mock => mock.OnUnloading(order));
using (mockRepository.Unordered())
{
clientTransactionListener.Expect(
mock => mock.RelationEndPointMapUnregistering(Arg.Is(TestableClientTransaction), Arg <RelationEndPointID> .Is.Anything)).Repeat.AtLeastOnce();
clientTransactionListener.Expect(mock => mock.DataContainerMapUnregistering(TestableClientTransaction, order.InternalDataContainer));
clientTransactionListener.Expect(mock => mock.ObjectMarkedInvalid(TestableClientTransaction, order));
}
unloadEventReceiver.Expect(mock => mock.OnUnloaded(order));
clientTransactionListener
.Expect(
mock =>
mock.ObjectsUnloaded(
Arg.Is(TestableClientTransaction), Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { order })));
}
mockRepository.ReplayAll();
TestableClientTransaction.AddListener(clientTransactionListener);
try
{
UnloadService.UnloadAll(TestableClientTransaction);
}
finally
{
TestableClientTransaction.RemoveListener(clientTransactionListener);
}
mockRepository.VerifyAll();
}
public void CollectionQuery_CallsFilterQueryResult_AndAllowsGetObjectDuringFiltering()
{
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener> ();
listenerMock
.Expect(mock => mock.FilterQueryResult(Arg.Is(TestableClientTransaction), Arg <QueryResult <DomainObject> > .Is.Anything))
.Return(TestQueryFactory.CreateTestQueryResult <DomainObject> ())
.WhenCalled(mi => DomainObjectIDs.OrderItem1.GetObject <OrderItem>());
TestableClientTransaction.AddListener(listenerMock);
var query = QueryFactory.CreateQueryFromConfiguration("OrderQuery");
query.Parameters.Add("customerID", DomainObjectIDs.Customer1);
TestableClientTransaction.QueryManager.GetCollection(query);
listenerMock.VerifyAllExpectations();
listenerMock.BackToRecord(); // For Discarding
}
public void InvokesFilterQueryResultEvent()
{
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener>();
var fakeResult = new[] { new object[0] };
listenerMock
.Expect(
mock => mock.FilterCustomQueryResult(
Arg.Is(TestableClientTransaction), Arg.Is(_query), Arg <IEnumerable <object[]> > .Matches(e => e.Count() == 2)))
.Return(fakeResult);
TestableClientTransaction.AddListener(listenerMock);
var result = QueryManager.GetCustom(_query, QueryResultRowTestHelper.ExtractRawValues);
Assert.That(result, Is.SameAs(fakeResult));
}
public void OppositeObjectID_Get_DoesNotRaisePropertyReadEvents()
{
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener> ();
TestableClientTransaction.AddListener(listenerMock);
Dev.Null = _endPoint.OppositeObjectID;
listenerMock.AssertWasNotCalled(mock => mock.PropertyValueReading(
Arg <ClientTransaction> .Is.Anything,
Arg <DomainObject> .Is.Anything,
Arg <PropertyDefinition> .Is.Anything,
Arg <ValueAccess> .Is.Anything));
listenerMock.AssertWasNotCalled(mock => mock.PropertyValueRead(
Arg <ClientTransaction> .Is.Anything,
Arg <DomainObject> .Is.Anything,
Arg <PropertyDefinition> .Is.Anything,
Arg <object> .Is.Anything,
Arg <ValueAccess> .Is.Anything));
}
public void GetObjects_NewObjects_Events()
{
var expectedObjects = new DomainObject[] { Order.NewObject(), OrderItem.NewObject() };
_eventReceiver.Clear();
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener> ();
TestableClientTransaction.AddListener(listenerMock);
LifetimeService.GetObjects <DomainObject> (TestableClientTransaction, expectedObjects[0].ID, expectedObjects[1].ID);
Assert.That(_eventReceiver.LoadedDomainObjectLists, Is.Empty);
listenerMock.AssertWasNotCalled(mock => mock.ObjectsLoading(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <ObjectID> > .Is.Anything));
listenerMock.AssertWasNotCalled(mock => mock.ObjectsLoaded(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <DomainObject> > .Is.Anything));
}
public void GetObjects_LoadedObjects_Events()
{
DomainObjectIDs.Order1.GetObject <Order> ();
DomainObjectIDs.Order3.GetObject <Order> ();
DomainObjectIDs.OrderItem1.GetObject <OrderItem>();
_eventReceiver.Clear();
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener> ();
TestableClientTransaction.AddListener(listenerMock);
LifetimeService.GetObjects <DomainObject> (TestableClientTransaction, DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.OrderItem1);
Assert.That(_eventReceiver.LoadedDomainObjectLists, Is.Empty);
listenerMock.AssertWasNotCalled(mock => mock.ObjectsLoading(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <ObjectID> > .Is.Anything));
listenerMock.AssertWasNotCalled(mock => mock.ObjectsLoaded(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <DomainObject> > .Is.Anything));
}
public void GetObjects_UnloadedObjects_Events()
{
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener> ();
TestableClientTransaction.AddListener(listenerMock);
DomainObject[] objects = LifetimeService.GetObjects <DomainObject> (
TestableClientTransaction,
DomainObjectIDs.Order1,
DomainObjectIDs.Order3,
DomainObjectIDs.OrderItem1);
Assert.That(_eventReceiver.LoadedDomainObjectLists.Count, Is.EqualTo(1));
Assert.That(_eventReceiver.LoadedDomainObjectLists[0], Is.EqualTo(objects));
listenerMock.AssertWasCalled(mock => mock.ObjectsLoading(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <ObjectID> > .List.Equal(new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.OrderItem1 })));
listenerMock.AssertWasCalled(mock => mock.ObjectsLoaded(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equal(objects)));
}
public void Events_EmptyTransaction()
{
var mockRepository = new MockRepository();
// Actual events are more comprehensive, since all opposite objects are also unloaded. We only test for some of them, so use a dynamic mock.
var clientTransactionListener = mockRepository.DynamicMock <IClientTransactionListener> ();
mockRepository.ReplayAll();
TestableClientTransaction.AddListener(clientTransactionListener);
try
{
UnloadService.UnloadAll(TestableClientTransaction);
}
finally
{
TestableClientTransaction.RemoveListener(clientTransactionListener);
}
clientTransactionListener.AssertWasNotCalled(
mock => mock.ObjectsUnloading(Arg <ClientTransaction> .Is.Anything, Arg <ReadOnlyCollection <DomainObject> > .Is.Anything));
clientTransactionListener.AssertWasNotCalled(
mock => mock.ObjectsUnloaded(Arg <ClientTransaction> .Is.Anything, Arg <ReadOnlyCollection <DomainObject> > .Is.Anything));
}
public void Events_Cancellation()
{
var order = LoadOrderWithRelations(DomainObjectIDs.Order1);
var mockRepository = new MockRepository();
var clientTransactionListener = mockRepository.StrictMock <IClientTransactionListener> ();
var unloadEventReceiver = mockRepository.StrictMock <IUnloadEventReceiver> ();
var exception = new Exception("Test");
order.SetUnloadEventReceiver(unloadEventReceiver);
using (mockRepository.Ordered())
{
clientTransactionListener
.Expect(
mock =>
mock.ObjectsUnloading(
Arg.Is(TestableClientTransaction), Arg <ReadOnlyCollection <DomainObject> > .List.ContainsAll(new[] { order })));
unloadEventReceiver.Expect(mock => mock.OnUnloading(order)).Throw(exception);
}
mockRepository.ReplayAll();
TestableClientTransaction.AddListener(clientTransactionListener);
try
{
Assert.That(() => UnloadService.UnloadAll(TestableClientTransaction), Throws.Exception.SameAs(exception));
}
finally
{
TestableClientTransaction.RemoveListener(clientTransactionListener);
}
mockRepository.VerifyAll();
CheckDataAndEndPoints(order, true);
}
public void CopyCollectionEventHandlers_DoesNotLoadRelatedObjectContentsInDestinationTransaction()
{
var mockRepository = new MockRepository();
var listenerMock = mockRepository.StrictMock <IClientTransactionListener> ();
var innerTransaction = new TestableClientTransaction();
listenerMock.Stub(stub => stub.TransactionDiscard(innerTransaction));
listenerMock.DataContainerMapRegistering(null, null);
LastCall.IgnoreArguments().Repeat.Any();
listenerMock.RelationEndPointMapRegistering(null, null);
LastCall.IgnoreArguments().Repeat.Any();
listenerMock.VirtualRelationEndPointStateUpdated(null, null, null);
LastCall.IgnoreArguments().Repeat.Any();
mockRepository.ReplayAll();
Order order = DomainObjectIDs.Order1.GetObject <Order> ();
order.OrderItems.Added += delegate { };
using (innerTransaction.EnterDiscardingScope())
{
// preload order, but not orderItems
order.GetHandle().GetObject();
innerTransaction.AddListener(listenerMock);
int loadedObjectsBefore = innerTransaction.DataManager.DataContainers.Count;
innerTransaction.CopyCollectionEventHandlers(order, TestableClientTransaction);
int loadedObjectsAfter = innerTransaction.DataManager.DataContainers.Count;
Assert.That(loadedObjectsAfter, Is.EqualTo(loadedObjectsBefore));
}
mockRepository.VerifyAll();
}
public void Events_Recalculation()
{
var order1 = DomainObjectIDs.Order1.GetObject <Order> ();
var order3 = (Order)LifetimeService.GetObjectReference(TestableClientTransaction, DomainObjectIDs.Order3);
var order4 = (Order)LifetimeService.GetObjectReference(TestableClientTransaction, DomainObjectIDs.Order4);
var mockRepository = new MockRepository();
// Actual events are more comprehensive, since all opposite objects are also unloaded. We only test for some of them, so use a dynamic mock.
var clientTransactionListener = mockRepository.DynamicMock <IClientTransactionListener> ();
var unloadEventReceiver = mockRepository.StrictMock <IUnloadEventReceiver> ();
order1.SetUnloadEventReceiver(unloadEventReceiver);
order3.SetUnloadEventReceiver(unloadEventReceiver);
order4.SetUnloadEventReceiver(unloadEventReceiver);
using (mockRepository.Ordered())
{
clientTransactionListener
.Expect(
mock => mock.ObjectsUnloading(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { order1 })))
.WhenCalled(mi => order3.EnsureDataAvailable());
unloadEventReceiver.Expect(mock => mock.OnUnloading(order1));
clientTransactionListener
.Expect(
mock => mock.ObjectsUnloading(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { order3 })));
unloadEventReceiver
.Expect(mock => mock.OnUnloading(order3))
.WhenCalled(mi => order4.EnsureDataAvailable());
clientTransactionListener
.Expect(
mock => mock.ObjectsUnloading(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { order4 })));
unloadEventReceiver.Expect(mock => mock.OnUnloading(order4));
using (mockRepository.Unordered())
{
clientTransactionListener.Expect(
mock => mock.DataContainerMapUnregistering(Arg.Is(TestableClientTransaction), Arg <DataContainer> .Matches(dc => dc.ID == order1.ID)));
clientTransactionListener.Expect(
mock => mock.DataContainerMapUnregistering(Arg.Is(TestableClientTransaction), Arg <DataContainer> .Matches(dc => dc.ID == order3.ID)));
clientTransactionListener.Expect(
mock => mock.DataContainerMapUnregistering(Arg.Is(TestableClientTransaction), Arg <DataContainer> .Matches(dc => dc.ID == order4.ID)));
}
unloadEventReceiver.Expect(mock => mock.OnUnloaded(order4));
unloadEventReceiver.Expect(mock => mock.OnUnloaded(order3));
unloadEventReceiver.Expect(mock => mock.OnUnloaded(order1));
clientTransactionListener
.Expect(
mock => mock.ObjectsUnloaded(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { order1, order3, order4 })));
}
mockRepository.ReplayAll();
TestableClientTransaction.AddListener(clientTransactionListener);
try
{
UnloadService.UnloadAll(TestableClientTransaction);
}
finally
{
TestableClientTransaction.RemoveListener(clientTransactionListener);
}
mockRepository.VerifyAll();
}
public void Events()
{
var order1 = LoadOrderWithRelations(DomainObjectIDs.Order1);
var order3 = LoadOrderWithRelations(DomainObjectIDs.Order3);
var mockRepository = new MockRepository();
// Actual events are more comprehensive, since all opposite objects are also unloaded. We only test for some of them, so use a dynamic mock.
var clientTransactionListener = mockRepository.DynamicMock <IClientTransactionListener>();
var unloadEventReceiver = mockRepository.StrictMock <IUnloadEventReceiver>();
order1.SetUnloadEventReceiver(unloadEventReceiver);
order3.SetUnloadEventReceiver(unloadEventReceiver);
using (mockRepository.Ordered())
{
clientTransactionListener
.Expect(
mock => mock.ObjectsUnloading(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.ContainsAll(new[] { order1, order3 })));
unloadEventReceiver.Expect(mock => mock.OnUnloading(order1));
unloadEventReceiver.Expect(mock => mock.OnUnloading(order3));
using (mockRepository.Unordered())
{
clientTransactionListener.Expect(
mock => mock.RelationEndPointMapUnregistering(TestableClientTransaction, RelationEndPointID.Resolve(order1, o => o.Customer)));
clientTransactionListener.Expect(
mock => mock.RelationEndPointMapUnregistering(TestableClientTransaction, RelationEndPointID.Resolve(order1, o => o.Official)));
clientTransactionListener.Expect(
mock => mock.RelationEndPointMapUnregistering(TestableClientTransaction, RelationEndPointID.Resolve(order1, o => o.OrderTicket)));
clientTransactionListener.Expect(
mock => mock.RelationEndPointMapUnregistering(TestableClientTransaction, RelationEndPointID.Resolve(order3, o => o.Customer)));
clientTransactionListener.Expect(
mock => mock.RelationEndPointMapUnregistering(TestableClientTransaction, RelationEndPointID.Resolve(order3, o => o.Official)));
clientTransactionListener.Expect(
mock => mock.RelationEndPointMapUnregistering(TestableClientTransaction, RelationEndPointID.Resolve(order3, o => o.OrderTicket)));
clientTransactionListener.Expect(mock => mock.DataContainerMapUnregistering(TestableClientTransaction, order1.InternalDataContainer));
clientTransactionListener.Expect(mock => mock.DataContainerMapUnregistering(TestableClientTransaction, order3.InternalDataContainer));
}
unloadEventReceiver.Expect(mock => mock.OnUnloaded(order3));
unloadEventReceiver.Expect(mock => mock.OnUnloaded(order1));
clientTransactionListener
.Expect(
mock => mock.ObjectsUnloaded(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.ContainsAll(new[] { order1, order3 })));
}
mockRepository.ReplayAll();
TestableClientTransaction.AddListener(clientTransactionListener);
try
{
UnloadService.UnloadAll(TestableClientTransaction);
}
finally
{
TestableClientTransaction.RemoveListener(clientTransactionListener);
}
mockRepository.VerifyAll();
}
