public void DataContainerMapRegistering_IgnoresNonNewObjects()
{
var middleTransaction = CreateSubTransactionAndClearListeners(_rootTransaction);
var subTransaction = CreateSubTransactionAndClearListeners(middleTransaction);
var dataContainer = DataContainer.CreateForExisting(DomainObjectIDs.Order1, null, pd => pd.DefaultValue);
var domainObject = LifetimeService.GetObjectReference(subTransaction, dataContainer.ID);
dataContainer.SetDomainObject(domainObject);
_listener.DataContainerMapRegistering(subTransaction, dataContainer);
Assert.That(_rootTransaction.IsInvalid(DomainObjectIDs.Order1), Is.False);
Assert.That(middleTransaction.IsInvalid(DomainObjectIDs.Order1), Is.False);
Assert.That(subTransaction.IsInvalid(DomainObjectIDs.Order1), Is.False);
}
public void CanWrite_DeletedObject_ReturnsFalse()
{
var instance = SampleBindableDomainObject.NewObject();
var property = GetProperty(instance);
var strategy = (IBindablePropertyWriteAccessStrategy) new BindableDomainObjectPropertyWriteAccessStrategy();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
LifetimeService.DeleteObject(instance.DefaultTransactionContext.ClientTransaction, instance);
Assert.That(instance.State, Is.EqualTo(StateType.Deleted));
var result = strategy.CanWrite(instance, property);
Assert.That(result, Is.False);
}
}
public void PropertyAccess_Subtransaction()
{
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var instance = (ClassWithAllDataTypes)LifetimeService.GetObjectReference(ClientTransaction.Current, _nonExistingObjectIDForSubtransaction);
CheckObjectIsMarkedInvalid(_nonExistingObjectIDForSubtransaction);
Assert.That(() => instance.StringProperty, ThrowsObjectInvalidException(_nonExistingObjectIDForSubtransaction));
var instance2 = (Order)LifetimeService.GetObjectReference(ClientTransaction.Current, _nonExistingObjectID);
Assert.That(() => instance2.OrderNumber, ThrowsObjectNotFoundException(_nonExistingObjectID));
CheckObjectIsMarkedInvalid(_nonExistingObjectID);
}
CheckObjectIsMarkedInvalid(_nonExistingObjectID);
CheckObjectIsNotMarkedInvalid(_nonExistingObjectIDForSubtransaction);
}
public void CanWrite_NotLoadedObject_LoadsNonExistentObject_ReturnsFalse()
{
var instance = (SampleBindableDomainObject)LifetimeService.GetObjectReference(
ClientTransaction.Current,
new ObjectID(typeof(SampleBindableDomainObject), Guid.NewGuid()));
var property = GetProperty(instance);
var strategy = (IBindablePropertyWriteAccessStrategy) new BindableDomainObjectPropertyWriteAccessStrategy();
Assert.That(instance.State, Is.EqualTo(StateType.NotLoadedYet));
var result = strategy.CanWrite(instance, property);
Assert.That(result, Is.False);
Assert.That(instance.State, Is.EqualTo(StateType.Invalid));
}
public override void SetUp()
{
base.SetUp();
_loadedOrder1 = DomainObjectIDs.Order1.GetObject <Order> ();
_notYetLoadedOrder2 = (Order)LifetimeService.GetObjectReference(TestableClientTransaction, DomainObjectIDs.Order3);
_newOrder = Order.NewObject();
_loadedOrder1Context = new DomainObjectTransactionContext(_loadedOrder1, TestableClientTransaction);
_notYetLoadedOrder2Context = new DomainObjectTransactionContext(_notYetLoadedOrder2, TestableClientTransaction);
_newOrderContext = new DomainObjectTransactionContext(_newOrder, TestableClientTransaction);
var objectBeingInitialized = Order.NewObject();
PrivateInvoke.SetNonPublicField(objectBeingInitialized, "_isReferenceInitializeEventExecuting", true);
_referenceInitializationContext = new DomainObjectTransactionContext(objectBeingInitialized, TestableClientTransaction);
}
public static ObjectEndPoint CreateObjectEndPoint(RelationEndPointID endPointID, ObjectID oppositeObjectID)
{
if (endPointID.Definition.IsVirtual)
{
var clientTransaction = ClientTransaction.Current;
VirtualObjectEndPoint endPoint = CreateVirtualObjectEndPoint(endPointID, clientTransaction);
endPoint.MarkDataComplete(LifetimeService.GetObjectReference(clientTransaction, oppositeObjectID));
return(endPoint);
}
else
{
var endPoint = CreateRealObjectEndPoint(endPointID);
RealObjectEndPointTestHelper.SetValueViaDataContainer(endPoint, oppositeObjectID);
endPoint.Commit();
return(endPoint);
}
}
public void Get_StateCombinationsFromDatabase()
{
DatabaseFixtures dbFixtures = new DatabaseFixtures();
var expectedAcl = dbFixtures.CreateAndCommitAccessControlListWithStateCombinations(10, ClientTransactionScope.CurrentTransaction);
var expectedStateCombinations = expectedAcl.StateCombinations;
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
var actualAcl = (StatefulAccessControlList)LifetimeService.GetObject(ClientTransaction.Current, expectedAcl.ID, false);
Assert.That(actualAcl.StateCombinations.Count, Is.EqualTo(9));
for (int i = 0; i < 9; i++)
{
Assert.That(actualAcl.StateCombinations[i].ID, Is.EqualTo(expectedStateCombinations[i].ID));
}
}
}
public void EnsureDataAvailable_Subtransaction()
{
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var instance = LifetimeService.GetObjectReference(ClientTransaction.Current, _nonExistingObjectIDForSubtransaction);
CheckObjectIsMarkedInvalid(instance.ID);
Assert.That(() => instance.EnsureDataAvailable(), ThrowsObjectInvalidException(_nonExistingObjectIDForSubtransaction));
var instance2 = LifetimeService.GetObjectReference(ClientTransaction.Current, _nonExistingObjectID);
Assert.That(() => instance2.EnsureDataAvailable(), ThrowsObjectNotFoundException(_nonExistingObjectID));
CheckObjectIsMarkedInvalid(_nonExistingObjectID);
}
CheckObjectIsMarkedInvalid(_nonExistingObjectID);
CheckObjectIsNotMarkedInvalid(_nonExistingObjectIDForSubtransaction);
}
public void MultiplePropertiesWithSameShortName()
{
var derivedClass = (DerivedClassWithDifferentProperties)LifetimeService.NewObject(TestableClientTransaction, typeof(DerivedClassWithDifferentProperties), ParamList.Empty);
ClassWithDifferentProperties baseClass = derivedClass;
derivedClass.String = "Derived";
baseClass.String = "Base";
Assert.That(derivedClass.String, Is.EqualTo("Derived"));
Assert.That(baseClass.String, Is.EqualTo("Base"));
baseClass.String = "NewBase";
derivedClass.String = "NewDerived";
Assert.That(derivedClass.String, Is.EqualTo("NewDerived"));
Assert.That(baseClass.String, Is.EqualTo("NewBase"));
}
public void Get_AccessControlEntriesFromDatabase()
{
DatabaseFixtures dbFixtures = new DatabaseFixtures();
AccessControlList expectedAcl =
dbFixtures.CreateAndCommitAccessControlListWithAccessControlEntries(10, ClientTransactionScope.CurrentTransaction);
ObjectList <AccessControlEntry> expectedAces = expectedAcl.AccessControlEntries;
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
var actualAcl = (AccessControlList)LifetimeService.GetObject(ClientTransaction.Current, expectedAcl.ID, false);
Assert.That(actualAcl.AccessControlEntries.Count, Is.EqualTo(10));
for (int i = 0; i < 10; i++)
{
Assert.That(actualAcl.AccessControlEntries[i].ID, Is.EqualTo(expectedAces[i].ID));
}
}
}
public void GetObject_Twice()
{
DomainObject domainObject1 = LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.ClassWithAllDataTypes1, false);
Assert.That(_eventReceiver.LoadedDomainObjectLists.Count, Is.EqualTo(1));
var domainObjects = _eventReceiver.LoadedDomainObjectLists[0];
Assert.That(domainObjects.Count, Is.EqualTo(1));
Assert.That(domainObjects[0], Is.SameAs(domainObject1));
_eventReceiver.Clear();
DomainObject domainObject2 = LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.ClassWithAllDataTypes1, false);
Assert.That(_eventReceiver.LoadedDomainObjectLists.Count, Is.EqualTo(0));
Assert.That(domainObject2, Is.SameAs(domainObject1));
}
public void OnDomainObjectCreated()
{
var mixinInstance = new HookedDomainObjectMixin();
Assert.That(mixinInstance.OnLoadedCalled, Is.False);
Assert.That(mixinInstance.OnCreatedCalled, Is.False);
Assert.That(mixinInstance.OnDomainObjectReferenceInitializingCalled, Is.False);
using (new MixedObjectInstantiationScope(mixinInstance))
{
var tx = ClientTransaction.CreateRootTransaction();
LifetimeService.NewObject(tx, typeof(HookedTargetClass), ParamList.Empty);
}
Assert.That(mixinInstance.OnLoadedCalled, Is.False);
Assert.That(mixinInstance.OnCreatedCalled, Is.True);
Assert.That(mixinInstance.OnDomainObjectReferenceInitializingCalled, Is.True);
}
public void TryGetObjects()
{
var notFoundObjectID = new ObjectID(typeof(Order), Guid.NewGuid());
var deletedObjectID = DomainObjectIDs.Order4;
var deletedObject = deletedObjectID.GetObject <Order> ();
deletedObject.Delete();
var invalidInstance = Order.NewObject();
invalidInstance.Delete();
Assert.That(invalidInstance.State, Is.EqualTo(StateType.Invalid));
Order[] orders = LifetimeService.TryGetObjects <Order> (
TestableClientTransaction, DomainObjectIDs.Order1, notFoundObjectID, deletedObjectID, invalidInstance.ID);
Assert.That(orders, Is.EqualTo(new[] { DomainObjectIDs.Order1.GetObject <Order> (), null, deletedObject, invalidInstance }));
}
public void GetObjects_DeletedInParentTransaction_Throws()
{
var order1 = DomainObjectIDs.Order1.GetObject <Order> ();
var order3 = DomainObjectIDs.Order3.GetObject <Order> ();
var order4 = DomainObjectIDs.Order4.GetObject <Order> ();
order3.Delete();
order4.Delete();
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
Assert.That(
() => LifetimeService.GetObjects <Order> (subTransaction, order1.ID, order3.ID, order4.ID),
Throws.TypeOf <ObjectInvalidException> ().With.Message.EqualTo(
"Object 'Order|83445473-844a-4d3f-a8c3-c27f8d98e8ba|System.Guid' is invalid in this transaction."));
}
}
public void GetObjects_LoadedObjects()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
var expectedObjects = new object[]
{
DomainObjectIDs.Order1.GetObject <Order> (), DomainObjectIDs.Order3.GetObject <Order> (),
DomainObjectIDs.OrderItem1.GetObject <OrderItem>()
};
DomainObject[] objects = LifetimeService.GetObjects <DomainObject> (
subTransaction,
DomainObjectIDs.Order1,
DomainObjectIDs.Order3,
DomainObjectIDs.OrderItem1);
Assert.That(objects, Is.EqualTo(expectedObjects));
}
}
public void TryGetObjects_DeletedInParentTransaction()
{
var order1 = DomainObjectIDs.Order1.GetObject <Order> ();
var order3 = DomainObjectIDs.Order3.GetObject <Order> ();
var order4 = DomainObjectIDs.Order4.GetObject <Order> ();
order3.Delete();
order4.Delete();
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
var result = LifetimeService.TryGetObjects <Order> (subTransaction, order1.ID, order3.ID, order4.ID);
Assert.That(result, Is.EqualTo(new[] { order1, order3, order4 }));
Assert.That(result[1].State, Is.EqualTo(StateType.Invalid));
Assert.That(result[2].State, Is.EqualTo(StateType.Invalid));
}
}
public void RaiseReferenceInitializatingEvent_IDAndActiveTransaction()
{
var domainObject = _transaction.ExecuteInScope(() => Order.NewObject()); // indirect call of RaiseReferenceInitializatingEvent
Assert.That(domainObject.OnReferenceInitializingCalled, Is.True);
Assert.That(domainObject.OnReferenceInitializingID, Is.EqualTo(domainObject.ID));
Assert.That(domainObject.OnReferenceInitializingActiveTx, Is.SameAs(_transaction));
using (ClientTransactionTestHelper.MakeInactive(_transaction))
{
Assert.That(_transaction.ActiveTransaction, Is.Not.SameAs(_transaction));
// Note that GetObjectReference makes _transaction the active transaction.
var objectReference = (Order)LifetimeService.GetObjectReference(_transaction, DomainObjectIDs.Order1);
Assert.That(objectReference.OnReferenceInitializingCalled, Is.True);
Assert.That(objectReference.OnReferenceInitializingID, Is.EqualTo(objectReference.ID));
Assert.That(objectReference.OnReferenceInitializingActiveTx, Is.SameAs(_transaction));
}
}
public void CreateClone_InvokesClonerCallback_OnReferencedObjects()
{
var cloneTransaction = ClientTransaction.CreateRootTransaction();
_cloner.CloneTransaction = cloneTransaction;
var referencedObject = (ClassWithClonerCallback)LifetimeService.NewObject(TestableClientTransaction, typeof(ClassWithClonerCallback), ParamList.Empty);
referencedObject.Property = 42;
_classWithClonerCallback.ReferencedObject = referencedObject;
var clone = _cloner.CreateClone(_classWithClonerCallback, new CompleteCloneStrategy());
var clonedReferencedObject = cloneTransaction.ExecuteInScope(() => clone.ReferencedObject);
Assert.That(clonedReferencedObject.CallbackInvoked, Is.True);
Assert.That(clonedReferencedObject.CallbackOriginal, Is.SameAs(referencedObject));
Assert.That(clonedReferencedObject.CallbackCloneTransaction, Is.SameAs(cloneTransaction));
Assert.That(clonedReferencedObject.CallbackCurrentTransaction, Is.SameAs(ClientTransaction.Current));
Assert.That(clonedReferencedObject.PropertyValueInCallback, Is.EqualTo(42));
}
public void GetObjects_NewObjects_Events()
{
var expectedObjects = new DomainObject[] { Order.NewObject(), OrderItem.NewObject() };
_eventReceiver.Clear();
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener> ();
TestableClientTransaction.AddListener(listenerMock);
LifetimeService.GetObjects <DomainObject> (TestableClientTransaction, expectedObjects[0].ID, expectedObjects[1].ID);
Assert.That(_eventReceiver.LoadedDomainObjectLists, Is.Empty);
listenerMock.AssertWasNotCalled(mock => mock.ObjectsLoading(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <ObjectID> > .Is.Anything));
listenerMock.AssertWasNotCalled(mock => mock.ObjectsLoaded(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <DomainObject> > .Is.Anything));
}
public void OnDomainObjectLoaded()
{
var tx = CreateTransactionWithStubbedLoading(_objectID);
var mixinInstance = new HookedDomainObjectMixin();
Assert.That(mixinInstance.OnLoadedCalled, Is.False);
Assert.That(mixinInstance.OnCreatedCalled, Is.False);
Assert.That(mixinInstance.OnDomainObjectReferenceInitializingCalled, Is.False);
using (new MixedObjectInstantiationScope(mixinInstance))
{
LifetimeService.GetObject(tx, _objectID, false);
}
Assert.That(mixinInstance.OnLoadedCalled, Is.True);
Assert.That(mixinInstance.OnLoadedLoadMode, Is.EqualTo(LoadMode.WholeDomainObjectInitialized));
Assert.That(mixinInstance.OnCreatedCalled, Is.False);
Assert.That(mixinInstance.OnDomainObjectReferenceInitializingCalled, Is.True);
}
public void TryGetObjects_NotFound()
{
Order newObject = Order.NewObject();
var guid = new Guid("33333333333333333333333333333333");
Order[] objects = LifetimeService.TryGetObjects <Order> (
TestableClientTransaction,
DomainObjectIDs.Order1,
newObject.ID,
new ObjectID(typeof(Order), guid),
DomainObjectIDs.Order3);
var expectedObjects = new DomainObject[] {
DomainObjectIDs.Order1.GetObject <Order> (),
newObject,
null,
DomainObjectIDs.Order3.GetObject <Order> ()
};
Assert.That(objects, Is.EqualTo(expectedObjects));
}
public void DataContainerMapRegistering_MarksNewObjectsInvalid()
{
var middleTransaction = CreateSubTransactionAndClearListeners(_rootTransaction);
var subTransaction = CreateSubTransactionAndClearListeners(middleTransaction);
var dataContainer = DataContainer.CreateNew(DomainObjectIDs.Order1);
var domainObject = LifetimeService.GetObjectReference(subTransaction, dataContainer.ID);
dataContainer.SetDomainObject(domainObject);
_listener.DataContainerMapRegistering(subTransaction, dataContainer);
Assert.That(_rootTransaction.IsInvalid(DomainObjectIDs.Order1), Is.True);
Assert.That(ClientTransactionTestHelper.CallGetInvalidObjectReference(_rootTransaction, DomainObjectIDs.Order1), Is.SameAs(domainObject));
Assert.That(middleTransaction.IsInvalid(DomainObjectIDs.Order1), Is.True);
Assert.That(ClientTransactionTestHelper.CallGetInvalidObjectReference(middleTransaction, DomainObjectIDs.Order1), Is.SameAs(domainObject));
Assert.That(subTransaction.IsInvalid(DomainObjectIDs.Order1), Is.False);
}
public void ResurrectObject_ViaSubTransaction()
{
var notFoundID = new ObjectID(typeof(Order), Guid.NewGuid());
var notFoundObject = LifetimeService.GetObjectReference(TestableClientTransaction, notFoundID);
var subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
notFoundObject.TryEnsureDataAvailable();
CheckStateIsInvalid(notFoundObject, TestableClientTransaction);
CheckStateIsInvalid(notFoundObject, subTransaction);
ResurrectionService.ResurrectInvalidObject(subTransaction, notFoundID);
CheckStateIsNotInvalid(notFoundObject, TestableClientTransaction, StateType.NotLoadedYet);
CheckStateIsNotInvalid(notFoundObject, subTransaction, StateType.NotLoadedYet);
}
}
public override void SetUp()
{
base.SetUp();
var clientTransaction = ClientTransaction.CreateRootTransaction();
var sampleObject = LifetimeService.NewObject(clientTransaction, typeof(SampleObject), ParamList.Empty);
_objectID = sampleObject.ID;
clientTransaction.Commit();
var locator = DefaultServiceLocator.Create();
var factory = new LinqToSqlExtensionFactory();
locator.RegisterSingle <IClientTransactionExtensionFactory> (() => factory);
locator.RegisterSingle <IPersistenceExtensionFactory> (() => factory);
_serviceLocatorScope = new ServiceLocatorScope(locator);
_tracingLinqToSqlAppender = new TracingLinqToSqlAppender();
SetAppender(_tracingLinqToSqlAppender);
}
public void SingleInheritance_GetObject()
{
ObjectID firstDerivedClassObjectID;
ObjectID secondDerivedClassObjectID;
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
var firstDerivedClass = SingleInheritanceFirstDerivedClass.NewObject();
firstDerivedClassObjectID = firstDerivedClass.ID;
var secondDerivedClass = SingleInheritanceSecondDerivedClass.NewObject();
secondDerivedClassObjectID = secondDerivedClass.ID;
ClientTransaction.Current.Commit();
}
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
Assert.IsInstanceOf(typeof(SingleInheritanceFirstDerivedClass), LifetimeService.GetObject(ClientTransaction.Current, firstDerivedClassObjectID, false));
Assert.IsInstanceOf(typeof(SingleInheritanceSecondDerivedClass), LifetimeService.GetObject(ClientTransaction.Current, secondDerivedClassObjectID, false));
}
}
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 GetFlattenedRelatedObjectGraph_WithTraversalFilter_FollowLink_IncludeObject()
{
Order order = DomainObjectIDs.Order1.GetObject <Order> ();
var graph = new DomainObjectGraphTraverser(order, new TestTraversalStrategy(false, false)).GetFlattenedRelatedObjectGraph();
var expected = new HashSet <DomainObject> {
order,
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.OrderTicket1, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.OrderItem1, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.OrderItem2, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Customer1, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Official1, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.IndustrialSector1, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Partner1, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.PartnerWithoutCeo, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Supplier1, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Distributor2, false)
};
Assert.That(graph, Is.EquivalentTo(expected));
}
private TransportedDomainObjects TransportAndDeleteObjects(params ObjectID[] objectsToLoadAndDelete)
{
var transporter = new DomainObjectTransporter();
foreach (ObjectID id in objectsToLoadAndDelete)
{
transporter.Load(id);
}
ModifyDatabase(
delegate
{
foreach (var id in objectsToLoadAndDelete)
{
var domainObject = LifetimeService.GetObject(ClientTransaction.Current, id, false);
LifetimeService.DeleteObject(ClientTransaction.Current, domainObject);
}
});
return(Transport(transporter));
}
private Order PrepareUnsynchronizedOrder(ObjectID orderID, ObjectID relatedCustomerID)
{
var unsynchronizedOrder = (Order)LifetimeService.GetObjectReference(TestableClientTransaction, orderID);
var dataContainer = DataContainer.CreateForExisting(
unsynchronizedOrder.ID,
null,
pd => pd.PropertyName.EndsWith("Customer") ? relatedCustomerID : pd.DefaultValue);
dataContainer.SetDomainObject(unsynchronizedOrder);
TestableClientTransaction.DataManager.RegisterDataContainer(dataContainer);
var endPointID = RelationEndPointID.Resolve(unsynchronizedOrder, o => o.Customer);
var endPoint = (IRealObjectEndPoint)TestableClientTransaction.DataManager.GetRelationEndPointWithoutLoading(endPointID);
var oppositeID = RelationEndPointID.CreateOpposite(endPoint.Definition, relatedCustomerID);
var oppositeEndPoint = TestableClientTransaction.DataManager.GetOrCreateVirtualEndPoint(oppositeID);
oppositeEndPoint.EnsureDataComplete();
Assert.That(endPoint.IsSynchronized, Is.False);
return(unsynchronizedOrder);
}
public IBusinessObjectWithIdentity GetObject(BindableObjectClassWithIdentity classWithIdentity, string uniqueIdentifier)
{
ArgumentUtility.CheckNotNull("classWithIdentity", classWithIdentity);
ArgumentUtility.CheckNotNullOrEmpty("uniqueIdentifier", uniqueIdentifier);
var objectID = ObjectID.Parse(uniqueIdentifier);
var domainObjectOrNull = LifetimeService.TryGetObject(ClientTransaction.Current, objectID);
if (domainObjectOrNull == null)
{
return(null);
}
if (domainObjectOrNull.State == StateType.Invalid)
{
return(null);
}
if (domainObjectOrNull.State == StateType.Deleted)
{
return(null);
}
return((IBusinessObjectWithIdentity)domainObjectOrNull);
}
