public void RaiseRelationReadEvent(
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects,
ValueAccess valueAccess)
{
}
public void AssociatedEndPointID()
{
var associatedCollection = DomainObjectIDs.Order1.GetObject <Order> ().OrderItems;
var readOnlyAdapter = new ReadOnlyDomainObjectCollectionAdapter <DomainObject> (associatedCollection);
Assert.That(readOnlyAdapter.AssociatedEndPointID, Is.EqualTo(associatedCollection.AssociatedEndPointID));
}
public virtual void RelationRead(
ClientTransaction clientTransaction,
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects,
ValueAccess valueAccess)
{
// Handled by Begin event
}
public void RaiseRelationReadEvent_Collection()
{
var endPointDefinition = GetSomeEndPointDefinition();
var relatedObjects = new ReadOnlyDomainObjectCollectionAdapter <DomainObject> (new DomainObjectCollection());
CheckEventWithListenersLast(
s => s.RaiseRelationReadEvent(_domainObject1, endPointDefinition, relatedObjects, ValueAccess.Current),
l => l.RelationRead(_clientTransaction, _domainObject1, endPointDefinition, relatedObjects, ValueAccess.Current),
x => x.RelationRead(_clientTransaction, _domainObject1, endPointDefinition, relatedObjects, ValueAccess.Current));
}
public override void SetUp()
{
base.SetUp();
_wrappedData = new DomainObjectCollection(typeof(Order));
_readOnlyAdapter = new ReadOnlyDomainObjectCollectionAdapter <DomainObject> (_wrappedData);
_readOnlyAdapterAsIList = _readOnlyAdapter;
_order1 = DomainObjectIDs.Order1.GetObject <Order> ();
_order2 = DomainObjectIDs.Order2.GetObject <Order> ();
_order3 = DomainObjectIDs.Order3.GetObject <Order> ();
_order4 = DomainObjectIDs.Order4.GetObject <Order> ();
}
public void RaiseRelationReadEvent(
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects,
ValueAccess valueAccess)
{
ArgumentUtility.CheckNotNull("domainObject", domainObject);
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
ArgumentUtility.CheckNotNull("relatedObjects", relatedObjects);
_extensionCollection.RelationRead(_clientTransaction, domainObject, relationEndPointDefinition, relatedObjects, valueAccess);
_listenerCollection.RelationRead(_clientTransaction, domainObject, relationEndPointDefinition, relatedObjects, valueAccess);
}
public void IsDataComplete()
{
Assert.That(_readOnlyAdapter.IsDataComplete, Is.True);
var associatedCollection = DomainObjectIDs.Order1.GetObject <Order> ().OrderItems;
UnloadService.UnloadVirtualEndPoint(
TestableClientTransaction,
associatedCollection.AssociatedEndPointID);
var readOnlyAdapter = new ReadOnlyDomainObjectCollectionAdapter <DomainObject> (associatedCollection);
Assert.That(readOnlyAdapter.IsDataComplete, Is.False);
}
public void RelationReadWithOneToManyRelation()
{
var orderItems = new ReadOnlyDomainObjectCollectionAdapter <DomainObject> (_order.OrderItems);
IRelationEndPointDefinition endPointDefinition = GetEndPointDefinition(typeof(Order), "OrderItems");
using (_mockRepository.Ordered())
{
_extension1.Expect(mock => mock.RelationRead(TestableClientTransaction, _order, endPointDefinition, orderItems, ValueAccess.Original));
_extension2.Expect(mock => mock.RelationRead(TestableClientTransaction, _order, endPointDefinition, orderItems, ValueAccess.Original));
}
_mockRepository.ReplayAll();
_collectionWithExtensions.RelationRead(TestableClientTransaction, _order, endPointDefinition, orderItems, ValueAccess.Original);
_mockRepository.VerifyAll();
}
public void RelationRead(
ClientTransaction clientTransaction,
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects,
ValueAccess valueAccess)
{
if (s_log.IsDebugEnabled())
{
var domainObjectsString = relatedObjects.IsDataComplete ? GetDomainObjectsString(relatedObjects) : "<data not loaded>";
s_log.DebugFormat(
"{0} RelationRead: {1} ({2}, {3}): {4}",
clientTransaction.ID,
relationEndPointDefinition.PropertyName,
valueAccess,
domainObject.ID,
domainObjectsString);
}
}
public void RelationRead_Collection()
{
var relationEndPointDefinition = MockRepository.GenerateStub <IRelationEndPointDefinition>();
relationEndPointDefinition.Stub(n => n.PropertyName).Return("Items");
var values =
new ReadOnlyDomainObjectCollectionAdapter <DomainObject> (new DomainObjectCollection(new[] { _domainObject2, _domainObject3 }, null));
CheckLoggingMethod(
() => _listener.RelationRead(_clientTransaction, _domainObject, relationEndPointDefinition, values, ValueAccess.Current),
string.Format(
"{0} RelationRead: {1} ({2}, {3}): {4}, {5}",
_clientTransaction.ID,
relationEndPointDefinition.PropertyName,
ValueAccess.Current,
_domainObject.ID,
_domainObject2.ID,
_domainObject3.ID));
}
public void RelationRead_LongCollection()
{
var relationEndPointDefinition = MockRepository.GenerateStub <IRelationEndPointDefinition>();
relationEndPointDefinition.Stub(n => n.PropertyName).Return("Items");
var values = new ReadOnlyDomainObjectCollectionAdapter <DomainObject> (
new DomainObjectCollection(
Enumerable.Range(0, 100).Select(i => LifetimeService.NewObject(_clientTransaction, typeof(Client), ParamList.Empty)),
null));
CheckLoggingMethod(
() => _listener.RelationRead(_clientTransaction, _domainObject, relationEndPointDefinition, values, ValueAccess.Current),
string.Format(
"{0} RelationRead: {1} ({2}, {3}): {4}, +90",
_clientTransaction.ID,
relationEndPointDefinition.PropertyName,
ValueAccess.Current,
_domainObject.ID,
string.Join(", ", values.Take(10))));
}
public void RelationRead(ClientTransaction clientTransaction, DomainObject domainObject, IRelationEndPointDefinition relationEndPointDefinition, ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects, ValueAccess valueAccess)
{
throw CreateException();
}
public virtual void RelationRead(ClientTransaction clientTransaction, DomainObject domainObject, IRelationEndPointDefinition relationEndPointDefinition, ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects, ValueAccess valueAccess)
{
foreach (var listener in _listeners)
{
listener.RelationRead(clientTransaction, domainObject, relationEndPointDefinition, relatedObjects, valueAccess);
}
}
public void AggregatedClientsAreNotified()
{
_compoundListener.AddListener(_listener1);
_compoundListener.AddListener(_listener2);
var order = Order.NewObject();
var order3 = Order.NewObject();
var domainObjects = new ReadOnlyCollection <DomainObject> (new DomainObject[0]);
var persistableData = new ReadOnlyCollection <PersistableData> (new PersistableData[0]);
var relatedObjects = new ReadOnlyDomainObjectCollectionAdapter <DomainObject> (new DomainObjectCollection());
var clientTransaction2 = ClientTransaction.CreateRootTransaction();
var realtionEndPointDefinitionMock = MockRepository.GenerateMock <IRelationEndPointDefinition>();
CheckNotification(listener => listener.TransactionInitialize(TestableClientTransaction));
CheckNotification(listener => listener.TransactionDiscard(TestableClientTransaction));
CheckNotification(listener => listener.SubTransactionCreating(TestableClientTransaction));
CheckNotification(listener => listener.SubTransactionInitialize(TestableClientTransaction, clientTransaction2));
CheckNotification(listener => listener.SubTransactionCreated(TestableClientTransaction, clientTransaction2));
CheckNotification(listener => listener.NewObjectCreating(TestableClientTransaction, typeof(string)));
CheckNotification(listener => listener.ObjectsLoading(TestableClientTransaction, new ReadOnlyCollection <ObjectID> (new ObjectID[0])));
CheckNotification(listener => listener.ObjectsLoaded(TestableClientTransaction, domainObjects));
CheckNotification(listener => listener.ObjectsNotFound(TestableClientTransaction, new ReadOnlyCollection <ObjectID> (new ObjectID[0])));
CheckNotification(listener => listener.ObjectsUnloading(TestableClientTransaction, domainObjects));
CheckNotification(listener => listener.ObjectsUnloaded(TestableClientTransaction, domainObjects));
CheckNotification(listener => listener.ObjectDeleting(TestableClientTransaction, order));
CheckNotification(listener => listener.ObjectDeleted(TestableClientTransaction, order));
var propertyDefinition = PropertyDefinitionObjectMother.CreateForFakePropertyInfo();
CheckNotification(listener => listener.PropertyValueReading(
TestableClientTransaction,
order,
propertyDefinition,
ValueAccess.Original));
CheckNotification(listener => listener.PropertyValueRead(
TestableClientTransaction,
order,
propertyDefinition,
"Foo",
ValueAccess.Original));
CheckNotification(listener => listener.PropertyValueChanging(
TestableClientTransaction,
order,
propertyDefinition,
"Foo",
"Bar"));
CheckNotification(listener => listener.PropertyValueChanged(
TestableClientTransaction,
order,
propertyDefinition,
"Foo",
"Bar"));
CheckNotification(listener => listener.RelationRead(TestableClientTransaction, order, realtionEndPointDefinitionMock, order, ValueAccess.Original));
CheckNotification(listener => listener.RelationRead(TestableClientTransaction, order, realtionEndPointDefinitionMock, relatedObjects, ValueAccess.Original));
CheckNotification(listener => listener.RelationReading(TestableClientTransaction, order, realtionEndPointDefinitionMock, ValueAccess.Current));
CheckNotification(listener => listener.RelationChanging(TestableClientTransaction, order, realtionEndPointDefinitionMock, order, order3));
CheckNotification(listener => listener.RelationChanged(TestableClientTransaction, order, realtionEndPointDefinitionMock, order, order3));
var eventRegistrar = MockRepository.GenerateStub <ICommittingEventRegistrar>();
CheckNotification(listener => listener.TransactionCommitting(TestableClientTransaction, domainObjects, eventRegistrar));
CheckNotification(listener => listener.TransactionCommitValidate(TestableClientTransaction, persistableData));
CheckNotification(listener => listener.TransactionCommitted(TestableClientTransaction, domainObjects));
CheckNotification(listener => listener.TransactionRollingBack(TestableClientTransaction, domainObjects));
CheckNotification(listener => listener.TransactionRolledBack(TestableClientTransaction, domainObjects));
var id = RelationEndPointID.Create(order.ID, typeof(Order).FullName + ".Customer");
var endPoint = RelationEndPointObjectMother.CreateObjectEndPoint(id, null);
CheckNotification(listener => listener.RelationEndPointMapRegistering(TestableClientTransaction, endPoint));
CheckNotification(listener => listener.RelationEndPointMapUnregistering(TestableClientTransaction, endPoint.ID));
CheckNotification(listener => listener.RelationEndPointBecomingIncomplete(TestableClientTransaction, endPoint.ID));
CheckNotification(listener => listener.ObjectMarkedInvalid(TestableClientTransaction, order));
CheckNotification(listener => listener.ObjectMarkedNotInvalid(TestableClientTransaction, order));
CheckNotification(listener => listener.DataContainerMapRegistering(TestableClientTransaction, order.InternalDataContainer));
CheckNotification(listener => listener.DataContainerMapUnregistering(TestableClientTransaction, order.InternalDataContainer));
CheckNotification(listener => listener.DataContainerStateUpdated(TestableClientTransaction, order.InternalDataContainer, StateType.Deleted));
CheckNotification(listener => listener.VirtualRelationEndPointStateUpdated(TestableClientTransaction, endPoint.ID, true));
}
