added integration tests

2025-12-06 07:16:09 +00:00 · 2016-06-09 17:10:06 +07:00
parent 9dc231d78b
commit 55ba6cf721
1 changed files with 230 additions and 0 deletions
--- a/Octokit.Tests.Integration/Clients/RepositoryForksClientTests.cs
+++ b/Octokit.Tests.Integration/Clients/RepositoryForksClientTests.cs
@@ -20,6 +20,18 @@ namespace Octokit.Tests.Integration.Clients
                Assert.Equal("TeamBinary", masterFork.Owner.Login);
            }

+            [IntegrationTest]
+            public async Task ReturnsForksForRepositoryWithRepositoryId()
+            {
+                var github = Helper.GetAuthenticatedClient();
+
+                var forks = await github.Repository.Forks.GetAll(7528679);
+
+                var masterFork = forks.FirstOrDefault(fork => fork.FullName == "TeamBinary/octokit.net");
+                Assert.NotNull(masterFork);
+                Assert.Equal("TeamBinary", masterFork.Owner.Login);
+            }
+
            [IntegrationTest]
            public async Task ReturnsCorrectCountOfForksWithoutStart()
            {
@@ -36,6 +48,22 @@ namespace Octokit.Tests.Integration.Clients
                Assert.Equal(1, forks.Count);
            }

+            [IntegrationTest]
+            public async Task ReturnsCorrectCountOfForksWithoutStartWithRepositoryId()
+            {
+                var github = Helper.GetAuthenticatedClient();
+
+                var options = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 1
+                };
+
+                var forks = await github.Repository.Forks.GetAll(7528679, options);
+
+                Assert.Equal(1, forks.Count);
+            }
+
            [IntegrationTest]
            public async Task ReturnsCorrectCountOfForksWithStart()
            {
@@ -53,6 +81,23 @@ namespace Octokit.Tests.Integration.Clients
                Assert.Equal(1, forks.Count);
            }

+            [IntegrationTest]
+            public async Task ReturnsCorrectCountOfForksWithStartWithRepositoryId()
+            {
+                var github = Helper.GetAuthenticatedClient();
+
+                var options = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 1,
+                    StartPage = 1
+                };
+
+                var forks = await github.Repository.Forks.GetAll(7528679, options);
+
+                Assert.Equal(1, forks.Count);
+            }
+
            [IntegrationTest]
            public async Task ReturnsDistinctForksBasedOnStartPage()
            {
@@ -83,6 +128,36 @@ namespace Octokit.Tests.Integration.Clients
                Assert.NotEqual(firstPage[2].Id, secondPage[2].Id);
            }

+            [IntegrationTest]
+            public async Task ReturnsDistinctForksBasedOnStartPageWithRepositoryId()
+            {
+                var github = Helper.GetAuthenticatedClient();
+
+                var startOptions = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 3,
+                    StartPage = 1
+                };
+
+                var firstPage = await github.Repository.Forks.GetAll(7528679, startOptions);
+
+                var skipStartOptions = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 3,
+                    StartPage = 2
+                };
+
+                var secondPage = await github.Repository.Forks.GetAll(7528679, skipStartOptions);
+
+                Assert.Equal(3, firstPage.Count);
+                Assert.Equal(3, secondPage.Count);
+                Assert.NotEqual(firstPage[0].Id, secondPage[0].Id);
+                Assert.NotEqual(firstPage[1].Id, secondPage[1].Id);
+                Assert.NotEqual(firstPage[2].Id, secondPage[2].Id);
+            }
+
            [IntegrationTest]
            public async Task ReturnsCorrectCountOfForksWithoutStartParameterized()
            {
@@ -101,6 +176,24 @@ namespace Octokit.Tests.Integration.Clients
                Assert.Equal(1, forks.Count);
            }

+            [IntegrationTest]
+            public async Task ReturnsCorrectCountOfForksWithoutStartParameterizedWithRepositoryId()
+            {
+                var github = Helper.GetAuthenticatedClient();
+
+                var options = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 1
+                };
+
+                var repositoryForksListRequest = new RepositoryForksListRequest { Sort = Sort.Newest };
+
+                var forks = await github.Repository.Forks.GetAll(7528679, repositoryForksListRequest, options);
+
+                Assert.Equal(1, forks.Count);
+            }
+
            [IntegrationTest]
            public async Task ReturnsCorrectCountOfForksWithStartParameterized()
            {
@@ -120,6 +213,25 @@ namespace Octokit.Tests.Integration.Clients
                Assert.Equal(1, forks.Count);
            }

+            [IntegrationTest]
+            public async Task ReturnsCorrectCountOfForksWithStartParameterizedWithRepositoryId()
+            {
+                var github = Helper.GetAuthenticatedClient();
+
+                var options = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 1,
+                    StartPage = 1
+                };
+
+                var repositoryForksListRequest = new RepositoryForksListRequest { Sort = Sort.Newest };
+
+                var forks = await github.Repository.Forks.GetAll(7528679, repositoryForksListRequest, options);
+
+                Assert.Equal(1, forks.Count);
+            }
+
            [IntegrationTest]
            public async Task ReturnsDistinctForksBasedOnStartPageParameterized()
            {
@@ -152,6 +264,38 @@ namespace Octokit.Tests.Integration.Clients
                Assert.NotEqual(firstPage[2].Id, secondPage[2].Id);
            }

