public override void SetUp()
{
base.SetUp();
_mockRepository = new MockRepository();
_persistenceStrategyMock = _mockRepository.StrictMock <IFetchEnabledPersistenceStrategy> ();
_loadedObjectDataRegistrationAgentMock = _mockRepository.StrictMock <ILoadedObjectDataRegistrationAgent> ();
_loadedObjectDataProviderStub = _mockRepository.Stub <ILoadedObjectDataProvider> ();
_eagerFetcherMock = _mockRepository.StrictMock <IEagerFetcher> ();
_fetchEnabledObjectLoader = new FetchEnabledObjectLoader(
_persistenceStrategyMock,
_loadedObjectDataRegistrationAgentMock,
_loadedObjectDataProviderStub,
_eagerFetcherMock);
_resultItem1 = LoadedObjectDataObjectMother.CreateLoadedObjectDataStub(DomainObjectIDs.Order1);
_resultItem2 = LoadedObjectDataObjectMother.CreateLoadedObjectDataStub(DomainObjectIDs.Order3);
_resultItemWithSourceData1 = LoadedObjectDataObjectMother.CreateLoadedObjectDataWithDataSourceData(DomainObjectIDs.Order1);
_resultItemWithSourceData2 = LoadedObjectDataObjectMother.CreateLoadedObjectDataWithDataSourceData(DomainObjectIDs.Order3);
_orderTicketEndPointDefinition = GetEndPointDefinition(typeof(Order), "OrderTicket");
_customerEndPointDefinition = GetEndPointDefinition(typeof(Order), "Customer");
var fetchQuery1 = CreateFakeQuery();
var fetchQuery2 = CreateFakeQuery();
_queryWithFetchQueries = CreateFakeQuery(
Tuple.Create(_orderTicketEndPointDefinition, fetchQuery1),
Tuple.Create(_customerEndPointDefinition, fetchQuery2));
}
public virtual IEnumerable <ILoadedObjectData> ResolveCollectionRelationData(
RelationEndPointID relationEndPointID, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
ArgumentUtility.CheckNotNull("relationEndPointID", relationEndPointID);
ArgumentUtility.CheckNotNull("alreadyLoadedObjectDataProvider", alreadyLoadedObjectDataProvider);
using (var persistenceManager = CreatePersistenceManager())
{
var dataContainers = persistenceManager.LoadRelatedDataContainers(relationEndPointID);
return(dataContainers.Select(dc => GetLoadedObjectDataForDataContainer(dc, alreadyLoadedObjectDataProvider)));
}
}
public FetchEnabledObjectLoader(
IFetchEnabledPersistenceStrategy persistenceStrategy,
ILoadedObjectDataRegistrationAgent loadedObjectDataRegistrationAgent,
ILoadedObjectDataProvider loadedObjectDataProvider,
IEagerFetcher eagerFetcher)
: base(persistenceStrategy, loadedObjectDataRegistrationAgent, loadedObjectDataProvider)
{
ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy);
ArgumentUtility.CheckNotNull("eagerFetcher", eagerFetcher);
_persistenceStrategy = persistenceStrategy;
_eagerFetcher = eagerFetcher;
}
public ObjectLoader(
IPersistenceStrategy persistenceStrategy,
ILoadedObjectDataRegistrationAgent loadedObjectDataRegistrationAgent,
ILoadedObjectDataProvider loadedObjectDataProvider)
{
ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy);
ArgumentUtility.CheckNotNull("loadedObjectDataRegistrationAgent", loadedObjectDataRegistrationAgent);
ArgumentUtility.CheckNotNull("loadedObjectDataProvider", loadedObjectDataProvider);
_persistenceStrategy = persistenceStrategy;
_loadedObjectDataRegistrationAgent = loadedObjectDataRegistrationAgent;
_loadedObjectDataProvider = loadedObjectDataProvider;
}
public virtual ILoadedObjectData ResolveObjectRelationData(
RelationEndPointID relationEndPointID,
ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
ArgumentUtility.CheckNotNull("relationEndPointID", relationEndPointID);
ArgumentUtility.CheckNotNull("alreadyLoadedObjectDataProvider", alreadyLoadedObjectDataProvider);
using (var persistenceManager = CreatePersistenceManager())
{
var dataContainer = persistenceManager.LoadRelatedDataContainer(relationEndPointID);
return(GetLoadedObjectDataForDataContainer(dataContainer, alreadyLoadedObjectDataProvider));
}
}
public override void SetUp()
{
base.SetUp();
_mockRepository = new MockRepository();
_persistenceStrategyMock = _mockRepository.StrictMock <IPersistenceStrategy> ();
_loadedObjectDataRegistrationAgentMock = _mockRepository.StrictMock <ILoadedObjectDataRegistrationAgent>();
_loadedObjectDataProviderStub = _mockRepository.Stub <ILoadedObjectDataProvider>();
_objectLoader = new ObjectLoader(_persistenceStrategyMock, _loadedObjectDataRegistrationAgentMock, _loadedObjectDataProviderStub);
_fakeQuery = CreateFakeQuery();
_loadedObjectDataStub1 = MockRepository.GenerateStub <ILoadedObjectData> ();
_loadedObjectDataStub2 = MockRepository.GenerateStub <ILoadedObjectData> ();
}
public virtual ILoadedObjectData ResolveObjectRelationData(
RelationEndPointID relationEndPointID,
ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
ArgumentUtility.CheckNotNull("relationEndPointID", relationEndPointID);
ArgumentUtility.CheckNotNull("alreadyLoadedObjectDataProvider", alreadyLoadedObjectDataProvider);
if (!relationEndPointID.Definition.IsVirtual || relationEndPointID.Definition.Cardinality != CardinalityType.One)
{
throw new ArgumentException("ResolveObjectRelationData can only be called for virtual object end points.", "relationEndPointID");
}
// parentRelatedObject may be null
var parentRelatedObject = _parentTransactionContext.ResolveRelatedObject(relationEndPointID);
return(TransferParentObject(parentRelatedObject, alreadyLoadedObjectDataProvider));
}
private ILoadedObjectData TransferParentObject(DomainObject parentObject, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
if (parentObject == null)
{
return(new NullLoadedObjectData());
}
var existingLoadedObject = alreadyLoadedObjectDataProvider.GetLoadedObject(parentObject.ID);
if (existingLoadedObject != null)
{
return(existingLoadedObject);
}
else
{
return(TransferParentObject(parentObject.ID));
}
}
public override void SetUp()
{
base.SetUp();
_parentTransactionContextMock = MockRepository.GenerateStrictMock <IParentTransactionContext> ();
_unlockedParentTransactionContextMock = MockRepository.GenerateStrictMock <IUnlockedParentTransactionContext> ();
_persistenceStrategy = new SubPersistenceStrategy(_parentTransactionContextMock);
_queryStub = MockRepository.GenerateStub <IQuery>();
_orderNumberPropertyDefinition = GetPropertyDefinition(typeof(Order), "OrderNumber");
_fileNamePropertyDefinition = GetPropertyDefinition(typeof(OrderTicket), "FileName");
_productPropertyDefinition = GetPropertyDefinition(typeof(OrderItem), "Product");
_virtualObjectRelationEndPointID = RelationEndPointID.Create(DomainObjectIDs.Order1, GetEndPointDefinition(typeof(Order), "OrderTicket"));
_collectionEndPointID = RelationEndPointID.Create(DomainObjectIDs.Order1, GetEndPointDefinition(typeof(Order), "OrderItems"));
_nonVirtualEndPointID = RelationEndPointID.Create(DomainObjectIDs.Order1, GetEndPointDefinition(typeof(Order), "Customer"));
_alreadyLoadedObjectDataProviderMock = MockRepository.GenerateStrictMock <ILoadedObjectDataProvider>();
}
public virtual IEnumerable <ILoadedObjectData> ResolveCollectionRelationData(
RelationEndPointID relationEndPointID,
ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
ArgumentUtility.CheckNotNull("relationEndPointID", relationEndPointID);
ArgumentUtility.CheckNotNull("alreadyLoadedObjectDataProvider", alreadyLoadedObjectDataProvider);
if (relationEndPointID.Definition.Cardinality != CardinalityType.Many)
{
throw new ArgumentException("ResolveCollectionRelationData can only be called for CollectionEndPoints.", "relationEndPointID");
}
var parentObjects = _parentTransactionContext.ResolveRelatedObjects(relationEndPointID);
return(parentObjects
.Select(parentObject =>
{
Assertion.IsNotNull(parentObject);
return TransferParentObject(parentObject, alreadyLoadedObjectDataProvider);
}));
}
private ILoadedObjectData GetLoadedObjectDataForDataContainer(DataContainer dataContainer, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
if (dataContainer == null)
{
return(new NullLoadedObjectData());
}
var knownLoadedObjectData = alreadyLoadedObjectDataProvider.GetLoadedObject(dataContainer.ID);
return(knownLoadedObjectData ?? new FreshlyLoadedObjectData(dataContainer));
}
public IEnumerable <LoadedObjectDataWithDataSourceData> ExecuteFetchQuery(IQuery query, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
throw new System.NotImplementedException();
}
public IEnumerable <ILoadedObjectData> ExecuteCollectionQuery(IQuery query, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
throw new System.NotImplementedException();
}
public IEnumerable <ILoadedObjectData> ResolveCollectionRelationData(RelationEndPointID relationEndPointID, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
throw new System.NotImplementedException();
}
public ILoadedObjectData ResolveObjectRelationData(RelationEndPointID relationEndPointID, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
throw new System.NotImplementedException();
}
public virtual IEnumerable <ILoadedObjectData> ExecuteCollectionQuery(IQuery query, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
ArgumentUtility.CheckNotNull("query", query);
ArgumentUtility.CheckNotNull("alreadyLoadedObjectDataProvider", alreadyLoadedObjectDataProvider);
var queryResult = _parentTransactionContext.ExecuteCollectionQuery(query);
Assertion.IsNotNull(queryResult, "Parent transaction never returns a null query result for collection query.");
var parentObjects = queryResult.AsEnumerable();
return(parentObjects.Select(parentObject => TransferParentObject(parentObject, alreadyLoadedObjectDataProvider)));
}
public IEnumerable <LoadedObjectDataWithDataSourceData> ExecuteFetchQuery(IQuery query, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
ArgumentUtility.CheckNotNull("query", query);
ArgumentUtility.CheckNotNull("alreadyLoadedObjectDataProvider", alreadyLoadedObjectDataProvider);
if (query.QueryType != QueryType.Collection)
{
throw new ArgumentException("Only collection queries can be used for fetching.", "query");
}
var dataContainers = ExecuteDataContainerQuery(query);
return(dataContainers.Select(dc => new LoadedObjectDataWithDataSourceData(GetLoadedObjectDataForDataContainer(dc, alreadyLoadedObjectDataProvider), dc)));
}
public virtual IEnumerable <ILoadedObjectData> ExecuteCollectionQuery(IQuery query, ILoadedObjectDataProvider alreadyLoadedObjectDataProvider)
{
ArgumentUtility.CheckNotNull("query", query); ArgumentUtility.CheckNotNull("alreadyLoadedObjectDataProvider", alreadyLoadedObjectDataProvider);
if (query.QueryType != QueryType.Collection)
{
throw new ArgumentException("Only collection queries can be used to load data containers.", "query");
}
var dataContainers = ExecuteDataContainerQuery(query);
return(dataContainers.Select(dc => GetLoadedObjectDataForDataContainer(dc, alreadyLoadedObjectDataProvider)));
}
