public void ShouldLimitNumberOfRecentCommitsRetrieved()
        {
            using (var tempFolder = new TemporaryFolder())
            {
                var tempRepository = new TemporaryRepository(tempFolder);
                tempRepository.RunCommand("init");
                for (var i = 0; i < 20; i ++)
                    tempRepository.TouchFileAndCommit();

                var executor = new GitCommandExecutor(tempFolder.Path);
                var log = new LogRetriever(executor).GetRecentCommits(10).ToArray();

                Assert.AreEqual(10, log.Length);
            }
        }
Beispiel #2
0
        void RefreshGraph(LogRetriever logRetriever)
        {
            var commits       = logRetriever.GetRecentCommits().ToArray();
            var activeRefName = logRetriever.GetActiveReferenceName();

            var reachableCommitHashes = commits.Select(c => c.Hash).ToArray();
            var unreachableHashes     = logRetriever.GetRecentUnreachableCommitHashes();
            var unreachableCommits    = logRetriever
                                        .GetSpecificCommits(unreachableHashes)
                                        .Where(c => !reachableCommitHashes.Contains(c.Hash))
                                        .ToArray();

            _graph = GenerateGraphFromCommits(commits, activeRefName, unreachableCommits);
            OnPropertyChanged("Graph");
        }
        public void ShouldReturnMostRecentCommitFirst()
        {
            using (var tempFolder = new TemporaryFolder())
            {
                var tempRepository = new TemporaryRepository(tempFolder);
                tempRepository.RunCommand("init");
                tempRepository.TouchFileAndCommit();
                tempRepository.TouchFileAndCommit();

                var executor = new GitCommandExecutor(tempFolder.Path);
                var log = new LogRetriever(executor).GetRecentCommits().ToArray();

                var firstCommitReturned = log.ElementAt(0);
                var secondCommitReturned = log.ElementAt(1);

                CollectionAssert.AreEqual(new[] { secondCommitReturned.Hash }, firstCommitReturned.ParentHashes);
            }
        }
Beispiel #4
0
        void RefreshGraph(LogRetriever logRetriever)
        {
            var commits       = logRetriever.GetRecentCommits(NumOfCommitsToShow).ToArray();
            var activeRefName = logRetriever.GetActiveReferenceName();

            var reachableCommitHashes = commits.Select(c => c.Hash).ToArray();
            var unreachableHashes     = logRetriever.GetRecentUnreachableCommitHashes();
            IEnumerable <Commit> unreachableCommits = null;

            if (VisualizeUnreachable)
            {
                unreachableCommits = logRetriever
                                     .GetSpecificCommits(unreachableHashes)
                                     .Where(c => !reachableCommitHashes.Contains(c.Hash))
                                     .ToArray();
            }

            Graph = GenerateGraphFromCommits(commits, activeRefName, unreachableCommits);
        }
        public void ShouldReturnMultipleUnreachableCommitHashesAfterRewind()
        {
            using (var tempFolder = new TemporaryFolder())
            {
                var tempRepository = new TemporaryRepository(tempFolder);
                var executor = new GitCommandExecutor(tempFolder.Path);
                var log = new LogRetriever(executor);

                tempRepository.RunCommand("init");
                tempRepository.TouchFileAndCommit();
                var firstCommitHash = log.GetRecentCommits(1).Single().Hash;

                for (var i = 0; i < 10; i++)
                    tempRepository.TouchFileAndCommit();

                tempRepository.RunCommand("reset --hard " + firstCommitHash);

                var orphanedHashes = log.GetRecentUnreachableCommitHashes(100);
                Assert.AreEqual(10, orphanedHashes.Count());
            }
        }
