public void EndRegisterIfRequired_RaisesEndEvent_EvenWhenRegistrationThrows() { var dataContainer1 = DataContainerObjectMother.Create(DomainObjectIDs.Order1); var dataContainer2 = DataContainerObjectMother.Create(DomainObjectIDs.Order3); var collector = CreateCollectorAndPrepare(dataContainer1, dataContainer2); var exception = new Exception("Test"); using (_mockRepository.Ordered()) { var loadedObjectIDs = new[] { dataContainer1.ID, dataContainer2.ID }; _registrationListenerMock.Expect(mock => mock.OnBeforeObjectRegistration(Arg <ReadOnlyCollection <ObjectID> > .List.Equal(loadedObjectIDs))); _dataManagerMock.Expect(mock => mock.RegisterDataContainer(dataContainer1)); _dataManagerMock.Expect(mock => mock.RegisterDataContainer(dataContainer2)).Throw(exception); _registrationListenerMock .Expect(mock => mock.OnAfterObjectRegistration( Arg <ReadOnlyCollection <ObjectID> > .List.Equal(new[] { dataContainer1.ID, dataContainer2.ID }), Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { dataContainer1.DomainObject }))); } _mockRepository.ReplayAll(); Assert.That(() => _agent.EndRegisterIfRequired(collector), Throws.Exception.SameAs(exception)); _mockRepository.VerifyAll(); }
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 void EndRegisterIfRequired_RegistersDataContainers_AndRaisesEvents() { var dataContainer1 = DataContainerObjectMother.Create(DomainObjectIDs.Order1); var dataContainer2 = DataContainerObjectMother.Create(DomainObjectIDs.Order3); var collector = CreateCollectorAndPrepare(dataContainer1, dataContainer2); using (_mockRepository.Ordered()) { var loadedObjectIDs = new[] { dataContainer1.ID, dataContainer2.ID }; _registrationListenerMock.Expect(mock => mock.OnBeforeObjectRegistration(Arg <ReadOnlyCollection <ObjectID> > .List.Equal(loadedObjectIDs))); _dataManagerMock.Expect(mock => mock.RegisterDataContainer(dataContainer1)); _dataManagerMock.Expect(mock => mock.RegisterDataContainer(dataContainer2)); _registrationListenerMock .Expect(mock => mock.OnAfterObjectRegistration( Arg <ReadOnlyCollection <ObjectID> > .List.Equal(new[] { dataContainer1.ID, dataContainer2.ID }), Arg <ReadOnlyCollection <DomainObject> > .List.Equal(new[] { dataContainer1.DomainObject, dataContainer2.DomainObject }))); } _mockRepository.ReplayAll(); _agent.EndRegisterIfRequired(collector); _mockRepository.VerifyAll(); }
public void PersistData_ChangedDataContainer() { var persistableData = CreatePersistableDataForExistingOrder(); persistableData.DataContainer.SetTimestamp(1676); SetPropertyValue(persistableData.DataContainer, typeof(Order), "OrderNumber", 12); Assert.That(persistableData.DataContainer.State, Is.EqualTo(StateType.Changed)); _parentTransactionContextMock.Expect(mock => mock.UnlockParentTransaction()).Return(_unlockedParentTransactionContextMock); var parentDataContainer = DataContainerObjectMother.CreateExisting(persistableData.DomainObject); parentDataContainer.SetTimestamp(4711); Assert.That(parentDataContainer.State, Is.EqualTo(StateType.Unchanged)); _parentTransactionContextMock .Expect(mock => mock.GetDataContainerWithoutLoading(persistableData.DomainObject.ID)) .Return(parentDataContainer); _unlockedParentTransactionContextMock .Expect(mock => mock.Dispose()) .WhenCalled(mi => { Assert.That(parentDataContainer.Timestamp, Is.EqualTo(1676), "ParentDataContainer must be changed prior to Dispose."); Assert.That(GetPropertyValue(parentDataContainer, typeof(Order), "OrderNumber"), Is.EqualTo(12)); Assert.That(parentDataContainer.State, Is.EqualTo(StateType.Changed)); Assert.That(parentDataContainer.HasBeenMarkedChanged, Is.False); }); _persistenceStrategy.PersistData(new[] { persistableData }.AsOneTime()); _parentTransactionContextMock.VerifyAllExpectations(); _unlockedParentTransactionContextMock.VerifyAllExpectations(); }
public void DataContainerStateUpdated_AllowedForActiveTransaction_NotInLoadMode() { Assert.That(_listener.IsInLoadMode, Is.False); var someDataContainer = DataContainerObjectMother.Create(DomainObjectIDs.Client1); Assert.That(() => _listener.DataContainerStateUpdated(_transaction, someDataContainer, StateType.Changed), Throws.Nothing); }
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]); }
private PersistableData CreatePersistableDataForExistingOrder() { var domainObject = DomainObjectMother.CreateFakeObject <Order> (); var dataContainer = DataContainerObjectMother.CreateExisting(domainObject.ID); dataContainer.SetDomainObject(domainObject); return(new PersistableData(domainObject, StateType.Changed, dataContainer, new IRelationEndPoint[0])); }
public void RaiseDataContainerMapUnregisteringEvent() { var dataContainer = DataContainerObjectMother.Create(Order.NewObject()); CheckEventWithListenersOnly( s => s.RaiseDataContainerMapUnregisteringEvent(dataContainer), l => l.DataContainerMapUnregistering(_clientTransaction, dataContainer)); }
private DataContainer CreateChangedDataContainer( ObjectID objectID, int timestamp, PropertyDefinition propertyDefinition, object currentPropertyValue) { var parentDataContainer = DataContainerObjectMother.CreateExisting(objectID); parentDataContainer.SetTimestamp(timestamp); parentDataContainer.SetValue(propertyDefinition, currentPropertyValue); return(parentDataContainer); }
public void RaiseDataContainerStateUpdatedEvent() { var dataContainer = DataContainerObjectMother.Create(Order.NewObject()); var newDataContainerState = StateType.New; CheckEventWithListenersOnly( s => s.RaiseDataContainerStateUpdatedEvent(dataContainer, newDataContainerState), l => l.DataContainerStateUpdated(_clientTransaction, dataContainer, newDataContainerState)); }
public void DataContainerStateUpdated_ForbiddenWhenTransactionReadOnly() { ClientTransactionTestHelper.SetIsWriteable(_transaction, false); Assert.That(_listener.IsInLoadMode, Is.False); var someDataContainer = DataContainerObjectMother.Create(DomainObjectIDs.Client1); Assert.That( () => _listener.DataContainerStateUpdated(_transaction, someDataContainer, StateType.Changed), Throws.TypeOf <ClientTransactionReadOnlyException> ()); }
public override void SetUp() { base.SetUp(); _commandStub = MockRepository.GenerateStub <IStorageProviderCommand <IEnumerable <DataContainer>, IRdbmsProviderCommandExecutionContext> >(); _executionContext = MockRepository.GenerateStub <IRdbmsProviderCommandExecutionContext>(); _order1Container = DataContainerObjectMother.Create(DomainObjectIDs.Order1); _order2Container = DataContainerObjectMother.Create(DomainObjectIDs.Order3); _order3Container = DataContainerObjectMother.Create(DomainObjectIDs.Order4); }
public void DataContainerStateUpdated_LoadedObject_AllowedInLoadMode() { ClientTransactionTestHelper.SetIsWriteable(_transaction, false); _listener.AddCurrentlyLoadingObjectIDs(new[] { DomainObjectIDs.Client1 }); Assert.That(_listener.IsInLoadMode, Is.True); var someDataContainer = DataContainerObjectMother.Create(DomainObjectIDs.Client1); Assert.That(() => _listener.DataContainerStateUpdated(_transaction, someDataContainer, StateType.Changed), Throws.Nothing); }
public void GetObject_DeletedObject_IncludeDeletedTrue() { var dataContainer = DataContainerObjectMother.CreateDeleted(_domainObject1); Assert.That(dataContainer.State, Is.EqualTo(StateType.Deleted)); _dataManagerMock.Stub(stub => stub.GetDataContainerWithLazyLoad(_objectID1, true)).Return(dataContainer); var result = _agent.GetObject(_objectID1, true); Assert.That(result, Is.SameAs(dataContainer.DomainObject)); }
public void Execute_NonMatchingDataContainer() { var dataContainer = DataContainerObjectMother.Create(DomainObjectIDs.Order3); _innerCommandMock.Expect(mock => mock.Execute(_fakeContext)).Return(dataContainer); Assert.That( () => _associateCommand.Execute(_fakeContext), Throws.TypeOf <PersistenceException> ().With.Message.EqualTo( "The ObjectID of the loaded DataContainer 'Order|83445473-844a-4d3f-a8c3-c27f8d98e8ba|System.Guid' and the expected ObjectID " + "'Order|5682f032-2f0b-494b-a31c-c97f02b89c36|System.Guid' differ.")); }
public void GetObject_DeletedObject_IncludeDeletedFalse() { var dataContainer = DataContainerObjectMother.CreateDeleted(_domainObject1); Assert.That(dataContainer.State, Is.EqualTo(StateType.Deleted)); _dataManagerMock.Stub(stub => stub.GetDataContainerWithLazyLoad(_objectID1, true)).Return(dataContainer); Assert.That( () => _agent.GetObject(_objectID1, false), Throws.TypeOf <ObjectDeletedException>().With.Property <ObjectDeletedException> (e => e.ID).EqualTo(_objectID1)); }
public void Execute_MatchingDataContainer() { var dataContainer = DataContainerObjectMother.Create(_expectedID); _innerCommandMock.Expect(mock => mock.Execute(_fakeContext)).Return(dataContainer); var result = _associateCommand.Execute(_fakeContext); _innerCommandMock.VerifyAllExpectations(); Assert.That(result.ObjectID, Is.EqualTo(_expectedID)); Assert.That(result.LocatedObject, Is.SameAs(dataContainer)); }
public void DataContainerStateUpdated_SomeObject_ForbiddenInLoadMode() { ClientTransactionTestHelper.SetIsWriteable(_transaction, false); _listener.AddCurrentlyLoadingObjectIDs(new[] { DomainObjectIDs.Client1 }); Assert.That(_listener.IsInLoadMode, Is.True); var someDataContainer = DataContainerObjectMother.Create(DomainObjectIDs.Client2); Assert.That( () => _listener.DataContainerStateUpdated(_transaction, someDataContainer, StateType.Changed), Throws.TypeOf <ClientTransactionReadOnlyException>()); }
public void Execute_DuplicatedDataContainer() { var command = new MultiDataContainerAssociateWithIDsCommand(new[] { DomainObjectIDs.Order1 }, _commandStub); var otherOrder1DataContainer = DataContainerObjectMother.Create(_order1Container.ID); _commandStub.Stub(stub => stub.Execute(_executionContext)).Return(new[] { _order1Container, otherOrder1DataContainer }); var result = command.Execute(_executionContext).ToList(); Assert.That(result.Count, Is.EqualTo(1)); Assert.That(result[0].LocatedObject, Is.SameAs(otherOrder1DataContainer)); Assert.That(result[0].ObjectID, Is.EqualTo(DomainObjectIDs.Order1)); }
public void LoadObjectData_Multiple() { var objectID1 = DomainObjectIDs.Order1; var objectID2 = DomainObjectIDs.Order3; var objectID3 = DomainObjectIDs.Order4; var parentObject1 = DomainObjectMother.CreateFakeObject <Order> (objectID1); var parentDataContainer1 = CreateChangedDataContainer(objectID1, 4711, _orderNumberPropertyDefinition, 17); CheckDataContainer(parentDataContainer1, objectID1, 4711, StateType.Changed, _orderNumberPropertyDefinition, 17, 0, true); var parentObject3 = DomainObjectMother.CreateFakeObject <Order> (objectID3); var parentDataContainer3 = DataContainerObjectMother.CreateExisting(objectID3); var parentEventListenerMock = MockRepository.GenerateStrictMock <IDataContainerEventListener> (); parentDataContainer1.SetEventListener(parentEventListenerMock); parentDataContainer3.SetEventListener(parentEventListenerMock); // Use a strict mock because the parameter should not be enumerated, it should only be passed on TryGetObjects _parentTransactionContextMock .Expect(mock => mock.TryGetObjects(Arg <IEnumerable <ObjectID> > .List.Equal(new[] { objectID1, objectID2, objectID3 }))) .Return(new[] { parentObject1, null, parentObject3 }); _parentTransactionContextMock .Expect(mock => mock.GetDataContainerWithLazyLoad(objectID1, true)) .Return(parentDataContainer1); _parentTransactionContextMock .Expect(mock => mock.GetDataContainerWithLazyLoad(objectID3, true)) .Return(parentDataContainer3); var result = _persistenceStrategy.LoadObjectData(new[] { objectID1, objectID2, objectID3 }.AsOneTime()).ToList(); _parentTransactionContextMock.VerifyAllExpectations(); parentEventListenerMock.AssertWasNotCalled( mock => mock.PropertyValueReading(Arg <DataContainer> .Is.Anything, Arg <PropertyDefinition> .Is.Anything, Arg <ValueAccess> .Is.Anything)); Assert.That(result[0], Is.TypeOf <FreshlyLoadedObjectData> ()); Assert.That(result[0].ObjectID, Is.EqualTo(objectID1)); CheckDataContainer(((FreshlyLoadedObjectData)result[0]).FreshlyLoadedDataContainer, objectID1, 4711, StateType.Unchanged, _orderNumberPropertyDefinition, 17, 17, false); Assert.That(result[1], Is.TypeOf <NotFoundLoadedObjectData> ()); Assert.That(result[1].ObjectID, Is.EqualTo(objectID2)); Assert.That(result[2], Is.TypeOf <FreshlyLoadedObjectData> ()); Assert.That(result[2].ObjectID, Is.EqualTo(objectID3)); }
public void PersistData_EndPoints() { var domainObject = DomainObjectMother.CreateFakeObject <Order> (); var persistedDataContainer = DataContainerObjectMother.CreateExisting(domainObject); var persistedEndPoint1 = RelationEndPointObjectMother.CreateStub(); persistedEndPoint1.Stub(stub => stub.HasChanged).Return(true); var persistedEndPoint2 = RelationEndPointObjectMother.CreateStub(); persistedEndPoint2.Stub(stub => stub.HasChanged).Return(false); var persistedEndPoint3 = RelationEndPointObjectMother.CreateStub(); persistedEndPoint3.Stub(stub => stub.HasChanged).Return(true); var persistableData = new PersistableData( domainObject, StateType.Changed, persistedDataContainer, new[] { persistedEndPoint1, persistedEndPoint2, persistedEndPoint3 }); var counter = new OrderedExpectationCounter(); _parentTransactionContextMock.Expect(mock => mock.UnlockParentTransaction()).Return(_unlockedParentTransactionContextMock); var parentEndPointMock1 = MockRepository.GenerateStrictMock <IRelationEndPoint> (); _parentTransactionContextMock .Expect(mock => mock.GetRelationEndPointWithoutLoading(persistedEndPoint1.ID)) .Return(parentEndPointMock1); parentEndPointMock1 .Expect(mock => mock.SetDataFromSubTransaction(persistedEndPoint1)) .Ordered(counter, "SetDataFromSubTransaction must occur prior to Dispose."); var parentEndPointMock3 = MockRepository.GenerateStrictMock <IRelationEndPoint> (); _parentTransactionContextMock .Expect(mock => mock.GetRelationEndPointWithoutLoading(persistedEndPoint3.ID)) .Return(parentEndPointMock3); parentEndPointMock3 .Expect(mock => mock.SetDataFromSubTransaction(persistedEndPoint3)) .Ordered(counter, "SetDataFromSubTransaction must occur prior to Dispose."); _unlockedParentTransactionContextMock.Expect(mock => mock.Dispose()).Ordered(counter, "Dispose should come at the end."); _persistenceStrategy.PersistData(new[] { persistableData }.AsOneTime()); _parentTransactionContextMock.VerifyAllExpectations(); _unlockedParentTransactionContextMock.VerifyAllExpectations(); parentEndPointMock1.VerifyAllExpectations(); parentEndPointMock3.VerifyAllExpectations(); }
public void PersistData_NewDataContainer_WithEndPoint() { var domainObject = DomainObjectMother.CreateFakeObject <Order> (); var persistedDataContainer = DataContainerObjectMother.CreateNew(domainObject); SetPropertyValue(persistedDataContainer, typeof(Order), "OrderNumber", 12); var persistedEndPoint = RelationEndPointObjectMother.CreateStub(); persistedEndPoint.Stub(stub => stub.HasChanged).Return(true); var persistableData = new PersistableData(domainObject, StateType.New, persistedDataContainer, new[] { persistedEndPoint }); var counter = new OrderedExpectationCounter(); _parentTransactionContextMock.Expect(mock => mock.UnlockParentTransaction()).Return(_unlockedParentTransactionContextMock); _parentTransactionContextMock.Stub(stub => stub.IsInvalid(domainObject.ID)).Return(true); _parentTransactionContextMock.Stub(stub => stub.GetDataContainerWithoutLoading(domainObject.ID)).Return(null); _unlockedParentTransactionContextMock .Expect(mock => mock.MarkNotInvalid(domainObject.ID)) .Ordered(counter); _unlockedParentTransactionContextMock .Expect(mock => mock.RegisterDataContainer(Arg <DataContainer> .Is.Anything)) .WhenCalledOrdered( counter, mi => CheckDataContainer((DataContainer)mi.Arguments[0], domainObject, null, StateType.New, _orderNumberPropertyDefinition, 12, 0, true), "New DataContainers must be registered before the parent relation end-points are retrieved for persistence (and prior to Dispose)." ); var parentEndPointMock = MockRepository.GenerateStrictMock <IRelationEndPoint>(); _parentTransactionContextMock .Expect(mock => mock.GetRelationEndPointWithoutLoading(persistedEndPoint.ID)) .Return(parentEndPointMock) .Ordered(counter, "New DataContainers must be registered before the parent relation end-points are retrieved for persistence."); parentEndPointMock .Expect(mock => mock.SetDataFromSubTransaction(persistedEndPoint)) .Ordered(counter, "SetDataFromSubTransaction must occur prior to Dispose."); _unlockedParentTransactionContextMock.Expect(mock => mock.Dispose()).Ordered(counter, "Dispose should come at the end."); _persistenceStrategy.PersistData(new[] { persistableData }.AsOneTime()); _parentTransactionContextMock.VerifyAllExpectations(); _unlockedParentTransactionContextMock.VerifyAllExpectations(); parentEndPointMock.VerifyAllExpectations(); }
public void PersistData_DeletedDataContainer_WithEndPoint_ExistingInParent() { var domainObject = DomainObjectMother.CreateFakeObject <Order> (); var persistedDataContainer = DataContainerObjectMother.CreateDeleted(domainObject); var persistedEndPoint = RelationEndPointObjectMother.CreateStub(); persistedEndPoint.Stub(stub => stub.HasChanged).Return(true); var persistableData = new PersistableData(domainObject, StateType.Deleted, persistedDataContainer, new[] { persistedEndPoint }); _parentTransactionContextMock.Expect(mock => mock.UnlockParentTransaction()).Return(_unlockedParentTransactionContextMock); var counter = new OrderedExpectationCounter(); var parentEndPointMock = MockRepository.GenerateStrictMock <IRelationEndPoint> (); _parentTransactionContextMock .Expect(mock => mock.GetRelationEndPointWithoutLoading(persistedEndPoint.ID)) .Return(parentEndPointMock); parentEndPointMock .Expect(mock => mock.SetDataFromSubTransaction(persistedEndPoint)) .Ordered(counter, "SetDataFromSubTransaction must occur prior to Dispose."); var parentDataContainer = DataContainerObjectMother.CreateExisting(persistedDataContainer.ID); parentDataContainer.SetDomainObject(domainObject); _parentTransactionContextMock .Stub(stub => stub.GetDataContainerWithoutLoading(domainObject.ID)) .Return(parentDataContainer); _unlockedParentTransactionContextMock .Expect(mock => mock.Dispose()) .WhenCalledOrdered( counter, mi => Assert.That( parentDataContainer.State, Is.EqualTo(StateType.Deleted), "Parent DataContainer must be deleted before parent transaction is locked again."), "Dispose should come at the end."); _persistenceStrategy.PersistData(new[] { persistableData }.AsOneTime()); _parentTransactionContextMock.VerifyAllExpectations(); _unlockedParentTransactionContextMock.VerifyAllExpectations(); parentEndPointMock.VerifyAllExpectations(); }
public void PersistData_DeletedDataContainer_WithEndPoint_NewInParent() { var domainObject = DomainObjectMother.CreateFakeObject <Order> (); var persistedDataContainer = DataContainerObjectMother.CreateDeleted(domainObject); var persistedEndPoint = RelationEndPointObjectMother.CreateStub(); persistedEndPoint.Stub(stub => stub.HasChanged).Return(true); var persistableData = new PersistableData(domainObject, StateType.Deleted, persistedDataContainer, new[] { persistedEndPoint }); var counter = new OrderedExpectationCounter(); _parentTransactionContextMock.Expect(mock => mock.UnlockParentTransaction()).Return(_unlockedParentTransactionContextMock); var parentEndPointMock = MockRepository.GenerateStrictMock <IRelationEndPoint> (); _parentTransactionContextMock .Expect(mock => mock.GetRelationEndPointWithoutLoading(persistedEndPoint.ID)) .Return(parentEndPointMock) .Ordered(counter, "Deleted DataContainers must be persisted after the parent relation end-points are retrieved for persistence."); parentEndPointMock .Expect(mock => mock.SetDataFromSubTransaction(persistedEndPoint)) .Ordered(counter, "SetDataFromSubTransaction must occur prior to Dispose."); var parentDataContainer = DataContainerObjectMother.CreateNew(persistedDataContainer.ID); parentDataContainer.SetDomainObject(domainObject); _parentTransactionContextMock .Stub(stub => stub.GetDataContainerWithoutLoading(domainObject.ID)) .Return(parentDataContainer); _unlockedParentTransactionContextMock .Expect(mock => mock.Discard(parentDataContainer)) .Ordered(counter, "Deleted DataContainers must be persisted after the parent relation end-points are retrieved for persistence."); _unlockedParentTransactionContextMock .Expect(mock => mock.Dispose()) .Ordered(counter, "Dispose should come at the end."); _persistenceStrategy.PersistData(new[] { persistableData }.AsOneTime()); _parentTransactionContextMock.VerifyAllExpectations(); _unlockedParentTransactionContextMock.VerifyAllExpectations(); parentEndPointMock.VerifyAllExpectations(); }
public void LoadObjectData_Multiple_ParentObjectIsDeleted() { var objectID = DomainObjectIDs.Order1; var parentObject = DomainObjectMother.CreateFakeObject <Order> (); var deletedParentDataContainer = DataContainerObjectMother.CreateDeleted(objectID); _parentTransactionContextMock .Expect(mock => mock.TryGetObject(objectID)) .Return(parentObject); _parentTransactionContextMock .Expect(mock => mock.GetDataContainerWithLazyLoad(objectID, true)) .Return(deletedParentDataContainer); Assert.That( () => _persistenceStrategy.LoadObjectData(objectID), Throws.TypeOf <ObjectDeletedException> ().With.Message.EqualTo( "Object 'Order|5682f032-2f0b-494b-a31c-c97f02b89c36|System.Guid' is already deleted in the parent transaction.")); _parentTransactionContextMock.VerifyAllExpectations(); }
public void PersistData_MarkedAsChangedDataContainer() { var persistableData1 = CreateMarkAsChangedPersistableDataForOrder(); var persistableData2 = CreateMarkAsChangedPersistableDataForOrder(); var persistableData3 = CreateMarkAsChangedPersistableDataForOrder(); _parentTransactionContextMock.Expect(mock => mock.UnlockParentTransaction()).Return(_unlockedParentTransactionContextMock); var unchangedParentDataContainer = DataContainerObjectMother.CreateExisting(persistableData1.DomainObject); _parentTransactionContextMock .Expect(mock => mock.GetDataContainerWithoutLoading(persistableData1.DomainObject.ID)) .Return(unchangedParentDataContainer); var changedParentDataContainer = DataContainerObjectMother.CreateExisting(persistableData2.DomainObject); SetPropertyValue(changedParentDataContainer, typeof(Order), "OrderNumber", 23); _parentTransactionContextMock .Expect(mock => mock.GetDataContainerWithoutLoading(persistableData2.DomainObject.ID)) .Return(changedParentDataContainer); var newParentDataContainer = DataContainerObjectMother.CreateNew(persistableData3.DomainObject); _parentTransactionContextMock .Expect(mock => mock.GetDataContainerWithoutLoading(persistableData3.DomainObject.ID)) .Return(newParentDataContainer); _unlockedParentTransactionContextMock .Expect(mock => mock.Dispose()) .WhenCalled(mi => { Assert.That(unchangedParentDataContainer.HasBeenMarkedChanged, Is.True); Assert.That(changedParentDataContainer.HasBeenMarkedChanged, Is.True); Assert.That(newParentDataContainer.HasBeenMarkedChanged, Is.False); }); _persistenceStrategy.PersistData(new[] { persistableData1, persistableData2, persistableData3 }.AsOneTime()); _parentTransactionContextMock.VerifyAllExpectations(); _unlockedParentTransactionContextMock.VerifyAllExpectations(); }
public static FreshlyLoadedObjectData CreateFreshlyLoadedObjectData(ObjectID objectID) { return(new FreshlyLoadedObjectData(DataContainerObjectMother.Create(objectID))); }
public IMethodOptions <IEnumerable <ILoadedObjectData> > ExpectLoadObjectData(IEnumerable <ObjectID> loadedObjectIDs) { return(Mock .Expect(mock => mock.LoadObjectData(Arg <IEnumerable <ObjectID> > .List.Equal(loadedObjectIDs))) .Return(loadedObjectIDs.Select(id => (ILoadedObjectData) new FreshlyLoadedObjectData(DataContainerObjectMother.CreateExisting(id))))); }