TraversibleRelationship GetTraversibleRelationship(TheoreticalRelationship relationship)
 {
     if (ReferenceEquals(relationship, null))
     {
         return(null);
     }
     return(new TraversibleRelationship(relationship.TicketRelationship,
                                        relationship.PrimaryTicket,
                                        relationship.SecondaryTicket,
                                        relationship.Relationship?.GetIdentity()));
 }
Exemple #2
0
        public void GetRelevantHierarchicalRelationships_does_not_include_a_relationship_which_permits_circles(DirectionalRelationship relationship,
                                                                                                               Identity <long, Ticket> ticketId,
                                                                                                               [Frozen] IGetsHierarchicalTicketRelationships relationshipProvider,
                                                                                                               PossiblyCircularHierarchicalTicketRelationshipProviderAdapter sut)
        {
            var theoreticalRelationship = new TheoreticalRelationship {
                Relationship  = relationship,
                PrimaryTicket = ticketId
            };

            relationship.Behaviour.ProhibitCircularRelationship = false;

            sut.GetRelevantHierarchicalRelationships(new[] { theoreticalRelationship });

            Mock.Get(relationshipProvider)
            .Verify(x => x.GetRelationships(It.Is <IIdentity <Ticket>[]>(p => p.Length == 0)), Times.Once);
        }
Exemple #3
0
        public void GetRelevantHierarchicalRelationships_can_get_a_relationship_with_a_secondary_ticket_identity(DirectionalRelationship relationship,
                                                                                                                 Identity <long, Ticket> ticketId,
                                                                                                                 [Frozen] IGetsHierarchicalTicketRelationships relationshipProvider,
                                                                                                                 PossiblyCircularHierarchicalTicketRelationshipProviderAdapter sut)
        {
            var theoreticalRelationship = new TheoreticalRelationship {
                Relationship    = relationship,
                SecondaryTicket = ticketId
            };

            relationship.Behaviour.ProhibitCircularRelationship = true;

            sut.GetRelevantHierarchicalRelationships(new[] { theoreticalRelationship });

            Mock.Get(relationshipProvider)
            .Verify(x => x.GetRelationships(ticketId), Times.Once);
        }
        public void GetTraversibleRelationships_does_not_return_removed_hierarchical_relationship([Frozen] IMapper mapper,
                                                                                                  TheoreticalRelationship rel1,
                                                                                                  HierarchicalTicketRelationship hRel1,
                                                                                                  TraversibleRelationship trav1,
                                                                                                  TraversibleRelationshipProvider sut)
        {
            rel1.Type = TheoreticalRelationshipType.Removed;
            rel1.TicketRelationship = Identity.Create <TicketRelationship>(5);
            ((IEntity)hRel1.TicketRelationship).IdentityValue = 5L;

            Mock.Get(mapper).Setup(x => x.Map <TraversibleRelationship>(rel1)).Returns(trav1);

            var result = sut.GetTraversibleRelationships(new[] { rel1 }, new[] { hRel1 });

            Assert.That(result, Is.Empty);
        }
        public void GetTraversibleRelationships_does_not_return_removed_theoretical_relationship([Frozen] IMapper mapper,
                                                                                                 TheoreticalRelationship rel1,
                                                                                                 TraversibleRelationship trav1,
                                                                                                 TraversibleRelationshipProvider sut)
        {
            rel1.Type = TheoreticalRelationshipType.Removed;

            Mock.Get(mapper).Setup(x => x.Map <TraversibleRelationship>(rel1)).Returns(trav1);

            var result = sut.GetTraversibleRelationships(new[] { rel1 }, Enumerable.Empty <HierarchicalTicketRelationship>());

            Assert.That(result, Is.Empty);
        }
        public void GetTraversibleRelationships_returns_mapped_existing_and_added_theoretical_relationships([Frozen] IMapper mapper,
                                                                                                            TheoreticalRelationship rel1,
                                                                                                            TheoreticalRelationship rel2,
                                                                                                            TraversibleRelationship trav1,
                                                                                                            TraversibleRelationship trav2,
                                                                                                            TraversibleRelationshipProvider sut)
        {
            rel1.Type = TheoreticalRelationshipType.Existing;
            rel2.Type = TheoreticalRelationshipType.Added;

            Mock.Get(mapper).Setup(x => x.Map <TraversibleRelationship>(rel1)).Returns(trav1);
            Mock.Get(mapper).Setup(x => x.Map <TraversibleRelationship>(rel2)).Returns(trav2);

            var result = sut.GetTraversibleRelationships(new[] { rel1, rel2 }, Enumerable.Empty <HierarchicalTicketRelationship>());

            Assert.That(result, Is.EquivalentTo(new[] { trav1, trav2 }));
        }