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> (); }