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