public void CreateSubTransaction()
{
var counter = new OrderedExpectationCounter();
bool subTransactionCreatingCalled = false;
_thisEventSinkWithStrictMock.Expect(mock => mock.RaiseSubTransactionCreatingEvent())
.WhenCalledOrdered(counter, mi =>
{
Assert.That(_manager.IsWriteable, Is.True);
subTransactionCreatingCalled = true;
});
ClientTransaction fakeSubTransaction = ClientTransactionObjectMother.CreateWithParent(_thisTransaction);
Func <ClientTransaction, ClientTransaction> factory = tx =>
{
Assert.That(tx, Is.SameAs(_thisTransaction));
Assert.That(subTransactionCreatingCalled, Is.True);
Assert.That(_manager.IsWriteable, Is.False, "IsWriteable needs to be set before the factory is called.");
ClientTransactionTestHelper.SetIsWriteable(_thisTransaction, false); // required by assertion in ReadOnlyClientTransactionListener
return(fakeSubTransaction);
};
_hierarchyStrictMock.Expect(mock => mock.AppendLeafTransaction(fakeSubTransaction)).Ordered(counter);
_thisEventSinkWithStrictMock.Expect(mock => mock.RaiseSubTransactionCreatedEvent(fakeSubTransaction)).Ordered(counter);
var result = _manager.CreateSubTransaction(factory);
Assert.That(result, Is.Not.Null.And.SameAs(fakeSubTransaction));
Assert.That(_manager.SubTransaction, Is.SameAs(fakeSubTransaction));
Assert.That(_manager.IsWriteable, Is.False);
_hierarchyStrictMock.VerifyAllExpectations();
}
public void MarkDataComplete_RaisesEvent()
{
var counter = new OrderedExpectationCounter();
_loadState.RegisterOriginalOppositeEndPoint(_collectionEndPointMock, _relatedEndPointStub);
var eventRaiserMock = MockRepository.GenerateStrictMock <IDomainObjectCollectionEventRaiser> ();
_collectionEndPointMock.Stub(stub => stub.ID).Return(_endPointID);
_collectionEndPointMock.Stub(stub => stub.GetCollectionEventRaiser()).Return(eventRaiserMock);
_collectionEndPointMock.Replay();
var newManagerMock = MockRepository.GenerateMock <ICollectionEndPointDataManager> ();
newManagerMock.Expect(mock => mock.RegisterOriginalOppositeEndPoint(_relatedEndPointStub)).Ordered(counter);
newManagerMock.Expect(mock => mock.RegisterOriginalItemWithoutEndPoint(_relatedObject2)).Ordered(counter);
newManagerMock.Replay();
_dataManagerFactoryStub.Stub(stub => stub.CreateEndPointDataManager(_endPointID)).Return(newManagerMock);
var expectedManagerPosition = counter.GetNextExpectedPosition();
Action <ICollectionEndPointDataManager> stateSetter = dataManager => counter.CheckPosition("stateSetter", expectedManagerPosition);
eventRaiserMock.Expect(mock => mock.WithinReplaceData()).Ordered(counter);
eventRaiserMock.Replay();
_loadState.MarkDataComplete(_collectionEndPointMock, new DomainObject[] { _relatedObject, _relatedObject2 }, stateSetter);
newManagerMock.VerifyAllExpectations();
eventRaiserMock.VerifyAllExpectations();
}
public void RegisterObject()
{
var counter = new OrderedExpectationCounter();
_enlistedDomainObjectManagerMock
.Expect(mock => mock.EnlistDomainObject(_domainObject))
.Ordered(counter);
StubEmptyDataContainersCollection(_dataManagerMock);
_dataManagerMock
.Expect(mock => mock.RegisterDataContainer(Arg <DataContainer> .Is.Anything))
.WhenCalled(mi =>
{
var dc = (DataContainer)mi.Arguments[0];
Assert.That(dc.ID, Is.EqualTo(_objectID));
Assert.That(dc.DomainObject, Is.SameAs(_domainObject));
})
.Ordered(counter);
_context.RegisterObject(_domainObject);
_enlistedDomainObjectManagerMock.VerifyAllExpectations();
_dataManagerMock.VerifyAllExpectations();
Assert.That(_context.RegisteredObject, Is.SameAs(_domainObject));
}
private IDataManagementCommand SetupDeleteExpectationsWithException(IDataManager dataManagerMock, DomainObject deletedObject, Exception exception)
{
var initialCommandStub = MockRepository.GenerateStrictMock <IDataManagementCommand> ();
var actualCommandMock = MockRepository.GenerateStrictMock <IDataManagementCommand> ();
var counter = new OrderedExpectationCounter();
actualCommandMock.Stub(stub => stub.GetAllExceptions()).Return(Enumerable.Empty <Exception> ());
initialCommandStub.Stub(stub => stub.ExpandToAllRelatedObjects()).Return(new ExpandedCommand(actualCommandMock)).Ordered(counter);
actualCommandMock.Expect(mock => mock.Begin()).Throw(exception);
dataManagerMock.Expect(mock => mock.CreateDeleteCommand(deletedObject)).Return(initialCommandStub);
return(actualCommandMock);
}
public void End()
{
var counter = new OrderedExpectationCounter();
TransactionEventSinkMock
.Expect(mock => mock.RaiseRelationChangedEvent(DomainObject, CollectionEndPoint.Definition, _removedRelatedObject, null))
.Ordered(counter);
CollectionMockEventReceiver
.Expect(mock => mock.Removed(_removedRelatedObject))
.WhenCalledOrdered(counter, mi => Assert.That(ClientTransaction.Current, Is.SameAs(Transaction)));
_command.End();
TransactionEventSinkMock.VerifyAllExpectations();
CollectionMockEventReceiver.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 Rollback_RaisesEvent()
{
var counter = new OrderedExpectationCounter();
_collectionEndPointMock.Stub(stub => stub.GetCollectionEventRaiser()).Return(_eventRaiserMock);
_dataManagerMock.Expect(mock => mock.Rollback()).Ordered(counter);
_dataManagerMock.Replay();
_eventRaiserMock.Expect(mock => mock.WithinReplaceData()).Ordered(counter);
_eventRaiserMock.Replay();
_loadState.Rollback(_collectionEndPointMock);
_dataManagerMock.VerifyAllExpectations();
_eventRaiserMock.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 SynchronizeOppositeEndPoint()
{
var counter = new OrderedExpectationCounter();
_collectionEndPointMock.Stub(stub => stub.GetCollectionEventRaiser()).Return(_eventRaiserMock);
_dataManagerMock.Expect(mock => mock.RegisterOriginalOppositeEndPoint(_relatedEndPointStub)).Ordered(counter);
_dataManagerMock.Replay();
_eventRaiserMock.Expect(mock => mock.WithinReplaceData()).Ordered(counter);
_eventRaiserMock.Replay();
AddUnsynchronizedOppositeEndPoint(_loadState, _relatedEndPointStub);
_loadState.SynchronizeOppositeEndPoint(_collectionEndPointMock, _relatedEndPointStub);
_dataManagerMock.VerifyAllExpectations();
_eventRaiserMock.VerifyAllExpectations();
}
public void Synchronize()
{
var counter = new OrderedExpectationCounter();
_collectionEndPointMock.Stub(stub => stub.GetCollectionEventRaiser()).Return(_eventRaiserMock);
_dataManagerMock.Stub(stub => stub.OriginalItemsWithoutEndPoints).Return(new[] { _relatedObject });
_dataManagerMock.Expect(mock => mock.UnregisterOriginalItemWithoutEndPoint(_relatedObject)).Ordered(counter);
_dataManagerMock.Replay();
_eventRaiserMock.Expect(mock => mock.WithinReplaceData()).Ordered(counter);
_eventRaiserMock.Replay();
_loadState.Synchronize(_collectionEndPointMock);
_dataManagerMock.VerifyAllExpectations();
_eventRaiserMock.VerifyAllExpectations();
}
public void SortCurrentData_RaisesEvent()
{
var counter = new OrderedExpectationCounter();
_collectionEndPointMock.Stub(stub => stub.GetCollectionEventRaiser()).Return(_eventRaiserMock);
Comparison <DomainObject> comparison = (one, two) => 0;
_dataManagerMock.Expect(mock => mock.SortCurrentData(comparison)).Ordered(counter);
_dataManagerMock.Replay();
_eventRaiserMock.Expect(mock => mock.WithinReplaceData()).Ordered(counter);
_eventRaiserMock.Replay();
_loadState.SortCurrentData(_collectionEndPointMock, comparison);
_dataManagerMock.VerifyAllExpectations();
_eventRaiserMock.VerifyAllExpectations();
}
public void SetDataFromSubTransaction()
{
var counter = new OrderedExpectationCounter();
_collectionEndPointMock.Stub(stub => stub.GetCollectionEventRaiser()).Return(_eventRaiserMock);
var sourceDataManager = MockRepository.GenerateStub <ICollectionEndPointDataManager> ();
var sourceLoadState = new CompleteCollectionEndPointLoadState(sourceDataManager, _endPointProviderStub, _transactionEventSinkStub);
_dataManagerMock.Expect(mock => mock.SetDataFromSubTransaction(sourceDataManager, _endPointProviderStub)).Ordered(counter);
_dataManagerMock.Replay();
_eventRaiserMock.Expect(mock => mock.WithinReplaceData()).Ordered(counter);
_eventRaiserMock.Replay();
_loadState.SetDataFromSubTransaction(_collectionEndPointMock, sourceLoadState);
_dataManagerMock.VerifyAllExpectations();
_eventRaiserMock.VerifyAllExpectations();
}
