Beispiel #1
0
        public void UseGitClient()
        {
            GitCommitArgs ga = new GitCommitArgs();
            ga.Author.Name = "Tester";
            ga.Author.EmailAddress = "*****@*****.**";
            ga.Signature.Name = "Other";
            ga.Signature.EmailAddress = "*****@*****.**";

            // Use stable time and offset to always produce the same hash
            DateTime ct = new DateTime(2002, 01, 01, 0, 0, 0, DateTimeKind.Utc);
            ga.Author.When = ct;
            ga.Author.TimeOffsetInMinutes = 120;
            ga.Signature.When = ct;
            ga.Signature.TimeOffsetInMinutes = 120;

            string repoDir = GetTempPath();
            string repo2Dir = GetTempPath();
            GitId firstResult;
            GitId lastCommit;
            using (GitRepository repo = GitRepository.Create(repoDir))
            using (GitClient git = new GitClient())
            {
                string ignoreFile = Path.Combine(repoDir, ".gitignore");
                string file = Path.Combine(repoDir, "newfile");
                string subDir = Path.Combine(repoDir, "dir");
                string fileInSubDir = Path.Combine(subDir, "file2");
                string file3 = Path.Combine(repoDir, "other");
                string file4 = Path.Combine(repoDir, "q.ignore");
                File.WriteAllText(file, "Some body");
                Directory.CreateDirectory(subDir);
                File.WriteAllText(fileInSubDir, "Some other body");
                File.WriteAllText(file3, "file3");

                File.WriteAllText(ignoreFile, "*.ignore\n");
                File.WriteAllText(file4, "file4");

                git.Add(ignoreFile);
                git.Add(file);
                git.Commit(repoDir, ga, out firstResult);

                git.Add(fileInSubDir);

                int ticked = 0;

                File.AppendAllText(file, "\nExtra Line");

                GitStatusArgs gsa = new GitStatusArgs();
                gsa.IncludeIgnored = true;
                gsa.IncludeUnmodified = true;

                Assert.That(git.Status(repoDir, gsa,
                    delegate(object sender, GitStatusEventArgs e)
                    {
                        switch (e.RelativePath)
                        {
                            case "newfile":
                                //Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Added));
                                Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "newfile index normal");
                                Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "newfile wc modified");
                                Assert.That(e.WorkingDirectoryModified);
                                Assert.That(e.Ignored, Is.False);
                                break;
                            case "dir/file2":
                                Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.New), "file2 index added");
                                Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "file2 wc normal");
                                Assert.That(e.Ignored, Is.False);
                                break;
                            case "other":
                                Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
                                Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New));
                                Assert.That(e.Ignored, Is.False);
                                break;
                            case ".gitignore":
                                Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal));
                                Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
                                Assert.That(e.Ignored, Is.False);
                                break;
                            case "q.ignore":
                                // TODO: Make this ignored
                                Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
                                Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
                                Assert.That(e.Ignored, Is.True);
                                break;
                            default:
                                Assert.Fail("Invalid node found: {0}", e.RelativePath);
                                break;
                        }

                        Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
                        ticked++;
                    }), Is.True);

                Assert.That(ticked, Is.EqualTo(5), "Ticked");

                ga.LogMessage = "Intermediate";
                git.Commit(repoDir, ga);

                Assert.That(git.Delete(fileInSubDir));
                Assert.That(git.Add(file));

                GitId commit;

                ga.LogMessage = "A log message to remember";

                // The passed path is currently just used to find the local repository
                lastCommit = new GitId("996cf198b49ed6fce3bcba232e2d88eb473560f9");

                Assert.That(git.Commit(repoDir, ga, out commit));
                Assert.That(commit, Is.EqualTo(lastCommit));

                File.Move(file, file + ".a");

                ticked = 0;
                gsa.IncludeIgnored = false;
                gsa.IncludeUnversioned = true;
                gsa.IncludeUnmodified = false;
                Assert.That(git.Status(repoDir, gsa,
                    delegate(object sender, GitStatusEventArgs e)
                    {
                        switch (e.RelativePath)
                        {
                            /*case "dir":
                                Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "dir index normal");
                                Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "dir wc normal");
                                break;*/
                            case "newfile":
                                Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile index normal");
                                Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Deleted), "newfile wc deleted");
                                break;
                            case "newfile.a":
                                Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile.a index normal");
                                Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "newfile.a wc new");
                                break;
                            case "other":
                                Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "other index normal");
                                Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "other wc normal");
                                break;
                            default:
                                Assert.Fail("Invalid node found: {0}", e.RelativePath);
                                break;
                        }

                        Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
                        ticked++;
                    }), Is.True);

                Assert.That(ticked, Is.EqualTo(3));

                GitCloneArgs gc = new GitCloneArgs();
                gc.Synchronous = true;

                git.Clone(repoDir, repo2Dir, gc);

                GitCommit theCommit;
                Assert.That(repo.Lookup(commit, out theCommit));
                Assert.That(repo.Branches.Create(theCommit, "vNext"));
                Assert.That(repo.Branches, Is.Not.Empty);
            }

            using (GitRepository repo1 = new GitRepository(repoDir))
            using (GitRepository repo2 = new GitRepository(repo2Dir))
            {
                GitReference head = repo1.HeadReference;
                Assert.That(head, Is.Not.Null, "Has head");

                Assert.That(head.Name, Is.EqualTo("refs/heads/master"));
                //Assert.That(repo2.Head, Is.Not.Null);

                GitId headId;
                Assert.That(repo1.ResolveReference(repo1.HeadReference, out headId));
                Assert.That(headId, Is.EqualTo(lastCommit));
                GitCommit commit;

                Assert.That(repo1.Lookup(headId, out commit));
                Assert.That(commit, Is.Not.Null, "Have a commit");

                Assert.That(commit.Id, Is.EqualTo(lastCommit));
                Assert.That(commit.Ancestors, Is.Not.Empty);
                Assert.That(commit.Ancestor, Is.Not.Null);
                Assert.That(commit.Ancestor.Ancestor, Is.Not.Null);
                Assert.That(commit.Ancestor.Ancestor.Ancestor, Is.Null);
                Assert.That(commit.Ancestor.Ancestor.Id, Is.EqualTo(firstResult));

                Assert.That(commit.Author, Is.Not.Null);
                Assert.That(commit.Author.Name, Is.EqualTo("Tester"));
                Assert.That(commit.Author.EmailAddress, Is.EqualTo("*****@*****.**"));

                Assert.That(commit.Committer, Is.Not.Null);
                Assert.That(commit.Committer.Name, Is.EqualTo("Other"));
                Assert.That(commit.Committer.EmailAddress, Is.EqualTo("*****@*****.**"));

                Assert.That(commit.Committer.TimeOffsetInMinutes, Is.EqualTo(120), "Time offset"); // CEST dependent
                Assert.That(commit.Committer.When, Is.EqualTo(ct), "Exact time");
                Assert.That(commit.LogMessage, Is.EqualTo("A log message to remember\n"));

                Assert.That(commit.Parents, Is.Not.Empty);
                Assert.That(commit.ParentIds, Is.Not.Empty);

                Assert.That(commit.Tree, Is.Not.Empty);
                Assert.That(commit.Tree.Count, Is.EqualTo(2));
                Assert.That(commit.Ancestor.Tree.Count, Is.EqualTo(3));
                Assert.That(commit.Ancestor.Ancestor.Tree.Count, Is.EqualTo(2));
                Assert.That(commit.Tree.Id, Is.Not.EqualTo(commit.Ancestor.Tree.Id));

                GitId id;
                Assert.That(repo1.LookupViaPrefix(commit.Id.ToString(), out id));
                Assert.That(id, Is.EqualTo(commit.Id));

                Assert.That(repo1.LookupViaPrefix(commit.Id.ToString().Substring(0, 10), out id));
                Assert.That(id, Is.EqualTo(commit.Id));

                Assert.That(commit.Peel<GitObject>().Id, Is.EqualTo(commit.Tree.Id));
                Assert.That(commit.Peel<GitTree>(), Is.EqualTo(commit.Tree)); // Compares members
                Assert.That(commit.Tree.Peel<GitObject>(), Is.Null);

                GitTagArgs ta = new GitTagArgs();
                ta.Signature.When = ct;
                ta.Signature.Name = "Me";
                ta.Signature.EmailAddress = "[email protected]";
                ta.LogMessage = "Some message";
                ga.Author.TimeOffsetInMinutes = 120;
                Assert.That(commit.Tag("MyTag", ta, out id));
                Assert.That(id, Is.EqualTo(new GitId("db31f8333fc64d7e7921ea91f6e007b755dcfcbb")));

                GitTag tag;
                Assert.That(repo1.Lookup(id, out tag));
                Assert.That(tag, Is.Not.Null);
                Assert.That(tag.Name, Is.EqualTo("MyTag"));
                Assert.That(tag.LogMessage, Is.EqualTo("Some message\n"));
                Assert.That(tag.Tagger.Name, Is.EqualTo("Me"));

                Assert.That(tag.Target.Id, Is.EqualTo(commit.Id));
                Assert.That(tag.Peel<GitTree>(), Is.EqualTo(commit.Peel<GitTree>()));

                repo1.CheckOut(commit.Tree);

                //Console.WriteLine("1:");
                //foreach (GitTreeEntry e in commit.Tree)
                //{
                //    Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
                //}

                //Console.WriteLine("2:");
                //foreach (GitTreeEntry e in commit.Ancestor.Tree)
                //{
                //    Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
                //}

                //Console.WriteLine("3:");
                //foreach (GitTreeEntry e in commit.Ancestor.Ancestor.Tree)
                //{
                //    Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
                //}
                //Console.WriteLine("-");
            }
        }