+            [IntegrationTest]
+            public async Task ReturnsDistinctForksBasedOnStartPageParameterizedWithRepositoryId()
+            {
+                var github = Helper.GetAuthenticatedClient();
+
+                var repositoryForksListRequest = new RepositoryForksListRequest { Sort = Sort.Newest };
+
+                var startOptions = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 3,
+                    StartPage = 1
+                };
+
+                var firstPage = await github.Repository.Forks.GetAll(7528679, repositoryForksListRequest, startOptions);
+
+                var skipStartOptions = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 3,
+                    StartPage = 2
+                };
+
+                var secondPage = await github.Repository.Forks.GetAll(7528679, repositoryForksListRequest, skipStartOptions);
+
+                Assert.Equal(3, firstPage.Count);
+                Assert.Equal(3, secondPage.Count);
+                Assert.NotEqual(firstPage[0].Id, secondPage[0].Id);
+                Assert.NotEqual(firstPage[1].Id, secondPage[1].Id);
+                Assert.NotEqual(firstPage[2].Id, secondPage[2].Id);
+            }
+
            [IntegrationTest]
            public async Task ReturnsForksForRepositorySortingTheResultWithOldestFirstWithApiOptions()
            {
@@ -190,6 +334,44 @@ namespace Octokit.Tests.Integration.Clients
                }
            }

+            [IntegrationTest]
+            public async Task ReturnsForksForRepositorySortingTheResultWithOldestFirstWithApiOptionsWithRepositoryId()
+            {
+                var github = Helper.GetAuthenticatedClient();
+
+                var repositoryForksListRequest = new RepositoryForksListRequest { Sort = Sort.Oldest };
+
+                var startOptions = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 3,
+                    StartPage = 1
+                };
+
+                var firstPage = await github.Repository.Forks.GetAll(7528679, repositoryForksListRequest, startOptions);
+                var firstPageOrdered = firstPage.OrderBy(r => r.CreatedAt).ToList();
+
+                var skipStartOptions = new ApiOptions
+                {
+                    PageCount = 1,
+                    PageSize = 3,
+                    StartPage = 1
+                };
+
+                var secondPage = await github.Repository.Forks.GetAll(7528679, repositoryForksListRequest, skipStartOptions);
+                var secondPageOrdered = secondPage.OrderBy(r => r.CreatedAt).ToList();
+
+                for (var index = 0; index < firstPage.Count; index++)
+                {
+                    Assert.Equal(firstPageOrdered[index].FullName, firstPage[index].FullName);
+                }
+
+                for (var index = 0; index < firstPage.Count; index++)
+                {
+                    Assert.Equal(secondPageOrdered[index].FullName, secondPage[index].FullName);
+                }
+            }
+
            [IntegrationTest]
            public async Task ReturnsForksForRepositorySortingTheResultWithOldestFirst()
            {
@@ -203,6 +385,20 @@ namespace Octokit.Tests.Integration.Clients
                    Assert.Equal(sortedForks[index].FullName, actualForks[index].FullName);
                }
            }
+
+            [IntegrationTest]
+            public async Task ReturnsForksForRepositorySortingTheResultWithOldestFirstWithRepositoryId()
+            {
+                var github = Helper.GetAuthenticatedClient();
+
+                var actualForks = (await github.Repository.Forks.GetAll(7528679, new RepositoryForksListRequest { Sort = Sort.Oldest })).ToArray();
+                var sortedForks = actualForks.OrderBy(fork => fork.CreatedAt).ToArray();
+
+                for (var index = 0; index < actualForks.Length; index++)
+                {
+                    Assert.Equal(sortedForks[index].FullName, actualForks[index].FullName);
+                }
+            }
        }

        public class TheCreateMethod
@@ -224,6 +420,23 @@ namespace Octokit.Tests.Integration.Clients
                Assert.Equal(true, forkCreated.Fork);
            }

+            [IntegrationTest]
+            public async Task ForkCreatedForUserLoggedInWithRepositoryId()
+            {
+                // The fork is created asynchronously by github and therefore it cannot 
+                // be certain that the repo exists when the test ends. It is therefore deleted
+                // before the test starts instead of after.
+                Helper.DeleteRepo(Helper.Credentials.Login, "octokit.net");
+
+                var github = Helper.GetAuthenticatedClient();
+
+                var forkCreated = await github.Repository.Forks.Create(7528679, new NewRepositoryFork());
+
+                Assert.NotNull(forkCreated);
+                Assert.Equal(string.Format("{0}/octokit.net", Helper.UserName), forkCreated.FullName);
+                Assert.Equal(true, forkCreated.Fork);
+            }
+
            [OrganizationTest]
            public async Task ForkCreatedForOrganization()
            {
@@ -240,6 +453,23 @@ namespace Octokit.Tests.Integration.Clients
                Assert.Equal(string.Format("{0}/octokit.net", Helper.Organization), forkCreated.FullName);
                Assert.Equal(true, forkCreated.Fork);
            }
+
+            [OrganizationTest]
+            public async Task ForkCreatedForOrganizationWithRepositoryId()
+            {
+                // The fork is created asynchronously by github and therefore it cannot 
+                // be certain that the repo exists when the test ends. It is therefore deleted
+                // before the test starts.
+                Helper.DeleteRepo(Helper.Organization, "octokit.net");
+
+                var github = Helper.GetAuthenticatedClient();
+
+                var forkCreated = await github.Repository.Forks.Create(7528679, new NewRepositoryFork { Organization = Helper.Organization });
+
+                Assert.NotNull(forkCreated);
+                Assert.Equal(string.Format("{0}/octokit.net", Helper.Organization), forkCreated.FullName);
+                Assert.Equal(true, forkCreated.Fork);
+            }
        }
    }
 }