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]);
}
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 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 RaiseDataContainerMapUnregisteringEvent()
{
var dataContainer = DataContainerObjectMother.Create(Order.NewObject());
CheckEventWithListenersOnly(
s => s.RaiseDataContainerMapUnregisteringEvent(dataContainer),
l => l.DataContainerMapUnregistering(_clientTransaction, dataContainer));
}
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 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 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 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 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 static FreshlyLoadedObjectData CreateFreshlyLoadedObjectData(ObjectID objectID)
{
return(new FreshlyLoadedObjectData(DataContainerObjectMother.Create(objectID)));
}