Beispiel #2
0
        public void UseGitClient()
        {
            GitCommitArgs ga = new GitCommitArgs();

            ga.Author.Name            = "Tester";
            ga.Author.EmailAddress    = "*****@*****.**";
            ga.Signature.Name         = "Other";
            ga.Signature.EmailAddress = "*****@*****.**";

            // Use stable time and offset to always produce the same hash
            DateTime ct = new DateTime(2002, 01, 01, 0, 0, 0, DateTimeKind.Utc);

            ga.Author.When = ct;
            ga.Author.TimeOffsetInMinutes    = 120;
            ga.Signature.When                = ct;
            ga.Signature.TimeOffsetInMinutes = 120;

            string repoDir  = GetTempPath();
            string repo2Dir = GetTempPath();
            GitId  firstResult;
            GitId  lastCommit;

            using (GitRepository repo = GitRepository.Create(repoDir))
                using (GitClient git = new GitClient())
                {
                    string ignoreFile   = Path.Combine(repoDir, ".gitignore");
                    string file         = Path.Combine(repoDir, "newfile");
                    string subDir       = Path.Combine(repoDir, "dir");
                    string fileInSubDir = Path.Combine(subDir, "file2");
                    string file3        = Path.Combine(repoDir, "other");
                    string file4        = Path.Combine(repoDir, "q.ignore");
                    File.WriteAllText(file, "Some body");
                    Directory.CreateDirectory(subDir);
                    File.WriteAllText(fileInSubDir, "Some other body");
                    File.WriteAllText(file3, "file3");

                    File.WriteAllText(ignoreFile, "*.ignore\n");
                    File.WriteAllText(file4, "file4");

                    git.Add(ignoreFile);
                    git.Add(file);
                    git.Commit(repoDir, ga, out firstResult);

                    git.Add(fileInSubDir);

                    int ticked = 0;

                    File.AppendAllText(file, "\nExtra Line");

                    GitStatusArgs gsa = new GitStatusArgs();
                    gsa.IncludeIgnored    = true;
                    gsa.IncludeUnmodified = true;

                    Assert.That(git.Status(repoDir, gsa,
                                           delegate(object sender, GitStatusEventArgs e)
                    {
                        switch (e.RelativePath)
                        {
                        case "newfile":
                            //Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Added));
                            Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "newfile index normal");
                            Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "newfile wc modified");
                            Assert.That(e.WorkingDirectoryModified);
                            Assert.That(e.Ignored, Is.False);
                            break;

                        case "dir/file2":
                            Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.New), "file2 index added");
                            Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal), "file2 wc normal");
                            Assert.That(e.Ignored, Is.False);
                            break;

                        case "other":
                            Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
                            Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New));
                            Assert.That(e.Ignored, Is.False);
                            break;

                        case ".gitignore":
                            Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal));
                            Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
                            Assert.That(e.Ignored, Is.False);
                            break;

                        case "q.ignore":
                            // TODO: Make this ignored
                            Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None));
                            Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Normal));
                            Assert.That(e.Ignored, Is.True);
                            break;

                        default:
                            Assert.Fail("Invalid node found: {0}", e.RelativePath);
                            break;
                        }

                        Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
                        ticked++;
                    }), Is.True);

                    Assert.That(ticked, Is.EqualTo(5), "Ticked");

                    ga.LogMessage = "Intermediate";
                    git.Commit(repoDir, ga);

                    Assert.That(git.Delete(fileInSubDir));
                    Assert.That(git.Add(file));

                    GitId commit;

                    ga.LogMessage = "A log message to remember";

                    // The passed path is currently just used to find the local repository
                    lastCommit = new GitId("996cf198b49ed6fce3bcba232e2d88eb473560f9");

                    Assert.That(git.Commit(repoDir, ga, out commit));
                    Assert.That(commit, Is.EqualTo(lastCommit));

                    File.Move(file, file + ".a");

                    ticked                 = 0;
                    gsa.IncludeIgnored     = false;
                    gsa.IncludeUnversioned = true;
                    gsa.IncludeUnmodified  = false;
                    Assert.That(git.Status(repoDir, gsa,
                                           delegate(object sender, GitStatusEventArgs e)
                    {
                        switch (e.RelativePath)
                        {
                        /*case "dir":
                         *  Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.Normal), "dir index normal");
                         *  Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "dir wc normal");
                         *  break;*/
                        case "newfile":
                            Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile index normal");
                            Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.Deleted), "newfile wc deleted");
                            break;

                        case "newfile.a":
                            Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "newfile.a index normal");
                            Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "newfile.a wc new");
                            break;

                        case "other":
                            Assert.That(e.IndexStatus, Is.EqualTo(GitStatus.None), "other index normal");
                            Assert.That(e.WorkingDirectoryStatus, Is.EqualTo(GitStatus.New), "other wc normal");
                            break;

                        default:
                            Assert.Fail("Invalid node found: {0}", e.RelativePath);
                            break;
                        }

                        Assert.That(e.FullPath, Is.EqualTo(Path.GetFullPath(Path.Combine(repoDir, e.RelativePath))));
                        ticked++;
                    }), Is.True);

                    Assert.That(ticked, Is.EqualTo(3));

                    GitCloneArgs gc = new GitCloneArgs();
                    gc.Synchronous = true;

                    git.Clone(repoDir, repo2Dir, gc);

                    GitCommit theCommit;
                    Assert.That(repo.Lookup(commit, out theCommit));
                    Assert.That(repo.Branches.Create(theCommit, "vNext"));
                    Assert.That(repo.Branches, Is.Not.Empty);
                }

            using (GitRepository repo1 = new GitRepository(repoDir))
                using (GitRepository repo2 = new GitRepository(repo2Dir))
                {
                    GitReference head = repo1.HeadReference;
                    Assert.That(head, Is.Not.Null, "Has head");

                    Assert.That(head.Name, Is.EqualTo("refs/heads/master"));
                    //Assert.That(repo2.Head, Is.Not.Null);

                    GitId headId;
                    Assert.That(repo1.ResolveReference(repo1.HeadReference, out headId));
                    Assert.That(headId, Is.EqualTo(lastCommit));
                    GitCommit commit;

                    Assert.That(repo1.Lookup(headId, out commit));
                    Assert.That(commit, Is.Not.Null, "Have a commit");

                    Assert.That(commit.Id, Is.EqualTo(lastCommit));
                    Assert.That(commit.Ancestors, Is.Not.Empty);
                    Assert.That(commit.Ancestor, Is.Not.Null);
                    Assert.That(commit.Ancestor.Ancestor, Is.Not.Null);
                    Assert.That(commit.Ancestor.Ancestor.Ancestor, Is.Null);
                    Assert.That(commit.Ancestor.Ancestor.Id, Is.EqualTo(firstResult));

                    Assert.That(commit.Author, Is.Not.Null);
                    Assert.That(commit.Author.Name, Is.EqualTo("Tester"));
                    Assert.That(commit.Author.EmailAddress, Is.EqualTo("*****@*****.**"));

                    Assert.That(commit.Committer, Is.Not.Null);
                    Assert.That(commit.Committer.Name, Is.EqualTo("Other"));
                    Assert.That(commit.Committer.EmailAddress, Is.EqualTo("*****@*****.**"));

                    Assert.That(commit.Committer.TimeOffsetInMinutes, Is.EqualTo(120), "Time offset"); // CEST dependent
                    Assert.That(commit.Committer.When, Is.EqualTo(ct), "Exact time");
                    Assert.That(commit.LogMessage, Is.EqualTo("A log message to remember\n"));

                    Assert.That(commit.Parents, Is.Not.Empty);
                    Assert.That(commit.ParentIds, Is.Not.Empty);

                    Assert.That(commit.Tree, Is.Not.Empty);
                    Assert.That(commit.Tree.Count, Is.EqualTo(2));
                    Assert.That(commit.Ancestor.Tree.Count, Is.EqualTo(3));
                    Assert.That(commit.Ancestor.Ancestor.Tree.Count, Is.EqualTo(2));
                    Assert.That(commit.Tree.Id, Is.Not.EqualTo(commit.Ancestor.Tree.Id));

                    GitId id;
                    Assert.That(repo1.LookupViaPrefix(commit.Id.ToString(), out id));
                    Assert.That(id, Is.EqualTo(commit.Id));

                    Assert.That(repo1.LookupViaPrefix(commit.Id.ToString().Substring(0, 10), out id));
                    Assert.That(id, Is.EqualTo(commit.Id));

                    Assert.That(commit.Peel <GitObject>().Id, Is.EqualTo(commit.Tree.Id));
                    Assert.That(commit.Peel <GitTree>(), Is.EqualTo(commit.Tree)); // Compares members
                    Assert.That(commit.Tree.Peel <GitObject>(), Is.Null);

                    GitTagArgs ta = new GitTagArgs();
                    ta.Signature.When             = ct;
                    ta.Signature.Name             = "Me";
                    ta.Signature.EmailAddress     = "[email protected]";
                    ta.LogMessage                 = "Some message";
                    ga.Author.TimeOffsetInMinutes = 120;
                    Assert.That(commit.Tag("MyTag", ta, out id));
                    Assert.That(id, Is.EqualTo(new GitId("db31f8333fc64d7e7921ea91f6e007b755dcfcbb")));

                    GitTag tag;
                    Assert.That(repo1.Lookup(id, out tag));
                    Assert.That(tag, Is.Not.Null);
                    Assert.That(tag.Name, Is.EqualTo("MyTag"));
                    Assert.That(tag.LogMessage, Is.EqualTo("Some message\n"));
                    Assert.That(tag.Tagger.Name, Is.EqualTo("Me"));

                    Assert.That(tag.Target.Id, Is.EqualTo(commit.Id));
                    Assert.That(tag.Peel <GitTree>(), Is.EqualTo(commit.Peel <GitTree>()));

                    repo1.CheckOut(commit.Tree);

                    //Console.WriteLine("1:");
                    //foreach (GitTreeEntry e in commit.Tree)
                    //{
                    //    Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
                    //}

                    //Console.WriteLine("2:");
                    //foreach (GitTreeEntry e in commit.Ancestor.Tree)
                    //{
                    //    Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
                    //}

                    //Console.WriteLine("3:");
                    //foreach (GitTreeEntry e in commit.Ancestor.Ancestor.Tree)
                    //{
                    //    Console.WriteLine(string.Format("{0}: {1} ({2})", e.Name, e.Kind, e.Children.Count));
                    //}
                    //Console.WriteLine("-");
                }
        }