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 void DelegatingMembers() { var objectID = DomainObjectIDs.Order1; var dataContainer = DataContainer.CreateNew(objectID); var relationEndPointID = RelationEndPointID.Create(objectID, typeof(Order), "OrderTicket"); var virtualEndPoint = MockRepository.GenerateStub <IVirtualEndPoint>(); var domainObject = DomainObjectMother.CreateFakeObject <Order>(); var persistableData = new PersistableData(domainObject, StateType.Unchanged, dataContainer, new IRelationEndPoint[0]); var dataManagementCommand = MockRepository.GenerateStub <IDataManagementCommand> (); var randomBoolean = BooleanObjectMother.GetRandomBoolean(); CheckDelegation(dm => dm.GetOrCreateVirtualEndPoint(relationEndPointID), virtualEndPoint); CheckDelegation(dm => dm.GetRelationEndPointWithLazyLoad(relationEndPointID), virtualEndPoint); CheckDelegation(dm => dm.GetRelationEndPointWithoutLoading(relationEndPointID), virtualEndPoint); CheckDelegation(dm => dm.GetDataContainerWithoutLoading(objectID), dataContainer); CheckDelegation(dm => dm.RegisterDataContainer(dataContainer)); CheckDelegation(dm => dm.Discard(dataContainer)); CheckDelegation(dm => dm.DataContainers, MockRepository.GenerateStub <IDataContainerMapReadOnlyView> ()); CheckDelegation(dm => dm.RelationEndPoints, MockRepository.GenerateStub <IRelationEndPointMapReadOnlyView> ()); CheckDelegation(dm => dm.GetState(objectID), StateType.Deleted); CheckDelegation(dm => dm.GetDataContainerWithLazyLoad(objectID, randomBoolean), dataContainer); CheckDelegation(dm => dm.GetDataContainersWithLazyLoad(new[] { objectID }, true), new[] { dataContainer }); CheckDelegation(dm => dm.GetLoadedDataByObjectState(StateType.Unchanged), new[] { persistableData }); CheckDelegation(dm => dm.MarkInvalid(domainObject)); CheckDelegation(dm => dm.MarkNotInvalid(objectID)); CheckDelegation(dm => dm.Commit()); CheckDelegation(dm => dm.Rollback()); CheckDelegation(dm => dm.CreateDeleteCommand(domainObject), dataManagementCommand); CheckDelegation(dm => dm.CreateUnloadCommand(new[] { objectID }), dataManagementCommand); CheckDelegation(dm => dm.CreateUnloadVirtualEndPointsCommand(new[] { relationEndPointID }), dataManagementCommand); CheckDelegation(dm => dm.CreateUnloadAllCommand(), dataManagementCommand); CheckDelegation(dm => dm.LoadLazyCollectionEndPoint(relationEndPointID)); CheckDelegation(dm => dm.LoadLazyVirtualObjectEndPoint(relationEndPointID)); CheckDelegation(dm => dm.LoadLazyDataContainer(objectID), dataContainer); }
public void Validate(ClientTransaction clientTransaction, PersistableData persistableData) { ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction); ArgumentUtility.CheckNotNull("persistableData", persistableData); foreach (var validator in _validators) { validator.Validate(clientTransaction, persistableData); } }
public void HasDataChanged_True() { var fakeDomainObject = DomainObjectMother.CreateFakeObject <Order>(); var fakeDataContainer = DataContainer.CreateNew(fakeDomainObject.ID); var item = new PersistableData(fakeDomainObject, StateType.Changed, fakeDataContainer, new IRelationEndPoint[0]); _dataManagerMock.Stub(stub => stub.GetLoadedDataByObjectState(StateType.Changed, StateType.Deleted, StateType.New)).Return(new[] { item }); _mockRepository.ReplayAll(); var result = _agent.HasDataChanged(); Assert.That(result, Is.True); }
public void Validate(ClientTransaction clientTransaction, PersistableData data) { ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction); ArgumentUtility.CheckNotNull("data", data); if (data.DomainObjectState == StateType.Deleted) { return; } foreach (var propertyDefinition in data.DomainObject.ID.ClassDefinition.GetPropertyDefinitions()) { ValidatePropertyDefinition(data.DomainObject, data.DataContainer, propertyDefinition); } }
public void CommitValidate_WithValidationFailures() { using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope()) { var domainObject1 = DomainObjectWithoutAnnotatedProperties.NewObject(); var domainObject2 = TestDomainObject.NewObject(); var domainObject3 = DomainObjectWithoutAnnotatedProperties.NewObject(); var persistableData1 = new PersistableData( domainObject1, StateType.New, DataContainerObjectMother.Create(domainObject1), new IRelationEndPoint[0]); var persistableData2 = new PersistableData( domainObject2, StateType.Changed, DataContainerObjectMother.Create(domainObject2), new IRelationEndPoint[0]); var persistableData3 = new PersistableData( domainObject3, StateType.Deleted, DataContainerObjectMother.Create(domainObject3), new IRelationEndPoint[0]); _validatorBuilderMock .Expect(mock => mock.BuildValidator(typeof(DomainObjectWithoutAnnotatedProperties))) .Return(_validatorMock1); _validatorBuilderMock .Expect(mock => mock.BuildValidator(typeof(TestDomainObject))) .Return(_validatorMock2); var validationFailure1 = new ValidationFailure("Test1", "Error1"); validationFailure1.SetValidatedInstance(domainObject1); var validationFailure2 = new ValidationFailure("Test2", "Error2"); validationFailure2.SetValidatedInstance(domainObject1); var validationFailure3 = new ValidationFailure("Test3", "Error3"); _validatorMock1.Expect(mock => mock.Validate(domainObject1)).Return(new ValidationResult(new [] { validationFailure1 })); _validatorMock2.Expect(mock => mock.Validate(domainObject2)).Return(new ValidationResult(new [] { validationFailure2, validationFailure3 })); _extension.CommitValidate(ClientTransaction.Current, Array.AsReadOnly(new[] { persistableData1, persistableData2, persistableData3 })); _validatorBuilderMock.VerifyAllExpectations(); _validatorMock1.VerifyAllExpectations(); _validatorMock2.VerifyAllExpectations(); } }
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 Validate() { var validators = new[] { MockRepository.GenerateStub <IPersistableDataValidator>(), MockRepository.GenerateStub <IPersistableDataValidator>() }; using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope()) { var domainObject = DomainObjectMother.CreateFakeObject <ClassWithAllDataTypes> (DomainObjectIDs.ClassWithAllDataTypes1); var dataContainer = DataContainer.CreateNew(domainObject.ID); var persistableData = new PersistableData(domainObject, StateType.Changed, dataContainer, Enumerable.Empty <IRelationEndPoint>()); var compoundValidator = new CompoundPersistableDataValidator(validators); compoundValidator.Validate(ClientTransaction.Current, persistableData); validators[0].AssertWasCalled(_ => _.Validate(ClientTransaction.Current, persistableData)); validators[1].AssertWasCalled(_ => _.Validate(ClientTransaction.Current, persistableData)); } }
public void Validate(ClientTransaction clientTransaction, PersistableData data) { ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction); ArgumentUtility.CheckNotNull("data", data); if (data.DomainObjectState == StateType.Deleted) { return; } Assertion.IsTrue( data.DomainObjectState != StateType.NotLoadedYet && data.DomainObjectState != StateType.Invalid, "No unloaded or invalid objects get this far."); foreach (var endPoint in data.GetAssociatedEndPoints()) { if (endPoint.Definition.IsMandatory && endPoint.IsDataComplete) { endPoint.ValidateMandatory(); } } }