public void TryGetObjects_WithInvalidObject_Works() { var order = Order.NewObject(); order.Delete(); Assert.That(order.State, Is.EqualTo(StateType.Invalid)); Assert.That(LifetimeService.TryGetObjects <Order> (TestableClientTransaction, order.ID), Is.EqualTo(new[] { order })); }
public void TryGetObjects_WithMoreThan2100IDs() { var ids = new List <ObjectID> (); ids.Add(DomainObjectIDs.Order1); ids.Add(DomainObjectIDs.Order3); ids.AddRange(Enumerable.Range(0, 4000).Select(i => new ObjectID(DomainObjectIDs.Order1.ClassDefinition, Guid.NewGuid()))); var result = LifetimeService.TryGetObjects <Order> (TestableClientTransaction, ids.ToArray()); Assert.That(result.Length, Is.EqualTo(4002)); Assert.That(result.Distinct().ToArray(), Is.EqualTo(new[] { DomainObjectIDs.Order1.GetObject <Order> (), DomainObjectIDs.Order3.GetObject <Order> (), null })); }
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 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 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 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 }))); }
/// <summary> /// Gets a number of objects that are already loaded (including invalid objects) or attempts to load them from the data source. /// If an object cannot be found, it will be marked <see cref="StateType.Invalid"/> in the <see cref="ClientTransaction"/>, and the result array will /// contain a <see langword="null" /> reference in its place. /// </summary> /// <typeparam name="T">The type of objects expected to be returned. Specify <see cref="DomainObject"/> if no specific type is expected.</typeparam> /// <param name="handles">Handles to the <see cref="DomainObject"/> that should be loaded.</param> /// <param name="clientTransaction">The <see cref="ClientTransaction"/>. If <see langword="null" /> (or unspecified), the /// <see cref="ClientTransaction.Current"/> transaction is used.</param> /// <returns>A list of objects of type <typeparamref name="T"/> corresponding to (and in the same order as) the IDs specified in /// <paramref name="handles"/>. This list can contain invalid and <see langword="null" /> <see cref="DomainObject"/> references.</returns> /// <exception cref="ArgumentNullException">The <paramref name="handles"/> parameter is <see langword="null"/>.</exception> /// <exception cref="InvalidCastException">One of the retrieved objects doesn't fit the specified type <typeparamref name="T"/>.</exception> public static T[] TryGetObjects <T> ([NotNull] this IEnumerable <IDomainObjectHandle <T> > handles, ClientTransaction clientTransaction = null) where T : DomainObject, ISupportsGetObject { ArgumentUtility.CheckNotNull("handles", handles); return(LifetimeService.TryGetObjects <T> (GetMandatoryClientTransaction(clientTransaction), handles.Select(h => h.ObjectID))); }