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