public void GetFlattenedRelatedObjectGraph_TraversalFilter()
{
var repository = new MockRepository();
Order order = GetDeepTestGraph();
var strategy = repository.StrictMock <IGraphTraversalStrategy>();
using (repository.Unordered())
{
strategy.Expect(mock => mock.ShouldProcessObject(order)).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.Official)).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.OrderTicket)).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.OrderItems[0])).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.OrderItems[1])).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.Customer)).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.Customer.Ceo)).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.Customer.IndustrialSector)).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.Customer.IndustrialSector.Companies[1])).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.Customer.IndustrialSector.Companies[1].Ceo)).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.Customer.IndustrialSector.Companies[2])).Return(true);
strategy.Expect(mock => mock.ShouldProcessObject(order.Customer.IndustrialSector.Companies[2].Ceo)).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order, 0, order.Properties[typeof(Order), "Official"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order, 0, order.Properties[typeof(Order), "OrderTicket"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order, 0, order.Properties[typeof(Order), "OrderItems"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order, 0, order.Properties[typeof(Order), "Customer"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Official, 1, order.Official.Properties[typeof(Official), "Orders"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.OrderTicket, 1, order.OrderTicket.Properties[typeof(OrderTicket), "Order"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.OrderItems[0], 1, order.OrderItems[0].Properties[typeof(OrderItem), "Order"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.OrderItems[1], 1, order.OrderItems[1].Properties[typeof(OrderItem), "Order"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer, 1, order.Customer.Properties[typeof(Customer), "Orders"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer, 1, order.Customer.Properties[typeof(Customer), "ContactPerson"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer, 1, order.Customer.Properties[typeof(Company), "Ceo"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer, 1, order.Customer.Properties[typeof(Company), "IndustrialSector"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer.Ceo, 2, order.Customer.Ceo.Properties[typeof(Ceo), "Company"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer.IndustrialSector, 2, order.Customer.IndustrialSector.Properties[typeof(IndustrialSector), "Companies"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer.IndustrialSector.Companies[1], 3, order.Customer.IndustrialSector.Companies[1].Properties[typeof(Company), "IndustrialSector"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer.IndustrialSector.Companies[1], 3, order.Customer.IndustrialSector.Companies[1].Properties[typeof(Company), "Ceo"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer.IndustrialSector.Companies[2], 3, order.Customer.IndustrialSector.Companies[2].Properties[typeof(Company), "IndustrialSector"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer.IndustrialSector.Companies[2], 3, order.Customer.IndustrialSector.Companies[2].Properties[typeof(Company), "Ceo"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer.IndustrialSector.Companies[1].Ceo, 4, order.Customer.IndustrialSector.Companies[1].Ceo.Properties[typeof(Ceo), "Company"])).Return(true);
strategy.Expect(mock => mock.ShouldFollowLink(order, order.Customer.IndustrialSector.Companies[2].Ceo, 4, order.Customer.IndustrialSector.Companies[2].Ceo.Properties[typeof(Ceo), "Company"])).Return(true);
}
repository.ReplayAll();
HashSet <DomainObject> result = new DomainObjectGraphTraverser(order, strategy).GetFlattenedRelatedObjectGraph();
var expected = new DomainObject[] { order, order.Official, order.OrderTicket, order.OrderItems[0], order.OrderItems[1],
order.Customer, order.Customer.Ceo, order.Customer.IndustrialSector,
order.Customer.IndustrialSector.Companies[1], order.Customer.IndustrialSector.Companies[1].Ceo,
order.Customer.IndustrialSector.Companies[2], order.Customer.IndustrialSector.Companies[2].Ceo };
repository.VerifyAll();
Assert.That(result, Is.EquivalentTo(expected));
}
public void GetFlattenedRelatedObjectGraph_ContainsIndirectRelatedObjects()
{
Order order = GetTestGraph();
HashSet <DomainObject> graph = new DomainObjectGraphTraverser(order, FullGraphTraversalStrategy.Instance).GetFlattenedRelatedObjectGraph();
Assert.That(graph, Has.Member(order.Customer.Ceo));
}
public void GetFlattenedRelatedObjectGraph_WithTraversalFilter_FollowLink()
{
Order order = DomainObjectIDs.Order1.GetObject <Order> ();
HashSet <DomainObject> graph = new DomainObjectGraphTraverser(order, new TestTraversalStrategy(true, 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),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Person1, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Person7, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Person3, false),
LifetimeService.GetObject(TestableClientTransaction, DomainObjectIDs.Person6, false)
};
Assert.That(graph, Is.EquivalentTo(expected));
}
public void GetFlattenedRelatedObjectGraph_ContainsRelatedObjects()
{
Order order = GetTestGraph();
HashSet <DomainObject> graph = new DomainObjectGraphTraverser(order, FullGraphTraversalStrategy.Instance).GetFlattenedRelatedObjectGraph();
foreach (DomainObject relatedObject in order.Properties.GetAllRelatedObjects())
{
Assert.That(graph, Has.Member(relatedObject));
}
}
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));
}
/// <summary>
/// Loads the object with the specified <see cref="ObjectID"/> plus all objects directly or indirectly referenced by it into the
/// transporter, as specified by the <see cref="IGraphTraversalStrategy"/>. Each object behaves as if it were loaded via <see cref="Load"/>.
/// </summary>
/// <param name="objectID">The <see cref="ObjectID"/> of the object which is to be loaded together with its related objects.</param>
/// <param name="strategy">An <see cref="IGraphTraversalStrategy"/> instance defining which related object links to follow and which
/// objects to include in the set of transported objects.</param>
/// <returns>The loaded objects, whose properties can be manipulated before they are transported.</returns>
/// <seealso cref="DomainObjectGraphTraverser.GetFlattenedRelatedObjectGraph"/>
public IEnumerable <DomainObject> LoadRecursive(ObjectID objectID, IGraphTraversalStrategy strategy)
{
ArgumentUtility.CheckNotNull("objectID", objectID);
ArgumentUtility.CheckNotNull("strategy", strategy);
DomainObject sourceObject = _transportTransaction.GetObject(objectID, false);
using (_transportTransaction.EnterNonDiscardingScope())
{
HashSet <DomainObject> graph = new DomainObjectGraphTraverser(sourceObject, strategy).GetFlattenedRelatedObjectGraph();
foreach (DomainObject domainObject in graph)
{
Load(domainObject.ID); // explicitly call load rather than just implicitly loading it into the transaction for consistency
}
return(graph);
}
}
