public void GetObject()
{
var order = (Order)LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Order1, false);
Assert.That(order, Is.Not.Null);
Assert.That(order.ID, Is.EqualTo(DomainObjectIDs.Order1));
Assert.That(order.CtorCalled, Is.False);
}
public void ModifyingProperty_NotLoaded()
{
_transporter.Load(DomainObjectIDs.Computer2);
var transportTransaction = _transporter.GetTransportedObject(DomainObjectIDs.Computer2).RootTransaction;
var source = LifetimeService.GetObject(transportTransaction, DomainObjectIDs.Computer1, false);
_listener.PropertyValueChanging(TestableClientTransaction, source, GetPropertyDefinition(typeof(Computer), "SerialNumber"), null, null);
}
public void GetObject_IncludeDeleted_True()
{
DomainObjectIDs.Order1.GetObject <Order> ().Delete();
var order = (Order)LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Order1, true);
Assert.That(order, Is.Not.Null);
Assert.That(order.ID, Is.EqualTo(DomainObjectIDs.Order1));
Assert.That(order.State, Is.EqualTo(StateType.Deleted));
}
public static DomainObject GetChangedObject(ClientTransaction transaction, ObjectID objectID)
{
var changedInstance = LifetimeService.GetObject(transaction, objectID, false);
changedInstance.RegisterForCommit();
Assert.That(changedInstance.State, Is.EqualTo(StateType.Changed));
Assert.That(ClientTransactionTestHelper.GetDataManager(transaction).DataContainers[objectID].State, Is.EqualTo(StateType.Changed));
return(changedInstance);
}
private Substitution GetSubstitution(ClientTransaction transaction)
{
if (_substitutionHandle == null)
{
return(null);
}
return((Substitution)LifetimeService.GetObject(transaction, _substitutionHandle.ObjectID, false));
}
public override void SetUp()
{
base.SetUp();
_transaction = new TestableClientTransaction();
_order1 = (Order)LifetimeService.GetObject(_transaction, DomainObjectIDs.Order1, false);
_transactionEventSinkWithMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_deleteOrder1Command = new DeleteCommand(_transaction, _order1, _transactionEventSinkWithMock);
}
public void GetObject_WithInvalidObject_Throws()
{
var instance = Order.NewObject();
instance.Delete();
Assert.That(instance.State, Is.EqualTo(StateType.Invalid));
Assert.That(() => LifetimeService.GetObject(TestableClientTransaction, instance.ID, false), Throws.TypeOf <ObjectInvalidException> ());
Assert.That(() => LifetimeService.GetObject(TestableClientTransaction, instance.ID, true), Throws.TypeOf <ObjectInvalidException> ());
}
public override void SetUp()
{
base.SetUp();
_transaction = ClientTransaction.CreateRootTransaction();
_cachingListener = new DomainObjectStateCache(_transaction);
_existingOrder = (Order)LifetimeService.GetObject(_transaction, DomainObjectIDs.Order1, false);
_newOrder = (Order)LifetimeService.NewObject(_transaction, typeof(Order), ParamList.Empty);
_notYetLoadedOrder = (Order)LifetimeService.GetObjectReference(_transaction, DomainObjectIDs.Order3);
}
public void Traversal_NotAffectedByNotProcessingAnObject()
{
Order order = DomainObjectIDs.Order1.GetObject <Order> ();
HashSet <DomainObject> graph = new DomainObjectGraphTraverser(order, new TestTraversalStrategy(false, true)).GetFlattenedRelatedObjectGraph();
var expected = new HashSet <DomainObject> {
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Distributor2, false)
};
Assert.That(graph, Is.EquivalentTo(expected));
}
public static ObjectID SetRelationInOtherTransaction(RelationEndPointID endPointID, ObjectID relatedID)
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
var domainObject = LifetimeService.GetObject(ClientTransaction.Current, endPointID.ObjectID, true);
SetForeignKeyProperty(domainObject, (RelationEndPointDefinition)endPointID.Definition, relatedID);
ClientTransaction.Current.Commit();
return(domainObject.ID);
}
}
protected T[] GetExpectedObjects <T> (params ObjectID[] expectedObjectIDs)
where T : DomainObject
{
if (expectedObjectIDs == null)
{
return new T[] { null }
}
;
return((from id in expectedObjectIDs
select(id == null ? null : (T)LifetimeService.GetObject(TestableClientTransaction, id, false))).ToArray());
}
public void GetObject_Deleted()
{
var domainObject = LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.ClassWithAllDataTypes1, false);
LifetimeService.DeleteObject(TestableClientTransaction, domainObject);
Assert.That(
() => LifetimeService.GetObject(TestableClientTransaction, domainObject.ID, false),
Throws.TypeOf <ObjectDeletedException> ().With.Message.EqualTo(
"Object 'ClassWithAllDataTypes|3f647d79-0caf-4a53-baa7-a56831f8ce2d|System.Guid' is already deleted."));
Assert.That(LifetimeService.GetObject(TestableClientTransaction, domainObject.ID, true), Is.SameAs(domainObject));
}
protected T CreateObjectInDatabaseAndLoad <T> () where T : DomainObject
{
ObjectID objectID;
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
var domainObject = LifetimeService.NewObject(ClientTransaction.Current, typeof(T), ParamList.Empty);
ClientTransaction.Current.Commit();
objectID = domainObject.ID;
}
return((T)LifetimeService.GetObject(ClientTransaction.Current, objectID, false));
}
public static ObjectID CreateObjectAndSetRelationInOtherTransaction <TCreated, TRelated> (ObjectID relatedID, Action <TCreated, TRelated> setter)
where TCreated : DomainObject
where TRelated : DomainObject
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
var domainObject = (TCreated)LifetimeService.NewObject(ClientTransaction.Current, typeof(TCreated), ParamList.Empty);
setter(domainObject, relatedID != null ? (TRelated)LifetimeService.GetObject(ClientTransaction.Current, relatedID, true) : null);
ClientTransaction.Current.Commit();
return(domainObject.ID);
}
}
public static ObjectID SetRelationInOtherTransaction <TOriginating, TRelated> (ObjectID originatingID, ObjectID relatedID, Action <TOriginating, TRelated> setter)
where TOriginating : DomainObject
where TRelated : DomainObject
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
var domainObject = (TOriginating)LifetimeService.GetObject(ClientTransaction.Current, originatingID, true);
setter(domainObject, relatedID != null ? (TRelated)LifetimeService.GetObject(ClientTransaction.Current, relatedID, true) : null);
ClientTransaction.Current.Commit();
return(domainObject.ID);
}
}
public override void SetUp()
{
base.SetUp();
_order = (Order)LifetimeService.GetObjectReference(WriteableSubTransaction, DomainObjectIDs.Order1);
_location = (Location)LifetimeService.GetObjectReference(WriteableSubTransaction, DomainObjectIDs.Location1);
_client1 = (Client)LifetimeService.GetObject(WriteableSubTransaction, DomainObjectIDs.Client1, false);
_client2 = (Client)LifetimeService.GetObject(WriteableSubTransaction, DomainObjectIDs.Client2, false);
_client3 = (Client)LifetimeService.GetObject(WriteableSubTransaction, DomainObjectIDs.Client3, false);
_client4 = (Client)LifetimeService.NewObject(WriteableSubTransaction, typeof(Client), ParamList.Empty);
_loadEventReceiverMock = MockRepository.GenerateStrictMock <ILoadEventReceiver>();
_order.SetLoadEventReceiver(_loadEventReceiverMock);
_location.SetLoadEventReceiver(_loadEventReceiverMock);
}
public void GetObject_Invalid()
{
var domainObject = ClassWithAllDataTypes.NewObject();
domainObject.Delete();
var expectedMessage = string.Format("Object '{0}' is invalid in this transaction.", domainObject.ID);
Assert.That(
() => LifetimeService.GetObject(TestableClientTransaction, domainObject.ID, true),
Throws.TypeOf <ObjectInvalidException> ().With.Message.EqualTo(expectedMessage));
Assert.That(
() => LifetimeService.GetObject(TestableClientTransaction, domainObject.ID, false),
Throws.TypeOf <ObjectInvalidException> ().With.Message.EqualTo(expectedMessage));
}
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 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 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 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 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 TransportedDomainObjects TransportAndChangeObjects(string propertyName, object newValue, 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);
var properties = new PropertyIndexer(domainObject);
properties[propertyName].SetValueWithoutTypeCheck(newValue);
}
});
return(Transport(transporter));
}
protected void CheckCollectionRelationRegistered(
ObjectID originatingObjectID, Type declaringType, string shortPropertyName, bool checkOrdering, params ObjectID[] expectedRelatedObjectIDs)
{
var relationEndPointDefinition =
originatingObjectID.ClassDefinition.GetMandatoryRelationEndPointDefinition(
declaringType.FullName + "." + shortPropertyName);
var endPointID = RelationEndPointID.Create(originatingObjectID, relationEndPointDefinition);
var collectionEndPoint = (ICollectionEndPoint)TestableClientTransaction.DataManager.GetRelationEndPointWithoutLoading(endPointID);
Assert.That(collectionEndPoint, Is.Not.Null);
var expectedRelatedObjects = expectedRelatedObjectIDs.Select(id => LifetimeService.GetObject(TestableClientTransaction, id, false)).ToArray();
if (checkOrdering)
{
Assert.That(collectionEndPoint.Collection, Is.EqualTo(expectedRelatedObjects));
}
else
{
Assert.That(collectionEndPoint.Collection, Is.EquivalentTo(expectedRelatedObjects));
}
}
public void LoadSingleObject()
{
var clientTransaction = ClientTransaction.CreateRootTransaction();
LifetimeService.GetObject(clientTransaction, _objectID, false);
clientTransaction.Discard();
Assert.That(
_tracingLinqToSqlAppender.TraceLog,
Is.StringMatching(
@"^ConnectionStarted \((?<connectionid>[^,]+)\)" + Environment.NewLine
+ @"StatementExecuted \(\k<connectionid>, (?<statementid>[^,]+), "
+ @"SELECT \[ID\], \[ClassID\], \[Timestamp\], \[SampleProperty\] "
+ @"FROM \[SampleObject\] WHERE \[ID\] = \@ID;" + Environment.NewLine
+ @"-- Ignore unbounded result sets: TOP \*" + Environment.NewLine
+ @"-- Parameters:" + Environment.NewLine
+ string.Format(@"-- \@ID = \[-\[{0}\]-\] \[-\[Type \(0\)\]-\]", _objectID.Value) + Environment.NewLine
+ @"\)" + Environment.NewLine
+ @"CommandDurationAndRowCount \(\k<connectionid>, \d+, \<null\>\)" + Environment.NewLine
+ @"StatementRowCount \(\k<connectionid>, \k<statementid>, 1\)" + Environment.NewLine
+ @"ConnectionDisposed \(\k<connectionid>\)" + Environment.NewLine
+ @"$"));
}
public void OnDomainObjectLoadedInSubTransaction()
{
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))
{
var subTx = tx.CreateSubTransaction();
LifetimeService.GetObject(subTx, _objectID, false);
subTx.Discard();
}
Assert.That(mixinInstance.OnLoadedCalled, Is.True);
Assert.That(mixinInstance.OnLoadedCount, Is.EqualTo(2));
Assert.That(mixinInstance.OnLoadedLoadMode, Is.EqualTo(LoadMode.DataContainerLoadedOnly));
Assert.That(mixinInstance.OnCreatedCalled, Is.False);
Assert.That(mixinInstance.OnDomainObjectReferenceInitializingCalled, Is.True);
}
public void TryGetObjects_UnloadedObjects_PropagatedToParent()
{
ClientTransaction parent = ClientTransaction.CreateRootTransaction();
ClientTransaction subTransaction = parent.CreateSubTransaction();
LifetimeService.GetObject(subTransaction, DomainObjectIDs.ClassWithAllDataTypes1, false); // preload ClassWithAllDataTypes
var extensionMock = MockRepository.GenerateMock <IClientTransactionExtension> ();
extensionMock.Stub(stub => stub.Key).Return("mock");
parent.Extensions.Add(extensionMock);
LifetimeService.TryGetObjects <DomainObject> (
subTransaction,
DomainObjectIDs.Order1,
DomainObjectIDs.ClassWithAllDataTypes1, // this has already been loaded
DomainObjectIDs.Order3,
DomainObjectIDs.OrderItem1);
extensionMock.AssertWasCalled(mock => mock.ObjectsLoading(Arg.Is(parent),
Arg <ReadOnlyCollection <ObjectID> > .List.Equal(new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.OrderItem1 })));
extensionMock.AssertWasNotCalled(mock => mock.ObjectsLoading(Arg.Is(parent),
Arg <ReadOnlyCollection <ObjectID> > .List.ContainsAll(new[] { DomainObjectIDs.ClassWithAllDataTypes1 })));
}
public static T GetObjectInTransaction <T> (ClientTransaction transaction, ObjectID objectID) where T : DomainObject
{
return((T)LifetimeService.GetObject(transaction, objectID, true));
}