jlengrand/github-api
1
0
Fork 0
mirror of https://github.com/jlengrand/github-api.git synced 2026-03-23 15:50:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add more tests for rate limit record selection

Browse Source
This commit is contained in:
Liam Newman
2020-05-31 13:31:36 -07:00
parent 46e3b2272e
commit afa170ba7c
8 changed files with 3227 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
src/test/java/org/kohsuke/github/GHRateLimitTest.java
View File

@@ -8,6 +8,7 @@ import org.junit.Test;
import java.io.IOException;
import java.time.Duration;
import java.util.Date;
import java.util.HashMap;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.sameInstance;
@@ -169,11 +170,13 @@ public class GHRateLimitTest extends AbstractGitHubWireMockTest {
// Verify the requesting a search url updates the search rate limit
assertThat(gitHub.lastRateLimit().getSearch().getRemaining(), equalTo(30));
Object searchResult = gitHub.createRequest()
HashMap<String, Object> searchResult = (HashMap<String, Object>) gitHub.createRequest()
.rateLimit(RateLimitTarget.SEARCH)
.setRawUrlPath(mockGitHub.apiServer().baseUrl()
+ "/search/repositories?q=tetris+language:assembly&sort=stars&order=desc")
.fetch(Object.class);
+ "/search/repositories?q=tetris+language%3Aassembly&sort=stars&order=desc")
.fetch(HashMap.class);
assertThat(searchResult.get("total_count"), equalTo(1918));
assertThat(mockGitHub.getRequestCount(), equalTo(6));
@@ -182,6 +185,21 @@ public class GHRateLimitTest extends AbstractGitHubWireMockTest {
assertThat(gitHub.lastRateLimit().getSearch(), not(sameInstance(headerRateLimit.getSearch())));
assertThat(gitHub.lastRateLimit().getSearch().getRemaining(), equalTo(29));
PagedSearchIterable<GHRepository> searchResult2 = gitHub.searchRepositories()
.q("tetris")
.language("assembly")
.sort(GHRepositorySearchBuilder.Sort.STARS)
.order(GHDirection.DESC)
.list();
assertThat(searchResult2.getTotalCount(), equalTo(1918));
assertThat(mockGitHub.getRequestCount(), equalTo(7));
assertThat(gitHub.lastRateLimit(), not(sameInstance(headerRateLimit)));
assertThat(gitHub.lastRateLimit().getCore(), sameInstance(headerRateLimit.getCore()));
assertThat(gitHub.lastRateLimit().getSearch(), not(sameInstance(headerRateLimit.getSearch())));
assertThat(gitHub.lastRateLimit().getSearch().getRemaining(), equalTo(28));
}
private void verifyRateLimitValues(GHRateLimit previousLimit, int remaining) {
@@ -300,6 +318,7 @@ public class GHRateLimitTest extends AbstractGitHubWireMockTest {
// ratelimit() tries not to make additional requests, uses queried rate limit since header not available
Thread.sleep(1500);
assertThat(gitHub.rateLimit(), sameInstance(rateLimit));
assertThat(mockGitHub.getRequestCount(), equalTo(4));
// -------------------------------------------------------------
// Some versions of GHE include header rate limit information, some do not
@@ -353,11 +372,49 @@ public class GHRateLimitTest extends AbstractGitHubWireMockTest {
// getRateLimit() uses headerRateLimit if /rate_limit returns a 404
// and headerRateLimit is available and not expired
assertThat(rateLimit, sameInstance(gitHub.lastRateLimit()));
headerRateLimit = rateLimit;
// ratelimit() should prefer headerRateLimit when getRateLimit fails and headerRateLimit is not expired
assertThat(gitHub.rateLimit(), sameInstance(rateLimit));
assertThat(mockGitHub.getRequestCount(), equalTo(6));
// Verify the requesting a search url updates the search rate limit
// Core rate limit record should not change while search is updated.
assertThat(gitHub.lastRateLimit().getSearch(), instanceOf(GHRateLimit.UnknownLimitRecord.class));
assertThat(gitHub.lastRateLimit().getSearch().isExpired(), equalTo(true));
HashMap<String, Object> searchResult = (HashMap<String, Object>) gitHub.createRequest()
.rateLimit(RateLimitTarget.SEARCH)
.setRawUrlPath(mockGitHub.apiServer().baseUrl()
+ "/search/repositories?q=tetris+language%3Aassembly&sort=stars&order=desc")
.fetch(Object.class);
assertThat(searchResult.get("total_count"), equalTo(1918));
assertThat(mockGitHub.getRequestCount(), equalTo(7));
assertThat(gitHub.lastRateLimit(), not(sameInstance(headerRateLimit)));
assertThat(gitHub.lastRateLimit().getCore(), sameInstance(headerRateLimit.getCore()));
assertThat(gitHub.lastRateLimit().getSearch(), not(sameInstance(headerRateLimit.getSearch())));
assertThat(gitHub.lastRateLimit().getSearch().getRemaining(), equalTo(29));
PagedSearchIterable<GHRepository> searchResult2 = gitHub.searchRepositories()
.q("tetris")
.language("assembly")
.sort(GHRepositorySearchBuilder.Sort.STARS)
.order(GHDirection.DESC)
.list();
assertThat(searchResult2.getTotalCount(), equalTo(1918));
assertThat(mockGitHub.getRequestCount(), equalTo(8));
assertThat(gitHub.lastRateLimit(), not(sameInstance(headerRateLimit)));
assertThat(gitHub.lastRateLimit().getCore(), sameInstance(headerRateLimit.getCore()));
assertThat(gitHub.lastRateLimit().getSearch(), not(sameInstance(headerRateLimit.getSearch())));
assertThat(gitHub.lastRateLimit().getSearch().getRemaining(), equalTo(28));
}
@Test

23
src/test/java/org/kohsuke/github/GitHubStaticTest.java
View File

@@ -65,14 +65,14 @@ public class GitHubStaticTest extends AbstractGitHubWireMockTest {
@Test
public void testGitHubRateLimitShouldReplaceRateLimit() throws Exception {
GHRateLimit.UnknownLimitRecord.unknownLimitResetSeconds = 5;
GHRateLimit.UnknownLimitRecord.reset();
GHRateLimit.UnknownLimitRecord.unknownLimitResetSeconds = 5;
GHRateLimit.Record unknown0 = GHRateLimit.UnknownLimitRecord.current();
Thread.sleep(1500);
GHRateLimit.UnknownLimitRecord.reset();
Thread.sleep(2000);
GHRateLimit.UnknownLimitRecord.unknownLimitResetSeconds = 5;
// For testing, we create an new unknown.
GHRateLimit.Record unknown1 = GHRateLimit.UnknownLimitRecord.current();
@@ -85,7 +85,7 @@ public class GitHubStaticTest extends AbstractGitHubWireMockTest {
sameInstance(unknown0));
// Sleep to make different created time
Thread.sleep(2000);
Thread.sleep(1500);
// To reduce object creation: There is only one valid Unknown record at a time.
assertThat("Unknown current should should limit the creation of new unknown records",
@@ -103,7 +103,7 @@ public class GitHubStaticTest extends AbstractGitHubWireMockTest {
GHRateLimit.Record recordExpired1 = new GHRateLimit.Record(10, 10, epochSeconds + 2L);
// Sleep to make expired and different created time
Thread.sleep(3000);
Thread.sleep(4000);
GHRateLimit.Record recordWorst = new GHRateLimit.Record(Integer.MAX_VALUE, Integer.MAX_VALUE, Long.MIN_VALUE);
GHRateLimit.Record record00 = new GHRateLimit.Record(10, 10, epochSeconds + 10L);
@@ -123,21 +123,18 @@ public class GitHubStaticTest extends AbstractGitHubWireMockTest {
unknownExpired1.currentOrUpdated(unknownExpired0),
sameInstance(unknownExpired1));
assertThat(
"Expired unknown should not be replaced by expired earlier normal record, regardless of created or reset time",
assertThat("Expired unknown should not be replaced by expired earlier normal record",
unknownExpired0.currentOrUpdated(recordExpired0),
sameInstance(unknownExpired0));
assertThat(
"Expired normal record should not be replace an expired earlier unknown record, regardless of created or reset time",
assertThat("Expired normal record should not be replaced an expired earlier unknown record",
recordExpired0.currentOrUpdated(unknownExpired0),
sameInstance(recordExpired0));
assertThat(
"Expired unknown should be replaced by expired later normal record, regardless of created or reset time",
assertThat("Expired unknown should be replaced by expired later normal record",
unknownExpired0.currentOrUpdated(recordExpired1),
sameInstance(recordExpired1));
assertThat(
"Expired later normal record should not be replace an expired unknown record, regardless of created or reset time",
"Expired later normal record should not be replaced an expired unknown record, regardless of created or reset time",
recordExpired1.currentOrUpdated(unknownExpired0),
sameInstance(recordExpired1));
@@ -151,7 +148,7 @@ public class GitHubStaticTest extends AbstractGitHubWireMockTest {
assertThat("Valid unknown should replace an expired normal record",
recordExpired1.currentOrUpdated(unknown0),
sameInstance(unknown0));
assertThat("Expired normal record should not replace a valid unknown record",
assertThat("Valid unknown record should not be replaced by expired normal record",
unknown0.currentOrUpdated(recordExpired1),
sameInstance(unknown0));