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)));
}