public void CanSortTwoRelatedItemsInCorrectOrder()
        {
            var fishPackage = MakeUpdateSet("fish", "1.2.3");

            var items = new List <PackageUpdateSet>
            {
                fishPackage,
                MakeUpdateSet("bar", "2.3.4", DependencyOn(fishPackage))
            };


            var logger = Substitute.For <INuKeeperLogger>();

            var sorter = new PackageUpdateSetTopologicalSort(logger);

            var sorted = sorter.Sort(items)
                         .ToList();

            AssertIsASortOf(sorted, items);
            Assert.That(sorted[0], Is.EqualTo(items[0]));
            Assert.That(sorted[1], Is.EqualTo(items[1]));

            logger.DidNotReceive().Detailed("No dependencies between items, no need to sort on dependencies");
            logger.Received(1).Detailed("Sorted 2 packages by dependencies but no change made");
        }
        public void CanSortTwoRelatedItemsinReverseOrder()
        {
            var fishPackage = MakeUpdateSet("fish", "1.2.3");

            var items = new List <PackageUpdateSet>
            {
                MakeUpdateSet("bar", "2.3.4", DependencyOn(fishPackage)),
                fishPackage
            };


            var logger = Substitute.For <INuKeeperLogger>();

            var sorter = new PackageUpdateSetTopologicalSort(logger);

            var sorted = sorter.Sort(items)
                         .ToList();

            AssertIsASortOf(sorted, items);

            Assert.That(sorted[0], Is.EqualTo(items[1]));
            Assert.That(sorted[1], Is.EqualTo(items[0]));

            logger.DidNotReceive().Detailed("No dependencies between items, no need to sort on dependencies");
            logger.Received(1).Detailed("Resorted 2 packages by dependencies, first change is fish moved to position 0 from 1.");
        }
        public void CanSortEmptyList()
        {
            var items = new List <PackageUpdateSet>();

            var sorter = new PackageUpdateSetTopologicalSort(Substitute.For <INuKeeperLogger>());

            var sorted = sorter.Sort(items)
                         .ToList();

            Assert.That(sorted, Is.Not.Null);
            Assert.That(sorted, Is.Empty);
        }
        public void CanSortOneItemInList()
        {
            var items = new List <PackageUpdateSet>
            {
                MakeUpdateSet("foo", "1.2.3")
            };

            var sorter = new PackageUpdateSetTopologicalSort(Substitute.For <INuKeeperLogger>());

            var sorted = sorter.Sort(items)
                         .ToList();

            AssertIsASortOf(sorted, items);
            Assert.That(sorted[0], Is.EqualTo(items[0]));
        }
        public void CanSortThreeRelatePackages()
        {
            var apexPackage = MakeUpdateSet("apex", "1.2.3");

            var items = new List <PackageUpdateSet>
            {
                MakeUpdateSet("foo", "1.2.3", DependencyOn(apexPackage)),
                apexPackage,
                MakeUpdateSet("bar", "2.3.4", DependencyOn(apexPackage)),
            };


            var logger = Substitute.For <INuKeeperLogger>();

            var sorter = new PackageUpdateSetTopologicalSort(logger);

            var sorted = sorter.Sort(items)
                         .ToList();


            AssertIsASortOf(sorted, items);
            Assert.That(sorted[0], Is.EqualTo(apexPackage));
        }
        public void CanSortWithCycle()
        {
            var pakageOne    = MakeUpdateSet("one", "1.2.3");
            var packageAlpha = MakeUpdateSet("alpha", "2.3.4", DependencyOn(pakageOne));

            pakageOne = MakeUpdateSet("one", "1.2.3", DependencyOn(packageAlpha));

            var items = new List <PackageUpdateSet>
            {
                pakageOne,
                packageAlpha
            };

            var logger = Substitute.For <INuKeeperLogger>();

            var sorter = new PackageUpdateSetTopologicalSort(logger);

            var sorted = sorter.Sort(items)
                         .ToList();

            AssertIsASortOf(sorted, items);
            logger.Received(1).Minimal(Arg.Is <string>(s => s.StartsWith("Cannot sort by dependencies, cycle found at item")));
        }