public override void SetUp()
{
base.SetUp();
_registrationAgentMock = MockRepository.GenerateStrictMock <IFetchedRelationDataRegistrationAgent>();
_fetchResultLoaderMock = MockRepository.GenerateStrictMock <IFetchEnabledObjectLoader>();
_eagerFetcher = new EagerFetcher(_registrationAgentMock);
_fetchQueryStub1 = MockRepository.GenerateStub <IQuery> ();
_fetchQueryStub2 = MockRepository.GenerateStub <IQuery> ();
_orderTicketEndPointDefinition = GetEndPointDefinition(typeof(Order), "OrderTicket");
_customerEndPointDefinition = GetEndPointDefinition(typeof(Order), "Customer");
_industrialSectorEndPointDefinition = GetEndPointDefinition(typeof(Company), "IndustrialSector");
_originatingOrder1 = DomainObjectMother.CreateFakeObject <Order>();
_originatingOrder2 = DomainObjectMother.CreateFakeObject <Order>();
_originatingOrderData1 = LoadedObjectDataObjectMother.CreateLoadedObjectDataStub(_originatingOrder1);
_originatingOrderData2 = LoadedObjectDataObjectMother.CreateLoadedObjectDataStub(_originatingOrder2);
_fetchedOrderItem1 = DomainObjectMother.CreateFakeObject <OrderItem>();
_fetchedOrderItem2 = DomainObjectMother.CreateFakeObject <OrderItem>();
_fetchedOrderItem3 = DomainObjectMother.CreateFakeObject <OrderItem>();
_fetchedOrderItemData1 = LoadedObjectDataObjectMother.CreateLoadedObjectDataWithDataSourceData(_fetchedOrderItem1);
_fetchedOrderItemData2 = LoadedObjectDataObjectMother.CreateLoadedObjectDataWithDataSourceData(_fetchedOrderItem2);
_fetchedOrderItemData3 = LoadedObjectDataObjectMother.CreateLoadedObjectDataWithDataSourceData(_fetchedOrderItem3);
_fetchedCustomer = DomainObjectMother.CreateFakeObject <Customer>();
_fetchedCustomerData = LoadedObjectDataObjectMother.CreateLoadedObjectDataWithDataSourceData(_fetchedCustomer);
_pendingRegistrationCollector = new LoadedObjectDataPendingRegistrationCollector();
}
public void GetOrLoadCollectionQueryResult_PerformsEagerFetching_AndRegistersLoadedObjects()
{
LoadedObjectDataPendingRegistrationCollector collector = null;
var consolidatedResultItems = new[] { CreateEquivalentData(_resultItem1), CreateEquivalentData(_resultItem2) };
using (_mockRepository.Ordered())
{
_persistenceStrategyMock
.Expect(mock => mock.ExecuteCollectionQuery(_queryWithFetchQueries, _loadedObjectDataProviderStub))
.Return(new[] { _resultItem1, _resultItem2 });
_loadedObjectDataRegistrationAgentMock
.Expect(
mock => mock.BeginRegisterIfRequired(
Arg.Is(new[] { _resultItem1, _resultItem2 }), Arg.Is(true), Arg <LoadedObjectDataPendingRegistrationCollector> .Is.NotNull))
.WhenCalled(mi => collector = (LoadedObjectDataPendingRegistrationCollector)mi.Arguments[2])
.Return(consolidatedResultItems);
_eagerFetcherMock
.Expect(
mock => mock.PerformEagerFetching(
Arg.Is(consolidatedResultItems),
Arg.Is(_queryWithFetchQueries.EagerFetchQueries),
Arg.Is(_fetchEnabledObjectLoader),
Arg <LoadedObjectDataPendingRegistrationCollector> .Matches(c => c == collector)));
_loadedObjectDataRegistrationAgentMock
.Expect(mock => mock.EndRegisterIfRequired(Arg <LoadedObjectDataPendingRegistrationCollector> .Matches(c => c == collector)));
}
_mockRepository.ReplayAll();
var result = _fetchEnabledObjectLoader.GetOrLoadCollectionQueryResult(_queryWithFetchQueries);
_mockRepository.VerifyAll();
Assert.That(result, Is.EqualTo(consolidatedResultItems));
}
public void GetOrLoadCollectionQueryResult_EndsRegistration_EvenWhenAnExceptionIsThrown()
{
var exception = new Exception("Test");
LoadedObjectDataPendingRegistrationCollector collector = null;
_persistenceStrategyMock
.Expect(mock => mock.ExecuteCollectionQuery(_queryWithFetchQueries, _loadedObjectDataProviderStub))
.Return(new[] { _resultItem1, _resultItem2 });
_loadedObjectDataRegistrationAgentMock
.Expect(
mock => mock.BeginRegisterIfRequired(
Arg.Is(new[] { _resultItem1, _resultItem2 }), Arg.Is(true), Arg <LoadedObjectDataPendingRegistrationCollector> .Is.NotNull))
.WhenCalled(mi => collector = (LoadedObjectDataPendingRegistrationCollector)mi.Arguments[2])
.Return(new[] { _resultItem1, _resultItem2 });
_eagerFetcherMock
.Expect(
mock => mock.PerformEagerFetching(
Arg.Is(new[] { _resultItem1, _resultItem2 }),
Arg.Is(_queryWithFetchQueries.EagerFetchQueries),
Arg.Is(_fetchEnabledObjectLoader),
Arg <LoadedObjectDataPendingRegistrationCollector> .Matches(c => c == collector)))
.Throw(exception);
_loadedObjectDataRegistrationAgentMock
.Expect(mock => mock.EndRegisterIfRequired(Arg <LoadedObjectDataPendingRegistrationCollector> .Matches(c => c == collector)));
_mockRepository.ReplayAll();
Assert.That(() => _fetchEnabledObjectLoader.GetOrLoadCollectionQueryResult(_queryWithFetchQueries), Throws.Exception.SameAs(exception));
_mockRepository.VerifyAll();
}
public void BeginRegisterIfRequired_ConsolidatesDuplicates()
{
var freshlyLoadedObject1a = GetFreshlyLoadedObject();
var registerableDataContainer1a = freshlyLoadedObject1a.FreshlyLoadedDataContainer;
Assert.That(registerableDataContainer1a.HasDomainObject, Is.False);
var freshlyLoadedObject1b = GetFreshlyLoadedObject(freshlyLoadedObject1a.ObjectID);
var registerableDataContainer1b = freshlyLoadedObject1b.FreshlyLoadedDataContainer;
Assert.That(registerableDataContainer1b.HasDomainObject, Is.False);
_mockRepository.ReplayAll();
var allObjects = new ILoadedObjectData[] { freshlyLoadedObject1a, freshlyLoadedObject1b };
var collector = new LoadedObjectDataPendingRegistrationCollector();
var result = _agent.BeginRegisterIfRequired(allObjects, false, collector);
_mockRepository.VerifyAll();
CheckHasEnlistedDomainObject(registerableDataContainer1a);
Assert.That(collector.DataPendingRegistration, Is.EquivalentTo(new[] { freshlyLoadedObject1a }));
Assert.That(result, Is.EqualTo(new[] { freshlyLoadedObject1a, freshlyLoadedObject1a }));
Assert.That(registerableDataContainer1b.HasDomainObject, Is.False);
}
public void BeginRegisterIfRequired_WithNotFoundObjects_AndThrowOnNotFoundTrue_RaisesdOnNotFoundAndThrows()
{
var freshlyLoadedObject = GetFreshlyLoadedObject();
var registerableDataContainer = freshlyLoadedObject.FreshlyLoadedDataContainer;
Assert.That(registerableDataContainer.HasDomainObject, Is.False);
var notFoundLoadedObject = GetNotFoundLoadedObject();
_registrationListenerMock
.Expect(
mock => mock.OnObjectsNotFound(
Arg <ReadOnlyCollection <ObjectID> > .List.Equal(new[] { notFoundLoadedObject.ObjectID })));
_mockRepository.ReplayAll();
var allObjects =
new ILoadedObjectData[]
{
freshlyLoadedObject,
notFoundLoadedObject
};
var collector = new LoadedObjectDataPendingRegistrationCollector();
Assert.That(() => _agent.BeginRegisterIfRequired(allObjects, true, collector), Throws.TypeOf <ObjectsNotFoundException> ());
_mockRepository.VerifyAll();
// Note: In this case, we currently set the DomainObjects of the freshly loaded DataContainer, and we also add them to the collector. This
// shouldn't make any difference, and it's easier to implement.
Assert.That(registerableDataContainer.HasDomainObject, Is.True);
Assert.That(collector.DataPendingRegistration, Is.EquivalentTo(new[] { freshlyLoadedObject }));
}
public void BeginRegisterIfRequired_WithNotFoundObjects_AndThrowOnNotFoundFalse_RaisesOnNotFoundAndProceeds()
{
var freshlyLoadedObject = GetFreshlyLoadedObject();
var registerableDataContainer = freshlyLoadedObject.FreshlyLoadedDataContainer;
Assert.That(registerableDataContainer.HasDomainObject, Is.False);
var notFoundLoadedObject = GetNotFoundLoadedObject();
using (_mockRepository.Ordered())
{
_registrationListenerMock
.Expect(
mock => mock.OnObjectsNotFound(
Arg <ReadOnlyCollection <ObjectID> > .List.Equal(new[] { notFoundLoadedObject.ObjectID })));
}
_mockRepository.ReplayAll();
var allObjects =
new ILoadedObjectData[]
{
freshlyLoadedObject,
notFoundLoadedObject
};
var collector = new LoadedObjectDataPendingRegistrationCollector();
var result = _agent.BeginRegisterIfRequired(allObjects, false, collector);
_mockRepository.VerifyAll();
CheckHasEnlistedDomainObject(registerableDataContainer);
Assert.That(collector.DataPendingRegistration, Is.EqualTo(new[] { freshlyLoadedObject }));
Assert.That(result, Is.EqualTo(allObjects));
}
public void BeginRegisterIfRequired_RaisesBeginEvent_AndSetsDomainObjects_ButDoesNotRegister()
{
var freshlyLoadedObject = GetFreshlyLoadedObject();
var registerableDataContainer = freshlyLoadedObject.FreshlyLoadedDataContainer;
Assert.That(registerableDataContainer.HasDomainObject, Is.False);
var alreadyExistingLoadedObject = GetAlreadyExistingLoadedObject();
var nullLoadedObject = GetNullLoadedObject();
var invalidLoadedObject = GetInvalidLoadedObject();
_mockRepository.ReplayAll();
var allObjects =
new ILoadedObjectData[]
{
freshlyLoadedObject,
alreadyExistingLoadedObject,
nullLoadedObject,
invalidLoadedObject
};
var collector = new LoadedObjectDataPendingRegistrationCollector();
var result = _agent.BeginRegisterIfRequired(allObjects, false, collector);
_mockRepository.VerifyAll();
CheckHasEnlistedDomainObject(registerableDataContainer);
Assert.That(collector.DataPendingRegistration, Is.EquivalentTo(new[] { freshlyLoadedObject }));
Assert.That(result, Is.EqualTo(allObjects));
}
public override void SetUp()
{
base.SetUp();
_data1 = LoadedObjectDataObjectMother.CreateFreshlyLoadedObjectData(DomainObjectIDs.Order1);
_data2 = LoadedObjectDataObjectMother.CreateFreshlyLoadedObjectData(DomainObjectIDs.Order3);
_collector = new LoadedObjectDataPendingRegistrationCollector();
}
private static LoadedObjectDataPendingRegistrationCollector CreateCollectorAndPrepare(params DataContainer[] dataContainers)
{
var collector = new LoadedObjectDataPendingRegistrationCollector();
foreach (var dataContainer in dataContainers)
{
collector.Add(new FreshlyLoadedObjectData(dataContainer));
dataContainer.SetDomainObject(DomainObjectMother.CreateFakeObject(dataContainer.ID));
}
return(collector);
}
public void GetOrLoadFetchQueryResult()
{
var pendingRegistrationCollector = new LoadedObjectDataPendingRegistrationCollector();
var consolidatedResultItems =
new[]
{
CreateEquivalentData(_resultItemWithSourceData1.LoadedObjectData),
CreateEquivalentData(_resultItemWithSourceData2.LoadedObjectData)
};
using (_mockRepository.Ordered())
{
_persistenceStrategyMock
.Expect(mock => mock.ExecuteFetchQuery(_queryWithFetchQueries, _loadedObjectDataProviderStub))
.Return(new[] { _resultItemWithSourceData1, _resultItemWithSourceData2 });
_loadedObjectDataRegistrationAgentMock
.Expect(
mock => mock.BeginRegisterIfRequired(
Arg <IEnumerable <ILoadedObjectData> > .List.Equal(
new[] { _resultItemWithSourceData1.LoadedObjectData, _resultItemWithSourceData2.LoadedObjectData }),
Arg.Is(true),
Arg.Is(pendingRegistrationCollector)))
.Return(consolidatedResultItems);
_eagerFetcherMock
.Expect(
mock => mock.PerformEagerFetching(
Arg <ICollection <ILoadedObjectData> > .List.Equal(consolidatedResultItems),
Arg.Is(_queryWithFetchQueries.EagerFetchQueries),
Arg.Is(_fetchEnabledObjectLoader),
Arg.Is(pendingRegistrationCollector)));
}
_mockRepository.ReplayAll();
var result = _fetchEnabledObjectLoader.GetOrLoadFetchQueryResult(_queryWithFetchQueries, pendingRegistrationCollector);
_mockRepository.VerifyAll();
Assert.That(
result,
Is.EqualTo(
new[]
{
new LoadedObjectDataWithDataSourceData(consolidatedResultItems[0], _resultItemWithSourceData1.DataSourceData),
new LoadedObjectDataWithDataSourceData(consolidatedResultItems[1], _resultItemWithSourceData2.DataSourceData)
}));
}
public void PerformEagerFetching(
ICollection <ILoadedObjectData> originatingObjects,
IEnumerable <KeyValuePair <IRelationEndPointDefinition, IQuery> > fetchQueries,
IFetchEnabledObjectLoader fetchResultLoader,
LoadedObjectDataPendingRegistrationCollector pendingRegistrationCollector)
{
ArgumentUtility.CheckNotNull("originatingObjects", originatingObjects);
ArgumentUtility.CheckNotNull("fetchQueries", fetchQueries);
ArgumentUtility.CheckNotNull("fetchResultLoader", fetchResultLoader);
ArgumentUtility.CheckNotNull("pendingRegistrationCollector", pendingRegistrationCollector);
if (originatingObjects.Count <= 0)
{
return;
}
foreach (var item in fetchQueries)
{
var relationEndPointDefinition = item.Key;
var fetchQuery = item.Value;
s_log.DebugFormat(
"Eager fetching objects for {0} via query {1} ('{2}').",
relationEndPointDefinition.PropertyName,
fetchQuery.ID,
fetchQuery.Statement);
var fetchedObjects = fetchResultLoader.GetOrLoadFetchQueryResult(fetchQuery, pendingRegistrationCollector);
s_log.DebugFormat(
"The eager fetch query for {0} yielded {1} related objects for {2} original objects.",
relationEndPointDefinition.PropertyName,
fetchedObjects.Count,
originatingObjects.Count);
try
{
_registrationAgent.GroupAndRegisterRelatedObjects(relationEndPointDefinition, originatingObjects, fetchedObjects);
}
catch (InvalidOperationException ex)
{
throw new UnexpectedQueryResultException("Eager fetching encountered an unexpected query result: " + ex.Message, ex);
}
}
}
public void EndRegisterIfRequired(LoadedObjectDataPendingRegistrationCollector pendingLoadedObjectDataCollector)
{
throw new NotImplementedException();
}
public IEnumerable <ILoadedObjectData> BeginRegisterIfRequired(IEnumerable <ILoadedObjectData> loadedObjects, bool throwOnNotFound, LoadedObjectDataPendingRegistrationCollector pendingLoadedObjectDataCollector)
{
throw new NotImplementedException();
}
public ICollection <LoadedObjectDataWithDataSourceData> GetOrLoadFetchQueryResult(IQuery query, LoadedObjectDataPendingRegistrationCollector pendingRegistrationCollector)
{
throw new NotImplementedException();
}
public void PerformEagerFetching(ICollection <ILoadedObjectData> originatingObjects, IEnumerable <KeyValuePair <IRelationEndPointDefinition, IQuery> > fetchQueries, IFetchEnabledObjectLoader fetchResultLoader, LoadedObjectDataPendingRegistrationCollector pendingRegistrationCollector)
{
throw new NotImplementedException();
}