Beispiel #6
0
        void RefreshGraph(LogRetriever logRetriever)
        {
            var commits = logRetriever.GetRecentCommits().ToArray();
            var activeRefName = logRetriever.GetActiveReferenceName();

            var reachableCommitHashes = commits.Select(c => c.Hash).ToArray();
            var unreachableHashes = logRetriever.GetRecentUnreachableCommitHashes();
            var unreachableCommits = logRetriever
                .GetSpecificCommits(unreachableHashes)
                .Where(c => !reachableCommitHashes.Contains(c.Hash))
                .ToArray();

            _graph = GenerateGraphFromCommits(commits, activeRefName, unreachableCommits);
            OnPropertyChanged("Graph");
        }
        public void ShouldReturnSameDataForSpecificCommitsAsWhenRetrievedViaRecentCommits()
        {
            using (var tempFolder = new TemporaryFolder())
            {
                var tempRepository = new TemporaryRepository(tempFolder);
                tempRepository.RunCommand("init");
                tempRepository.TouchFileAndCommit();
                tempRepository.TouchFileAndCommit();

                var executor = new GitCommandExecutor(tempFolder.Path);
                var logRetriever = new LogRetriever(executor);

                var recentCommits = logRetriever.GetRecentCommits().ToArray();
                var recentCommitHashes = recentCommits.Select(c => c.Hash);

                var specificCommits = logRetriever.GetSpecificCommits(recentCommitHashes);

                CollectionAssert.AreEqual(recentCommits, specificCommits, new SerializedObjectComparer());
            }
        }
        public void ShouldReturnUnreachableCommitHashesAfterRewind()
        {
            using (var tempFolder = new TemporaryFolder())
            {
                var tempRepository = new TemporaryRepository(tempFolder);
                var executor = new GitCommandExecutor(tempFolder.Path);
                var log = new LogRetriever(executor);

                tempRepository.RunCommand("init");
                tempRepository.TouchFileAndCommit();
                var firstCommitHash = log.GetRecentCommits(1).Single().Hash;
                tempRepository.TouchFileAndCommit();
                var secondCommitHash = log.GetRecentCommits(1).Single().Hash;
                tempRepository.RunCommand("reset --hard " + firstCommitHash);

                var orphanedHashes = log.GetRecentUnreachableCommitHashes();
                CollectionAssert.AreEqual(new[] { secondCommitHash }, orphanedHashes);
            }
        }
        public void ShouldReturnTwoRecentCommits()
        {
            using (var tempFolder = new TemporaryFolder())
            {
                var tempRepository = new TemporaryRepository(tempFolder);
                tempRepository.RunCommand("init");
                tempRepository.TouchFileAndCommit();
                tempRepository.TouchFileAndCommit();

                var executor = new GitCommandExecutor(tempFolder.Path);
                var log = new LogRetriever(executor).GetRecentCommits().ToArray();

                Assert.AreEqual(2, log.Length);

                var commit = log.ElementAt(0);
                Assert.IsNotNullOrEmpty(commit.Hash);
                Assert.AreEqual(40, commit.Hash.Length);
                CollectionAssert.AreEqual(new[] { log.ElementAt(1).Hash }, commit.ParentHashes);

                commit = log.ElementAt(1);
                Assert.IsNotNullOrEmpty(commit.Hash);
                Assert.AreEqual(40, commit.Hash.Length);
                Assert.IsNull(commit.ParentHashes);
            }
        }
        public void ShouldReturnSingleRecentCommitWithLocalRefs()
        {
            using (var tempFolder = new TemporaryFolder())
            {
                var tempRepository = new TemporaryRepository(tempFolder);
                tempRepository.RunCommand("init");
                tempRepository.TouchFileAndCommit();

                var executor = new GitCommandExecutor(tempFolder.Path);
                var log = new LogRetriever(executor).GetRecentCommits().ToArray();

                var commit = log.Single();
                CollectionAssert.AreEqual(new[] { "HEAD", "master" }, commit.Refs);
            }
        }
        public void ShouldReturnSingleRecentCommitWithHashButNoParents()
        {
            using (var tempFolder = new TemporaryFolder())
            {
                var tempRepository = new TemporaryRepository(tempFolder);
                tempRepository.RunCommand("init");
                tempRepository.TouchFileAndCommit();

                var executor = new GitCommandExecutor(tempFolder.Path);
                var log = new LogRetriever(executor).GetRecentCommits().ToArray();

                Assert.AreEqual(1, log.Length);

                var commit = log.Single();
                Assert.IsNotNullOrEmpty(commit.Hash);
                Assert.AreEqual(40, commit.Hash.Length);
                Assert.IsNull(commit.ParentHashes);
            }
        }
        public void ShouldReturnSingleRecentCommit()
        {
            using (var tempFolder = new TemporaryFolder())
            {
                var tempRepository = new TemporaryRepository(tempFolder);
                tempRepository.RunCommand("init");
                tempRepository.TouchFileAndCommit();

                var executor = new GitCommandExecutor(tempFolder.Path);
                var log = new LogRetriever(executor).GetRecentCommits().ToArray();

                Assert.AreEqual(1, log.Length);
            }
        }