public CollectionEndPointSetCollectionCommand(
ICollectionEndPoint modifiedEndPoint,
DomainObjectCollection newCollection,
IDomainObjectCollectionData modifiedCollectionData,
ICollectionEndPointCollectionManager collectionEndPointCollectionManager,
IClientTransactionEventSink transactionEventSink)
: base(
ArgumentUtility.CheckNotNull("modifiedEndPoint", modifiedEndPoint),
null,
null,
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink))
{
ArgumentUtility.CheckNotNull("newCollection", newCollection);
ArgumentUtility.CheckNotNull("modifiedCollectionData", modifiedCollectionData);
ArgumentUtility.CheckNotNull("collectionEndPointCollectionManager", collectionEndPointCollectionManager);
if (modifiedEndPoint.IsNull)
{
throw new ArgumentException("Modified end point is null, a NullEndPointModificationCommand is needed.", "modifiedEndPoint");
}
_newCollection = newCollection;
_modifiedCollectionData = modifiedCollectionData;
_collectionEndPointCollectionManager = collectionEndPointCollectionManager;
var oldOppositeObjects = ModifiedCollectionData;
_removedObjects = oldOppositeObjects.Where(oldObject => !NewCollection.Contains(oldObject.ID)).ToArray();
var newOppositeObjects = NewCollection.Cast <DomainObject> ();
_addedObjects = newOppositeObjects.Where(newObject => !ModifiedCollectionData.ContainsObjectID(newObject.ID)).ToArray();
}
public CollectionEndPointRemoveCommand(
ICollectionEndPoint modifiedEndPoint,
DomainObject removedObject,
IDomainObjectCollectionData collectionData,
IRelationEndPointProvider endPointProvider,
IClientTransactionEventSink transactionEventSink)
: base(
ArgumentUtility.CheckNotNull("modifiedEndPoint", modifiedEndPoint),
ArgumentUtility.CheckNotNull("removedObject", removedObject),
null,
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink))
{
ArgumentUtility.CheckNotNull("collectionData", collectionData);
ArgumentUtility.CheckNotNull("endPointProvider", endPointProvider);
if (modifiedEndPoint.IsNull)
{
throw new ArgumentException("Modified end point is null, a NullEndPointModificationCommand is needed.", "modifiedEndPoint");
}
_index = modifiedEndPoint.Collection.IndexOf(removedObject);
_modifiedCollectionData = collectionData;
_modifiedCollection = modifiedEndPoint.Collection;
_endPointProvider = endPointProvider;
}
public override void SetUp()
{
base.SetUp();
_mockRepository = new MockRepository();
_eventSinkWithMock = _mockRepository.StrictMock <IClientTransactionEventSink>();
_persistenceStrategyMock = _mockRepository.StrictMock <IPersistenceStrategy> ();
_dataManagerMock = _mockRepository.StrictMock <IDataManager> ();
_clientTransaction = ClientTransactionObjectMother.Create();
_agent = new CommitRollbackAgent(_clientTransaction, _eventSinkWithMock, _persistenceStrategyMock, _dataManagerMock);
_fakeChangedDomainObject = LifetimeService.NewObject(_clientTransaction, typeof(Order), ParamList.Empty);
_fakeNewDomainObject = LifetimeService.NewObject(_clientTransaction, typeof(Order), ParamList.Empty);
_fakeDeletedDomainObject = LifetimeService.NewObject(_clientTransaction, typeof(Order), ParamList.Empty);
var fakeDataContainer1 = DataContainerObjectMother.Create();
var fakeDataContainer2 = DataContainerObjectMother.Create();
var fakeDataContainer3 = DataContainerObjectMother.Create();
_fakeChangedPersistableItem = new PersistableData(_fakeChangedDomainObject, StateType.Changed, fakeDataContainer1, new IRelationEndPoint[0]);
_fakeNewPersistableItem = new PersistableData(_fakeNewDomainObject, StateType.New, fakeDataContainer2, new IRelationEndPoint[0]);
_fakeDeletedPersistableItem = new PersistableData(_fakeDeletedDomainObject, StateType.Deleted, fakeDataContainer3, new IRelationEndPoint[0]);
}
public RelationEndPointMap(IClientTransactionEventSink transactionEventSink)
{
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink);
_transactionEventSink = transactionEventSink;
_relationEndPoints = new Dictionary <RelationEndPointID, IRelationEndPoint> ();
}
public SynchronizedRealObjectEndPointSyncState(FlattenedDeserializationInfo info)
{
ArgumentUtility.CheckNotNull("info", info);
_endPointProvider = info.GetValueForHandle <IRelationEndPointProvider>();
_transactionEventSink = info.GetValueForHandle <IClientTransactionEventSink>();
}
public CompleteCollectionEndPointLoadState(
ICollectionEndPointDataManager dataManager,
IRelationEndPointProvider endPointProvider,
IClientTransactionEventSink transactionEventSink)
: base(dataManager, endPointProvider, transactionEventSink)
{
}
private object[] _deserializedData; // only used for deserialization
public DataManager(
ClientTransaction clientTransaction,
IClientTransactionEventSink transactionEventSink,
IDataContainerEventListener dataContainerEventListener,
IInvalidDomainObjectManager invalidDomainObjectManager,
IObjectLoader objectLoader,
IRelationEndPointManager relationEndPointManager)
{
ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction);
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink);
ArgumentUtility.CheckNotNull("dataContainerEventListener", dataContainerEventListener);
ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager);
ArgumentUtility.CheckNotNull("objectLoader", objectLoader);
ArgumentUtility.CheckNotNull("relationEndPointManager", relationEndPointManager);
_clientTransaction = clientTransaction;
_transactionEventSink = transactionEventSink;
_dataContainerEventListener = dataContainerEventListener;
_invalidDomainObjectManager = invalidDomainObjectManager;
_objectLoader = objectLoader;
_relationEndPointManager = relationEndPointManager;
_dataContainerMap = new DataContainerMap(_transactionEventSink);
_domainObjectStateCache = new DomainObjectStateCache(clientTransaction);
}
public VirtualObjectEndPoint(
ClientTransaction clientTransaction,
RelationEndPointID id,
ILazyLoader lazyLoader,
IRelationEndPointProvider endPointProvider,
IClientTransactionEventSink transactionEventSink,
IVirtualObjectEndPointDataManagerFactory dataManagerFactory)
: base(
ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction),
ArgumentUtility.CheckNotNull("id", id))
{
ArgumentUtility.CheckNotNull("lazyLoader", lazyLoader);
ArgumentUtility.CheckNotNull("endPointProvider", endPointProvider);
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink);
ArgumentUtility.CheckNotNull("dataManagerFactory", dataManagerFactory);
if (!ID.Definition.IsVirtual)
{
throw new ArgumentException("End point ID must refer to a virtual end point.", "id");
}
_lazyLoader = lazyLoader;
_endPointProvider = endPointProvider;
_transactionEventSink = transactionEventSink;
_dataManagerFactory = dataManagerFactory;
SetIncompleteState();
_hasBeenTouched = false;
}
public override void SetUp()
{
base.SetUp();
_transaction = ClientTransactionObjectMother.Create();
_eventSinkWithMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_invalidDomainObjectManagerMock = MockRepository.GenerateStrictMock <IInvalidDomainObjectManager> ();
_dataManagerMock = MockRepository.GenerateStrictMock <IDataManager> ();
_enlistedDomainObjectManagerMock = MockRepository.GenerateStrictMock <IEnlistedDomainObjectManager> ();
_persistenceStrategyMock = MockRepository.GenerateStrictMock <IPersistenceStrategy>();
_agent = new ObjectLifetimeAgent(
_transaction,
_eventSinkWithMock,
_invalidDomainObjectManagerMock,
_dataManagerMock,
_enlistedDomainObjectManagerMock,
_persistenceStrategyMock);
_objectID1 = DomainObjectIDs.Order1;
_domainObject1 = DomainObjectMother.CreateFakeObject(_objectID1);
_dataContainer1 = DataContainerObjectMother.CreateExisting(_domainObject1);
_objectID2 = DomainObjectIDs.Order3;
_domainObject2 = DomainObjectMother.CreateFakeObject(_objectID2);
_dataContainer2 = DataContainerObjectMother.CreateExisting(_domainObject2);
_domainObjectCreatorMock = MockRepository.GenerateStrictMock <IDomainObjectCreator>();
_typeDefinitionWithCreatorMock = ClassDefinitionObjectMother.CreateClassDefinitionWithTable(
TestDomainStorageProviderDefinition,
classType: typeof(OrderItem),
instanceCreator: _domainObjectCreatorMock);
_objectIDWithCreatorMock = new ObjectID(_typeDefinitionWithCreatorMock, Guid.NewGuid());
}
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;
}
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));
}
// construction and disposing
public DataContainerMap(IClientTransactionEventSink transactionEventSink)
{
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink);
_transactionEventSink = transactionEventSink;
_dataContainers = new DataContainerCollection();
}
public override ITransactionHierarchyManager CreateTransactionHierarchyManager(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
return(new TransactionHierarchyManager(constructedTransaction, eventSink));
}
public virtual IDataManager CreateDataManager(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IInvalidDomainObjectManager invalidDomainObjectManager,
IPersistenceStrategy persistenceStrategy,
ITransactionHierarchyManager hierarchyManager)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager);
ArgumentUtility.CheckNotNull("persistenceStrategy", persistenceStrategy);
ArgumentUtility.CheckNotNull("hierarchyManager", hierarchyManager);
var dataContainerEventListener = CreateDataContainerEventListener(eventSink);
var delegatingDataManager = new DelegatingDataManager();
var objectLoader = CreateObjectLoader(
constructedTransaction, eventSink, persistenceStrategy, invalidDomainObjectManager, delegatingDataManager, hierarchyManager);
var endPointManager = CreateRelationEndPointManager(
constructedTransaction,
GetEndPointProvider(delegatingDataManager),
GetLazyLoader(delegatingDataManager),
eventSink);
var dataManager = new DataManager(
constructedTransaction, eventSink, dataContainerEventListener, invalidDomainObjectManager, objectLoader, endPointManager);
delegatingDataManager.InnerDataManager = dataManager;
return(dataManager);
}
public override void SetUp()
{
base.SetUp();
_eventSinkWithDynamicMock = MockRepository.GenerateMock <IClientTransactionEventSink>();
_map = new DataContainerMap(_eventSinkWithDynamicMock);
}
private TransactionHierarchyManager(
ClientTransaction thisTransaction,
IClientTransactionEventSink thisEventSink,
IClientTransactionHierarchy transactionHierarchy,
ClientTransaction parentTransaction,
ITransactionHierarchyManager parentHierarchyManager,
IClientTransactionEventSink parentEventSink)
{
ArgumentUtility.CheckNotNull("thisTransaction", thisTransaction);
ArgumentUtility.CheckNotNull("thisEventSink", thisEventSink);
ArgumentUtility.CheckNotNull("transactionHierarchy", transactionHierarchy);
_thisTransaction = thisTransaction;
_thisEventSink = thisEventSink;
_parentTransaction = parentTransaction;
_parentHierarchyManager = parentHierarchyManager;
_parentEventSink = parentEventSink;
_transactionHierarchy = transactionHierarchy;
_readOnlyClientTransactionListener = new ReadOnlyClientTransactionListenerWithLoadRules();
_newObjectHierarchyInvalidationClientTransactionListener = new NewObjectHierarchyInvalidationClientTransactionListener();
}
protected abstract IObjectLoader CreateObjectLoader(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IPersistenceStrategy persistenceStrategy,
IInvalidDomainObjectManager invalidDomainObjectManager,
IDataManager dataManager,
ITransactionHierarchyManager hierarchyManager);
public override IInvalidDomainObjectManager CreateInvalidDomainObjectManager(
ClientTransaction constructedTransaction, IClientTransactionEventSink eventSink)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
return(new InvalidDomainObjectManager(eventSink));
}
protected override IRelationEndPointManager CreateRelationEndPointManager(
ClientTransaction constructedTransaction,
IRelationEndPointProvider endPointProvider,
ILazyLoader lazyLoader,
IClientTransactionEventSink eventSink)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("endPointProvider", endPointProvider);
ArgumentUtility.CheckNotNull("lazyLoader", lazyLoader);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
var endPointChangeDetectionStrategy = new RootCollectionEndPointChangeDetectionStrategy();
var collectionEndPointDataManagerFactory = new CollectionEndPointDataManagerFactory(endPointChangeDetectionStrategy);
var virtualObjectEndPointDataManagerFactory = new VirtualObjectEndPointDataManagerFactory();
var relationEndPointFactory = CreateRelationEndPointFactory(
constructedTransaction,
endPointProvider,
lazyLoader,
eventSink,
virtualObjectEndPointDataManagerFactory,
collectionEndPointDataManagerFactory);
var virtualEndPointStateUpdateListener = new VirtualEndPointStateUpdateListener(eventSink);
var stateUpdateRaisingRelationEndPointFactory = new StateUpdateRaisingRelationEndPointFactoryDecorator(
relationEndPointFactory,
virtualEndPointStateUpdateListener);
var relationEndPointRegistrationAgent = new RootRelationEndPointRegistrationAgent(endPointProvider);
return(new RelationEndPointManager(
constructedTransaction, lazyLoader, eventSink, stateUpdateRaisingRelationEndPointFactory, relationEndPointRegistrationAgent));
}
protected override IObjectLoader CreateObjectLoader(
ClientTransaction constructedTransaction,
IClientTransactionEventSink eventSink,
IPersistenceStrategy persistenceStrategy,
IInvalidDomainObjectManager invalidDomainObjectManager,
IDataManager dataManager,
ITransactionHierarchyManager hierarchyManager)
{
ArgumentUtility.CheckNotNull("constructedTransaction", constructedTransaction);
ArgumentUtility.CheckNotNull("eventSink", eventSink);
var fetchEnabledPersistenceStrategy =
ArgumentUtility.CheckNotNullAndType <IFetchEnabledPersistenceStrategy> ("persistenceStrategy", persistenceStrategy);
ArgumentUtility.CheckNotNull("invalidDomainObjectManager", invalidDomainObjectManager);
ArgumentUtility.CheckNotNull("dataManager", dataManager);
ArgumentUtility.CheckNotNull("hierarchyManager", hierarchyManager);
var loadedObjectDataProvider = new LoadedObjectDataProvider(dataManager, invalidDomainObjectManager);
var registrationListener = new LoadedObjectDataRegistrationListener(eventSink, hierarchyManager);
var loadedObjectDataRegistrationAgent = new LoadedObjectDataRegistrationAgent(constructedTransaction, dataManager, registrationListener);
IFetchedRelationDataRegistrationAgent registrationAgent =
new DelegatingFetchedRelationDataRegistrationAgent(
new FetchedRealObjectRelationDataRegistrationAgent(),
new FetchedVirtualObjectRelationDataRegistrationAgent(dataManager),
new FetchedCollectionRelationDataRegistrationAgent(dataManager));
var eagerFetcher = new EagerFetcher(registrationAgent);
return(new FetchEnabledObjectLoader(
fetchEnabledPersistenceStrategy,
loadedObjectDataRegistrationAgent,
loadedObjectDataProvider,
eagerFetcher));
}
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> ();
}
private IRealObjectEndPointSyncState _syncState; // keeps track of whether this end-point is synchronised with the opposite end point
public RealObjectEndPoint(
ClientTransaction clientTransaction,
RelationEndPointID id,
DataContainer foreignKeyDataContainer,
IRelationEndPointProvider endPointProvider,
IClientTransactionEventSink transactionEventSink)
: base(
ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction),
ArgumentUtility.CheckNotNull("id", id))
{
ArgumentUtility.CheckNotNull("foreignKeyDataContainer", foreignKeyDataContainer);
ArgumentUtility.CheckNotNull("endPointProvider", endPointProvider);
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink);
if (ID.Definition.IsVirtual)
{
throw new ArgumentException("End point ID must refer to a non-virtual end point.", "id");
}
var propertyDefinition = GetPropertyDefinition();
if (foreignKeyDataContainer.ID != id.ObjectID)
{
throw new ArgumentException("The foreign key data container must be from the same object as the end point definition.", "foreignKeyDataContainer");
}
_foreignKeyDataContainer = foreignKeyDataContainer;
_endPointProvider = endPointProvider;
_transactionEventSink = transactionEventSink;
_propertyDefinition = propertyDefinition;
_syncState = new UnknownRealObjectEndPointSyncState(_endPointProvider);
}
public override void SetUp()
{
base.SetUp();
_definition = Configuration.GetTypeDefinition(typeof(Order)).GetRelationEndPointDefinition(typeof(Order).FullName + ".OrderTicket");
_virtualObjectEndPointMock = MockRepository.GenerateStrictMock <IVirtualObjectEndPoint> ();
_dataManagerMock = MockRepository.GenerateStrictMock <IVirtualObjectEndPointDataManager> ();
_dataManagerMock.Stub(stub => stub.EndPointID).Return(RelationEndPointID.Create(DomainObjectIDs.Order1, _definition));
_endPointProviderStub = MockRepository.GenerateStub <IRelationEndPointProvider> ();
_transactionEventSinkStub = MockRepository.GenerateStub <IClientTransactionEventSink>();
_loadState = new CompleteVirtualObjectEndPointLoadState(_dataManagerMock, _endPointProviderStub, _transactionEventSinkStub);
_relatedObject = DomainObjectMother.CreateFakeObject <OrderTicket> (DomainObjectIDs.OrderTicket1);
_relatedEndPointStub = MockRepository.GenerateStub <IRealObjectEndPoint> ();
_relatedEndPointStub.Stub(stub => stub.GetDomainObjectReference()).Return(_relatedObject);
_relatedEndPointStub.Stub(stub => stub.ObjectID).Return(_relatedObject.ID);
_relatedObject2 = DomainObjectMother.CreateFakeObject <OrderTicket> (DomainObjectIDs.OrderTicket2);
_relatedEndPointStub2 = MockRepository.GenerateStub <IRealObjectEndPoint> ();
_relatedEndPointStub2.Stub(stub => stub.ID).Return(RelationEndPointID.Create(_relatedObject2.ID, typeof(OrderTicket), "Order"));
_relatedEndPointStub2.Stub(stub => stub.GetDomainObjectReference()).Return(_relatedObject2);
_relatedEndPointStub2.Stub(stub => stub.ObjectID).Return(_relatedObject2.ID);
_owningObject = DomainObjectMother.CreateFakeObject <Order> ();
}
public override void SetUp()
{
base.SetUp();
_persistenceStrategyMock = MockRepository.GenerateStrictMock <IPersistenceStrategy> ();
_objectLoaderMock = MockRepository.GenerateStrictMock <IObjectLoader> ();
_transactionEventSinkWithMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_queryManager = new QueryManager(
_persistenceStrategyMock,
_objectLoaderMock,
_transactionEventSinkWithMock);
_collectionQuery = QueryFactory.CreateQueryFromConfiguration("OrderQuery");
_scalarQuery = QueryFactory.CreateQueryFromConfiguration("OrderNoSumByCustomerNameQuery");
_customQuery = QueryFactory.CreateQueryFromConfiguration("CustomQuery");
_fakeOrder1 = DomainObjectMother.CreateFakeObject <Order> ();
_fakeOrder2 = DomainObjectMother.CreateFakeObject <Order>();
_loadedObjectDataStub1 = MockRepository.GenerateStub <ILoadedObjectData> ();
_loadedObjectDataStub2 = MockRepository.GenerateStub <ILoadedObjectData> ();
_rowConversion = qrr => qrr.GetRawValue(0);
}
public IRelationEndPointManager CallCreateRelationEndPointManager(
ClientTransaction constructedTransaction,
IRelationEndPointProvider endPointProvider,
ILazyLoader lazyLoader,
IClientTransactionEventSink eventSink)
{
return(CreateRelationEndPointManager(constructedTransaction, endPointProvider, lazyLoader, eventSink));
}
protected override IRelationEndPointManager CreateRelationEndPointManager(
ClientTransaction constructedTransaction,
IRelationEndPointProvider endPointProvider,
ILazyLoader lazyLoader,
IClientTransactionEventSink eventSink)
{
throw new NotImplementedException();
}
public ObjectEndPointSetSameCommand(IObjectEndPoint modifiedEndPoint, IClientTransactionEventSink transactionEventSink)
: base(
ArgumentUtility.CheckNotNull("modifiedEndPoint", modifiedEndPoint),
modifiedEndPoint.GetOppositeObject(),
modifiedEndPoint.GetOppositeObject(),
transactionEventSink)
{
}
public SynchronizedRealObjectEndPointSyncState(IRelationEndPointProvider endPointProvider, IClientTransactionEventSink transactionEventSink)
{
ArgumentUtility.CheckNotNull("endPointProvider", endPointProvider);
ArgumentUtility.CheckNotNull("transactionEventSink", transactionEventSink);
_endPointProvider = endPointProvider;
_transactionEventSink = transactionEventSink;
}
public override void SetUp()
{
base.SetUp();
_transactionEventSinkWithMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_manager = new InvalidDomainObjectManager(_transactionEventSinkWithMock);
_order1 = DomainObjectMother.CreateFakeObject <Order> (DomainObjectIDs.Order1);
}
protected RealObjectEndPoint(FlattenedDeserializationInfo info)
: base(info)
{
_foreignKeyDataContainer = info.GetValueForHandle <DataContainer> ();
_propertyDefinition = GetPropertyDefinition();
_endPointProvider = info.GetValueForHandle <IRelationEndPointProvider> ();
_transactionEventSink = info.GetValueForHandle <IClientTransactionEventSink> ();
_syncState = info.GetValueForHandle <IRealObjectEndPointSyncState> ();
}
