protected virtual RelationEndPointFactory CreateRelationEndPointFactory(
ClientTransaction constructedTransaction,
IRelationEndPointProvider endPointProvider,
ILazyLoader lazyLoader,
IClientTransactionEventSink eventSink,
IVirtualObjectEndPointDataManagerFactory virtualObjectEndPointDataManagerFactory,
ICollectionEndPointDataManagerFactory collectionEndPointDataManagerFactory)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("endPointProvider", endPointProvider);
ArgumentUtility.CheckNotNull("lazyLoader", lazyLoader);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
ArgumentUtility.CheckNotNull("virtualObjectEndPointDataManagerFactory", virtualObjectEndPointDataManagerFactory);
ArgumentUtility.CheckNotNull("collectionEndPointDataManagerFactory", collectionEndPointDataManagerFactory);
var associatedCollectionDataStrategyFactory = new AssociatedCollectionDataStrategyFactory(endPointProvider);
var collectionEndPointCollectionProvider = new CollectionEndPointCollectionProvider(associatedCollectionDataStrategyFactory);
return(new RelationEndPointFactory(
constructedTransaction,
endPointProvider,
lazyLoader,
eventSink,
virtualObjectEndPointDataManagerFactory,
collectionEndPointDataManagerFactory,
collectionEndPointCollectionProvider,
associatedCollectionDataStrategyFactory));
}
public RelationEndPointFactory(
ClientTransaction clientTransaction,
IRelationEndPointProvider endPointProvider,
ILazyLoader lazyLoader,
IClientTransactionEventSink transactionEventSink,
IVirtualObjectEndPointDataManagerFactory virtualObjectEndPointDataManagerFactory,
ICollectionEndPointDataManagerFactory collectionEndPointDataManagerFactory,
ICollectionEndPointCollectionProvider collectionEndPointCollectionProvider,
IAssociatedCollectionDataStrategyFactory associatedCollectionDataStrategyFactory)
{
ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction);
ArgumentUtility.CheckNotNull("endPointProvider", endPointProvider);
ArgumentUtility.CheckNotNull("lazyLoader", lazyLoader);
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink);
ArgumentUtility.CheckNotNull("virtualObjectEndPointDataManagerFactory", virtualObjectEndPointDataManagerFactory);
ArgumentUtility.CheckNotNull("collectionEndPointDataManagerFactory", collectionEndPointDataManagerFactory);
ArgumentUtility.CheckNotNull("collectionEndPointCollectionProvider", collectionEndPointCollectionProvider);
ArgumentUtility.CheckNotNull("associatedCollectionDataStrategyFactory", associatedCollectionDataStrategyFactory);
_clientTransaction = clientTransaction;
_endPointProvider = endPointProvider;
_lazyLoader = lazyLoader;
_transactionEventSink = transactionEventSink;
_virtualObjectEndPointDataManagerFactory = virtualObjectEndPointDataManagerFactory;
_collectionEndPointDataManagerFactory = collectionEndPointDataManagerFactory;
_collectionEndPointCollectionProvider = collectionEndPointCollectionProvider;
_associatedCollectionDataStrategyFactory = associatedCollectionDataStrategyFactory;
}
public override void SetUp()
{
base.SetUp();
_customerEndPointID = RelationEndPointID.Create(DomainObjectIDs.Customer1, "Remotion.Data.DomainObjects.UnitTests.TestDomain.Customer.Orders");
_order1 = DomainObjectIDs.Order1.GetObject <Order> ();
_order3 = DomainObjectIDs.Order3.GetObject <Order> ();
_fakeCollection = new OrderCollection();
_collectionManagerMock = MockRepository.GenerateStrictMock <ICollectionEndPointCollectionManager> ();
_lazyLoaderMock = MockRepository.GenerateMock <ILazyLoader> ();
_endPointProviderStub = MockRepository.GenerateStub <IRelationEndPointProvider> ();
_transactionEventSinkStub = MockRepository.GenerateStub <IClientTransactionEventSink> ();
_dataManagerFactoryStub = MockRepository.GenerateStub <ICollectionEndPointDataManagerFactory> ();
_loadStateMock = MockRepository.GenerateStrictMock <ICollectionEndPointLoadState> ();
_endPoint = new CollectionEndPoint(
TestableClientTransaction,
_customerEndPointID,
_collectionManagerMock,
_lazyLoaderMock,
_endPointProviderStub,
_transactionEventSinkStub,
_dataManagerFactoryStub);
PrivateInvoke.SetNonPublicField(_endPoint, "_loadState", _loadStateMock);
_endPointProviderStub.Stub(stub => stub.GetOrCreateVirtualEndPoint(_customerEndPointID)).Return(_endPoint);
_relatedEndPointStub = MockRepository.GenerateStub <IRealObjectEndPoint> ();
}
public IncompleteCollectionEndPointLoadState(
IEndPointLoader endPointLoader,
ICollectionEndPointDataManagerFactory dataManagerFactory)
: base(endPointLoader)
{
ArgumentUtility.CheckNotNull("dataManagerFactory", dataManagerFactory);
_dataManagerFactory = dataManagerFactory;
}
protected CollectionEndPoint(FlattenedDeserializationInfo info)
: base(info)
{
_collectionManager = info.GetValueForHandle <ICollectionEndPointCollectionManager>();
_lazyLoader = info.GetValueForHandle <ILazyLoader>();
_endPointProvider = info.GetValueForHandle <IRelationEndPointProvider> ();
_transactionEventSink = info.GetValueForHandle <IClientTransactionEventSink> ();
_dataManagerFactory = info.GetValueForHandle <ICollectionEndPointDataManagerFactory> ();
_loadState = info.GetValue <ICollectionEndPointLoadState>();
_hasBeenTouched = info.GetBoolValue();
}
public override void SetUp()
{
base.SetUp();
_clientTransaction = ClientTransaction.CreateRootTransaction();
_endPointProviderStub = MockRepository.GenerateStub <IRelationEndPointProvider> ();
_lazyLoaderStub = MockRepository.GenerateStub <ILazyLoader> ();
_transactionEventSinkStub = MockRepository.GenerateStub <IClientTransactionEventSink>();
var virtualObjectEndPointDataManager = MockRepository.GenerateStub <IVirtualObjectEndPointDataManager> ();
virtualObjectEndPointDataManager.Stub(stub => stub.OriginalOppositeEndPoint).Return(null);
_virtualObjectEndPointDataManagerFactoryStub = MockRepository.GenerateStub <IVirtualObjectEndPointDataManagerFactory> ();
_virtualObjectEndPointDataManagerFactoryStub
.Stub(stub => stub.CreateEndPointDataManager(Arg <RelationEndPointID> .Is.Anything))
.Return(virtualObjectEndPointDataManager);
var collectionEndPointDataManager = MockRepository.GenerateStub <ICollectionEndPointDataManager> ();
collectionEndPointDataManager.Stub(stub => stub.OriginalOppositeEndPoints).Return(new IRealObjectEndPoint[0]);
_collectionEndPointDataManagerFactoryStub = MockRepository.GenerateStub <ICollectionEndPointDataManagerFactory> ();
_collectionEndPointDataManagerFactoryStub
.Stub(stub => stub.CreateEndPointDataManager(Arg <RelationEndPointID> .Is.Anything))
.Return(collectionEndPointDataManager);
_collectionEndPointCollectionProviderStub = MockRepository.GenerateStub <ICollectionEndPointCollectionProvider>();
_associatedCollectionStrategyFactoryStub = MockRepository.GenerateStub <IAssociatedCollectionDataStrategyFactory>();
_factory = new RelationEndPointFactory(
_clientTransaction,
_endPointProviderStub,
_lazyLoaderStub,
_transactionEventSinkStub,
_virtualObjectEndPointDataManagerFactoryStub,
_collectionEndPointDataManagerFactoryStub,
_collectionEndPointCollectionProviderStub,
_associatedCollectionStrategyFactoryStub);
}
public CollectionEndPoint(
ClientTransaction clientTransaction,
RelationEndPointID id,
ICollectionEndPointCollectionManager collectionManager,
ILazyLoader lazyLoader,
IRelationEndPointProvider endPointProvider,
IClientTransactionEventSink transactionEventSink,
ICollectionEndPointDataManagerFactory dataManagerFactory)
: base(ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction), ArgumentUtility.CheckNotNull("id", id))
{
ArgumentUtility.CheckNotNull("collectionManager", collectionManager);
ArgumentUtility.CheckNotNull("lazyLoader", lazyLoader);
ArgumentUtility.CheckNotNull("endPointProvider", endPointProvider);
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink);
ArgumentUtility.CheckNotNull("dataManagerFactory", dataManagerFactory);
if (id.Definition.Cardinality != CardinalityType.Many)
{
throw new ArgumentException("End point ID must refer to an end point with cardinality 'Many'.", "id");
}
if (id.Definition.IsAnonymous)
{
throw new ArgumentException("End point ID must not refer to an anonymous end point.", "id");
}
Assertion.IsTrue(ID.Definition.IsVirtual);
_hasBeenTouched = false;
_collectionManager = collectionManager;
_lazyLoader = lazyLoader;
_endPointProvider = endPointProvider;
_transactionEventSink = transactionEventSink;
_dataManagerFactory = dataManagerFactory;
SetIncompleteLoadState();
}
public override void SetUp()
{
base.SetUp();
_endPointID = RelationEndPointID.Create(DomainObjectIDs.Customer1, typeof(Customer), "Orders");
_collectionEndPointMock = MockRepository.GenerateStrictMock <ICollectionEndPoint> ();
_endPointLoaderMock = MockRepository.GenerateStrictMock <IncompleteCollectionEndPointLoadState.IEndPointLoader> ();
_dataManagerFactoryStub = MockRepository.GenerateStub <ICollectionEndPointDataManagerFactory> ();
var dataManagerStub = MockRepository.GenerateStub <ICollectionEndPointDataManager> ();
dataManagerStub.Stub(stub => stub.HasDataChanged()).Return(false);
_loadState = new IncompleteCollectionEndPointLoadState(_endPointLoaderMock, _dataManagerFactoryStub);
_relatedObject = DomainObjectMother.CreateFakeObject <Order> ();
_relatedEndPointStub = MockRepository.GenerateStub <IRealObjectEndPoint> ();
_relatedEndPointStub.Stub(stub => stub.ObjectID).Return(_relatedObject.ID);
_relatedObject2 = DomainObjectMother.CreateFakeObject <Order> ();
_relatedEndPointStub2 = MockRepository.GenerateStub <IRealObjectEndPoint> ();
_relatedEndPointStub2.Stub(stub => stub.ObjectID).Return(_relatedObject2.ID);
}
public IncompleteCollectionEndPointLoadState(FlattenedDeserializationInfo info)
: base(info)
{
_dataManagerFactory = info.GetValueForHandle <ICollectionEndPointDataManagerFactory>();
}
