Esempio n. 1
0
        public void Equals_returns_false_for_object([HasIdentity] TicketRelationship ticketRel,
                                                    [HasIdentity] DirectionalRelationship rel1)
        {
            var sut = new TraversibleRelationship(ticketRel.GetIdentity(), null, null, rel1.GetIdentity());

            Assert.That(() => sut.Equals(new Object()), Is.False);
        }
Esempio n. 2
0
        public void Equals_returns_true_for_two_equal_identities([HasIdentity] TicketRelationship ticketRel,
                                                                 [HasIdentity] DirectionalRelationship rel1,
                                                                 [HasIdentity] DirectionalRelationship rel2)
        {
            var sut = new TraversibleRelationship(ticketRel.GetIdentity(), null, null, rel1.GetIdentity());
            var two = new TraversibleRelationship(ticketRel.GetIdentity(), null, null, rel2.GetIdentity());

            Assert.That(() => sut.Equals(two), Is.True);
        }
        public void AreRelationshipsValid_returns_true_if_no_relationship_is_circular([Frozen] IGetsHierarchicalTicketRelationshipsWhichCouldCreateACircularRelationship hierarchicalRelationshipProvider,
                                                                                      [Frozen] IGetsTraversibleRelationships traversibleRelationshipProvider,
                                                                                      [Frozen] IDetectsCircularRelationship detector,
                                                                                      CircularRelationshipValidator sut,
                                                                                      IEnumerable <TheoreticalRelationship> relationships,
                                                                                      IIdentity <Ticket> editedTicket,
                                                                                      IEnumerable <HierarchicalTicketRelationship> hierarchicalRelationships,
                                                                                      TraversibleRelationship traversibleRelationship)
        {
            var allRelationships = new[] { traversibleRelationship };

            Mock.Get(hierarchicalRelationshipProvider)
            .Setup(x => x.GetRelevantHierarchicalRelationships(relationships))
            .Returns(hierarchicalRelationships);
            Mock.Get(traversibleRelationshipProvider)
            .Setup(x => x.GetTraversibleRelationships(relationships, hierarchicalRelationships))
            .Returns(allRelationships);
            Mock.Get(detector)
            .Setup(x => x.IsRelationshipCircular(traversibleRelationship.Type, allRelationships))
            .Returns(false);

            var result = sut.AreRelationshipsValid(editedTicket, relationships);

            Assert.That(result, Is.True);
        }
        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_returns_mapped_hierarchical_relationships([Frozen] IMapper mapper,
                                                                                          HierarchicalTicketRelationship rel1,
                                                                                          HierarchicalTicketRelationship rel2,
                                                                                          TraversibleRelationship trav1,
                                                                                          TraversibleRelationship trav2,
                                                                                          TraversibleRelationshipProvider sut)
        {
            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(Enumerable.Empty <TheoreticalRelationship>(), new[] { rel1, rel2 });

            Assert.That(result, Is.EquivalentTo(new[] { trav1, trav2 }));
        }
        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 }));
        }