[maven-release-plugin] prepare release github-api-1.128

Remove now unnecessary JDK 16 specific workaround

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,15 +1,16 @@
-# Description 
-** Describe your change here** 
+# Description
+
+<!-- Describe your change here -->
 
 # Before submitting a PR:
-We love getting PRs, but we hate asking people for the same basic changes every time. 
+We love getting PRs, but we hate asking people for the same basic changes every time.
 
-- [ ] Push your changes to a branch other than `master`. Create your PR from that branch.    
+- [ ] Push your changes to a branch other than `main`. Create your PR from that branch.
 - [ ] Add JavaDocs and other comments
 - [ ] Write tests that run and pass in CI. See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to capture snapshot data.
-- [ ] Run `mvn -D enable-ci clean install site` locally. If this command doesn't succeed, your change will not pass CI. 
+- [ ] Run `mvn -D enable-ci clean install site` locally. If this command doesn't succeed, your change will not pass CI.
 
 # When creating a PR: 
 
-- [ ] Fill in the "Description" above. 
-- [ ] Enable "Allow edits from maintainers". 
+- [ ] Fill in the "Description" above.
+- [ ] Enable "Allow edits from maintainers".

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,67 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main, gh-pages ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '20 0 * * 6'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'java' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/maven-build.yml

@@ -21,7 +21,7 @@ jobs:
         with:
           java-version: ${{ matrix.java }}
       - name: Cached .m2
-        uses: actions/cache@v2.1.4
+        uses: actions/cache@v2.1.5
         with:
           path: ~/.m2/repository
           key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
@@ -30,7 +30,7 @@ jobs:
       - name: Maven Install (skipTests)
         env:
           MAVEN_OPTS: ${{ env.JAVA_11_PLUS_MAVEN_OPTS }}
-        run: mvn -B install -DskipTests -D enable-ci --file pom.xml
+        run: mvn -B install -DskipTests --file pom.xml
   site:
     name: site (Java ${{ matrix.java }})
     runs-on: ubuntu-latest
@@ -44,7 +44,7 @@ jobs:
         uses: actions/setup-java@v1
         with:
           java-version: ${{ matrix.java }}
-      - uses: actions/cache@v2.1.4
+      - uses: actions/cache@v2.1.5
         with:
           path: ~/.m2/repository
           key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
@@ -66,7 +66,7 @@ jobs:
       uses: actions/setup-java@v1
       with:
         java-version: ${{ matrix.java }}
-    - uses: actions/cache@v2.1.4
+    - uses: actions/cache@v2.1.5
       with:
         path: ~/.m2/repository
         key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
@@ -79,6 +79,9 @@ jobs:
     - name: Maven Install with Code Coverage
       if: matrix.os != 'windows' && matrix.java == '8'
       run: mvn -B install -D enable-ci --file pom.xml
+    - name: Codecov Report 
+      if: matrix.os != 'windows' && matrix.java == '8'
+      uses: codecov/codecov-action@v1.4.1  
     # JDK 11+
     - name: Maven Install without Code Coverage
       if: matrix.os == 'windows' && matrix.java != '8'

CONTRIBUTING.md

@@ -41,7 +41,7 @@ Once you have credentials setup, you add new test classes and test methods as yo
 
 Keep `useProxy` enabled and iterate on your tests as needed. With `useProxy` enabled your tests will interact with 
 GitHub - you will need to clean up your server-state between runs. This can be done manually to start with.
-Once your test code is somewhat stable, use `getGitHubBeforeAfter()` to get a `GitHub` instance for test setup and cleanup.
+Once your test code is somewhat stable, use `getNonRecordingGitHub()` to get a `GitHub` instance for test setup and cleanup.
 Interactions with that `GitHub` instance will not be recorded as part of the test, keeping the test data files to a minimum. 
 
 #### Running tests against your personal GitHub user account

README.md

@@ -2,7 +2,7 @@
 
 [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/org.kohsuke/github-api?server=https%3A%2F%2Foss.sonatype.org)](https://mvnrepository.com/artifact/org.kohsuke/github-api)
 [![Join the chat at https://gitter.im/hub4j/github-api](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/hub4j/github-api?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-![CI](https://github.com/hub4j/github-api/workflows/CI/badge.svg?branch=master)
+![CI](https://github.com/hub4j/github-api/workflows/CI/badge.svg?branch=main)
 
 
 

codecov.yml

@@ -0,0 +1,7 @@
+ignore:
+  - "**/extras/okhttp3/ObsoleteUrlFactory**"
+  - "**/extras/OkHttpConnector"
+  - "**/extras/OkHttp3Connector"
+  - "**/example/**"
+  - "**/github/EnforcementLevel"
+

pom.xml

@@ -2,7 +2,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>org.kohsuke</groupId>
   <artifactId>github-api</artifactId>
-  <version>1.126</version>
+  <version>1.128</version>
   <name>GitHub API for Java</name>
   <url>https://github-api.kohsuke.org/</url>
   <description>GitHub API for Java</description>
@@ -11,7 +11,7 @@
     <connection>scm:git:git@github.com/hub4j/${project.artifactId}.git</connection>
     <developerConnection>scm:git:ssh://git@github.com/hub4j/${project.artifactId}.git</developerConnection>
     <url>https://github.com/hub4j/github-api/</url>
-    <tag>github-api-1.126</tag>
+    <tag>github-api-1.128</tag>
   </scm>
 
   <distributionManagement>
@@ -33,8 +33,8 @@
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <spotbugs-maven-plugin.version>4.2.0</spotbugs-maven-plugin.version>
-    <spotbugs.version>4.2.1</spotbugs.version>
+    <spotbugs-maven-plugin.version>4.2.3</spotbugs-maven-plugin.version>
+    <spotbugs.version>4.2.3</spotbugs.version>
     <spotbugs-maven-plugin.failOnError>true</spotbugs-maven-plugin.failOnError>
     <hamcrest.version>2.2</hamcrest.version>
     <okhttp3.version>4.4.1</okhttp3.version>
@@ -46,6 +46,7 @@
     <jacoco.haltOnFailure>false</jacoco.haltOnFailure>
     <jjwt.suite.version>0.11.2</jjwt.suite.version>
 
+    <jacoco.surefire.argLine />
     <surefire.argLine />
   </properties>
 
@@ -107,6 +108,9 @@
               <goals>
                 <goal>prepare-agent</goal>
               </goals>
+              <configuration>
+                <propertyName>jacoco.surefire.argLine</propertyName>
+              </configuration>
             </execution>
             <!-- attached to Maven test phase -->
             <execution>
@@ -156,9 +160,11 @@
 
 
                       <!-- Deprecated -->
+                      <exclude>org.kohsuke.github.extras.OkHttpConnector</exclude>
                       <exclude>org.kohsuke.github.extras.OkHttp3Connector</exclude>
                       <exclude>org.kohsuke.github.EnforcementLevel</exclude>
                       <exclude>org.kohsuke.github.GHPerson.1</exclude>
+                      
                       <!-- TODO: Some coverage, but more needed -->
                       <exclude>org.kohsuke.github.GHPullRequestReviewBuilder.DraftReviewComment</exclude>
                       <exclude>org.kohsuke.github.GHIssue.PullRequest</exclude>
@@ -274,7 +280,7 @@
             <id>default-test</id>
             <configuration>
               <excludesFile>src/test/resources/slow-or-flaky-tests.txt</excludesFile>
-              <argLine>${surefire.argLine}</argLine>
+              <argLine>@{jacoco.surefire.argLine} ${surefire.argLine}</argLine>
             </configuration>
           </execution>
         </executions>
@@ -315,7 +321,7 @@
       <plugin>
         <groupId>com.diffplug.spotless</groupId>
         <artifactId>spotless-maven-plugin</artifactId>
-        <version>2.8.1</version>
+        <version>2.10.1</version>
         <executions>
           <execution>
             <id>spotless-check</id>
@@ -381,7 +387,7 @@
     <dependency>
       <groupId>com.tngtech.archunit</groupId>
       <artifactId>archunit</artifactId>
-      <version>0.17.0</version>
+      <version>0.18.0</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -418,7 +424,7 @@
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
-      <version>2.12.1</version>
+      <version>2.12.3</version>
     </dependency>
     <dependency>
       <groupId>commons-io</groupId>
@@ -449,7 +455,7 @@
     <dependency>
       <groupId>org.kohsuke.stapler</groupId>
       <artifactId>stapler</artifactId>
-      <version>1.262</version>
+      <version>1.263</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -461,7 +467,7 @@
     <dependency>
       <groupId>org.eclipse.jgit</groupId>
       <artifactId>org.eclipse.jgit</artifactId>
-      <version>5.10.0.202012080955-r</version>
+      <version>5.11.0.202103091610-r</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -511,13 +517,13 @@
     <dependency>
       <groupId>org.kohsuke</groupId>
       <artifactId>wordnet-random-name</artifactId>
-      <version>1.3</version>
+      <version>1.5</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
-      <version>3.7.7</version>
+      <version>3.9.0</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -582,7 +588,7 @@
                   <!-- There are some tests that take longer or are a little
                     flaky. Run them here. -->
                   <includesFile>src/test/resources/slow-or-flaky-tests.txt</includesFile>
-                  <argLine>${surefire.argLine}</argLine>
+                  <argLine>@{jacoco.surefire.argLine} ${surefire.argLine}</argLine>
                 </configuration>
               </execution>
             </executions>
@@ -590,16 +596,6 @@
         </plugins>
       </build>
     </profile>
-    <profile>
-      <id>jdk11+</id>
-      <activation>
-        <jdk>[11,)</jdk>
-      </activation>
-      <properties>
-        <!-- this is required for GithubHttpUrlConnectionClient#setRequestMethod() to work with JDK 16+ -->
-        <surefire.argLine>--add-opens java.base/java.net=ALL-UNNAMED</surefire.argLine>
-      </properties>
-    </profile>
     <profile>
       <id>ci-non-windows</id>
       <activation>
@@ -642,6 +638,30 @@
               </execution>
             </executions>
           </plugin>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-enforcer-plugin</artifactId>
+            <version>3.0.0-M3</version>
+            <executions>
+              <execution>
+                <id>enforce-jacoco-exist</id>
+                <phase>verify</phase>
+                <goals>
+                  <goal>enforce</goal>
+                </goals>
+                <configuration>
+                  <rules>
+                    <requireFilesExist>
+                      <files>
+                        <file>${project.build.directory}/jacoco.exec</file>
+                      </files>
+                    </requireFilesExist>
+                  </rules>
+                  <fail>true</fail>
+                </configuration>
+              </execution>
+            </executions>
+          </plugin>
         </plugins>
       </build>
     </profile>

src/main/java/org/kohsuke/github/GHArtifact.java

@@ -0,0 +1,140 @@
+package org.kohsuke.github;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import org.apache.commons.lang3.StringUtils;
+import org.kohsuke.github.function.InputStreamFunction;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.Date;
+import java.util.Objects;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * An artifact from a workflow run.
+ *
+ * @author Guillaume Smet
+ */
+public class GHArtifact extends GHObject {
+
+    // Not provided by the API.
+    @JsonIgnore
+    private GHRepository owner;
+
+    private String name;
+    private long sizeInBytes;
+    private String archiveDownloadUrl;
+    private boolean expired;
+    private String expiresAt;
+
+    /**
+     * Gets the name.
+     *
+     * @return the name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Gets the size of the artifact in bytes.
+     *
+     * @return the size
+     */
+    public long getSizeInBytes() {
+        return sizeInBytes;
+    }
+
+    /**
+     * Gets the archive download URL.
+     *
+     * @return the archive download URL
+     */
+    public URL getArchiveDownloadUrl() {
+        return GitHubClient.parseURL(archiveDownloadUrl);
+    }
+
+    /**
+     * If this artifact has expired.
+     *
+     * @return if the artifact has expired
+     */
+    public boolean isExpired() {
+        return expired;
+    }
+
+    /**
+     * Gets the date at which this artifact will expire.
+     *
+     * @return the date of expiration
+     */
+    public Date getExpiresAt() {
+        return GitHubClient.parseDate(expiresAt);
+    }
+
+    /**
+     * Repository to which the artifact belongs.
+     *
+     * @return the repository
+     */
+    public GHRepository getRepository() {
+        return owner;
+    }
+
+    /**
+     * @deprecated This object has no HTML URL.
+     */
+    @Override
+    public URL getHtmlUrl() throws IOException {
+        return null;
+    }
+
+    /**
+     * Deletes the artifact.
+     *
+     * @throws IOException
+     *             the io exception
+     */
+    public void delete() throws IOException {
+        root.createRequest().method("DELETE").withUrlPath(getApiRoute()).fetchHttpStatusCode();
+    }
+
+    /**
+     * Downloads the artifact.
+     *
+     * @param <T>
+     *            the type of result
+     * @param streamFunction
+     *            The {@link InputStreamFunction} that will process the stream
+     * @throws IOException
+     *             The IO exception.
+     * @return the result of reading the stream.
+     */
+    public <T> T download(InputStreamFunction<T> streamFunction) throws IOException {
+        requireNonNull(streamFunction, "Stream function must not be null");
+
+        return root.createRequest().method("GET").withUrlPath(getApiRoute(), "zip").fetchStream(streamFunction);
+    }
+
+    private String getApiRoute() {
+        if (owner == null) {
+            // Workflow runs returned from search to do not have an owner. Attempt to use url.
+            final URL url = Objects.requireNonNull(getUrl(), "Missing instance URL!");
+            return StringUtils.prependIfMissing(url.toString().replace(root.getApiUrl(), ""), "/");
+        }
+        return "/repos/" + owner.getOwnerName() + "/" + owner.getName() + "/actions/artifacts/" + getId();
+    }
+
+    GHArtifact wrapUp(GHRepository owner) {
+        this.owner = owner;
+        return wrapUp(owner.root);
+    }
+
+    GHArtifact wrapUp(GitHub root) {
+        this.root = root;
+        if (owner != null)
+            owner.wrap(root);
+        return this;
+    }
+}

src/main/java/org/kohsuke/github/GHArtifactsIterable.java

@@ -0,0 +1,49 @@
+package org.kohsuke.github;
+
+import java.net.MalformedURLException;
+import java.util.Iterator;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Iterable for artifacts listing.
+ */
+class GHArtifactsIterable extends PagedIterable<GHArtifact> {
+    private final transient GHRepository owner;
+    private final GitHubRequest request;
+
+    private GHArtifactsPage result;
+
+    public GHArtifactsIterable(GHRepository owner, GitHubRequest.Builder<?> requestBuilder) {
+        this.owner = owner;
+        try {
+            this.request = requestBuilder.build();
+        } catch (MalformedURLException e) {
+            throw new GHException("Malformed URL", e);
+        }
+    }
+
+    @Nonnull
+    @Override
+    public PagedIterator<GHArtifact> _iterator(int pageSize) {
+        return new PagedIterator<>(
+                adapt(GitHubPageIterator.create(owner.getRoot().getClient(), GHArtifactsPage.class, request, pageSize)),
+                null);
+    }
+
+    protected Iterator<GHArtifact[]> adapt(final Iterator<GHArtifactsPage> base) {
+        return new Iterator<GHArtifact[]>() {
+            public boolean hasNext() {
+                return base.hasNext();
+            }
+
+            public GHArtifact[] next() {
+                GHArtifactsPage v = base.next();
+                if (result == null) {
+                    result = v;
+                }
+                return v.getArtifacts(owner);
+            }
+        };
+    }
+}

src/main/java/org/kohsuke/github/GHArtifactsPage.java

@@ -0,0 +1,20 @@
+package org.kohsuke.github;
+
+/**
+ * Represents the one page of artifacts result when listing artifacts.
+ */
+class GHArtifactsPage {
+    private int total_count;
+    private GHArtifact[] artifacts;
+
+    public int getTotalCount() {
+        return total_count;
+    }
+
+    GHArtifact[] getArtifacts(GHRepository owner) {
+        for (GHArtifact artifact : artifacts) {
+            artifact.wrapUp(owner);
+        }
+        return artifacts;
+    }
+}

src/main/java/org/kohsuke/github/GHCheckRunsIterable.java

@@ -8,13 +8,13 @@ import javax.annotation.Nonnull;
  * Iterable for check-runs listing.
  */
 class GHCheckRunsIterable extends PagedIterable<GHCheckRun> {
-    private final transient GitHub root;
+    private final GHRepository owner;
     private final GitHubRequest request;
 
     private GHCheckRunsPage result;
 
-    public GHCheckRunsIterable(GitHub root, GitHubRequest request) {
-        this.root = root;
+    public GHCheckRunsIterable(GHRepository owner, GitHubRequest request) {
+        this.owner = owner;
         this.request = request;
     }
 
@@ -22,7 +22,7 @@ class GHCheckRunsIterable extends PagedIterable<GHCheckRun> {
     @Override
     public PagedIterator<GHCheckRun> _iterator(int pageSize) {
         return new PagedIterator<>(
-                adapt(GitHubPageIterator.create(root.getClient(), GHCheckRunsPage.class, request, pageSize)),
+                adapt(GitHubPageIterator.create(owner.getRoot().getClient(), GHCheckRunsPage.class, request, pageSize)),
                 null);
     }
 
@@ -37,7 +37,7 @@ class GHCheckRunsIterable extends PagedIterable<GHCheckRun> {
                 if (result == null) {
                     result = v;
                 }
-                return v.getCheckRuns(root);
+                return v.getCheckRuns(owner);
             }
         };
     }

src/main/java/org/kohsuke/github/GHCheckRunsPage.java

@@ -11,9 +11,9 @@ class GHCheckRunsPage {
         return total_count;
     }
 
-    GHCheckRun[] getCheckRuns(GitHub root) {
+    GHCheckRun[] getCheckRuns(GHRepository owner) {
         for (GHCheckRun check_run : check_runs) {
-            check_run.wrap(root);
+            check_run.wrap(owner);
         }
         return check_runs;
     }

src/main/java/org/kohsuke/github/GHContentSearchBuilder.java

@@ -118,6 +118,41 @@ public class GHContentSearchBuilder extends GHSearchBuilder<GHContent> {
         return q("repo:" + v);
     }
 
+    /**
+     * Order gh content search builder.
+     *
+     * @param v
+     *            the v
+     * @return the gh content search builder
+     */
+    public GHContentSearchBuilder order(GHDirection v) {
+        req.with("order", v);
+        return this;
+    }
+
+    /**
+     * Sort gh content search builder.
+     *
+     * @param sort
+     *            the sort
+     * @return the gh content search builder
+     */
+    public GHContentSearchBuilder sort(GHContentSearchBuilder.Sort sort) {
+        if (Sort.BEST_MATCH.equals(sort)) {
+            req.remove("sort");
+        } else {
+            req.with("sort", sort);
+        }
+        return this;
+    }
+
+    /**
+     * The enum Sort.
+     */
+    public enum Sort {
+        BEST_MATCH, INDEXED
+    }
+
     private static class ContentSearchResult extends SearchResult<GHContent> {
         private GHContent[] items;
 

src/main/java/org/kohsuke/github/GHEvent.java

@@ -57,6 +57,7 @@ public enum GHEvent {
     REPOSITORY,
     REPOSITORY_IMPORT,
     REPOSITORY_VULNERABILITY_ALERT,
+    SCHEDULE,
     SECURITY_ADVISORY,
     STAR,
     STATUS,
@@ -66,6 +67,11 @@ public enum GHEvent {
     WORKFLOW_DISPATCH,
     WORKFLOW_RUN,
 
+    /**
+     * Special event type that means we haven't found an enum value corresponding to the event.
+     */
+    UNKNOWN,
+
     /**
      * Special event type that means "every possible event"
      */

src/main/java/org/kohsuke/github/GHEventInfo.java

@@ -53,7 +53,7 @@ public class GHEventInfo extends GitHubInteractiveObject {
             if (e.name().replace("_", "").equalsIgnoreCase(t))
                 return e;
         }
-        return null; // unknown event type
+        return GHEvent.UNKNOWN;
     }
 
     GHEventInfo wrapUp(GitHub root) {

src/main/java/org/kohsuke/github/GHEventPayload.java

@@ -711,9 +711,11 @@ public class GHEventPayload extends GitHubInteractiveObject {
         }
 
         /**
-         * Gets master branch.
+         * Gets default branch.
          *
-         * @return the master branch
+         * Name is an artifact of when "master" was the most common default.
+         *
+         * @return the default branch
          */
         @SuppressFBWarnings(value = "UWF_UNWRITTEN_FIELD", justification = "Comes from JSON deserialization")
         public String getMasterBranch() {
@@ -959,7 +961,7 @@ public class GHEventPayload extends GitHubInteractiveObject {
         }
 
         /**
-         * The full Git ref that was pushed. Example: “refs/heads/master”
+         * The full Git ref that was pushed. Example: “refs/heads/main”
          *
          * @return the ref
          */
@@ -1384,10 +1386,20 @@ public class GHEventPayload extends GitHubInteractiveObject {
         private GHWorkflowRun workflowRun;
         private GHWorkflow workflow;
 
+        /**
+         * Gets the workflow run.
+         *
+         * @return the workflow run
+         */
         public GHWorkflowRun getWorkflowRun() {
             return workflowRun;
         }
 
+        /**
+         * Gets the associated workflow.
+         *
+         * @return the associated workflow
+         */
         public GHWorkflow getWorkflow() {
             return workflow;
         }
@@ -1400,13 +1412,42 @@ public class GHEventPayload extends GitHubInteractiveObject {
                         "Expected workflow and workflow_run payload, but got something else. Maybe we've got another type of event?");
             }
             GHRepository repository = getRepository();
-            if (repository != null) {
-                workflowRun.wrapUp(repository);
-                workflow.wrapUp(repository);
-            } else {
-                workflowRun.wrapUp(root);
-                workflow.wrapUp(root);
+            if (repository == null) {
+                throw new IllegalStateException("Repository must not be null");
             }
+            workflowRun.wrapUp(repository);
+            workflow.wrapUp(repository);
+        }
+    }
+
+    /**
+     * A label was created, edited or deleted.
+     *
+     * @see <a href= "https://docs.github.com/en/developers/webhooks-and-events/webhook-events-and-payloads#label">
+     *      label event</a>
+     */
+    public static class Label extends GHEventPayload {
+
+        private GHLabel label;
+
+        private GHLabelChanges changes;
+
+        /**
+         * Gets the label.
+         *
+         * @return the label
+         */
+        public GHLabel getLabel() {
+            return label;
+        }
+
+        /**
+         * Gets changes (for action="edited")
+         *
+         * @return changes
+         */
+        public GHLabelChanges getChanges() {
+            return changes;
         }
     }
 }

src/main/java/org/kohsuke/github/GHIssue.java

@@ -328,13 +328,15 @@ public class GHIssue extends GHObject implements Reactable {
      *
      * Labels that are already present on the target are ignored.
      *
+     * @return the complete list of labels including the new additions
      * @param names
      *            Names of the label
      * @throws IOException
      *             the io exception
      */
-    public void addLabels(String... names) throws IOException {
-        _addLabels(Arrays.asList(names));
+    @WithBridgeMethods(void.class)
+    public List<GHLabel> addLabels(String... names) throws IOException {
+        return _addLabels(Arrays.asList(names));
     }
 
     /**
@@ -342,13 +344,15 @@ public class GHIssue extends GHObject implements Reactable {
      *
      * Labels that are already present on the target are ignored.
      *
+     * @return the complete list of labels including the new additions
      * @param labels
      *            the labels
      * @throws IOException
      *             the io exception
      */
-    public void addLabels(GHLabel... labels) throws IOException {
-        addLabels(Arrays.asList(labels));
+    @WithBridgeMethods(void.class)
+    public List<GHLabel> addLabels(GHLabel... labels) throws IOException {
+        return addLabels(Arrays.asList(labels));
     }
 
     /**
@@ -356,17 +360,23 @@ public class GHIssue extends GHObject implements Reactable {
      *
      * Labels that are already present on the target are ignored.
      *
+     * @return the complete list of labels including the new additions
      * @param labels
      *            the labels
      * @throws IOException
      *             the io exception
      */
-    public void addLabels(Collection<GHLabel> labels) throws IOException {
-        _addLabels(GHLabel.toNames(labels));
+    @WithBridgeMethods(void.class)
+    public List<GHLabel> addLabels(Collection<GHLabel> labels) throws IOException {
+        return _addLabels(GHLabel.toNames(labels));
     }
 
-    private void _addLabels(Collection<String> names) throws IOException {
-        root.createRequest().with("labels", names).method("POST").withUrlPath(getIssuesApiRoute() + "/labels").send();
+    private List<GHLabel> _addLabels(Collection<String> names) throws IOException {
+        return Arrays.asList(root.createRequest()
+                .with("labels", names)
+                .method("POST")
+                .withUrlPath(getIssuesApiRoute() + "/labels")
+                .fetch(GHLabel[].class));
     }
 
     /**
@@ -374,13 +384,18 @@ public class GHIssue extends GHObject implements Reactable {
      *
      * Attempting to remove a label that is not present throws {@link GHFileNotFoundException}.
      *
+     * @return the remaining list of labels
      * @param name
      *            the name
      * @throws IOException
      *             the io exception, throws {@link GHFileNotFoundException} if label was not present.
      */
-    public void removeLabel(String name) throws IOException {
-        root.createRequest().method("DELETE").withUrlPath(getIssuesApiRoute() + "/labels", name).send();
+    @WithBridgeMethods(void.class)
+    public List<GHLabel> removeLabel(String name) throws IOException {
+        return Arrays.asList(root.createRequest()
+                .method("DELETE")
+                .withUrlPath(getIssuesApiRoute() + "/labels", name)
+                .fetch(GHLabel[].class));
     }
 
     /**
@@ -388,13 +403,15 @@ public class GHIssue extends GHObject implements Reactable {
      *
      * Attempting to remove labels that are not present on the target are ignored.
      *
+     * @return the remaining list of labels
      * @param names
      *            the names
      * @throws IOException
      *             the io exception
      */
-    public void removeLabels(String... names) throws IOException {
-        _removeLabels(Arrays.asList(names));
+    @WithBridgeMethods(void.class)
+    public List<GHLabel> removeLabels(String... names) throws IOException {
+        return _removeLabels(Arrays.asList(names));
     }
 
     /**
@@ -402,14 +419,16 @@ public class GHIssue extends GHObject implements Reactable {
      *
      * Attempting to remove labels that are not present on the target are ignored.
      *
+     * @return the remaining list of labels
      * @param labels
      *            the labels
      * @throws IOException
      *             the io exception
      * @see #removeLabels(String...) #removeLabels(String...)
      */
-    public void removeLabels(GHLabel... labels) throws IOException {
-        removeLabels(Arrays.asList(labels));
+    @WithBridgeMethods(void.class)
+    public List<GHLabel> removeLabels(GHLabel... labels) throws IOException {
+        return removeLabels(Arrays.asList(labels));
     }
 
     /**
@@ -417,23 +436,27 @@ public class GHIssue extends GHObject implements Reactable {
      *
      * Attempting to remove labels that are not present on the target are ignored.
      *
+     * @return the remaining list of labels
      * @param labels
      *            the labels
      * @throws IOException
      *             the io exception
      */
-    public void removeLabels(Collection<GHLabel> labels) throws IOException {
-        _removeLabels(GHLabel.toNames(labels));
+    @WithBridgeMethods(void.class)
+    public List<GHLabel> removeLabels(Collection<GHLabel> labels) throws IOException {
+        return _removeLabels(GHLabel.toNames(labels));
     }
 
-    private void _removeLabels(Collection<String> names) throws IOException {
+    private List<GHLabel> _removeLabels(Collection<String> names) throws IOException {
+        List<GHLabel> remainingLabels = Collections.emptyList();
         for (String name : names) {
             try {
-                removeLabel(name);
+                remainingLabels = removeLabel(name);
             } catch (GHFileNotFoundException e) {
                 // when trying to remove multiple labels, we ignore already removed
             }
         }
+        return remainingLabels;
     }
 
     /**

src/main/java/org/kohsuke/github/GHLabelChanges.java

@@ -0,0 +1,49 @@
+package org.kohsuke.github;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+/**
+ * Wrapper to define changed fields on label action="edited"
+ *
+ * @see GHEventPayload.Label
+ */
+@SuppressFBWarnings("UWF_UNWRITTEN_FIELD")
+public class GHLabelChanges {
+
+    private GHFrom name;
+    private GHFrom color;
+
+    /**
+     * Old label name.
+     *
+     * @return old label name (or null if not changed)
+     */
+    public GHFrom getName() {
+        return name;
+    }
+
+    /**
+     * Old label color.
+     *
+     * @return old label color (or null if not changed)
+     */
+    public GHFrom getColor() {
+        return color;
+    }
+
+    /**
+     * Wrapper for changed values.
+     */
+    public static class GHFrom {
+        private String from;
+
+        /**
+         * Previous value that was changed.
+         *
+         * @return previous value
+         */
+        public String getFrom() {
+            return from;
+        }
+    }
+}

src/main/java/org/kohsuke/github/GHReleaseBuilder.java

@@ -41,7 +41,7 @@ public class GHReleaseBuilder {
      * Specifies the commitish value that determines where the Git tag is created from. Can be any branch or commit SHA.
      *
      * @param commitish
-     *            Defaults to the repository’s default branch (usually "master"). Unused if the Git tag already exists.
+     *            Defaults to the repository’s default branch (usually "main"). Unused if the Git tag already exists.
      * @return the gh release builder
      */
     public GHReleaseBuilder commitish(String commitish) {

src/main/java/org/kohsuke/github/GHReleaseUpdater.java

@@ -45,7 +45,7 @@ public class GHReleaseUpdater {
      * Specifies the commitish value that determines where the Git tag is created from. Can be any branch or commit SHA.
      *
      * @param commitish
-     *            Defaults to the repository’s default branch (usually "master"). Unused if the Git tag already exists.
+     *            Defaults to the repository’s default branch (usually "main"). Unused if the Git tag already exists.
      * @return the gh release updater
      */
     public GHReleaseUpdater commitish(String commitish) {

src/main/java/org/kohsuke/github/GHRepository.java

@@ -31,6 +31,7 @@ import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.apache.commons.lang3.StringUtils;
 import org.kohsuke.github.function.InputStreamFunction;
+import org.kohsuke.github.internal.EnumUtils;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -49,6 +50,7 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
@@ -56,9 +58,16 @@ import java.util.WeakHashMap;
 
 import javax.annotation.Nonnull;
 
-import static java.util.Arrays.*;
+import static java.util.Arrays.asList;
 import static java.util.Objects.requireNonNull;
-import static org.kohsuke.github.internal.Previews.*;
+import static org.kohsuke.github.internal.Previews.ANTIOPE;
+import static org.kohsuke.github.internal.Previews.ANT_MAN;
+import static org.kohsuke.github.internal.Previews.BAPTISTE;
+import static org.kohsuke.github.internal.Previews.FLASH;
+import static org.kohsuke.github.internal.Previews.INERTIA;
+import static org.kohsuke.github.internal.Previews.MERCY;
+import static org.kohsuke.github.internal.Previews.NEBULA;
+import static org.kohsuke.github.internal.Previews.SHADOW_CAT;
 
 /**
  * A repository on GitHub.
@@ -98,6 +107,8 @@ public class GHRepository extends GHObject {
     @JsonProperty("private")
     private boolean _private;
 
+    private String visibility;
+
     private int forks_count, stargazers_count, watchers_count, size, open_issues_count, subscribers_count;
 
     private String pushed_at;
@@ -450,7 +461,7 @@ public class GHRepository extends GHObject {
      * Creates a named ref, such as tag, branch, etc.
      *
      * @param name
-     *            The name of the fully qualified reference (ie: refs/heads/master). If it doesn't start with 'refs' and
+     *            The name of the fully qualified reference (ie: refs/heads/main). If it doesn't start with 'refs' and
      *            have at least two slashes, it will be rejected.
      * @param sha
      *            The SHA1 value to set this reference to
@@ -567,7 +578,15 @@ public class GHRepository extends GHObject {
      *             the io exception
      */
     public Map<String, Long> listLanguages() throws IOException {
-        return root.createRequest().withUrlPath(getApiTailUrl("languages")).fetch(HashMap.class);
+        HashMap<String, Long> result = new HashMap<>();
+        root.createRequest().withUrlPath(getApiTailUrl("languages")).fetch(HashMap.class).forEach((key, value) -> {
+            Long addValue = -1L;
+            if (value instanceof Integer) {
+                addValue = Long.valueOf((Integer) value);
+            }
+            result.put(key.toString(), addValue);
+        });
+        return result;
     }
 
     /**
@@ -704,6 +723,41 @@ public class GHRepository extends GHObject {
         return _private;
     }
 
+    /**
+     * Visibility of a repository.
+     */
+    public enum Visibility {
+        PUBLIC, INTERNAL, PRIVATE, UNKNOWN;
+
+        public static Visibility from(String value) {
+            return EnumUtils.getNullableEnumOrDefault(Visibility.class, value, Visibility.UNKNOWN);
+        }
+
+        @Override
+        public String toString() {
+            return name().toLowerCase(Locale.ROOT);
+        }
+    }
+
+    /**
+     * Gets the visibility of the repository.
+     *
+     * @return the visibility
+     */
+    @Deprecated
+    @Preview(NEBULA)
+    public Visibility getVisibility() {
+        if (visibility == null) {
+            try {
+                populate();
+            } catch (final IOException e) {
+                // Convert this to a runtime exception to avoid messy method signature
+                throw new GHException("Could not populate the visibility of the repository", e);
+            }
+        }
+        return Visibility.from(visibility);
+    }
+
     /**
      * Is template boolean.
      *
@@ -794,16 +848,18 @@ public class GHRepository extends GHObject {
     /**
      * Returns the primary branch you'll configure in the "Admin &gt; Options" config page.
      *
-     * @return This field is null until the user explicitly configures the master branch.
+     * @return This field is null until the user explicitly configures the default branch.
      */
     public String getDefaultBranch() {
         return default_branch;
     }
 
     /**
-     * Gets master branch.
+     * Gets default branch.
      *
-     * @return the master branch
+     * Name is an artifact of when "master" was the most common default.
+     *
+     * @return the default branch
      * @deprecated Renamed to {@link #getDefaultBranch()}
      */
     @Deprecated
@@ -1196,6 +1252,26 @@ public class GHRepository extends GHObject {
         set().private_(value);
     }
 
+    /**
+     * Sets visibility.
+     *
+     * @param value
+     *            the value
+     * @throws IOException
+     *             the io exception
+     */
+    @Deprecated
+    @Preview(NEBULA)
+    public void setVisibility(final Visibility value) throws IOException {
+        root.createRequest()
+                .method("PATCH")
+                .withPreview(NEBULA)
+                .with("name", name)
+                .with("visibility", value)
+                .withUrlPath(getApiTailUrl(""))
+                .send();
+    }
+
     /**
      * Allow squash merge.
      *
@@ -1701,7 +1777,7 @@ public class GHRepository extends GHObject {
      * Retrive a tree of the given type for the current GitHub repository.
      *
      * @param sha
-     *            sha number or branch name ex: "master"
+     *            sha number or branch name ex: "main"
      * @return refs matching the request type
      * @throws IOException
      *             on failure communicating with GitHub, potentially due to an invalid tree type being requested
@@ -1725,7 +1801,7 @@ public class GHRepository extends GHObject {
      * https://developer.github.com/v3/git/trees/#get-a-tree-recursively
      *
      * @param sha
-     *            sha number or branch name ex: "master"
+     *            sha number or branch name ex: "main"
      * @param recursive
      *            use 1
      * @return the tree recursive
@@ -1944,7 +2020,7 @@ public class GHRepository extends GHObject {
                 .withUrlPath(String.format("/repos/%s/%s/commits/%s/check-runs", getOwnerName(), name, ref))
                 .withPreview(ANTIOPE)
                 .build();
-        return new GHCheckRunsIterable(root, request);
+        return new GHCheckRunsIterable(this, request);
     }
 
     /**
@@ -2961,6 +3037,47 @@ public class GHRepository extends GHObject {
                 .wrapUp(this);
     }
 
+    /**
+     * Lists all the artifacts of this repository.
+     *
+     * @return the paged iterable
+     */
+    public PagedIterable<GHArtifact> listArtifacts() {
+        return new GHArtifactsIterable(this, root.createRequest().withUrlPath(getApiTailUrl("actions/artifacts")));
+    }
+
+    /**
+     * Gets an artifact by id.
+     *
+     * @param id
+     *            the id of the artifact
+     * @return the artifact
+     * @throws IOException
+     *             the io exception
+     */
+    public GHArtifact getArtifact(long id) throws IOException {
+        return root.createRequest()
+                .withUrlPath(getApiTailUrl("actions/artifacts"), String.valueOf(id))
+                .fetch(GHArtifact.class)
+                .wrapUp(this);
+    }
+
+    /**
+     * Gets a job from a workflow run by id.
+     *
+     * @param id
+     *            the id of the job
+     * @return the job
+     * @throws IOException
+     *             the io exception
+     */
+    public GHWorkflowJob getWorkflowJob(long id) throws IOException {
+        return root.createRequest()
+                .withUrlPath(getApiTailUrl("/actions/jobs/"), String.valueOf(id))
+                .fetch(GHWorkflowJob.class)
+                .wrapUp(this);
+    }
+
     // Only used within listTopics().
     private static class Topics {
         public List<String> names;
@@ -3035,7 +3152,7 @@ public class GHRepository extends GHObject {
      * @param streamFunction
      *            The {@link InputStreamFunction} that will process the stream
      * @param ref
-     *            if <code>null</code> the repository's default branch, usually <code>master</code>,
+     *            if <code>null</code> the repository's default branch, usually <code>main</code>,
      * @throws IOException
      *             The IO exception.
      * @return the result of reading the stream.
@@ -3052,7 +3169,7 @@ public class GHRepository extends GHObject {
      * @param streamFunction
      *            The {@link InputStreamFunction} that will process the stream
      * @param ref
-     *            if <code>null</code> the repository's default branch, usually <code>master</code>,
+     *            if <code>null</code> the repository's default branch, usually <code>main</code>,
      * @throws IOException
      *             The IO exception.
      * @return the result of reading the stream.
@@ -3091,11 +3208,17 @@ public class GHRepository extends GHObject {
             // There is bug in Push event payloads that returns the wrong url.
             // All other occurrences of "url" take the form "https://api.github.com/...".
             // For Push event repository records, they take the form "https://github.com/{fullName}".
-            root.createRequest().withPreview(BAPTISTE).setRawUrlPath(url.toString()).fetchInto(this).wrap(root);
+            root.createRequest()
+                    .withPreview(BAPTISTE)
+                    .withPreview(NEBULA)
+                    .setRawUrlPath(url.toString())
+                    .fetchInto(this)
+                    .wrap(root);
         } catch (HttpException e) {
             if (e.getCause() instanceof JsonParseException) {
                 root.createRequest()
                         .withPreview(BAPTISTE)
+                        .withPreview(NEBULA)
                         .withUrlPath("/repos/" + full_name)
                         .fetchInto(this)
                         .wrap(root);

src/main/java/org/kohsuke/github/GHRepositoryBuilder.java

@@ -1,9 +1,12 @@
 package org.kohsuke.github;
 
+import org.kohsuke.github.GHRepository.Visibility;
+
 import java.io.IOException;
 import java.net.URL;
 
 import static org.kohsuke.github.internal.Previews.BAPTISTE;
+import static org.kohsuke.github.internal.Previews.NEBULA;
 
 abstract class GHRepositoryBuilder<S> extends AbstractBuilder<GHRepository, S> {
 
@@ -146,6 +149,20 @@ abstract class GHRepositoryBuilder<S> extends AbstractBuilder<GHRepository, S> {
         return with("private", enabled);
     }
 
+    /**
+     * Sets the repository visibility
+     *
+     * @param visibility
+     *            visibility of repository
+     * @return a builder to continue with building
+     * @throws IOException
+     *             In case of any networking error or error from the server.
+     */
+    public S visibility(final Visibility visibility) throws IOException {
+        requester.withPreview(NEBULA);
+        return with("visibility", visibility);
+    }
+
     /**
      * Enables issue tracker
      *

src/main/java/org/kohsuke/github/GHWorkflow.java

@@ -60,6 +60,15 @@ public class GHWorkflow extends GHObject {
         return GitHubClient.parseURL(htmlUrl);
     }
 
+    /**
+     * Repository to which the workflow belongs.
+     *
+     * @return the repository
+     */
+    public GHRepository getRepository() {
+        return owner;
+    }
+
     /**
      * The badge URL, like https://github.com/octo-org/octo-repo/workflows/CI/badge.svg
      *

src/main/java/org/kohsuke/github/GHWorkflowJob.java

@@ -0,0 +1,256 @@
+package org.kohsuke.github;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import org.apache.commons.lang3.StringUtils;
+import org.kohsuke.github.GHWorkflowRun.Conclusion;
+import org.kohsuke.github.GHWorkflowRun.Status;
+import org.kohsuke.github.function.InputStreamFunction;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * A workflow run job.
+ *
+ * @author Guillaume Smet
+ */
+public class GHWorkflowJob extends GHObject {
+
+    // Not provided by the API.
+    @JsonIgnore
+    private GHRepository owner;
+
+    private String name;
+
+    private String headSha;
+
+    private String startedAt;
+    private String completedAt;
+
+    private String status;
+    private String conclusion;
+
+    private long runId;
+
+    private String htmlUrl;
+    private String checkRunUrl;
+
+    private List<Step> steps = new ArrayList<>();
+
+    /**
+     * The name of the job.
+     *
+     * @return the name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Gets the HEAD SHA.
+     *
+     * @return sha for the HEAD commit
+     */
+    public String getHeadSha() {
+        return headSha;
+    }
+
+    /**
+     * When was this job started?
+     *
+     * @return start date
+     */
+    public Date getStartedAt() {
+        return GitHubClient.parseDate(startedAt);
+    }
+
+    /**
+     * When was this job completed?
+     *
+     * @return completion date
+     */
+    public Date getCompletedAt() {
+        return GitHubClient.parseDate(completedAt);
+    }
+
+    /**
+     * Gets status of the job.
+     * <p>
+     * Can be {@code UNKNOWN} if the value returned by GitHub is unknown from the API.
+     *
+     * @return status of the job
+     */
+    public Status getStatus() {
+        return Status.from(status);
+    }
+
+    /**
+     * Gets the conclusion of the job.
+     * <p>
+     * Can be {@code UNKNOWN} if the value returned by GitHub is unknown from the API.
+     *
+     * @return conclusion of the job
+     */
+    public Conclusion getConclusion() {
+        return Conclusion.from(conclusion);
+    }
+
+    /**
+     * The run id.
+     *
+     * @return the run id
+     */
+    public long getRunId() {
+        return runId;
+    }
+
+    @Override
+    public URL getHtmlUrl() {
+        return GitHubClient.parseURL(htmlUrl);
+    }
+
+    /**
+     * The check run URL.
+     *
+     * @return the check run url
+     */
+    public URL getCheckRunUrl() {
+        return GitHubClient.parseURL(checkRunUrl);
+    }
+
+    /**
+     * Gets the execution steps of this job.
+     *
+     * @return the execution steps
+     */
+    public List<Step> getSteps() {
+        return steps;
+    }
+
+    /**
+     * Repository to which the job belongs.
+     *
+     * @return the repository
+     */
+    public GHRepository getRepository() {
+        return owner;
+    }
+
+    /**
+     * Downloads the logs.
+     * <p>
+     * The logs are returned as a text file.
+     *
+     * @param <T>
+     *            the type of result
+     * @param streamFunction
+     *            The {@link InputStreamFunction} that will process the stream
+     * @throws IOException
+     *             The IO exception.
+     * @return the result of reading the stream.
+     */
+    public <T> T downloadLogs(InputStreamFunction<T> streamFunction) throws IOException {
+        requireNonNull(streamFunction, "Stream function must not be null");
+
+        return root.createRequest().method("GET").withUrlPath(getApiRoute(), "logs").fetchStream(streamFunction);
+    }
+
+    private String getApiRoute() {
+        if (owner == null) {
+            // Workflow runs returned from search to do not have an owner. Attempt to use url.
+            final URL url = Objects.requireNonNull(getUrl(), "Missing instance URL!");
+            return StringUtils.prependIfMissing(url.toString().replace(root.getApiUrl(), ""), "/");
+
+        }
+        return "/repos/" + owner.getOwnerName() + "/" + owner.getName() + "/actions/jobs/" + getId();
+    }
+
+    GHWorkflowJob wrapUp(GHRepository owner) {
+        this.owner = owner;
+        return wrapUp(owner.root);
+    }
+
+    GHWorkflowJob wrapUp(GitHub root) {
+        this.root = root;
+        if (owner != null) {
+            owner.wrap(root);
+        }
+        return this;
+    }
+
+    public static class Step {
+
+        private String name;
+        private int number;
+
+        private String startedAt;
+        private String completedAt;
+
+        private String status;
+        private String conclusion;
+
+        /**
+         * Gets the name of the step.
+         *
+         * @return name
+         */
+        public String getName() {
+            return name;
+        }
+
+        /**
+         * Gets the sequential number of the step.
+         *
+         * @return number
+         */
+        public int getNumber() {
+            return number;
+        }
+
+        /**
+         * When was this step started?
+         *
+         * @return start date
+         */
+        public Date getStartedAt() {
+            return GitHubClient.parseDate(startedAt);
+        }
+
+        /**
+         * When was this step completed?
+         *
+         * @return completion date
+         */
+        public Date getCompletedAt() {
+            return GitHubClient.parseDate(completedAt);
+        }
+
+        /**
+         * Gets status of the step.
+         * <p>
+         * Can be {@code UNKNOWN} if the value returned by GitHub is unknown from the API.
+         *
+         * @return status of the step
+         */
+        public Status getStatus() {
+            return Status.from(status);
+        }
+
+        /**
+         * Gets the conclusion of the step.
+         * <p>
+         * Can be {@code UNKNOWN} if the value returned by GitHub is unknown from the API.
+         *
+         * @return conclusion of the step
+         */
+        public Conclusion getConclusion() {
+            return Conclusion.from(conclusion);
+        }
+    }
+}

src/main/java/org/kohsuke/github/GHWorkflowJobQueryBuilder.java

@@ -0,0 +1,47 @@
+package org.kohsuke.github;
+
+import java.net.MalformedURLException;
+
+/**
+ * Lists up jobs of a workflow run with some filtering.
+ *
+ * @author Guillaume Smet
+ */
+public class GHWorkflowJobQueryBuilder extends GHQueryBuilder<GHWorkflowJob> {
+    private final GHRepository repo;
+
+    GHWorkflowJobQueryBuilder(GHWorkflowRun workflowRun) {
+        super(workflowRun.getRepository().root);
+        this.repo = workflowRun.getRepository();
+        req.withUrlPath(repo.getApiTailUrl("actions/runs"), String.valueOf(workflowRun.getId()), "jobs");
+    }
+
+    /**
+     * Apply a filter to only return the jobs of the most recent execution of the workflow run.
+     *
+     * @return the workflow run job query builder
+     */
+    public GHWorkflowJobQueryBuilder latest() {
+        req.with("filter", "latest");
+        return this;
+    }
+
+    /**
+     * Apply a filter to return jobs from all executions of this workflow run.
+     *
+     * @return the workflow run job run query builder
+     */
+    public GHWorkflowJobQueryBuilder all() {
+        req.with("filter", "all");
+        return this;
+    }
+
+    @Override
+    public PagedIterable<GHWorkflowJob> list() {
+        try {
+            return new GHWorkflowJobsIterable(repo, req.build());
+        } catch (MalformedURLException e) {
+            throw new GHException(e.getMessage(), e);
+        }
+    }
+}

src/main/java/org/kohsuke/github/GHWorkflowJobsIterable.java

@@ -0,0 +1,44 @@
+package org.kohsuke.github;
+
+import java.util.Iterator;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Iterable for workflow run jobs listing.
+ */
+class GHWorkflowJobsIterable extends PagedIterable<GHWorkflowJob> {
+    private final GHRepository repo;
+    private final GitHubRequest request;
+
+    private GHWorkflowJobsPage result;
+
+    public GHWorkflowJobsIterable(GHRepository repo, GitHubRequest request) {
+        this.repo = repo;
+        this.request = request;
+    }
+
+    @Nonnull
+    @Override
+    public PagedIterator<GHWorkflowJob> _iterator(int pageSize) {
+        return new PagedIterator<>(
+                adapt(GitHubPageIterator.create(repo.root.getClient(), GHWorkflowJobsPage.class, request, pageSize)),
+                null);
+    }
+
+    protected Iterator<GHWorkflowJob[]> adapt(final Iterator<GHWorkflowJobsPage> base) {
+        return new Iterator<GHWorkflowJob[]>() {
+            public boolean hasNext() {
+                return base.hasNext();
+            }
+
+            public GHWorkflowJob[] next() {
+                GHWorkflowJobsPage v = base.next();
+                if (result == null) {
+                    result = v;
+                }
+                return v.getWorkflowJobs(repo);
+            }
+        };
+    }
+}

src/main/java/org/kohsuke/github/GHWorkflowJobsPage.java

@@ -0,0 +1,20 @@
+package org.kohsuke.github;
+
+/**
+ * Represents the one page of jobs result when listing jobs from a workflow run.
+ */
+class GHWorkflowJobsPage {
+    private int total_count;
+    private GHWorkflowJob[] jobs;
+
+    public int getTotalCount() {
+        return total_count;
+    }
+
+    GHWorkflowJob[] getWorkflowJobs(GHRepository repo) {
+        for (GHWorkflowJob job : jobs) {
+            job.wrapUp(repo);
+        }
+        return jobs;
+    }
+}

src/main/java/org/kohsuke/github/GHWorkflowRun.java

@@ -2,6 +2,7 @@ package org.kohsuke.github;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import org.apache.commons.lang3.StringUtils;
+import org.kohsuke.github.function.InputStreamFunction;
 import org.kohsuke.github.internal.EnumUtils;
 
 import java.io.IOException;
@@ -13,6 +14,8 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * A workflow run.
  *
@@ -83,7 +86,7 @@ public class GHWorkflowRun extends GHObject {
     /**
      * The jobs URL, like https://api.github.com/repos/octo-org/octo-repo/actions/runs/30433642/jobs
      *
-     * @return the diff url
+     * @return the jobs url
      */
     public URL getJobsUrl() {
         return GitHubClient.parseURL(jobsUrl);
@@ -92,7 +95,7 @@ public class GHWorkflowRun extends GHObject {
     /**
      * The logs URL, like https://api.github.com/repos/octo-org/octo-repo/actions/runs/30433642/logs
      *
-     * @return the diff url
+     * @return the logs url
      */
     public URL getLogsUrl() {
         return GitHubClient.parseURL(logsUrl);
@@ -101,7 +104,7 @@ public class GHWorkflowRun extends GHObject {
     /**
      * The check suite URL, like https://api.github.com/repos/octo-org/octo-repo/check-suites/414944374
      *
-     * @return the diff url
+     * @return the check suite url
      */
     public URL getCheckSuiteUrl() {
         return GitHubClient.parseURL(checkSuiteUrl);
@@ -110,7 +113,7 @@ public class GHWorkflowRun extends GHObject {
     /**
      * The artifacts URL, like https://api.github.com/repos/octo-org/octo-repo/actions/runs/30433642/artifacts
      *
-     * @return the diff url
+     * @return the artifacts url
      */
     public URL getArtifactsUrl() {
         return GitHubClient.parseURL(artifactsUrl);
@@ -119,7 +122,7 @@ public class GHWorkflowRun extends GHObject {
     /**
      * The cancel URL, like https://api.github.com/repos/octo-org/octo-repo/actions/runs/30433642/cancel
      *
-     * @return the diff url
+     * @return the cancel url
      */
     public URL getCancelUrl() {
         return GitHubClient.parseURL(cancelUrl);
@@ -128,7 +131,7 @@ public class GHWorkflowRun extends GHObject {
     /**
      * The rerun URL, like https://api.github.com/repos/octo-org/octo-repo/actions/runs/30433642/rerun
      *
-     * @return the diff url
+     * @return the rerun url
      */
     public URL getRerunUrl() {
         return GitHubClient.parseURL(rerunUrl);
@@ -137,7 +140,7 @@ public class GHWorkflowRun extends GHObject {
     /**
      * The workflow URL, like https://api.github.com/repos/octo-org/octo-repo/actions/workflows/159038
      *
-     * @return the diff url
+     * @return the workflow url
      */
     public URL getWorkflowUrl() {
         return GitHubClient.parseURL(workflowUrl);
@@ -185,7 +188,7 @@ public class GHWorkflowRun extends GHObject {
      * @return type of event
      */
     public GHEvent getEvent() {
-        return Enum.valueOf(GHEvent.class, event.toUpperCase(Locale.ROOT));
+        return EnumUtils.getNullableEnumOrDefault(GHEvent.class, event, GHEvent.UNKNOWN);
     }
 
     /**
@@ -210,6 +213,15 @@ public class GHWorkflowRun extends GHObject {
         return Conclusion.from(conclusion);
     }
 
+    /**
+     * Repository to which the workflow run belongs.
+     *
+     * @return the repository
+     */
+    public GHRepository getRepository() {
+        return owner;
+    }
+
     /**
      * Gets the pull requests participated in this workflow run.
      *
@@ -261,6 +273,64 @@ public class GHWorkflowRun extends GHObject {
         root.createRequest().method("POST").withUrlPath(getApiRoute(), "rerun").fetchHttpStatusCode();
     }
 
+    /**
+     * Lists the artifacts attached to this workflow run.
+     *
+     * @return the paged iterable
+     */
+    public PagedIterable<GHArtifact> listArtifacts() {
+        return new GHArtifactsIterable(owner, root.createRequest().withUrlPath(getApiRoute(), "artifacts"));
+    }
+
+    /**
+     * Downloads the logs.
+     * <p>
+     * The logs are in the form of a zip archive.
+     * <p>
+     * Note that the archive is the same as the one downloaded from a workflow run so it contains the logs for all jobs.
+     *
+     * @param <T>
+     *            the type of result
+     * @param streamFunction
+     *            The {@link InputStreamFunction} that will process the stream
+     * @throws IOException
+     *             The IO exception.
+     * @return the result of reading the stream.
+     */
+    public <T> T downloadLogs(InputStreamFunction<T> streamFunction) throws IOException {
+        requireNonNull(streamFunction, "Stream function must not be null");
+
+        return root.createRequest().method("GET").withUrlPath(getApiRoute(), "logs").fetchStream(streamFunction);
+    }
+
+    /**
+     * Delete the logs.
+     *
+     * @throws IOException
+     *             the io exception
+     */
+    public void deleteLogs() throws IOException {
+        root.createRequest().method("DELETE").withUrlPath(getApiRoute(), "logs").fetchHttpStatusCode();
+    }
+
+    /**
+     * Returns the list of jobs of this workflow run for the last execution.
+     *
+     * @return list of jobs from the last execution
+     */
+    public PagedIterable<GHWorkflowJob> listJobs() {
+        return new GHWorkflowJobQueryBuilder(this).latest().list();
+    }
+
+    /**
+     * Returns the list of jobs from all the executions of this workflow run.
+     *
+     * @return list of jobs from all the executions
+     */
+    public PagedIterable<GHWorkflowJob> listAllJobs() {
+        return new GHWorkflowJobQueryBuilder(this).all().list();
+    }
+
     private String getApiRoute() {
         if (owner == null) {
             // Workflow runs returned from search to do not have an owner. Attempt to use url.

src/main/java/org/kohsuke/github/GHWorkflowRunQueryBuilder.java

@@ -93,7 +93,7 @@ public class GHWorkflowRunQueryBuilder extends GHQueryBuilder<GHWorkflowRun> {
     @Override
     public PagedIterable<GHWorkflowRun> list() {
         try {
-            return new GHWorkflowRunsIterable(root, req.withUrlPath(repo.getApiTailUrl("actions/runs")).build());
+            return new GHWorkflowRunsIterable(repo, req.withUrlPath(repo.getApiTailUrl("actions/runs")).build());
         } catch (MalformedURLException e) {
             throw new GHException(e.getMessage(), e);
         }

src/main/java/org/kohsuke/github/GHWorkflowRunsIterable.java

@@ -8,13 +8,13 @@ import javax.annotation.Nonnull;
  * Iterable for workflow runs listing.
  */
 class GHWorkflowRunsIterable extends PagedIterable<GHWorkflowRun> {
-    private final transient GitHub root;
+    private final GHRepository owner;
     private final GitHubRequest request;
 
     private GHWorkflowRunsPage result;
 
-    public GHWorkflowRunsIterable(GitHub root, GitHubRequest request) {
-        this.root = root;
+    public GHWorkflowRunsIterable(GHRepository owner, GitHubRequest request) {
+        this.owner = owner;
         this.request = request;
     }
 
@@ -22,7 +22,8 @@ class GHWorkflowRunsIterable extends PagedIterable<GHWorkflowRun> {
     @Override
     public PagedIterator<GHWorkflowRun> _iterator(int pageSize) {
         return new PagedIterator<>(
-                adapt(GitHubPageIterator.create(root.getClient(), GHWorkflowRunsPage.class, request, pageSize)),
+                adapt(GitHubPageIterator
+                        .create(owner.getRoot().getClient(), GHWorkflowRunsPage.class, request, pageSize)),
                 null);
     }
 
@@ -37,7 +38,7 @@ class GHWorkflowRunsIterable extends PagedIterable<GHWorkflowRun> {
                 if (result == null) {
                     result = v;
                 }
-                return v.getWorkflowRuns(root);
+                return v.getWorkflowRuns(owner);
             }
         };
     }

src/main/java/org/kohsuke/github/GHWorkflowRunsPage.java

@@ -11,9 +11,9 @@ class GHWorkflowRunsPage {
         return totalCount;
     }
 
-    GHWorkflowRun[] getWorkflowRuns(GitHub root) {
+    GHWorkflowRun[] getWorkflowRuns(GHRepository owner) {
         for (GHWorkflowRun workflowRun : workflowRuns) {
-            workflowRun.wrapUp(root);
+            workflowRun.wrapUp(owner);
         }
         return workflowRuns;
     }

src/main/java/org/kohsuke/github/GitHubClient.java

@@ -141,10 +141,9 @@ abstract class GitHubClient {
             getRateLimit();
             return true;
         } catch (IOException e) {
-            if (LOGGER.isLoggable(FINE))
-                LOGGER.log(FINE,
-                        "Exception validating credentials on " + getApiUrl() + " with login '" + login + "' " + e,
-                        e);
+            LOGGER.log(FINE,
+                    "Exception validating credentials on " + getApiUrl() + " with login '" + login + "' " + e,
+                    e);
             return false;
         }
     }
@@ -384,11 +383,7 @@ abstract class GitHubClient {
             GitHubResponse.ResponseInfo responseInfo = null;
             try {
                 try {
-                    if (LOGGER.isLoggable(FINE)) {
-                        LOGGER.log(FINE,
-                                "GitHub API request [" + (login == null ? "anonymous" : login) + "]: "
-                                        + request.method() + " " + request.url().toString());
-                    }
+                    logRequest(request);
                     rateLimitChecker.checkRateLimit(this, request);
 
                     responseInfo = getResponseInfo(request);
@@ -424,6 +419,12 @@ abstract class GitHubClient {
         throw new GHIOException("Ran out of retries for URL: " + request.url().toString());
     }
 
+    private void logRequest(@Nonnull final GitHubRequest request) {
+        LOGGER.log(FINE,
+                () -> "GitHub API request [" + (login == null ? "anonymous" : login) + "]: " + request.method() + " "
+                        + request.url().toString());
+    }
+
     @Nonnull
     protected abstract GitHubResponse.ResponseInfo getResponseInfo(GitHubRequest request) throws IOException;
 
@@ -437,20 +438,15 @@ abstract class GitHubClient {
             // special case handling for 304 unmodified, as the content will be ""
         } else if (responseInfo.statusCode() == HttpURLConnection.HTTP_ACCEPTED) {
 
-            // Response code 202 means data is being generated.
+            // Response code 202 means data is being generated or an action that can require some time is triggered.
             // This happens in specific cases:
             // statistics - See https://developer.github.com/v3/repos/statistics/#a-word-about-caching
             // fork creation - See https://developer.github.com/v3/repos/forks/#create-a-fork
+            // workflow run cancellation - See https://docs.github.com/en/rest/reference/actions#cancel-a-workflow-run
 
-            if (responseInfo.url().toString().endsWith("/forks")) {
-                LOGGER.log(INFO, "The fork is being created. Please try again in 5 seconds.");
-            } else if (responseInfo.url().toString().endsWith("/statistics")) {
-                LOGGER.log(INFO, "The statistics are being generated. Please try again in 5 seconds.");
-            } else {
-                LOGGER.log(INFO,
-                        "Received 202 from " + responseInfo.url().toString() + " . Please try again in 5 seconds.");
-            }
-            // Maybe throw an exception instead?
+            LOGGER.log(FINE,
+                    "Received HTTP_ACCEPTED(202) from " + responseInfo.url().toString()
+                            + " . Please try again in 5 seconds.");
         } else if (handler != null) {
             body = handler.apply(responseInfo);
         }
@@ -562,9 +558,7 @@ abstract class GitHubClient {
             GHRateLimit.Record observed = new GHRateLimit.Record(limit, remaining, reset, responseInfo);
             updateRateLimit(GHRateLimit.fromRecord(observed, responseInfo.request().rateLimitTarget()));
         } catch (NumberFormatException | NullPointerException e) {
-            if (LOGGER.isLoggable(FINEST)) {
-                LOGGER.log(FINEST, "Missing or malformed X-RateLimit header: ", e);
-            }
+            LOGGER.log(FINEST, "Missing or malformed X-RateLimit header: ", e);
         }
     }
 

src/main/java/org/kohsuke/github/GitHubHttpUrlConnectionClient.java

@@ -5,7 +5,6 @@ import org.kohsuke.github.authorization.AuthorizationProvider;
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.lang.reflect.Field;
 import java.net.HttpURLConnection;
 import java.net.ProtocolException;
 import java.nio.charset.StandardCharsets;
@@ -163,30 +162,9 @@ class GitHubHttpUrlConnectionClient extends GitHubClient {
                 connection.setRequestMethod(method);
             } catch (ProtocolException e) {
                 // JDK only allows one of the fixed set of verbs. Try to override that
-                try {
-                    Field $method = HttpURLConnection.class.getDeclaredField("method");
-                    $method.setAccessible(true);
-                    $method.set(connection, method);
-                } catch (Exception x) {
-                    throw (IOException) new IOException("Failed to set the custom verb").initCause(x);
-                }
-                // sun.net.www.protocol.https.DelegatingHttpsURLConnection delegates to another HttpURLConnection
-                try {
-                    Field $delegate = connection.getClass().getDeclaredField("delegate");
-                    $delegate.setAccessible(true);
-                    Object delegate = $delegate.get(connection);
-                    if (delegate instanceof HttpURLConnection) {
-                        HttpURLConnection nested = (HttpURLConnection) delegate;
-                        setRequestMethod(method, nested);
-                    }
-                } catch (NoSuchFieldException x) {
-                    // no problem
-                } catch (IllegalAccessException x) {
-                    throw (IOException) new IOException("Failed to set the custom verb").initCause(x);
-                }
+                connection.setRequestProperty("X-HTTP-Method-Override", method);
+                connection.setRequestMethod("POST");
             }
-            if (!connection.getRequestMethod().equals(method))
-                throw new IllegalStateException("Failed to set the request method to " + method);
         }
 
         /**

src/main/java/org/kohsuke/github/GitHubRequest.java

@@ -602,13 +602,27 @@ class GitHubRequest {
          * @return the request builder
          */
         public B set(String key, Object value) {
-            for (int index = 0; index < args.size(); index++) {
+            remove(key);
+            return with(key, value);
+
+        }
+
+        /**
+         * Removes all arg entries for a specific key.
+         *
+         * @param key
+         *            the key
+         * @return the request builder
+         */
+        public B remove(String key) {
+            for (int index = 0; index < args.size();) {
                 if (args.get(index).key.equals(key)) {
-                    args.set(index, new Entry(key, value));
-                    return (B) this;
+                    args.remove(index);
+                } else {
+                    index++;
                 }
             }
-            return with(key, value);
+            return (B) this;
         }
 
         /**

src/main/java/org/kohsuke/github/internal/EnumUtils.java

@@ -1,12 +1,15 @@
 package org.kohsuke.github.internal;
 
 import java.util.Locale;
+import java.util.logging.Logger;
 
 /**
  * Utils for Enums.
  */
 public final class EnumUtils {
 
+    private static final Logger LOGGER = Logger.getLogger(EnumUtils.class.getName());
+
     /**
      * Returns an enum value matching the value if found, null if the value is null and {@code defaultEnum} if the value
      * cannot be matched to a value of the enum.
@@ -30,6 +33,8 @@ public final class EnumUtils {
         try {
             return Enum.valueOf(enumClass, value.toUpperCase(Locale.ROOT));
         } catch (IllegalArgumentException e) {
+            LOGGER.warning("Unknown value " + value + " for enum class " + enumClass.getName() + ", defaulting to "
+                    + defaultEnum.name());
             return defaultEnum;
         }
     }

src/test/java/org/kohsuke/github/AbstractGitHubWireMockTest.java

@@ -4,10 +4,9 @@ import com.github.tomakehurst.wiremock.core.WireMockConfiguration;
 import com.github.tomakehurst.wiremock.extension.responsetemplating.ResponseTemplateTransformer;
 import com.github.tomakehurst.wiremock.extension.responsetemplating.helpers.HandlebarsCurrentDateHelper;
 import org.apache.commons.io.IOUtils;
-import org.hamcrest.Description;
 import org.hamcrest.Matcher;
+import org.hamcrest.MatcherAssert;
 import org.hamcrest.Matchers;
-import org.hamcrest.StringDescription;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -21,13 +20,14 @@ import java.io.FileInputStream;
 import java.io.IOException;
 import java.util.*;
 
+import static org.hamcrest.Matchers.*;
 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;
 
 /**
  * @author Liam Newman
  */
-public abstract class AbstractGitHubWireMockTest extends Assert {
+public abstract class AbstractGitHubWireMockTest {
 
     private final GitHubBuilder githubBuilder = createGitHubBuilder();
 
@@ -45,7 +45,7 @@ public abstract class AbstractGitHubWireMockTest extends Assert {
      */
     protected GitHub gitHub;
 
-    private GitHub gitHubBeforeAfter;
+    private GitHub nonRecordingGitHub;
 
     protected final String baseFilesClassPath = this.getClass().getName().replace('.', '/');
     protected final String baseRecordPath = "src/test/resources/" + baseFilesClassPath + "/wiremock";
@@ -115,9 +115,9 @@ public abstract class AbstractGitHubWireMockTest extends Assert {
         }
 
         if (mockGitHub.isUseProxy()) {
-            gitHubBeforeAfter = getGitHubBuilder().withEndpoint("https://api.github.com/").build();
+            nonRecordingGitHub = getGitHubBuilder().withEndpoint("https://api.github.com/").build();
         } else {
-            gitHubBeforeAfter = null;
+            nonRecordingGitHub = null;
         }
     }
 
@@ -210,7 +210,7 @@ public abstract class AbstractGitHubWireMockTest extends Assert {
         if (mockGitHub.isUseProxy()) {
             tempGitHubRepositories.add(fullName);
             try {
-                GHRepository repository = getGitHubBeforeAfter().getRepository(fullName);
+                GHRepository repository = getNonRecordingGitHub().getRepository(fullName);
                 if (repository != null) {
                     repository.delete();
                 }
@@ -227,22 +227,22 @@ public abstract class AbstractGitHubWireMockTest extends Assert {
      *
      * @return a github instance after checking Authentication
      */
-    public GitHub getGitHubBeforeAfter() {
-        verifyAuthenticated(gitHubBeforeAfter);
-        return gitHubBeforeAfter;
+    public GitHub getNonRecordingGitHub() {
+        verifyAuthenticated(nonRecordingGitHub);
+        return nonRecordingGitHub;
     }
 
     protected void kohsuke() {
         // No-op for now
         // Generally this means the test is doing something that requires additional access rights
         // Not always clear which ones.
-        // TODO: Add helpers that assert the expected rights using gitHubBeforeAfter and only when proxy is enabled
+        // TODO: Add helpers that assert the expected rights using nonRecordingGitHub and only when proxy is enabled
         // String login = getUserTest().getLogin();
         // assumeTrue(login.equals("kohsuke") || login.equals("kohsuke2"));
     }
 
     private GHCreateRepositoryBuilder getCreateBuilder(String name) throws IOException {
-        GitHub github = getGitHubBeforeAfter();
+        GitHub github = getNonRecordingGitHub();
 
         if (mockGitHub.isTestWithOrg()) {
             return github.getOrganization(GITHUB_API_TEST_ORG).createRepository(name);
@@ -255,52 +255,23 @@ public abstract class AbstractGitHubWireMockTest extends Assert {
         return mockGitHub.isTestWithOrg() ? GITHUB_API_TEST_ORG : gitHub.getMyself().getLogin();
     }
 
+    public static void fail() {
+        Assert.fail();
+    }
+    public static void fail(String reason) {
+        Assert.fail(reason);
+    }
+
     public static <T> void assertThat(T actual, Matcher<? super T> matcher) {
-        assertThat("", actual, matcher);
+        MatcherAssert.assertThat("", actual, matcher);
     }
 
     public static <T> void assertThat(String reason, T actual, Matcher<? super T> matcher) {
-        if (!matcher.matches(actual)) {
-            Description description = new StringDescription();
-            description.appendText(reason)
-                    .appendText(System.lineSeparator())
-                    .appendText("Expected: ")
-                    .appendDescriptionOf(matcher)
-                    .appendText(System.lineSeparator())
-                    .appendText("     but: ");
-            matcher.describeMismatch(actual, description);
-            throw new AssertionError(description.toString());
-        }
+        MatcherAssert.assertThat(reason, actual, matcher);
     }
 
     public static void assertThat(String reason, boolean assertion) {
-        if (!assertion) {
-            throw new AssertionError(reason);
-        }
-    }
-
-    public static void assertEquals(Object expected, Object actual) {
-        assertThat(actual, Matchers.equalTo(expected));
-    }
-
-    public static void assertNotEquals(Object expected, Object actual) {
-        assertThat(actual, Matchers.not(expected));
-    }
-
-    public static void assertNotNull(Object actual) {
-        assertThat(actual, Matchers.notNullValue());
-    }
-
-    public static void assertNull(Object actual) {
-        assertThat(actual, Matchers.nullValue());
-    }
-
-    public static void assertTrue(Boolean condition) {
-        assertThat(condition, Matchers.is(true));
-    }
-
-    public static void assertFalse(Boolean condition) {
-        assertThat(condition, Matchers.is(false));
+        MatcherAssert.assertThat(reason, assertion);
     }
 
     protected static class TemplatingHelper {

src/test/java/org/kohsuke/github/AppTest.java

@@ -17,7 +17,6 @@ import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.Map.Entry;
-import java.util.regex.Pattern;
 
 import static org.hamcrest.Matchers.*;
 
@@ -84,20 +83,20 @@ public class AppTest extends AbstractGitHubWireMockTest {
         if (mockGitHub.isUseProxy()) {
             Thread.sleep(3000);
         }
-        assertNotNull(r.getReadme());
+        assertThat(r.getReadme(), notNullValue());
 
         r.delete();
     }
 
     private void cleanupUserRepository(final String name) throws IOException {
         if (mockGitHub.isUseProxy()) {
-            cleanupRepository(getUser(getGitHubBeforeAfter()).getLogin() + "/" + name);
+            cleanupRepository(getUser(getNonRecordingGitHub()).getLogin() + "/" + name);
         }
     }
 
     @Test
     public void testCredentialValid() throws IOException {
-        assertTrue(gitHub.isCredentialValid());
+        assertThat(gitHub.isCredentialValid(), is(true));
         assertThat(gitHub.lastRateLimit().getCore(), not(instanceOf(GHRateLimit.UnknownLimitRecord.class)));
         assertThat(gitHub.lastRateLimit().getCore().getLimit(), equalTo(5000));
 
@@ -105,7 +104,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
                 .withEndpoint(mockGitHub.apiServer().baseUrl())
                 .build();
         assertThat(gitHub.lastRateLimit(), sameInstance(GHRateLimit.DEFAULT));
-        assertFalse(gitHub.isCredentialValid());
+        assertThat(gitHub.isCredentialValid(), is(false));
         // For invalid credentials, we get a 401 but it includes anonymous rate limit headers
         assertThat(gitHub.lastRateLimit().getCore(), not(instanceOf(GHRateLimit.UnknownLimitRecord.class)));
         assertThat(gitHub.lastRateLimit().getCore().getLimit(), equalTo(60));
@@ -116,7 +115,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
         // Simulated GHE: getRateLimit returns 404
         assertThat(gitHub.lastRateLimit(), sameInstance(GHRateLimit.DEFAULT));
         assertThat(gitHub.lastRateLimit().getCore().isExpired(), is(true));
-        assertTrue(gitHub.isCredentialValid());
+        assertThat(gitHub.isCredentialValid(), is(true));
 
         // lastRateLimitUpdates because 404 still includes header rate limit info
         assertThat(gitHub.lastRateLimit(), notNullValue());
@@ -127,7 +126,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
                 .withEndpoint(mockGitHub.apiServer().baseUrl())
                 .build();
         assertThat(gitHub.lastRateLimit(), sameInstance(GHRateLimit.DEFAULT));
-        assertFalse(gitHub.isCredentialValid());
+        assertThat(gitHub.isCredentialValid(), is(false));
         // Simulated GHE: For invalid credentials, we get a 401 that does not include ratelimit info
         assertThat(gitHub.lastRateLimit(), sameInstance(GHRateLimit.DEFAULT));
     }
@@ -138,7 +137,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
         GHIssue i = repository.getIssue(4);
         List<GHIssueComment> v = i.getComments();
         // System.out.println(v);
-        assertTrue(v.isEmpty());
+        assertThat(v, is(empty()));
 
         i = repository.getIssue(3);
         v = i.getComments();
@@ -151,7 +150,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
         assertThat(v.get(0).getParent().getNumber(), equalTo(3));
         assertThat(v.get(0).getParent().getId(), equalTo(6863845L));
         assertThat(v.get(0).getUser().getLogin(), equalTo("kohsuke"));
-        assertThat(v.get(0).listReactions().toList().size(), equalTo(0));
+        assertThat(v.get(0).listReactions().toList(), is(empty()));
 
         assertThat(v.get(1).getHtmlUrl().toString(),
                 equalTo("https://github.com/kohsuke/test/issues/3#issuecomment-8547251"));
@@ -179,7 +178,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
                 .label("question")
                 .milestone(milestone)
                 .create();
-        assertNotNull(o);
+        assertThat(o, notNullValue());
         o.close();
     }
 
@@ -192,17 +191,17 @@ public class AppTest extends AbstractGitHubWireMockTest {
                 .environment("unittest")
                 .create();
         try {
-            assertNotNull(deployment.getCreator());
-            assertNotNull(deployment.getId());
+            assertThat(deployment.getCreator(), notNullValue());
+            assertThat(deployment.getId(), notNullValue());
             List<GHDeployment> deployments = repository.listDeployments(null, "main", null, "unittest").toList();
-            assertNotNull(deployments);
-            assertFalse(Iterables.isEmpty(deployments));
+            assertThat(deployments, notNullValue());
+            assertThat(deployments, is(not(emptyIterable())));
             GHDeployment unitTestDeployment = deployments.get(0);
-            assertEquals("unittest", unitTestDeployment.getEnvironment());
-            assertEquals("unittest", unitTestDeployment.getOriginalEnvironment());
-            assertEquals(false, unitTestDeployment.isProductionEnvironment());
-            assertEquals(false, unitTestDeployment.isTransientEnvironment());
-            assertEquals("main", unitTestDeployment.getRef());
+            assertThat(unitTestDeployment.getEnvironment(), equalTo("unittest"));
+            assertThat(unitTestDeployment.getOriginalEnvironment(), equalTo("unittest"));
+            assertThat(unitTestDeployment.isProductionEnvironment(), equalTo(false));
+            assertThat(unitTestDeployment.isTransientEnvironment(), equalTo(false));
+            assertThat(unitTestDeployment.getRef(), equalTo("main"));
         } finally {
             // deployment.delete();
             assert true;
@@ -225,15 +224,15 @@ public class AppTest extends AbstractGitHubWireMockTest {
                     .environment("new-ci-env")
                     .create();
             Iterable<GHDeploymentStatus> deploymentStatuses = deployment.listStatuses();
-            assertNotNull(deploymentStatuses);
-            assertEquals(1, Iterables.size(deploymentStatuses));
+            assertThat(deploymentStatuses, notNullValue());
+            assertThat(Iterables.size(deploymentStatuses), equalTo(1));
             GHDeploymentStatus actualStatus = Iterables.get(deploymentStatuses, 0);
-            assertEquals(ghDeploymentStatus.getId(), actualStatus.getId());
-            assertEquals(ghDeploymentStatus.getState(), actualStatus.getState());
-            assertEquals(ghDeploymentStatus.getLogUrl(), actualStatus.getLogUrl());
+            assertThat(actualStatus.getId(), equalTo(ghDeploymentStatus.getId()));
+            assertThat(actualStatus.getState(), equalTo(ghDeploymentStatus.getState()));
+            assertThat(actualStatus.getLogUrl(), equalTo(ghDeploymentStatus.getLogUrl()));
             // Target url was deprecated and replaced with log url. The gh api will
             // prefer the log url value and return it in place of target url.
-            assertEquals(ghDeploymentStatus.getTargetUrl(), actualStatus.getLogUrl());
+            assertThat(actualStatus.getLogUrl(), equalTo(ghDeploymentStatus.getTargetUrl()));
             assertThat(ghDeploymentStatus.getDeploymentUrl(), equalTo(deployment.getUrl()));
             assertThat(ghDeploymentStatus.getRepositoryUrl(), equalTo(repository.getUrl()));
         } finally {
@@ -248,7 +247,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
                 .getRepository("github-api")
                 .getIssues(GHIssueState.CLOSED);
         // prior to using PagedIterable GHRepository.getIssues(GHIssueState) would only retrieve 30 issues
-        assertTrue(closedIssues.size() > 150);
+        assertThat(closedIssues.size(), greaterThan(150));
         String readRepoString = GitHub.getMappingObjectWriter().writeValueAsString(closedIssues.get(0));
     }
 
@@ -264,11 +263,11 @@ public class AppTest extends AbstractGitHubWireMockTest {
 
         int x = 0;
         for (GHIssue issue : closedIssues) {
-            assertNotNull(issue);
+            assertThat(issue, notNullValue());
             x++;
         }
 
-        assertTrue(x > 150);
+        assertThat(x, greaterThan(150));
     }
 
     @Test
@@ -279,7 +278,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
     @Test
     public void testMyOrganizations() throws IOException {
         Map<String, GHOrganization> org = gitHub.getMyOrganizations();
-        assertFalse(org.keySet().contains(null));
+        assertThat(org.containsKey(null), is(false));
         // System.out.println(org);
     }
 
@@ -289,7 +288,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
         Map<String, GHOrganization> myOrganizations = gitHub.getMyOrganizations();
         // GitHub no longer has default 'owners' team, so there may be organization memberships without a team
         // https://help.github.com/articles/about-improved-organization-permissions/
-        assertTrue(myOrganizations.keySet().containsAll(teams.keySet()));
+        assertThat(myOrganizations.keySet().containsAll(teams.keySet()), is(true));
     }
 
     @Test
@@ -299,7 +298,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
             String organizationName = teamsPerOrg.getKey();
             for (GHTeam team : teamsPerOrg.getValue()) {
                 String teamName = team.getName();
-                assertTrue("Team " + teamName + " in organization " + organizationName + " does not contain myself",
+                assertThat("Team " + teamName + " in organization " + organizationName + " does not contain myself",
                         shouldBelongToTeam(organizationName, teamName));
             }
         }
@@ -312,7 +311,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
         user.login = "kohsuke";
 
         Map<String, GHOrganization> orgs = gitHub.getUserPublicOrganizations(user);
-        assertFalse(orgs.isEmpty());
+        assertThat(orgs.size(), greaterThan(0));
     }
 
     @Test
@@ -322,14 +321,14 @@ public class AppTest extends AbstractGitHubWireMockTest {
         user.login = "bitwiseman";
 
         Map<String, GHOrganization> orgs = gitHub.getUserPublicOrganizations(user);
-        assertTrue(orgs.isEmpty());
+        assertThat(orgs.size(), equalTo(0));
     }
 
     private boolean shouldBelongToTeam(String organizationName, String teamName) throws IOException {
         GHOrganization org = gitHub.getOrganization(organizationName);
-        assertNotNull(org);
+        assertThat(org, notNullValue());
         GHTeam team = org.getTeamByName(teamName);
-        assertNotNull(team);
+        assertThat(team, notNullValue());
         return team.hasMember(gitHub.getMyself());
     }
 
@@ -339,10 +338,10 @@ public class AppTest extends AbstractGitHubWireMockTest {
         GHTeam teamByName = organization.getTeams().get("Core Developers");
 
         GHTeam teamById = gitHub.getTeam((int) teamByName.getId());
-        assertNotNull(teamById);
+        assertThat(teamById, notNullValue());
 
-        assertEquals(teamByName.getId(), teamById.getId());
-        assertEquals(teamByName.getDescription(), teamById.getDescription());
+        assertThat(teamById.getId(), equalTo(teamByName.getId()));
+        assertThat(teamById.getDescription(), equalTo(teamByName.getDescription()));
     }
 
     @Test
@@ -351,16 +350,16 @@ public class AppTest extends AbstractGitHubWireMockTest {
         GHTeam teamByName = organization.getTeams().get("Core Developers");
 
         GHTeam teamById = organization.getTeam(teamByName.getId());
-        assertNotNull(teamById);
+        assertThat(teamById, notNullValue());
 
-        assertEquals(teamByName.getId(), teamById.getId());
-        assertEquals(teamByName.getDescription(), teamById.getDescription());
+        assertThat(teamById.getId(), equalTo(teamByName.getId()));
+        assertThat(teamById.getDescription(), equalTo(teamByName.getDescription()));
 
         GHTeam teamById2 = organization.getTeam(teamByName.getId());
-        assertNotNull(teamById2);
+        assertThat(teamById2, notNullValue());
 
-        assertEquals(teamByName.getId(), teamById2.getId());
-        assertEquals(teamByName.getDescription(), teamById2.getDescription());
+        assertThat(teamById2.getId(), equalTo(teamByName.getId()));
+        assertThat(teamById2.getDescription(), equalTo(teamByName.getDescription()));
 
     }
 
@@ -368,7 +367,8 @@ public class AppTest extends AbstractGitHubWireMockTest {
     @Test
     public void testFetchPullRequest() throws Exception {
         GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("jenkins");
-        assertEquals("master", r.getMasterBranch());
+        assertThat(r.getMasterBranch(), equalTo("main"));
+        assertThat(r.getDefaultBranch(), equalTo("main"));
         r.getPullRequest(1);
         r.getPullRequests(GHIssueState.OPEN);
     }
@@ -377,11 +377,11 @@ public class AppTest extends AbstractGitHubWireMockTest {
     @Test
     public void testFetchPullRequestAsList() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
-        assertEquals("master", r.getMasterBranch());
+        assertThat(r.getMasterBranch(), equalTo("main"));
         PagedIterable<GHPullRequest> i = r.listPullRequests(GHIssueState.CLOSED);
         List<GHPullRequest> prs = i.toList();
-        assertNotNull(prs);
-        assertTrue(prs.size() > 0);
+        assertThat(prs, notNullValue());
+        assertThat(prs, is(not(empty())));
     }
 
     @Ignore("Needs mocking check")
@@ -390,26 +390,26 @@ public class AppTest extends AbstractGitHubWireMockTest {
         kohsuke();
 
         GHRepository r = gitHub.getOrganization(GITHUB_API_TEST_ORG).getRepository("github-api");
-        assertTrue(r.hasPullAccess());
+        assertThat(r.hasPullAccess(), is(true));
 
         r = gitHub.getOrganization("github").getRepository("hub");
-        assertFalse(r.hasAdminAccess());
+        assertThat(r.hasAdminAccess(), is(false));
     }
 
     @Test
     public void testGetMyself() throws Exception {
         GHMyself me = gitHub.getMyself();
-        assertNotNull(me);
-        assertNotNull(gitHub.getUser("bitwiseman"));
+        assertThat(me, notNullValue());
+        assertThat(gitHub.getUser("bitwiseman"), notNullValue());
         PagedIterable<GHRepository> ghRepositories = me.listRepositories();
-        assertTrue(ghRepositories.iterator().hasNext());
+        assertThat(ghRepositories, is(not(emptyIterable())));
     }
 
     @Ignore("Needs mocking check")
     @Test
     public void testPublicKeys() throws Exception {
         List<GHKey> keys = gitHub.getMyself().getPublicKeys();
-        assertFalse(keys.isEmpty());
+        assertThat(keys, is(not(empty())));
     }
 
     @Test
@@ -422,8 +422,8 @@ public class AppTest extends AbstractGitHubWireMockTest {
     public void testGetTeamsForRepo() throws Exception {
         kohsuke();
         // 'Core Developers' and 'Owners'
-        assertEquals(2,
-                gitHub.getOrganization(GITHUB_API_TEST_ORG).getRepository("testGetTeamsForRepo").getTeams().size());
+        assertThat(gitHub.getOrganization(GITHUB_API_TEST_ORG).getRepository("testGetTeamsForRepo").getTeams().size(),
+                equalTo(2));
     }
 
     @Test
@@ -445,24 +445,24 @@ public class AppTest extends AbstractGitHubWireMockTest {
         kohsuke();
         int sz = 0;
         for (GHTeam t : gitHub.getOrganization(GITHUB_API_TEST_ORG).listTeams()) {
-            assertNotNull(t.getName());
+            assertThat(t.getName(), notNullValue());
             sz++;
         }
-        assertTrue(sz < 100);
+        assertThat(sz, lessThan(100));
     }
 
     @Test
     public void testOrgTeamByName() throws Exception {
         kohsuke();
         GHTeam e = gitHub.getOrganization(GITHUB_API_TEST_ORG).getTeamByName("Core Developers");
-        assertNotNull(e);
+        assertThat(e, notNullValue());
     }
 
     @Test
     public void testOrgTeamBySlug() throws Exception {
         kohsuke();
         GHTeam e = gitHub.getOrganization(GITHUB_API_TEST_ORG).getTeamBySlug("core-developers");
-        assertNotNull(e);
+        assertThat(e, notNullValue());
     }
 
     @Test
@@ -470,13 +470,13 @@ public class AppTest extends AbstractGitHubWireMockTest {
         GHCommit commit = gitHub.getUser("jenkinsci")
                 .getRepository("jenkins")
                 .getCommit("08c1c9970af4d609ae754fbe803e06186e3206f7");
-        assertEquals(1, commit.getParents().size());
-        assertEquals(1, commit.getFiles().size());
-        assertEquals("https://github.com/jenkinsci/jenkins/commit/08c1c9970af4d609ae754fbe803e06186e3206f7",
-                commit.getHtmlUrl().toString());
+        assertThat(commit.getParents().size(), equalTo(1));
+        assertThat(commit.getFiles().size(), equalTo(1));
+        assertThat(commit.getHtmlUrl().toString(),
+                equalTo("https://github.com/jenkinsci/jenkins/commit/08c1c9970af4d609ae754fbe803e06186e3206f7"));
 
         File f = commit.getFiles().get(0);
-        assertEquals(48, f.getLinesChanged());
+        assertThat(f.getLinesChanged(), equalTo(48));
         assertThat(f.getLinesAdded(), equalTo(40));
         assertThat(f.getLinesDeleted(), equalTo(8));
         assertThat(f.getPreviousFilename(), nullValue());
@@ -487,13 +487,13 @@ public class AppTest extends AbstractGitHubWireMockTest {
         assertThat(f.getRawUrl().toString(),
                 equalTo("https://github.com/jenkinsci/jenkins/raw/08c1c9970af4d609ae754fbe803e06186e3206f7/changelog.html"));
 
-        assertEquals("modified", f.getStatus());
-        assertEquals("changelog.html", f.getFileName());
+        assertThat(f.getStatus(), equalTo("modified"));
+        assertThat(f.getFileName(), equalTo("changelog.html"));
 
         // walk the tree
         GHTree t = commit.getTree();
         assertThat(IOUtils.toString(t.getEntry("todo.txt").readAsBlob()), containsString("executor rendering"));
-        assertNotNull(t.getEntry("war").asTree());
+        assertThat(t.getEntry("war").asTree(), notNullValue());
     }
 
     @Test
@@ -502,8 +502,8 @@ public class AppTest extends AbstractGitHubWireMockTest {
         for (GHCommit c : gitHub.getUser("kohsuke").getRepository("empty-commit").listCommits()) {
             sha1.add(c.getSHA1());
         }
-        assertEquals("fdfad6be4db6f96faea1f153fb447b479a7a9cb7", sha1.get(0));
-        assertEquals(1, sha1.size());
+        assertThat(sha1.get(0), equalTo("fdfad6be4db6f96faea1f153fb447b479a7a9cb7"));
+        assertThat(sha1.size(), equalTo(1));
     }
 
     @Ignore("Needs mocking check")
@@ -520,7 +520,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
         List<GHCommitComment> batch = comments.iterator().nextPage();
         for (GHCommitComment comment : batch) {
             // System.out.println(comment.getBody());
-            assertSame(comment.getOwner(), r);
+            assertThat(r, sameInstance(comment.getOwner()));
         }
     }
 
@@ -585,7 +585,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
             // System.out.println(hook);
         } finally {
             if (mockGitHub.isUseProxy()) {
-                r = getGitHubBeforeAfter().getOrganization(GITHUB_API_TEST_ORG).getRepository("github-api");
+                r = getNonRecordingGitHub().getOrganization(GITHUB_API_TEST_ORG).getRepository("github-api");
                 for (GHHook h : r.getHooks()) {
                     h.delete();
                 }
@@ -719,7 +719,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
         GHOrganization j = gitHub.getOrganization(GITHUB_API_TEST_ORG);
         GHTeam t = j.getTeams().get("Core Developers");
 
-        assertNotNull(j.getRepository("jenkins"));
+        assertThat(j.getRepository("jenkins"), notNullValue());
 
         // t.add(labs.getRepository("xyz"));
     }
@@ -736,18 +736,18 @@ public class AppTest extends AbstractGitHubWireMockTest {
         List<GHCommitStatus> lst = r.listCommitStatuses("ecbfdd7315ef2cf04b2be7f11a072ce0bd00c396").toList();
         state = lst.get(0);
         // System.out.println(state);
-        assertEquals("testing!", state.getDescription());
-        assertEquals("http://kohsuke.org/", state.getTargetUrl());
+        assertThat(state.getDescription(), equalTo("testing!"));
+        assertThat(state.getTargetUrl(), equalTo("http://kohsuke.org/"));
     }
 
     @Test
     public void testCommitShortInfo() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f23");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Kohsuke Kawaguchi");
-        assertEquals(commit.getCommitShortInfo().getMessage(), "doc");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.UNSIGNED);
+        assertThat("Kohsuke Kawaguchi", equalTo(commit.getCommitShortInfo().getAuthor().getName()));
+        assertThat("doc", equalTo(commit.getCommitShortInfo().getMessage()));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(GHVerification.Reason.UNSIGNED, equalTo(commit.getCommitShortInfo().getVerification().getReason()));
         assertThat(commit.getCommitShortInfo().getAuthor().getDate().toInstant().getEpochSecond(),
                 equalTo(1271650361L));
         assertThat(commit.getCommitShortInfo().getCommitter().getDate().toInstant().getEpochSecond(),
@@ -760,7 +760,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
         GHRepository r = gitHub.getUser("kohsuke").getRepository("github-api");
         GHPullRequest p = r.getPullRequest(17);
         GHUser u = p.getUser();
-        assertNotNull(u.getName());
+        assertThat(u.getName(), notNullValue());
     }
 
     @Test
@@ -770,11 +770,11 @@ public class AppTest extends AbstractGitHubWireMockTest {
         GHUser kohsuke = gitHub.getUser("kohsuke");
         GHUser b = gitHub.getUser("b");
 
-        assertTrue(j.hasMember(kohsuke));
-        assertFalse(j.hasMember(b));
+        assertThat(j.hasMember(kohsuke), is(true));
+        assertThat(j.hasMember(b), is(false));
 
-        assertTrue(j.hasPublicMember(kohsuke));
-        assertFalse(j.hasPublicMember(b));
+        assertThat(j.hasPublicMember(kohsuke), is(true));
+        assertThat(j.hasPublicMember(b), is(false));
     }
 
     @Ignore("Needs mocking check")
@@ -797,7 +797,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
                 if (tagName.equals(tag.getName())) {
                     String ash = tag.getCommit().getSHA1();
                     GHRef ref = r.createRef("refs/heads/" + releaseName, ash);
-                    assertEquals(ref.getRef(), "refs/heads/" + releaseName);
+                    assertThat(("refs/heads/" + releaseName), equalTo(ref.getRef()));
 
                     for (Map.Entry<String, GHBranch> entry : r.getBranches().entrySet()) {
                         // System.out.println(entry.getKey() + "/" + entry.getValue());
@@ -816,9 +816,9 @@ public class AppTest extends AbstractGitHubWireMockTest {
 
     @Test
     public void testRef() throws IOException {
-        GHRef masterRef = gitHub.getRepository("jenkinsci/jenkins").getRef("heads/master");
-        assertEquals(mockGitHub.apiServer().baseUrl() + "/repos/jenkinsci/jenkins/git/refs/heads/master",
-                masterRef.getUrl().toString());
+        GHRef mainRef = gitHub.getRepository("jenkinsci/jenkins").getRef("heads/main");
+        assertThat(mainRef.getUrl().toString(),
+                equalTo(mockGitHub.apiServer().baseUrl() + "/repos/jenkinsci/jenkins/git/refs/heads/main"));
     }
 
     @Test
@@ -841,14 +841,14 @@ public class AppTest extends AbstractGitHubWireMockTest {
         final GHDeployKey newDeployKey = myRepository.addDeployKey("test",
                 "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDUt0RAycC5cS42JKh6SecfFZBR1RrF+2hYMctz4mk74/arBE+wFb7fnSHGzdGKX2h5CFOWODifRCJVhB7hlVxodxe+QkQQYAEL/x1WVCJnGgTGQGOrhOMj95V3UE5pQKhsKD608C+u5tSofcWXLToP1/wZ7U4/AHjqYi08OLsWToHCax55TZkvdt2jo0hbIoYU+XI9Q8Uv4ONDN1oabiOdgeKi8+crvHAuvNleiBhWVBzFh8KdfzaH5uNdw7ihhFjEd1vzqACsjCINCjdMfzl6jD9ExuWuE92nZJnucls2cEoNC6k2aPmrZDg9hA32FXVpyseY+bDUWFU6LO2LG6PB kohsuke@atlas");
         try {
-            assertNotNull(newDeployKey.getId());
+            assertThat(newDeployKey.getId(), notNullValue());
 
             GHDeployKey k = Iterables.find(myRepository.getDeployKeys(), new Predicate<GHDeployKey>() {
                 public boolean apply(GHDeployKey deployKey) {
                     return newDeployKey.getId() == deployKey.getId();
                 }
             });
-            assertNotNull(k);
+            assertThat(k, notNullValue());
         } finally {
             newDeployKey.delete();
         }
@@ -858,10 +858,10 @@ public class AppTest extends AbstractGitHubWireMockTest {
     @Test
     public void testCommitStatusContext() throws IOException {
         GHRepository myRepository = getTestRepository();
-        GHRef masterRef = myRepository.getRef("heads/master");
-        GHCommitStatus commitStatus = myRepository.createCommitStatus(masterRef.getObject()
+        GHRef mainRef = myRepository.getRef("heads/main");
+        GHCommitStatus commitStatus = myRepository.createCommitStatus(mainRef.getObject()
                 .getSha(), GHCommitState.SUCCESS, "http://www.example.com", "test", "test/context");
-        assertEquals("test/context", commitStatus.getContext());
+        assertThat(commitStatus.getContext(), equalTo("test/context"));
 
     }
 
@@ -873,7 +873,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
             // System.out.println(u.getLogin());
             all.add(u);
         }
-        assertFalse(all.isEmpty());
+        assertThat(all, is(not(empty())));
     }
 
     @Test
@@ -884,10 +884,10 @@ public class AppTest extends AbstractGitHubWireMockTest {
                 .author("kohsuke")
                 .sort(GHCommitSearchBuilder.Sort.COMMITTER_DATE)
                 .list();
-        assertTrue(r.getTotalCount() > 0);
+        assertThat(r.getTotalCount(), greaterThan(0));
 
         GHCommit firstCommit = r.iterator().next();
-        assertTrue(firstCommit.getFiles().size() > 0);
+        assertThat(firstCommit.getFiles(), is(not(empty())));
     }
 
     @Test
@@ -897,7 +897,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
                 .isOpen()
                 .sort(GHIssueSearchBuilder.Sort.UPDATED)
                 .list();
-        assertTrue(r.getTotalCount() > 0);
+        assertThat(r.getTotalCount(), greaterThan(0));
         for (GHIssue issue : r) {
             assertThat(issue.getTitle(), notNullValue());
             PagedIterable<GHIssueComment> comments = issue.listComments();
@@ -910,29 +910,29 @@ public class AppTest extends AbstractGitHubWireMockTest {
     @Test // issue #99
     public void testReadme() throws IOException {
         GHContent readme = gitHub.getRepository("hub4j-test-org/test-readme").getReadme();
-        assertEquals(readme.getName(), "README.md");
-        assertEquals(readme.getContent(), "This is a markdown readme.\n");
+        assertThat("README.md", equalTo(readme.getName()));
+        assertThat("This is a markdown readme.\n", equalTo(readme.getContent()));
     }
 
     @Ignore("Needs mocking check")
     @Test
     public void testTrees() throws IOException {
-        GHTree masterTree = gitHub.getRepository("hub4j/github-api").getTree("master");
+        GHTree mainTree = gitHub.getRepository("hub4j/github-api").getTree("main");
         boolean foundReadme = false;
-        for (GHTreeEntry e : masterTree.getTree()) {
+        for (GHTreeEntry e : mainTree.getTree()) {
             if ("readme".equalsIgnoreCase(e.getPath().replaceAll("\\.md", ""))) {
                 foundReadme = true;
                 break;
             }
         }
-        assertTrue(foundReadme);
+        assertThat(foundReadme, is(true));
     }
 
     @Test
     public void testTreesRecursive() throws IOException {
-        GHTree masterTree = gitHub.getRepository("hub4j/github-api").getTreeRecursive("master", 1);
+        GHTree mainTree = gitHub.getRepository("hub4j/github-api").getTreeRecursive("main", 1);
         boolean foundThisFile = false;
-        for (GHTreeEntry e : masterTree.getTree()) {
+        for (GHTreeEntry e : mainTree.getTree()) {
             if (e.getPath().endsWith(AppTest.class.getSimpleName() + ".java")) {
                 foundThisFile = true;
                 assertThat(e.getPath(), equalTo("src/test/java/org/kohsuke/github/AppTest.java"));
@@ -948,7 +948,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
             }
 
         }
-        assertTrue(foundThisFile);
+        assertThat(foundThisFile, is(true));
     }
 
     @Test
@@ -961,14 +961,14 @@ public class AppTest extends AbstractGitHubWireMockTest {
         for (GHLabel l : lst) {
             assertThat(l.getUrl(), containsString(l.getName().replace(" ", "%20")));
         }
-        assertTrue(lst.size() > 5);
+        assertThat(lst.size(), greaterThan(5));
         GHLabel e = r.getLabel("enhancement");
-        assertEquals("enhancement", e.getName());
-        assertNotNull(e.getUrl());
-        assertEquals(177339106, e.getId());
-        assertEquals("MDU6TGFiZWwxNzczMzkxMDY=", e.getNodeId());
-        assertTrue(e.isDefault());
-        assertTrue(Pattern.matches("[0-9a-fA-F]{6}", e.getColor()));
+        assertThat(e.getName(), equalTo("enhancement"));
+        assertThat(e.getUrl(), notNullValue());
+        assertThat(e.getId(), equalTo(177339106L));
+        assertThat(e.getNodeId(), equalTo("MDU6TGFiZWwxNzczMzkxMDY="));
+        assertThat(e.isDefault(), is(true));
+        assertThat(e.getColor(), matchesPattern("[0-9a-fA-F]{6}"));
 
         GHLabel t = null;
         GHLabel t2 = null;
@@ -979,17 +979,17 @@ public class AppTest extends AbstractGitHubWireMockTest {
             assertThat(t, not(sameInstance(t2)));
             assertThat(t, equalTo(t2));
 
-            assertFalse(t2.isDefault());
+            assertThat(t2.isDefault(), is(false));
 
-            assertEquals(t.getId(), t2.getId());
-            assertEquals(t.getNodeId(), t2.getNodeId());
-            assertEquals(t.getName(), t2.getName());
-            assertEquals(t.getColor(), "123456");
-            assertEquals(t.getColor(), t2.getColor());
-            assertEquals(t.getDescription(), "");
-            assertEquals(t.getDescription(), t2.getDescription());
-            assertEquals(t.getUrl(), t2.getUrl());
-            assertEquals(t.isDefault(), t2.isDefault());
+            assertThat(t2.getId(), equalTo(t.getId()));
+            assertThat(t2.getNodeId(), equalTo(t.getNodeId()));
+            assertThat(t2.getName(), equalTo(t.getName()));
+            assertThat("123456", equalTo(t.getColor()));
+            assertThat(t2.getColor(), equalTo(t.getColor()));
+            assertThat("", equalTo(t.getDescription()));
+            assertThat(t2.getDescription(), equalTo(t.getDescription()));
+            assertThat(t2.getUrl(), equalTo(t.getUrl()));
+            assertThat(t2.isDefault(), equalTo(t.isDefault()));
 
             // update works on multiple changes in one call
             t3 = t.update().color("000000").description("It is dark!").done();
@@ -1001,10 +1001,10 @@ public class AppTest extends AbstractGitHubWireMockTest {
             assertThat(t, not(sameInstance(t3)));
             assertThat(t, not(equalTo(t3)));
 
-            assertEquals(t.getColor(), "123456");
-            assertEquals(t.getDescription(), "");
-            assertEquals(t3.getColor(), "000000");
-            assertEquals(t3.getDescription(), "It is dark!");
+            assertThat("123456", equalTo(t.getColor()));
+            assertThat("", equalTo(t.getDescription()));
+            assertThat("000000", equalTo(t3.getColor()));
+            assertThat("It is dark!", equalTo(t3.getDescription()));
 
             // Test deprecated methods
             t.setDescription("Deprecated");
@@ -1012,13 +1012,13 @@ public class AppTest extends AbstractGitHubWireMockTest {
 
             // By using the old instance t when calling setDescription it also sets color to the old value
             // this is a bad behavior, but it is expected
-            assertEquals(t.getColor(), "123456");
-            assertEquals(t.getDescription(), "Deprecated");
+            assertThat("123456", equalTo(t.getColor()));
+            assertThat("Deprecated", equalTo(t.getDescription()));
 
             t.setColor("000000");
             t = r.getLabel("test");
-            assertEquals(t.getColor(), "000000");
-            assertEquals(t.getDescription(), "Deprecated");
+            assertThat("000000", equalTo(t.getColor()));
+            assertThat("Deprecated", equalTo(t.getDescription()));
 
             // set() makes a single change
             t3 = t.set().description("this is also a test");
@@ -1027,8 +1027,8 @@ public class AppTest extends AbstractGitHubWireMockTest {
             assertThat(t, not(sameInstance(t3)));
             assertThat(t, not(equalTo(t3)));
 
-            assertEquals(t3.getColor(), "000000");
-            assertEquals(t3.getDescription(), "this is also a test");
+            assertThat("000000", equalTo(t3.getColor()));
+            assertThat("this is also a test", equalTo(t3.getDescription()));
 
             t.delete();
             try {
@@ -1041,12 +1041,12 @@ public class AppTest extends AbstractGitHubWireMockTest {
             t = r.createLabel("test2", "123457", "this is a different test");
             t2 = r.getLabel("test2");
 
-            assertEquals(t.getName(), t2.getName());
-            assertEquals(t.getColor(), "123457");
-            assertEquals(t.getColor(), t2.getColor());
-            assertEquals(t.getDescription(), "this is a different test");
-            assertEquals(t.getDescription(), t2.getDescription());
-            assertEquals(t.getUrl(), t2.getUrl());
+            assertThat(t2.getName(), equalTo(t.getName()));
+            assertThat("123457", equalTo(t.getColor()));
+            assertThat(t2.getColor(), equalTo(t.getColor()));
+            assertThat("this is a different test", equalTo(t.getDescription()));
+            assertThat(t2.getDescription(), equalTo(t.getDescription()));
+            assertThat(t2.getUrl(), equalTo(t.getUrl()));
             t.delete();
 
             // Allow null description
@@ -1063,7 +1063,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
     void cleanupLabel(String name) {
         if (mockGitHub.isUseProxy()) {
             try {
-                GHLabel t = getGitHubBeforeAfter().getRepository("hub4j-test-org/test-labels").getLabel(name);
+                GHLabel t = getNonRecordingGitHub().getRepository("hub4j-test-org/test-labels").getLabel(name);
                 t.delete();
             } catch (IOException e) {
 
@@ -1078,13 +1078,13 @@ public class AppTest extends AbstractGitHubWireMockTest {
         for (GHUser u : mr.listSubscribers()) {
             bitwiseman |= u.getLogin().equals("bitwiseman");
         }
-        assertTrue(bitwiseman);
+        assertThat(bitwiseman, is(true));
 
         boolean githubApiFound = false;
         for (GHRepository r : gitHub.getUser("bitwiseman").listRepositories()) {
             githubApiFound |= r.equals(mr);
         }
-        assertTrue(githubApiFound);
+        assertThat(githubApiFound, is(true));
     }
 
     @Test
@@ -1115,7 +1115,7 @@ public class AppTest extends AbstractGitHubWireMockTest {
             assertThat(t.getCreatedAt(), nullValue());
 
         }
-        assertTrue(found);
+        assertThat(found, is(true));
         gitHub.listNotifications().markAsRead();
     }
 
@@ -1195,8 +1195,8 @@ public class AppTest extends AbstractGitHubWireMockTest {
         GHMyself me = gitHub.getMyself();
         for (GHMembership m : me.listOrgMemberships()) {
             assertThat(m.getUser(), is((GHUser) me));
-            assertNotNull(m.getState());
-            assertNotNull(m.getRole());
+            assertThat(m.getState(), notNullValue());
+            assertThat(m.getRole(), notNullValue());
         }
     }
 
@@ -1207,15 +1207,15 @@ public class AppTest extends AbstractGitHubWireMockTest {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         String sha1 = "a12243f2fc5b8c2ba47dd677d0b0c7583539584d";
 
-        assertBlobContent(r.readBlob(sha1));
+        verifyBlobContent(r.readBlob(sha1));
 
         GHBlob blob = r.getBlob(sha1);
-        assertBlobContent(blob.read());
+        verifyBlobContent(blob.read());
         assertThat(blob.getSha(), is("a12243f2fc5b8c2ba47dd677d0b0c7583539584d"));
         assertThat(blob.getSize(), is(1104L));
     }
 
-    private void assertBlobContent(InputStream is) throws Exception {
+    private void verifyBlobContent(InputStream is) throws Exception {
         String content = new String(IOUtils.toByteArray(is), StandardCharsets.UTF_8);
         assertThat(content, containsString("Copyright (c) 2011- Kohsuke Kawaguchi and other contributors"));
         assertThat(content, containsString("FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR"));

src/test/java/org/kohsuke/github/ArchTests.java

@@ -9,8 +9,7 @@ import com.tngtech.archunit.lang.ArchRule;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-import static com.tngtech.archunit.lang.conditions.ArchConditions.beAnnotatedWith;
-import static com.tngtech.archunit.lang.conditions.ArchConditions.not;
+import static com.tngtech.archunit.lang.conditions.ArchConditions.*;
 import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
 import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.fields;
 import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods;
@@ -23,6 +22,11 @@ public class ArchTests {
             .withImportOption(new ImportOption.DoNotIncludeJars())
             .importPackages("org.kohsuke.github");
 
+    private static final JavaClasses tesetClassFiles = new ClassFileImporter()
+            .withImportOption(new ImportOption.OnlyIncludeTests())
+            .withImportOption(new ImportOption.DoNotIncludeJars())
+            .importPackages("org.kohsuke.github");
+
     private static final DescribedPredicate<JavaAnnotation<?>> previewAnnotationWithNoMediaType = new DescribedPredicate<JavaAnnotation<?>>(
             "preview has no required media types defined") {
 
@@ -105,4 +109,18 @@ public class ArchTests {
         methodRule.check(classFiles);
 
     }
+
+    @Test
+    public void testRequireUseOfAssertThat() {
+
+        String reason = "This project uses `assertThat(...)` instead of other assert*() methods.";
+
+        ArchRule onlyAssertThatRule = methods().that()
+                .haveNameContaining("assert")
+                .should()
+                .haveName("assertThat")
+                .because(reason);
+
+        onlyAssertThatRule.check(tesetClassFiles);
+    }
 }

src/test/java/org/kohsuke/github/CommitTest.java

@@ -9,7 +9,7 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
-import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.*;
 
 /**
  * @author Kohsuke Kawaguchi
@@ -18,7 +18,7 @@ public class CommitTest extends AbstractGitHubWireMockTest {
     @Test // issue 152
     public void lastStatus() throws IOException {
         GHTag t = gitHub.getRepository("stapler/stapler").listTags().iterator().next();
-        assertNotNull(t.getCommit().getLastStatus());
+        assertThat(t.getCommit().getLastStatus(), notNullValue());
     }
 
     @Test // issue 230
@@ -27,7 +27,7 @@ public class CommitTest extends AbstractGitHubWireMockTest {
         PagedIterable<GHCommit> commits = repo.queryCommits().path("pom.xml").list();
         for (GHCommit commit : Iterables.limit(commits, 10)) {
             GHCommit expected = repo.getCommit(commit.getSHA1());
-            assertEquals(expected.getFiles().size(), commit.getFiles().size());
+            assertThat(commit.getFiles().size(), equalTo(expected.getFiles().size()));
         }
     }
 
@@ -83,7 +83,7 @@ public class CommitTest extends AbstractGitHubWireMockTest {
                 .list()
                 .toList();
 
-        assertThat(commits.size(), equalTo(0));
+        assertThat(commits, is(empty()));
 
         commits = gitHub.getUser("jenkinsci")
                 .getRepository("jenkins")
@@ -129,7 +129,7 @@ public class CommitTest extends AbstractGitHubWireMockTest {
 
         List<GHPullRequest> listedPrs = commit.listPullRequests().toList();
 
-        assertEquals(listedPrs.size(), 1);
+        assertThat(1, equalTo(listedPrs.size()));
 
         assertThat("Pull request " + prNumber + " not found by searching from commit.",
                 listedPrs.stream().findFirst().filter(it -> it.getNumber() == prNumber).isPresent());
@@ -144,7 +144,7 @@ public class CommitTest extends AbstractGitHubWireMockTest {
 
         List<GHPullRequest> listedPrs = commit.listPullRequests().toList();
 
-        assertEquals(listedPrs.size(), 2);
+        assertThat(2, equalTo(listedPrs.size()));
 
         listedPrs.stream()
                 .forEach(pr -> assertThat("PR#" + pr.getNumber() + " not expected to be matched.",
@@ -157,12 +157,12 @@ public class CommitTest extends AbstractGitHubWireMockTest {
 
         GHCommit commit = repo.getCommit("ab92e13c0fc844fd51a379a48a3ad0b18231215c");
 
-        assertThat("Commit which was supposed to be HEAD in the \"master\" branch was not found.",
+        assertThat("Commit which was supposed to be HEAD in the \"main\" branch was not found.",
                 commit.listBranchesWhereHead()
                         .toList()
                         .stream()
                         .findFirst()
-                        .filter(it -> it.getName().equals("master"))
+                        .filter(it -> it.getName().equals("main"))
                         .isPresent());
     }
 
@@ -172,9 +172,9 @@ public class CommitTest extends AbstractGitHubWireMockTest {
 
         GHCommit commit = repo.getCommit("ab92e13c0fc844fd51a379a48a3ad0b18231215c");
 
-        assertEquals("Commit which was supposed to be HEAD in 2 branches was not found as such.",
-                2,
-                commit.listBranchesWhereHead().toList().size());
+        assertThat("Commit which was supposed to be HEAD in 2 branches was not found as such.",
+                commit.listBranchesWhereHead().toList().size(),
+                equalTo(2));
     }
 
     @Test
@@ -193,14 +193,14 @@ public class CommitTest extends AbstractGitHubWireMockTest {
         PagedIterable<GHCommit> commits = repo.queryCommits().path("pom.xml").list();
         for (GHCommit commit : Iterables.limit(commits, 10)) {
             GHCommit expected = repo.getCommit(commit.getSHA1());
-            assertEquals(expected.getCommitShortInfo().getVerification().isVerified(),
-                    commit.getCommitShortInfo().getVerification().isVerified());
-            assertEquals(expected.getCommitShortInfo().getVerification().getReason(),
-                    commit.getCommitShortInfo().getVerification().getReason());
-            assertEquals(expected.getCommitShortInfo().getVerification().getSignature(),
-                    commit.getCommitShortInfo().getVerification().getSignature());
-            assertEquals(expected.getCommitShortInfo().getVerification().getPayload(),
-                    commit.getCommitShortInfo().getVerification().getPayload());
+            assertThat(commit.getCommitShortInfo().getVerification().isVerified(),
+                    equalTo(expected.getCommitShortInfo().getVerification().isVerified()));
+            assertThat(commit.getCommitShortInfo().getVerification().getReason(),
+                    equalTo(expected.getCommitShortInfo().getVerification().getReason()));
+            assertThat(commit.getCommitShortInfo().getVerification().getSignature(),
+                    equalTo(expected.getCommitShortInfo().getVerification().getSignature()));
+            assertThat(commit.getCommitShortInfo().getVerification().getPayload(),
+                    equalTo(expected.getCommitShortInfo().getVerification().getPayload()));
         }
     }
 

src/test/java/org/kohsuke/github/EnumTest.java

@@ -27,7 +27,7 @@ public class EnumTest extends AbstractGitHubWireMockTest {
 
         assertThat(GHDirection.values().length, equalTo(2));
 
-        assertThat(GHEvent.values().length, equalTo(56));
+        assertThat(GHEvent.values().length, equalTo(58));
         assertThat(GHEvent.ALL.symbol(), equalTo("*"));
         assertThat(GHEvent.PULL_REQUEST.symbol(), equalTo(GHEvent.PULL_REQUEST.toString().toLowerCase()));
 
@@ -70,6 +70,7 @@ public class EnumTest extends AbstractGitHubWireMockTest {
 
         assertThat(GHRepository.CollaboratorAffiliation.values().length, equalTo(3));
         assertThat(GHRepository.ForkSort.values().length, equalTo(3));
+        assertThat(GHRepository.Visibility.values().length, equalTo(4));
 
         assertThat(GHRepositorySearchBuilder.Sort.values().length, equalTo(3));
 

src/test/java/org/kohsuke/github/GHAppInstallationTest.java

@@ -5,6 +5,8 @@ import org.junit.Test;
 import java.io.IOException;
 import java.util.List;
 
+import static org.hamcrest.Matchers.*;
+
 public class GHAppInstallationTest extends AbstractGHAppInstallationTest {
 
     @Test
@@ -13,16 +15,16 @@ public class GHAppInstallationTest extends AbstractGHAppInstallationTest {
 
         List<GHRepository> repositories = appInstallation.listRepositories().toList();
 
-        assertEquals(2, repositories.size());
-        assertTrue(repositories.stream().anyMatch(it -> it.getName().equals("empty")));
-        assertTrue(repositories.stream().anyMatch(it -> it.getName().equals("test-readme")));
+        assertThat(repositories.size(), equalTo(2));
+        assertThat(repositories.stream().map(GHRepository::getName).toArray(),
+                arrayContainingInAnyOrder("empty", "test-readme"));
     }
 
     @Test
     public void testListRepositoriesNoPermissions() throws IOException {
         GHAppInstallation appInstallation = getAppInstallationWithTokenApp2();
 
-        assertTrue("App does not have permissions and should have 0 repositories",
+        assertThat("App does not have permissions and should have 0 repositories",
                 appInstallation.listRepositories().toList().isEmpty());
     }
 

src/test/java/org/kohsuke/github/GHAppTest.java

@@ -126,7 +126,7 @@ public class GHAppTest extends AbstractGitHubWireMockTest {
         assertThat(installationToken2.getRepositorySelection(), is(GHRepositorySelection.ALL));
         assertThat(installationToken2.getExpiresAt(), is(GitHubClient.parseDate("2019-12-19T12:27:59Z")));
 
-        assertNull(installationToken2.getRepositories());;
+        assertThat(installationToken2.getRepositories(), nullValue());;
     }
 
     private void testAppInstallation(GHAppInstallation appInstallation) throws IOException {
@@ -154,7 +154,7 @@ public class GHAppTest extends AbstractGitHubWireMockTest {
         assertThat(appInstallation.getEvents(), containsInAnyOrder(events.toArray(new GHEvent[0])));
         assertThat(appInstallation.getCreatedAt(), is(GitHubClient.parseDate("2019-07-04T01:19:36.000Z")));
         assertThat(appInstallation.getUpdatedAt(), is(GitHubClient.parseDate("2019-07-30T22:48:09.000Z")));
-        assertNull(appInstallation.getSingleFileName());
+        assertThat(appInstallation.getSingleFileName(), nullValue());
     }
 
 }

src/test/java/org/kohsuke/github/GHBranchProtectionTest.java

@@ -6,10 +6,10 @@ import org.kohsuke.github.GHBranchProtection.EnforceAdmins;
 import org.kohsuke.github.GHBranchProtection.RequiredReviews;
 import org.kohsuke.github.GHBranchProtection.RequiredStatusChecks;
 
-import static org.hamcrest.CoreMatchers.*;
+import static org.hamcrest.Matchers.*;
 
 public class GHBranchProtectionTest extends AbstractGitHubWireMockTest {
-    private static final String BRANCH = "master";
+    private static final String BRANCH = "main";
     private static final String BRANCH_REF = "heads/" + BRANCH;
 
     private GHBranch branch;
@@ -43,33 +43,33 @@ public class GHBranchProtectionTest extends AbstractGitHubWireMockTest {
 
     private void verifyBranchProtection(GHBranchProtection protection) {
         RequiredStatusChecks statusChecks = protection.getRequiredStatusChecks();
-        assertNotNull(statusChecks);
-        assertTrue(statusChecks.isRequiresBranchUpToDate());
-        assertTrue(statusChecks.getContexts().contains("test-status-check"));
+        assertThat(statusChecks, notNullValue());
+        assertThat(statusChecks.isRequiresBranchUpToDate(), is(true));
+        assertThat(statusChecks.getContexts(), contains("test-status-check"));
 
         RequiredReviews requiredReviews = protection.getRequiredReviews();
-        assertNotNull(requiredReviews);
-        assertTrue(requiredReviews.isDismissStaleReviews());
-        assertTrue(requiredReviews.isRequireCodeOwnerReviews());
-        assertEquals(2, requiredReviews.getRequiredReviewers());
+        assertThat(requiredReviews, notNullValue());
+        assertThat(requiredReviews.isDismissStaleReviews(), is(true));
+        assertThat(requiredReviews.isRequireCodeOwnerReviews(), is(true));
+        assertThat(requiredReviews.getRequiredReviewers(), equalTo(2));
 
         EnforceAdmins enforceAdmins = protection.getEnforceAdmins();
-        assertNotNull(enforceAdmins);
-        assertTrue(enforceAdmins.isEnabled());
+        assertThat(enforceAdmins, notNullValue());
+        assertThat(enforceAdmins.isEnabled(), is(true));
     }
 
     @Test
     public void testEnableProtectionOnly() throws Exception {
         branch.enableProtection().enable();
-        assertTrue(repo.getBranch(BRANCH).isProtected());
+        assertThat(repo.getBranch(BRANCH).isProtected(), is(true));
     }
 
     @Test
     public void testDisableProtectionOnly() throws Exception {
         GHBranchProtection protection = branch.enableProtection().enable();
-        assertTrue(repo.getBranch(BRANCH).isProtected());
+        assertThat(repo.getBranch(BRANCH).isProtected(), is(true));
         branch.disableProtection();
-        assertFalse(repo.getBranch(BRANCH).isProtected());
+        assertThat(repo.getBranch(BRANCH).isProtected(), is(false));
     }
 
     @Test
@@ -77,18 +77,18 @@ public class GHBranchProtectionTest extends AbstractGitHubWireMockTest {
         GHBranchProtection protection = branch.enableProtection().requireReviews().enable();
 
         RequiredReviews requiredReviews = protection.getRequiredReviews();
-        assertNotNull(protection.getRequiredReviews());
-        assertFalse(requiredReviews.isDismissStaleReviews());
-        assertFalse(requiredReviews.isRequireCodeOwnerReviews());
+        assertThat(protection.getRequiredReviews(), notNullValue());
+        assertThat(requiredReviews.isDismissStaleReviews(), is(false));
+        assertThat(requiredReviews.isRequireCodeOwnerReviews(), is(false));
         assertThat(protection.getRequiredReviews().getRequiredReviewers(), equalTo(1));
 
         // Get goes through a different code path. Make sure it also gets the correct data.
         protection = branch.getProtection();
         requiredReviews = protection.getRequiredReviews();
 
-        assertNotNull(protection.getRequiredReviews());
-        assertFalse(requiredReviews.isDismissStaleReviews());
-        assertFalse(requiredReviews.isRequireCodeOwnerReviews());
+        assertThat(protection.getRequiredReviews(), notNullValue());
+        assertThat(requiredReviews.isDismissStaleReviews(), is(false));
+        assertThat(requiredReviews.isRequireCodeOwnerReviews(), is(false));
         assertThat(protection.getRequiredReviews().getRequiredReviewers(), equalTo(1));
     }
 
@@ -96,20 +96,21 @@ public class GHBranchProtectionTest extends AbstractGitHubWireMockTest {
     public void testSignedCommits() throws Exception {
         GHBranchProtection protection = branch.enableProtection().enable();
 
-        assertFalse(protection.getRequiredSignatures());
+        assertThat(protection.getRequiredSignatures(), is(false));
 
         protection.enabledSignedCommits();
-        assertTrue(protection.getRequiredSignatures());
+        assertThat(protection.getRequiredSignatures(), is(true));
 
         protection.disableSignedCommits();
-        assertFalse(protection.getRequiredSignatures());
+        assertThat(protection.getRequiredSignatures(), is(false));
     }
 
     @Test
     public void testGetProtection() throws Exception {
         GHBranchProtection protection = branch.enableProtection().enable();
         GHBranchProtection protectionTest = repo.getBranch(BRANCH).getProtection();
-        assertTrue(protectionTest instanceof GHBranchProtection);
-        assertTrue(repo.getBranch(BRANCH).isProtected());
+        Boolean condition = protectionTest instanceof GHBranchProtection;
+        assertThat(protectionTest, instanceOf(GHBranchProtection.class));
+        assertThat(repo.getBranch(BRANCH).isProtected(), is(true));
     }
 }

src/test/java/org/kohsuke/github/GHBranchTest.java

@@ -16,9 +16,9 @@ public class GHBranchTest extends AbstractGitHubWireMockTest {
     public void testMergeBranch() throws Exception {
         repository = getTempRepository();
 
-        String masterHead = repository.getRef("heads/master").getObject().getSha();
-        createRefAndPostContent(BRANCH_1, masterHead);
-        createRefAndPostContent(BRANCH_2, masterHead);
+        String mainHead = repository.getRef("heads/main").getObject().getSha();
+        createRefAndPostContent(BRANCH_1, mainHead);
+        createRefAndPostContent(BRANCH_2, mainHead);
 
         GHBranch otherBranch = repository.getBranch(BRANCH_2);
         String commitMessage = "merging " + BRANCH_2;
@@ -28,13 +28,13 @@ public class GHBranchTest extends AbstractGitHubWireMockTest {
 
         // Merging commit sha should work
         commitMessage = "merging from " + mergeCommit.getSHA1();
-        GHBranch master = repository.getBranch("master");
-        mergeCommit = master.merge(mergeCommit.getSHA1(), commitMessage);
+        GHBranch main = repository.getBranch("main");
+        mergeCommit = main.merge(mergeCommit.getSHA1(), commitMessage);
 
         assertThat(mergeCommit, notNullValue());
         assertThat(mergeCommit.getCommitShortInfo().getMessage(), equalTo(commitMessage));
 
-        mergeCommit = master.merge(mergeCommit.getSHA1(), commitMessage);
+        mergeCommit = main.merge(mergeCommit.getSHA1(), commitMessage);
         // Should be null since all changes already merged
         assertThat(mergeCommit, nullValue());
     }

src/test/java/org/kohsuke/github/GHCheckRunBuilderTest.java

@@ -30,8 +30,7 @@ import org.kohsuke.github.GHCheckRun.Status;
 import java.io.IOException;
 import java.util.Date;
 
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.*;
 
 @SuppressWarnings("deprecation") // preview
 public class GHCheckRunBuilderTest extends AbstractGHAppInstallationTest {
@@ -60,10 +59,10 @@ public class GHCheckRunBuilderTest extends AbstractGHAppInstallationTest {
                                         .withCaption("Princess Unikitty")))
                 .add(new GHCheckRunBuilder.Action("Help", "what I need help with", "doit"))
                 .create();
-        assertEquals(Status.COMPLETED, checkRun.getStatus());
-        assertEquals(1, checkRun.getOutput().getAnnotationsCount());
-        assertEquals(1424883286, checkRun.getId());
-        assertEquals("Hello Text!", checkRun.getOutput().getText());
+        assertThat(checkRun.getStatus(), equalTo(Status.COMPLETED));
+        assertThat(checkRun.getOutput().getAnnotationsCount(), equalTo(1));
+        assertThat(checkRun.getId(), equalTo(1424883286L));
+        assertThat(checkRun.getOutput().getText(), equalTo("Hello Text!"));
     }
 
     @Test
@@ -80,12 +79,12 @@ public class GHCheckRunBuilderTest extends AbstractGHAppInstallationTest {
                 .withConclusion(GHCheckRun.Conclusion.SUCCESS)
                 .add(output)
                 .create();
-        assertEquals(Status.COMPLETED, checkRun.getStatus());
-        assertEquals("Big Run", checkRun.getOutput().getTitle());
-        assertEquals("Lots of stuff here »", checkRun.getOutput().getSummary());
-        assertEquals(101, checkRun.getOutput().getAnnotationsCount());
-        assertEquals("Hello Text!", checkRun.getOutput().getText());
-        assertEquals(1424883599, checkRun.getId());
+        assertThat(checkRun.getStatus(), equalTo(Status.COMPLETED));
+        assertThat(checkRun.getOutput().getTitle(), equalTo("Big Run"));
+        assertThat(checkRun.getOutput().getSummary(), equalTo("Lots of stuff here »"));
+        assertThat(checkRun.getOutput().getAnnotationsCount(), equalTo(101));
+        assertThat(checkRun.getOutput().getText(), equalTo("Hello Text!"));
+        assertThat(checkRun.getId(), equalTo(1424883599L));
     }
 
     @Test
@@ -95,9 +94,9 @@ public class GHCheckRunBuilderTest extends AbstractGHAppInstallationTest {
                 .withConclusion(GHCheckRun.Conclusion.NEUTRAL)
                 .add(new GHCheckRunBuilder.Output("Quick note", "nothing more to see here"))
                 .create();
-        assertEquals(Status.COMPLETED, checkRun.getStatus());
-        assertEquals(0, checkRun.getOutput().getAnnotationsCount());
-        assertEquals(1424883957, checkRun.getId());
+        assertThat(checkRun.getStatus(), equalTo(Status.COMPLETED));
+        assertThat(checkRun.getOutput().getAnnotationsCount(), equalTo(0));
+        assertThat(checkRun.getId(), equalTo(1424883957L));
     }
 
     @Test
@@ -106,9 +105,9 @@ public class GHCheckRunBuilderTest extends AbstractGHAppInstallationTest {
                 .createCheckRun("outstanding", "89a9ae301e35e667756034fdc933b1fc94f63fc1")
                 .withStatus(GHCheckRun.Status.IN_PROGRESS)
                 .create();
-        assertEquals(Status.IN_PROGRESS, checkRun.getStatus());
-        assertNull(checkRun.getConclusion());
-        assertEquals(1424883451, checkRun.getId());
+        assertThat(checkRun.getStatus(), equalTo(Status.IN_PROGRESS));
+        assertThat(checkRun.getConclusion(), nullValue());
+        assertThat(checkRun.getId(), equalTo(1424883451L));
     }
 
     @Test
@@ -120,7 +119,7 @@ public class GHCheckRunBuilderTest extends AbstractGHAppInstallationTest {
                     .create();
             fail("should have been rejected");
         } catch (HttpException x) {
-            assertEquals(422, x.getResponseCode());
+            assertThat(x.getResponseCode(), equalTo(422));
             assertThat(x.getMessage(), containsString("\\\"conclusion\\\" wasn't supplied"));
             assertThat(x.getUrl(), containsString("/repos/hub4j-test-org/test-checks/check-runs"));
             assertThat(x.getResponseMessage(), equalTo("422 Unprocessable Entity"));
@@ -144,9 +143,9 @@ public class GHCheckRunBuilderTest extends AbstractGHAppInstallationTest {
                 .withConclusion(GHCheckRun.Conclusion.SUCCESS)
                 .withCompletedAt(new Date(999_999_999))
                 .create();
-        assertEquals(updated.getStartedAt(), new Date(999_999_000));
-        assertEquals(updated.getName(), "foo");
-        assertEquals(1, checkRun.getOutput().getAnnotationsCount());
+        assertThat(new Date(999_999_000), equalTo(updated.getStartedAt()));
+        assertThat("foo", equalTo(updated.getName()));
+        assertThat(checkRun.getOutput().getAnnotationsCount(), equalTo(1));
     }
 
 }

src/test/java/org/kohsuke/github/GHContentIntegrationTest.java

@@ -11,8 +11,7 @@ import java.io.InputStreamReader;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 
-import static org.hamcrest.CoreMatchers.*;
-import static org.hamcrest.Matchers.hasProperty;
+import static org.hamcrest.Matchers.*;
 
 /**
  * Integration test for {@link GHContent}.
@@ -29,7 +28,7 @@ public class GHContentIntegrationTest extends AbstractGitHubWireMockTest {
     @After
     public void cleanup() throws Exception {
         if (mockGitHub.isUseProxy()) {
-            repo = getGitHubBeforeAfter().getRepository("hub4j-test-org/GHContentIntegrationTest");
+            repo = getNonRecordingGitHub().getRepository("hub4j-test-org/GHContentIntegrationTest");
             try {
                 GHContent content = repo.getFileContent(createdFilename);
                 if (content != null) {
@@ -58,31 +57,31 @@ public class GHContentIntegrationTest extends AbstractGitHubWireMockTest {
         repo = gitHub.getRepository("hub4j-test-org/GHContentIntegrationTest");
         GHContent content = repo.getFileContent("ghcontent-ro/a-file-with-content");
 
-        assertTrue(content.isFile());
-        assertEquals("thanks for reading me\n", content.getContent());
+        assertThat(content.isFile(), is(true));
+        assertThat(content.getContent(), equalTo("thanks for reading me\n"));
     }
 
     @Test
     public void testGetEmptyFileContent() throws Exception {
         GHContent content = repo.getFileContent("ghcontent-ro/an-empty-file");
 
-        assertTrue(content.isFile());
-        assertEquals("", content.getContent());
+        assertThat(content.isFile(), is(true));
+        assertThat(content.getContent(), is(emptyString()));
     }
 
     @Test
     public void testGetDirectoryContent() throws Exception {
         List<GHContent> entries = repo.getDirectoryContent("ghcontent-ro/a-dir-with-3-entries");
 
-        assertTrue(entries.size() == 3);
+        assertThat(entries.size(), equalTo(3));
     }
 
     @Test
     public void testGetDirectoryContentTrailingSlash() throws Exception {
-        // Used to truncate the ?ref=master, see gh-224 https://github.com/kohsuke/github-api/pull/224
-        List<GHContent> entries = repo.getDirectoryContent("ghcontent-ro/a-dir-with-3-entries/", "master");
+        // Used to truncate the ?ref=main, see gh-224 https://github.com/kohsuke/github-api/pull/224
+        List<GHContent> entries = repo.getDirectoryContent("ghcontent-ro/a-dir-with-3-entries/", "main");
 
-        assertTrue(entries.get(0).getUrl().endsWith("?ref=master"));
+        assertThat(entries.get(0).getUrl(), endsWith("?ref=main"));
     }
 
     @Test
@@ -92,11 +91,11 @@ public class GHContentIntegrationTest extends AbstractGitHubWireMockTest {
                 createdFilename);
         GHContent createdContent = created.getContent();
 
-        assertNotNull(created.getCommit());
-        assertNotNull(created.getContent());
-        assertNotNull(createdContent.getContent());
+        assertThat(created.getCommit(), notNullValue());
+        assertThat(created.getContent(), notNullValue());
+        assertThat(createdContent.getContent(), notNullValue());
         assertThat(createdContent.getPath(), equalTo(createdFilename));
-        assertEquals("this is an awesome file I created\n", createdContent.getContent());
+        assertThat(createdContent.getContent(), equalTo("this is an awesome file I created\n"));
 
         GHContent content = repo.getFileContent(createdFilename);
         assertThat(content, is(notNullValue()));
@@ -116,17 +115,17 @@ public class GHContentIntegrationTest extends AbstractGitHubWireMockTest {
                 "Updated file for integration tests.");
         GHContent updatedContent = updatedContentResponse.getContent();
 
-        assertNotNull(updatedContentResponse.getCommit());
-        assertNotNull(updatedContentResponse.getContent());
+        assertThat(updatedContentResponse.getCommit(), notNullValue());
+        assertThat(updatedContentResponse.getContent(), notNullValue());
         // due to what appears to be a cache propagation delay, this test is too flaky
-        assertEquals("this is some new content",
-                new BufferedReader(new InputStreamReader(updatedContent.read())).readLine());
-        assertEquals("this is some new content\n", updatedContent.getContent());
+        assertThat(new BufferedReader(new InputStreamReader(updatedContent.read())).readLine(),
+                equalTo("this is some new content"));
+        assertThat(updatedContent.getContent(), equalTo("this is some new content\n"));
 
         GHContentUpdateResponse deleteResponse = updatedContent.delete("Enough of this foolishness!");
 
-        assertNotNull(deleteResponse.getCommit());
-        assertNull(deleteResponse.getContent());
+        assertThat(deleteResponse.getCommit(), notNullValue());
+        assertThat(deleteResponse.getContent(), nullValue());
 
         try {
             repo.getFileContent(createdFilename);

src/test/java/org/kohsuke/github/GHDeploymentTest.java

@@ -6,6 +6,8 @@ import java.io.IOException;
 import java.util.Arrays;
 import java.util.Map;
 
+import static org.hamcrest.Matchers.*;
+
 /**
  * @author Martin van Zijl
  */
@@ -15,38 +17,38 @@ public class GHDeploymentTest extends AbstractGitHubWireMockTest {
     public void testGetDeploymentByIdStringPayload() throws IOException {
         final GHRepository repo = getRepository();
         final GHDeployment deployment = repo.getDeployment(178653229);
-        assertNotNull(deployment);
-        assertEquals(178653229, deployment.getId());
-        assertEquals("production", deployment.getEnvironment());
-        assertEquals("custom", deployment.getPayload());
-        assertEquals("custom", deployment.getPayloadObject());
-        assertEquals("master", deployment.getRef());
-        assertEquals("3a09d2de4a9a1322a0ba2c3e2f54a919ca8fe353", deployment.getSha());
-        assertEquals("deploy", deployment.getTask());
-        assertEquals("production", deployment.getOriginalEnvironment());
-        assertEquals(false, deployment.isProductionEnvironment());
-        assertEquals(true, deployment.isTransientEnvironment());
+        assertThat(deployment, notNullValue());
+        assertThat(deployment.getId(), equalTo(178653229L));
+        assertThat(deployment.getEnvironment(), equalTo("production"));
+        assertThat(deployment.getPayload(), equalTo("custom"));
+        assertThat(deployment.getPayloadObject(), equalTo("custom"));
+        assertThat(deployment.getRef(), equalTo("main"));
+        assertThat(deployment.getSha(), equalTo("3a09d2de4a9a1322a0ba2c3e2f54a919ca8fe353"));
+        assertThat(deployment.getTask(), equalTo("deploy"));
+        assertThat(deployment.getOriginalEnvironment(), equalTo("production"));
+        assertThat(deployment.isProductionEnvironment(), equalTo(false));
+        assertThat(deployment.isTransientEnvironment(), equalTo(true));
     }
 
     @Test
     public void testGetDeploymentByIdObjectPayload() throws IOException {
         final GHRepository repo = getRepository();
         final GHDeployment deployment = repo.getDeployment(178653229);
-        assertNotNull(deployment);
-        assertEquals(178653229, deployment.getId());
-        assertEquals("production", deployment.getEnvironment());
-        assertEquals("master", deployment.getRef());
-        assertEquals("3a09d2de4a9a1322a0ba2c3e2f54a919ca8fe353", deployment.getSha());
-        assertEquals("deploy", deployment.getTask());
+        assertThat(deployment, notNullValue());
+        assertThat(deployment.getId(), equalTo(178653229L));
+        assertThat(deployment.getEnvironment(), equalTo("production"));
+        assertThat(deployment.getRef(), equalTo("main"));
+        assertThat(deployment.getSha(), equalTo("3a09d2de4a9a1322a0ba2c3e2f54a919ca8fe353"));
+        assertThat(deployment.getTask(), equalTo("deploy"));
         final Map<String, Object> payload = deployment.getPayloadMap();
-        assertEquals(4, payload.size());
-        assertEquals(1, payload.get("custom1"));
-        assertEquals("two", payload.get("custom2"));
-        assertEquals(Arrays.asList("3", 3, "three"), payload.get("custom3"));
-        assertNull(payload.get("custom4"));
-        assertEquals("production", deployment.getOriginalEnvironment());
-        assertEquals(false, deployment.isProductionEnvironment());
-        assertEquals(true, deployment.isTransientEnvironment());
+        assertThat(payload.size(), equalTo(4));
+        assertThat(payload.get("custom1"), equalTo(1));
+        assertThat(payload.get("custom2"), equalTo("two"));
+        assertThat(payload.get("custom3"), equalTo(Arrays.asList("3", 3, "three")));
+        assertThat(payload.get("custom4"), nullValue());
+        assertThat(deployment.getOriginalEnvironment(), equalTo("production"));
+        assertThat(deployment.isProductionEnvironment(), equalTo(false));
+        assertThat(deployment.isTransientEnvironment(), equalTo(true));
     }
 
     protected GHRepository getRepository() throws IOException {

src/test/java/org/kohsuke/github/GHDiscussionTest.java

@@ -26,7 +26,7 @@ public class GHDiscussionTest extends AbstractGitHubWireMockTest {
     public void cleanupDiscussions() throws Exception {
         // only need to clean up if we're pointing to the live site
         if (mockGitHub.isUseProxy()) {
-            for (GHDiscussion discussion : getGitHubBeforeAfter().getOrganization(GITHUB_API_TEST_ORG)
+            for (GHDiscussion discussion : getNonRecordingGitHub().getOrganization(GITHUB_API_TEST_ORG)
                     .getTeamBySlug(TEAM_SLUG)
                     .listDiscussions()) {
                 discussion.delete();

src/test/java/org/kohsuke/github/GHEventPayloadTest.java

@@ -11,7 +11,6 @@ import java.util.Collections;
 import java.util.List;
 import java.util.TimeZone;
 
-import static java.lang.Boolean.TRUE;
 import static org.hamcrest.Matchers.aMapWithSize;
 import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.endsWith;
@@ -50,7 +49,7 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
                 .parseEventPayload(payload.asReader(), GHEventPayload.Create.class);
         assertThat(event.getRef(), is("0.0.1"));
         assertThat(event.getRefType(), is("tag"));
-        assertThat(event.getMasterBranch(), is("master"));
+        assertThat(event.getMasterBranch(), is("main"));
         assertThat(event.getDescription(), is(""));
         assertThat(event.getRepository().getName(), is("public-repo"));
         assertThat(event.getRepository().getOwner().getLogin(), is("baxterthehacker"));
@@ -241,15 +240,15 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
         assertThat(event.getPullRequest().getNumber(), is(1));
         assertThat(event.getPullRequest().getTitle(), is("Update the README with new information"));
         assertThat(event.getPullRequest().getBody(),
-                is("This is a pretty simple change that we need to pull into " + "master."));
+                is("This is a pretty simple change that we need to pull into " + "main."));
         assertThat(event.getPullRequest().getUser().getLogin(), is("baxterthehacker"));
         assertThat(event.getPullRequest().getHead().getUser().getLogin(), is("baxterthehacker"));
         assertThat(event.getPullRequest().getHead().getRef(), is("changes"));
         assertThat(event.getPullRequest().getHead().getLabel(), is("baxterthehacker:changes"));
         assertThat(event.getPullRequest().getHead().getSha(), is("0d1a26e67d8f5eaf1f6ba5c57fc3c7d91ac0fd1c"));
         assertThat(event.getPullRequest().getBase().getUser().getLogin(), is("baxterthehacker"));
-        assertThat(event.getPullRequest().getBase().getRef(), is("master"));
-        assertThat(event.getPullRequest().getBase().getLabel(), is("baxterthehacker:master"));
+        assertThat(event.getPullRequest().getBase().getRef(), is("main"));
+        assertThat(event.getPullRequest().getBase().getLabel(), is("baxterthehacker:main"));
         assertThat(event.getPullRequest().getBase().getSha(), is("9049f1265b7d61be4a8904a9a27120d2064dab3b"));
         assertThat(event.getPullRequest().isMerged(), is(false));
         assertThat(event.getPullRequest().getMergeable(), nullValue());
@@ -314,7 +313,7 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
         assertThat(event.getPullRequest().getBase().getLabel(), is("trilogy-group:3.10"));
         assertThat(event.getPullRequest().getBase().getSha(), is("7a735f17d686c6a1fc7df5b9d395e5863868f364"));
         assertThat(event.getPullRequest().isMerged(), is(false));
-        assertThat(event.getPullRequest().getMergeable(), is(TRUE));
+        assertThat(event.getPullRequest().getMergeable(), is(true));
         assertThat(event.getPullRequest().getMergeableState(), is("draft"));
         assertThat(event.getPullRequest().getMergedBy(), nullValue());
         assertThat(event.getPullRequest().getCommentsCount(), is(1));
@@ -355,8 +354,8 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
         assertThat(event.getPullRequest().getHead().getLabel(), is("skalnik:patch-2"));
         assertThat(event.getPullRequest().getHead().getSha(), is("b7a1f9c27caa4e03c14a88feb56e2d4f7500aa63"));
         assertThat(event.getPullRequest().getBase().getUser().getLogin(), is("baxterthehacker"));
-        assertThat(event.getPullRequest().getBase().getRef(), is("master"));
-        assertThat(event.getPullRequest().getBase().getLabel(), is("baxterthehacker:master"));
+        assertThat(event.getPullRequest().getBase().getRef(), is("main"));
+        assertThat(event.getPullRequest().getBase().getLabel(), is("baxterthehacker:main"));
         assertThat(event.getPullRequest().getBase().getSha(), is("9049f1265b7d61be4a8904a9a27120d2064dab3b"));
 
         assertThat(event.getRepository().getName(), is("public-repo"));
@@ -376,15 +375,15 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
         assertThat(event.getPullRequest().getNumber(), is(1));
         assertThat(event.getPullRequest().getTitle(), is("Update the README with new information"));
         assertThat(event.getPullRequest().getBody(),
-                is("This is a pretty simple change that we need to pull into master."));
+                is("This is a pretty simple change that we need to pull into main."));
         assertThat(event.getPullRequest().getUser().getLogin(), is("baxterthehacker"));
         assertThat(event.getPullRequest().getHead().getUser().getLogin(), is("baxterthehacker"));
         assertThat(event.getPullRequest().getHead().getRef(), is("changes"));
         assertThat(event.getPullRequest().getHead().getLabel(), is("baxterthehacker:changes"));
         assertThat(event.getPullRequest().getHead().getSha(), is("0d1a26e67d8f5eaf1f6ba5c57fc3c7d91ac0fd1c"));
         assertThat(event.getPullRequest().getBase().getUser().getLogin(), is("baxterthehacker"));
-        assertThat(event.getPullRequest().getBase().getRef(), is("master"));
-        assertThat(event.getPullRequest().getBase().getLabel(), is("baxterthehacker:master"));
+        assertThat(event.getPullRequest().getBase().getRef(), is("main"));
+        assertThat(event.getPullRequest().getBase().getLabel(), is("baxterthehacker:main"));
         assertThat(event.getPullRequest().getBase().getSha(), is("9049f1265b7d61be4a8904a9a27120d2064dab3b"));
 
         assertThat(event.getRepository().getName(), is("public-repo"));
@@ -477,8 +476,8 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
         assertThat(event.getRepository().getHttpTransportUrl(), is("https://github.com/hub4j-test-org/github-api.git"));
 
         // ensure that root has been bound after populate
-        event.getRepository().getSource().getRef("heads/master");
-        event.getRepository().getParent().getRef("heads/master");
+        event.getRepository().getSource().getRef("heads/main");
+        event.getRepository().getParent().getRef("heads/main");
 
         // Source
         event = gitHub.parseEventPayload(payload.asReader(mockGitHub::mapToMockGitHub), GHEventPayload.Push.class);
@@ -525,7 +524,7 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
         assertThat(event.getState(), is(GHCommitState.SUCCESS));
         assertThat(event.getCommit().getSHA1(), is("9049f1265b7d61be4a8904a9a27120d2064dab3b"));
         assertThat(event.getRepository().getOwner().getLogin(), is("baxterthehacker"));
-        assertNull(event.getTargetUrl());
+        assertThat(event.getTargetUrl(), nullValue());
     }
 
     @Test
@@ -559,7 +558,7 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
         int expectedRequestCount = mockGitHub.isUseProxy() ? 3 : 2;
         assertThat("pull body should be populated",
                 checkRun.getPullRequests().get(0).getBody(),
-                equalTo("This is a pretty simple change that we need to pull into master."));
+                equalTo("This is a pretty simple change that we need to pull into main."));
         assertThat("multiple getPullRequests() calls are made, the pull is populated only once",
                 mockGitHub.getRequestCount(),
                 equalTo(expectedRequestCount));
@@ -624,7 +623,7 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
         int expectedRequestCount = mockGitHub.isUseProxy() ? 3 : 2;
         assertThat("pull body should be populated",
                 checkSuite.getPullRequests().get(0).getBody(),
-                equalTo("This is a pretty simple change that we need to pull into master."));
+                equalTo("This is a pretty simple change that we need to pull into main."));
         assertThat("multiple getPullRequests() calls are made, the pull is populated only once",
                 mockGitHub.getRequestCount(),
                 lessThanOrEqualTo(expectedRequestCount));
@@ -805,4 +804,55 @@ public class GHEventPayloadTest extends AbstractGitHubWireMockTest {
         assertThat(workflowRun.getHeadRepository().getFullName(),
                 is("gsmet-bot-playground/quarkus-bot-java-playground"));
     }
+
+    @Test
+    public void label_created() throws Exception {
+        GHEventPayload.Label labelPayload = GitHub.offline()
+                .parseEventPayload(payload.asReader(), GHEventPayload.Label.class);
+        GHLabel label = labelPayload.getLabel();
+
+        assertThat(labelPayload.getAction(), is("created"));
+        assertThat(labelPayload.getRepository().getFullName(), is("gsmet/quarkus-bot-java-playground"));
+        assertThat(label.getId(), is(2901546662L));
+        assertThat(label.getNodeId(), is("MDU6TGFiZWwyOTAxNTQ2NjYy"));
+        assertThat(label.getName(), is("new-label"));
+        assertThat(label.getColor(), is("f9d0c4"));
+        assertThat(label.isDefault(), is(false));
+        assertThat(label.getDescription(), is("description"));
+    }
+
+    @Test
+    public void label_edited() throws Exception {
+        GHEventPayload.Label labelPayload = GitHub.offline()
+                .parseEventPayload(payload.asReader(), GHEventPayload.Label.class);
+        GHLabel label = labelPayload.getLabel();
+
+        assertThat(labelPayload.getAction(), is("edited"));
+        assertThat(labelPayload.getRepository().getFullName(), is("gsmet/quarkus-bot-java-playground"));
+        assertThat(label.getId(), is(2901546662L));
+        assertThat(label.getNodeId(), is("MDU6TGFiZWwyOTAxNTQ2NjYy"));
+        assertThat(label.getName(), is("new-label-updated"));
+        assertThat(label.getColor(), is("4AE686"));
+        assertThat(label.isDefault(), is(false));
+        assertThat(label.getDescription(), is("description"));
+
+        assertThat(labelPayload.getChanges().getName().getFrom(), is("new-label"));
+        assertThat(labelPayload.getChanges().getColor().getFrom(), is("f9d0c4"));
+    }
+
+    @Test
+    public void label_deleted() throws Exception {
+        GHEventPayload.Label labelPayload = GitHub.offline()
+                .parseEventPayload(payload.asReader(), GHEventPayload.Label.class);
+        GHLabel label = labelPayload.getLabel();
+
+        assertThat(labelPayload.getAction(), is("deleted"));
+        assertThat(labelPayload.getRepository().getFullName(), is("gsmet/quarkus-bot-java-playground"));
+        assertThat(label.getId(), is(2901546662L));
+        assertThat(label.getNodeId(), is("MDU6TGFiZWwyOTAxNTQ2NjYy"));
+        assertThat(label.getName(), is("new-label-updated"));
+        assertThat(label.getColor(), is("4AE686"));
+        assertThat(label.isDefault(), is(false));
+        assertThat(label.getDescription(), is("description"));
+    }
 }

src/test/java/org/kohsuke/github/GHGistTest.java

@@ -5,7 +5,6 @@ import org.junit.Test;
 import java.io.FileNotFoundException;
 
 import static org.hamcrest.Matchers.*;
-import static org.hamcrest.core.Is.is;
 
 /**
  * @author Kohsuke Kawaguchi
@@ -26,12 +25,12 @@ public class GHGistTest extends AbstractGitHubWireMockTest {
         assertThat(gist.getDescription(), equalTo("Test Gist"));
         assertThat(gist.getFiles().size(), equalTo(3));
 
-        assertNotNull(gist.getUpdatedAt());
-        assertNotNull(gist.getCommentsUrl());
-        assertNotNull(gist.getCommitsUrl());
-        assertNotNull(gist.getGitPullUrl());
-        assertNotNull(gist.getGitPushUrl());
-        assertNotNull(gist.getHtmlUrl());
+        assertThat(gist.getUpdatedAt(), notNullValue());
+        assertThat(gist.getCommentsUrl(), notNullValue());
+        assertThat(gist.getCommitsUrl(), notNullValue());
+        assertThat(gist.getGitPullUrl(), notNullValue());
+        assertThat(gist.getGitPushUrl(), notNullValue());
+        assertThat(gist.getHtmlUrl(), notNullValue());
 
         String id = gist.getGistId();
 
@@ -98,13 +97,13 @@ public class GHGistTest extends AbstractGitHubWireMockTest {
     @Test
     public void starTest() throws Exception {
         GHGist gist = gitHub.getGist("9903708");
-        assertEquals("rtyler", gist.getOwner().getLogin());
+        assertThat(gist.getOwner().getLogin(), equalTo("rtyler"));
 
         gist.star();
-        assertTrue(gist.isStarred());
+        assertThat(gist.isStarred(), is(true));
 
         gist.unstar();
-        assertFalse(gist.isStarred());
+        assertThat(gist.isStarred(), is(false));
 
         GHGist newGist = gist.fork();
 
@@ -126,16 +125,15 @@ public class GHGistTest extends AbstractGitHubWireMockTest {
     public void gistFile() throws Exception {
         GHGist gist = gitHub.getGist("9903708");
 
-        assertTrue(gist.isPublic());
+        assertThat(gist.isPublic(), is(true));
         assertThat(gist.getId(), equalTo(9903708L));
         assertThat(gist.getGistId(), equalTo("9903708"));
 
-        assertEquals(1, gist.getFiles().size());
+        assertThat(gist.getFiles().size(), equalTo(1));
         GHGistFile f = gist.getFile("keybase.md");
 
-        assertEquals("text/markdown", f.getType());
-        assertEquals("Markdown", f.getLanguage());
-        assertTrue(f.getContent().contains("### Keybase proof"));
-        assertNotNull(f.getContent());
+        assertThat(f.getType(), equalTo("text/markdown"));
+        assertThat(f.getLanguage(), equalTo("Markdown"));
+        assertThat(f.getContent(), containsString("### Keybase proof"));
     }
 }

src/test/java/org/kohsuke/github/GHGistUpdaterTest.java

@@ -7,6 +7,8 @@ import org.junit.Test;
 import java.io.IOException;
 import java.util.Map;
 
+import static org.hamcrest.Matchers.*;
+
 /**
  * @author Martin van Zijl
  */
@@ -46,24 +48,24 @@ public class GHGistUpdaterTest extends AbstractGitHubWireMockTest {
                 .updateFile("update-me.txt", "Content updated by API")
                 .update();
 
-        assertEquals("Description updated by API", updatedGist.getDescription());
+        assertThat(updatedGist.getDescription(), equalTo("Description updated by API"));
 
         Map<String, GHGistFile> files = updatedGist.getFiles();
 
         // Check that the unmodified file stays intact.
-        assertTrue(files.containsKey("unmodified.txt"));
-        assertEquals("Should be unmodified", files.get("unmodified.txt").getContent());
+        assertThat(files.get("unmodified.txt"), is(notNullValue()));
+        assertThat(files.get("unmodified.txt").getContent(), equalTo("Should be unmodified"));
 
         // Check that the files are updated as expected.
         // assertFalse("File was not deleted.", files.containsKey("delete-me.txt"));
 
-        assertTrue(files.containsKey("new-file.txt"));
-        assertEquals("Added by updater", files.get("new-file.txt").getContent());
+        assertThat(files.get("new-file.txt"), is(notNullValue()));
+        assertThat(files.get("new-file.txt").getContent(), equalTo("Added by updater"));
 
-        assertFalse(files.containsKey("rename-me.py"));
-        assertTrue(files.containsKey("renamed.py"));
-        assertEquals("print 'hello'", files.get("renamed.py").getContent());
+        assertThat(files.containsKey("rename-me.py"), is(false));
+        assertThat(files.get("renamed.py"), is(notNullValue()));
+        assertThat(files.get("renamed.py").getContent(), equalTo("print 'hello'"));
 
-        assertEquals("Content updated by API", files.get("update-me.txt").getContent());
+        assertThat(files.get("update-me.txt").getContent(), equalTo("Content updated by API"));
     }
 }

src/test/java/org/kohsuke/github/GHIssueEventAttributeTest.java

@@ -13,13 +13,14 @@ import java.util.stream.StreamSupport;
 import static java.util.Arrays.asList;
 import static java.util.stream.Collectors.toList;
 import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.notNullValue;
 
 public class GHIssueEventAttributeTest extends AbstractGitHubWireMockTest {
 
     private enum Type implements Predicate<GHIssueEvent>, Consumer<GHIssueEvent> {
-        milestone(e -> assertNotNull(e.getMilestone()), "milestoned", "demilestoned"),
-        label(e -> assertNotNull(e.getLabel()), "labeled", "unlabeled"),
-        assignment(e -> assertNotNull(e.getAssignee()), "assigned", "unassigned");
+        milestone(e -> assertThat(e.getMilestone(), notNullValue()), "milestoned", "demilestoned"),
+        label(e -> assertThat(e.getLabel(), notNullValue()), "labeled", "unlabeled"),
+        assignment(e -> assertThat(e.getAssignee(), notNullValue()), "assigned", "unassigned");
 
         private final Consumer<GHIssueEvent> assertion;
         private final Set<String> subtypes;

src/test/java/org/kohsuke/github/GHIssueEventTest.java

@@ -5,6 +5,8 @@ import org.junit.Test;
 import java.io.IOException;
 import java.util.List;
 
+import static org.hamcrest.Matchers.*;
+
 /**
  * @author Martin van Zijl
  */
@@ -22,16 +24,16 @@ public class GHIssueEventTest extends AbstractGitHubWireMockTest {
 
         // Test that the events are present.
         List<GHIssueEvent> list = issue.listEvents().toList();
-        assertEquals(1, list.size());
+        assertThat(list.size(), equalTo(1));
 
         GHIssueEvent event = list.get(0);
-        assertEquals(issue.getNumber(), event.getIssue().getNumber());
-        assertEquals("labeled", event.getEvent());
+        assertThat(event.getIssue().getNumber(), equalTo(issue.getNumber()));
+        assertThat(event.getEvent(), equalTo("labeled"));
 
         // Test that we can get a single event directly.
         GHIssueEvent eventFromRepo = repo.getIssueEvent(event.getId());
-        assertEquals(event.getId(), eventFromRepo.getId());
-        assertEquals(event.getCreatedAt(), eventFromRepo.getCreatedAt());
+        assertThat(eventFromRepo.getId(), equalTo(event.getId()));
+        assertThat(eventFromRepo.getCreatedAt(), equalTo(event.getCreatedAt()));
 
         // Close the issue.
         issue.close();
@@ -41,11 +43,11 @@ public class GHIssueEventTest extends AbstractGitHubWireMockTest {
     public void testRepositoryEvents() throws Exception {
         GHRepository repo = getRepository();
         List<GHIssueEvent> list = repo.listIssueEvents().toList();
-        assertTrue(list.size() > 0);
+        assertThat(list, is(not(empty())));
 
         int i = 0;
         for (GHIssueEvent event : list) {
-            assertNotNull(event.getIssue());
+            assertThat(event.getIssue(), notNullValue());
             if (i++ > 10)
                 break;
         }

src/test/java/org/kohsuke/github/GHLicenseTest.java

@@ -46,7 +46,7 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
     @Test
     public void listLicenses() throws IOException {
         Iterable<GHLicense> licenses = gitHub.listLicenses();
-        assertTrue(licenses.iterator().hasNext());
+        assertThat(licenses, is(not(emptyIterable())));
     }
 
     /**
@@ -60,7 +60,7 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
         PagedIterable<GHLicense> licenses = gitHub.listLicenses();
         for (GHLicense lic : licenses) {
             if (lic.getKey().equals("mit")) {
-                assertTrue(lic.getUrl().equals(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/mit")));
+                assertThat(lic.getUrl(), equalTo(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/mit")));
                 return;
             }
         }
@@ -78,14 +78,14 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
     public void getLicense() throws IOException {
         String key = "mit";
         GHLicense license = gitHub.getLicense(key);
-        assertNotNull(license);
+        assertThat(license, notNullValue());
         assertThat("The name is correct", license.getName(), equalTo("MIT License"));
         assertThat("The HTML URL is correct",
                 license.getHtmlUrl(),
                 equalTo(new URL("http://choosealicense.com/licenses/mit/")));
         assertThat(license.getBody(), startsWith("MIT License\n" + "\n" + "Copyright (c) [year] [fullname]\n\n"));
-        assertThat(license.getForbidden().size(), equalTo(0));
-        assertThat(license.getPermitted().size(), equalTo(0));
+        assertThat(license.getForbidden(), is(empty()));
+        assertThat(license.getPermitted(), is(empty()));
         assertThat(license.getImplementation(),
                 equalTo("Create a text file (typically named LICENSE or LICENSE.txt) in the root of your source code and copy the text of the license into the file. Replace [year] with the current year and [fullname] with the name (or names) of the copyright holders."));
         assertThat(license.getCategory(), nullValue());
@@ -105,11 +105,12 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
     public void checkRepositoryLicense() throws IOException {
         GHRepository repo = gitHub.getRepository("hub4j/github-api");
         GHLicense license = repo.getLicense();
-        assertNotNull("The license is populated", license);
-        assertTrue("The key is correct", license.getKey().equals("mit"));
-        assertTrue("The name is correct", license.getName().equals("MIT License"));
-        assertTrue("The URL is correct",
-                license.getUrl().equals(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/mit")));
+        assertThat("The license is populated", license, notNullValue());
+        assertThat("The key is correct", license.getKey(), equalTo("mit"));
+        assertThat("The name is correct", license.getName(), equalTo("MIT License"));
+        assertThat("The URL is correct",
+                license.getUrl(),
+                equalTo(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/mit")));
     }
 
     /**
@@ -122,11 +123,12 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
     public void checkRepositoryLicenseAtom() throws IOException {
         GHRepository repo = gitHub.getRepository("atom/atom");
         GHLicense license = repo.getLicense();
-        assertNotNull("The license is populated", license);
-        assertTrue("The key is correct", license.getKey().equals("mit"));
-        assertTrue("The name is correct", license.getName().equals("MIT License"));
-        assertTrue("The URL is correct",
-                license.getUrl().equals(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/mit")));
+        assertThat("The license is populated", license, notNullValue());
+        assertThat("The key is correct", license.getKey(), equalTo("mit"));
+        assertThat("The name is correct", license.getName(), equalTo("MIT License"));
+        assertThat("The URL is correct",
+                license.getUrl(),
+                equalTo(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/mit")));
     }
 
     /**
@@ -139,11 +141,12 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
     public void checkRepositoryLicensePomes() throws IOException {
         GHRepository repo = gitHub.getRepository("pomes/pomes");
         GHLicense license = repo.getLicense();
-        assertNotNull("The license is populated", license);
-        assertTrue("The key is correct", license.getKey().equals("apache-2.0"));
-        assertTrue("The name is correct", license.getName().equals("Apache License 2.0"));
-        assertTrue("The URL is correct",
-                license.getUrl().equals(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/apache-2.0")));
+        assertThat("The license is populated", license, notNullValue());
+        assertThat("The key is correct", license.getKey(), equalTo("apache-2.0"));
+        assertThat("The name is correct", license.getName(), equalTo("Apache License 2.0"));
+        assertThat("The URL is correct",
+                license.getUrl(),
+                equalTo(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/apache-2.0")));
     }
 
     /**
@@ -157,7 +160,7 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
     public void checkRepositoryWithoutLicense() throws IOException {
         GHRepository repo = gitHub.getRepository(GITHUB_API_TEST_ORG + "/empty");
         GHLicense license = repo.getLicense();
-        assertNull("There is no license", license);
+        assertThat("There is no license", license, nullValue());
     }
 
     /**
@@ -171,13 +174,15 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
     public void checkRepositoryFullLicense() throws IOException {
         GHRepository repo = gitHub.getRepository("hub4j/github-api");
         GHLicense license = repo.getLicense();
-        assertNotNull("The license is populated", license);
-        assertTrue("The key is correct", license.getKey().equals("mit"));
-        assertTrue("The name is correct", license.getName().equals("MIT License"));
-        assertTrue("The URL is correct",
-                license.getUrl().equals(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/mit")));
-        assertTrue("The HTML URL is correct",
-                license.getHtmlUrl().equals(new URL("http://choosealicense.com/licenses/mit/")));
+        assertThat("The license is populated", license, notNullValue());
+        assertThat("The key is correct", license.getKey(), equalTo("mit"));
+        assertThat("The name is correct", license.getName(), equalTo("MIT License"));
+        assertThat("The URL is correct",
+                license.getUrl(),
+                equalTo(new URL(mockGitHub.apiServer().baseUrl() + "/licenses/mit")));
+        assertThat("The HTML URL is correct",
+                license.getHtmlUrl(),
+                equalTo(new URL("http://choosealicense.com/licenses/mit/")));
     }
 
     /**
@@ -191,13 +196,13 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
     public void checkRepositoryLicenseContent() throws IOException {
         GHRepository repo = gitHub.getRepository("pomes/pomes");
         GHContent content = repo.getLicenseContent();
-        assertNotNull("The license content is populated", content);
-        assertTrue("The type is 'file'", content.getType().equals("file"));
-        assertTrue("The license file is 'LICENSE'", content.getName().equals("LICENSE"));
+        assertThat("The license content is populated", content, notNullValue());
+        assertThat("The type is 'file'", content.getType(), equalTo("file"));
+        assertThat("The license file is 'LICENSE'", content.getName(), equalTo("LICENSE"));
 
         if (content.getEncoding().equals("base64")) {
             String licenseText = new String(IOUtils.toByteArray(content.read()));
-            assertTrue("The license appears to be an Apache License", licenseText.contains("Apache License"));
+            assertThat("The license appears to be an Apache License", licenseText.contains("Apache License"));
         } else {
             fail("Expected the license to be Base64 encoded but instead it was " + content.getEncoding());
         }
@@ -214,7 +219,7 @@ public class GHLicenseTest extends AbstractGitHubWireMockTest {
     public void checkRepositoryLicenseForIndeterminate() throws IOException {
         GHRepository repo = gitHub.getRepository("bndtools/bnd");
         GHLicense license = repo.getLicense();
-        assertNotNull("The license is populated", license);
+        assertThat("The license is populated", license, notNullValue());
         assertThat(license.getKey(), equalTo("other"));
         assertThat(license.getDescription(), is(nullValue()));
         assertThat(license.getUrl(), is(nullValue()));

src/test/java/org/kohsuke/github/GHMarketplacePlanTest.java

@@ -5,11 +5,7 @@ import org.junit.Test;
 import java.io.IOException;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.Matchers.*;
 import static org.kohsuke.github.GHDirection.DESC;
 import static org.kohsuke.github.GHMarketplaceAccountType.ORGANIZATION;
 import static org.kohsuke.github.GHMarketplaceListAccountBuilder.Sort.UPDATED;
@@ -31,30 +27,30 @@ public class GHMarketplacePlanTest extends AbstractGitHubWireMockTest {
     @Test
     public void listMarketplacePlans() throws IOException {
         List<GHMarketplacePlan> plans = gitHub.listMarketplacePlans().toList();
-        assertEquals(3, plans.size());
+        assertThat(plans.size(), equalTo(3));
         plans.forEach(this::testMarketplacePlan);
     }
 
     @Test
     public void listAccounts() throws IOException {
         List<GHMarketplacePlan> plans = gitHub.listMarketplacePlans().toList();
-        assertEquals(3, plans.size());
+        assertThat(plans.size(), equalTo(3));
         List<GHMarketplaceAccountPlan> marketplaceUsers = plans.get(0).listAccounts().createRequest().toList();
-        assertEquals(2, marketplaceUsers.size());
+        assertThat(marketplaceUsers.size(), equalTo(2));
         marketplaceUsers.forEach(this::testMarketplaceAccount);
     }
 
     @Test
     public void listAccountsWithDirection() throws IOException {
         List<GHMarketplacePlan> plans = gitHub.listMarketplacePlans().toList();
-        assertEquals(3, plans.size());
+        assertThat(plans.size(), equalTo(3));
 
         for (GHMarketplacePlan plan : plans) {
             List<GHMarketplaceAccountPlan> marketplaceUsers = plan.listAccounts()
                     .direction(DESC)
                     .createRequest()
                     .toList();
-            assertEquals(2, marketplaceUsers.size());
+            assertThat(marketplaceUsers.size(), equalTo(2));
             marketplaceUsers.forEach(this::testMarketplaceAccount);
         }
 
@@ -63,7 +59,7 @@ public class GHMarketplacePlanTest extends AbstractGitHubWireMockTest {
     @Test
     public void listAccountsWithSortAndDirection() throws IOException {
         List<GHMarketplacePlan> plans = gitHub.listMarketplacePlans().toList();
-        assertEquals(3, plans.size());
+        assertThat(plans.size(), equalTo(3));
 
         for (GHMarketplacePlan plan : plans) {
             List<GHMarketplaceAccountPlan> marketplaceUsers = plan.listAccounts()
@@ -71,7 +67,7 @@ public class GHMarketplacePlanTest extends AbstractGitHubWireMockTest {
                     .direction(DESC)
                     .createRequest()
                     .toList();
-            assertEquals(2, marketplaceUsers.size());
+            assertThat(marketplaceUsers.size(), equalTo(2));
             marketplaceUsers.forEach(this::testMarketplaceAccount);
         }
 
@@ -79,39 +75,39 @@ public class GHMarketplacePlanTest extends AbstractGitHubWireMockTest {
 
     private void testMarketplacePlan(GHMarketplacePlan plan) {
         // Non-nullable fields
-        assertNotNull(plan.getUrl());
-        assertNotNull(plan.getAccountsUrl());
-        assertNotNull(plan.getName());
-        assertNotNull(plan.getDescription());
-        assertNotNull(plan.getPriceModel());
-        assertNotNull(plan.getState());
+        assertThat(plan.getUrl(), notNullValue());
+        assertThat(plan.getAccountsUrl(), notNullValue());
+        assertThat(plan.getName(), notNullValue());
+        assertThat(plan.getDescription(), notNullValue());
+        assertThat(plan.getPriceModel(), notNullValue());
+        assertThat(plan.getState(), notNullValue());
 
         // primitive fields
-        assertNotEquals(0L, plan.getId());
-        assertNotEquals(0L, plan.getNumber());
-        assertTrue(plan.getMonthlyPriceInCents() >= 0);
+        assertThat(plan.getId(), not(0L));
+        assertThat(plan.getNumber(), not(0L));
+        assertThat(plan.getMonthlyPriceInCents(), greaterThanOrEqualTo(0L));
 
         // list
-        assertEquals(2, plan.getBullets().size());
+        assertThat(plan.getBullets().size(), equalTo(2));
     }
 
     private void testMarketplaceAccount(GHMarketplaceAccountPlan account) {
         // Non-nullable fields
-        assertNotNull(account.getLogin());
-        assertNotNull(account.getUrl());
-        assertNotNull(account.getType());
-        assertNotNull(account.getMarketplacePurchase());
+        assertThat(account.getLogin(), notNullValue());
+        assertThat(account.getUrl(), notNullValue());
+        assertThat(account.getType(), notNullValue());
+        assertThat(account.getMarketplacePurchase(), notNullValue());
         testMarketplacePurchase(account.getMarketplacePurchase());
 
         // primitive fields
-        assertNotEquals(0L, account.getId());
+        assertThat(account.getId(), not(0L));
 
         /* logical combination tests */
         // Rationale: organization_billing_email is only set when account type is ORGANIZATION.
         if (account.getType() == ORGANIZATION)
-            assertNotNull(account.getOrganizationBillingEmail());
+            assertThat(account.getOrganizationBillingEmail(), notNullValue());
         else
-            assertNull(account.getOrganizationBillingEmail());
+            assertThat(account.getOrganizationBillingEmail(), nullValue());
 
         // Rationale: marketplace_pending_change isn't always set... This is what GitHub says about it:
         // "When someone submits a plan change that won't be processed until the end of their billing cycle,
@@ -122,41 +118,41 @@ public class GHMarketplacePlanTest extends AbstractGitHubWireMockTest {
 
     private void testMarketplacePurchase(GHMarketplacePurchase marketplacePurchase) {
         // Non-nullable fields
-        assertNotNull(marketplacePurchase.getBillingCycle());
-        assertNotNull(marketplacePurchase.getNextBillingDate());
-        assertNotNull(marketplacePurchase.getUpdatedAt());
+        assertThat(marketplacePurchase.getBillingCycle(), notNullValue());
+        assertThat(marketplacePurchase.getNextBillingDate(), notNullValue());
+        assertThat(marketplacePurchase.getUpdatedAt(), notNullValue());
         testMarketplacePlan(marketplacePurchase.getPlan());
 
         /* logical combination tests */
         // Rationale: if onFreeTrial is true, then we should see free_trial_ends_on property set to something
         // different than null
         if (marketplacePurchase.isOnFreeTrial())
-            assertNotNull(marketplacePurchase.getFreeTrialEndsOn());
+            assertThat(marketplacePurchase.getFreeTrialEndsOn(), notNullValue());
         else
-            assertNull(marketplacePurchase.getFreeTrialEndsOn());
+            assertThat(marketplacePurchase.getFreeTrialEndsOn(), nullValue());
 
         // Rationale: if price model is PER_UNIT then unit_count can't be null
         if (marketplacePurchase.getPlan().getPriceModel() == GHMarketplacePriceModel.PER_UNIT)
-            assertNotNull(marketplacePurchase.getUnitCount());
+            assertThat(marketplacePurchase.getUnitCount(), notNullValue());
         else
-            assertNull(marketplacePurchase.getUnitCount());
+            assertThat(marketplacePurchase.getUnitCount(), nullValue());
 
     }
 
     private void testMarketplacePendingChange(GHMarketplacePendingChange marketplacePendingChange) {
         // Non-nullable fields
-        assertNotNull(marketplacePendingChange.getEffectiveDate());
+        assertThat(marketplacePendingChange.getEffectiveDate(), notNullValue());
         testMarketplacePlan(marketplacePendingChange.getPlan());
 
         // primitive fields
-        assertNotEquals(0L, marketplacePendingChange.getId());
+        assertThat(marketplacePendingChange.getId(), not(0L));
 
         /* logical combination tests */
         // Rationale: if price model is PER_UNIT then unit_count can't be null
         if (marketplacePendingChange.getPlan().getPriceModel() == GHMarketplacePriceModel.PER_UNIT)
-            assertNotNull(marketplacePendingChange.getUnitCount());
+            assertThat(marketplacePendingChange.getUnitCount(), notNullValue());
         else
-            assertNull(marketplacePendingChange.getUnitCount());
+            assertThat(marketplacePendingChange.getUnitCount(), nullValue());
 
     }
 

src/test/java/org/kohsuke/github/GHMilestoneTest.java

@@ -7,6 +7,9 @@ import org.junit.Test;
 import java.io.IOException;
 import java.util.Date;
 
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.nullValue;
+
 /**
  * @author Martin van Zijl
  */
@@ -20,7 +23,7 @@ public class GHMilestoneTest extends AbstractGitHubWireMockTest {
             return;
         }
 
-        for (GHMilestone milestone : getRepository(getGitHubBeforeAfter()).listMilestones(GHIssueState.ALL)) {
+        for (GHMilestone milestone : getRepository(getNonRecordingGitHub()).listMilestones(GHIssueState.ALL)) {
             if ("Original Title".equals(milestone.getTitle()) || "Updated Title".equals(milestone.getTitle())
                     || "Unset Test Milestone".equals(milestone.getTitle())) {
                 milestone.delete();
@@ -45,12 +48,12 @@ public class GHMilestoneTest extends AbstractGitHubWireMockTest {
         // Force reload.
         milestone = repo.getMilestone(milestone.getNumber());
 
-        assertEquals(NEW_TITLE, milestone.getTitle());
-        assertEquals(NEW_DESCRIPTION, milestone.getDescription());
+        assertThat(milestone.getTitle(), equalTo(NEW_TITLE));
+        assertThat(milestone.getDescription(), equalTo(NEW_DESCRIPTION));
 
         // The time is truncated when sent to the server, but still part of the returned value
         // 07:00 midnight PDT
-        assertEquals(OUTPUT_DUE_DATE, milestone.getDueOn());
+        assertThat(milestone.getDueOn(), equalTo(OUTPUT_DUE_DATE));
     }
 
     @Test
@@ -62,32 +65,30 @@ public class GHMilestoneTest extends AbstractGitHubWireMockTest {
         // set the milestone
         issue.setMilestone(milestone);
         issue = repo.getIssue(issue.getNumber()); // force reload
-        assertEquals(milestone.getNumber(), issue.getMilestone().getNumber());
+        assertThat(issue.getMilestone().getNumber(), equalTo(milestone.getNumber()));
 
         // remove the milestone
         issue.setMilestone(null);
         issue = repo.getIssue(issue.getNumber()); // force reload
-        assertEquals(null, issue.getMilestone());
+        assertThat(issue.getMilestone(), nullValue());
     }
 
     @Test
     public void testUnsetMilestoneFromPullRequest() throws IOException {
         GHRepository repo = getRepository();
         GHMilestone milestone = repo.createMilestone("Unset Test Milestone", "For testUnsetMilestone");
-        GHPullRequest p = repo.createPullRequest("testUnsetMilestoneFromPullRequest",
-                "test/stable",
-                "master",
-                "## test pull request");
+        GHPullRequest p = repo
+                .createPullRequest("testUnsetMilestoneFromPullRequest", "test/stable", "main", "## test pull request");
 
         // set the milestone
         p.setMilestone(milestone);
         p = repo.getPullRequest(p.getNumber()); // force reload
-        assertEquals(milestone.getNumber(), p.getMilestone().getNumber());
+        assertThat(p.getMilestone().getNumber(), equalTo(milestone.getNumber()));
 
         // remove the milestone
         p.setMilestone(null);
         p = repo.getPullRequest(p.getNumber()); // force reload
-        assertNull(p.getMilestone());
+        assertThat(p.getMilestone(), nullValue());
     }
 
     protected GHRepository getRepository() throws IOException {

src/test/java/org/kohsuke/github/GHOrganizationTest.java

@@ -1,13 +1,13 @@
 package org.kohsuke.github;
 
 import org.junit.After;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.kohsuke.github.GHOrganization.Permission;
 
 import java.io.IOException;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import static org.hamcrest.Matchers.*;
 
@@ -25,7 +25,7 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
             return;
         }
 
-        GHTeam team = getGitHubBeforeAfter().getOrganization(GITHUB_API_TEST_ORG).getTeamByName(TEAM_NAME_CREATE);
+        GHTeam team = getNonRecordingGitHub().getOrganization(GITHUB_API_TEST_ORG).getTeamByName(TEAM_NAME_CREATE);
         if (team != null) {
             team.delete();
         }
@@ -42,7 +42,7 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
                 .team(org.getTeamByName("Core Developers"))
                 .private_(false)
                 .create();
-        Assert.assertNotNull(repository);
+        assertThat(repository, notNullValue());
     }
 
     @Test
@@ -56,8 +56,8 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
                 .team(org.getTeamByName("Core Developers"))
                 .autoInit(true)
                 .create();
-        Assert.assertNotNull(repository);
-        Assert.assertNotNull(repository.getReadme());
+        assertThat(repository, notNullValue());
+        assertThat(repository.getReadme(), notNullValue());
     }
 
     @Test
@@ -75,10 +75,10 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
                 .autoInit(true)
                 .isTemplate(true)
                 .create();
-        Assert.assertNotNull(repository);
+        assertThat(repository, notNullValue());
         assertThat(mockGitHub.getRequestCount(), equalTo(requestCount + 1));
 
-        Assert.assertNotNull(repository.getReadme());
+        assertThat(repository.getReadme(), notNullValue());
         assertThat(mockGitHub.getRequestCount(), equalTo(requestCount + 2));
 
         // isTemplate() does not call populate() from create
@@ -107,8 +107,8 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
                 .owner(GITHUB_API_TEST_ORG)
                 .create();
 
-        Assert.assertNotNull(repository);
-        Assert.assertNotNull(repository.getReadme());
+        assertThat(repository, notNullValue());
+        assertThat(repository.getReadme(), notNullValue());
 
     }
 
@@ -139,20 +139,22 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
 
         List<GHUser> admins = org.listMembersWithFilter("all").toList();
 
-        assertNotNull(admins);
-        assertTrue(admins.size() >= 12); // In case more are added in the future
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("alexanderrtaylor")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("asthinasthi")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("bitwiseman")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("farmdawgnation")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("halkeye")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("jberglund-BSFT")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("kohsuke")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("kohsuke2")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("martinvanzijl")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("PauloMigAlmeida")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("Sage-Pierce")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("timja")));
+        assertThat(admins, notNullValue());
+        // In case more are added in the future
+        assertThat(admins.size(), greaterThanOrEqualTo(12));
+        assertThat(admins.stream().map(GHUser::getLogin).collect(Collectors.toList()),
+                hasItems("alexanderrtaylor",
+                        "asthinasthi",
+                        "bitwiseman",
+                        "farmdawgnation",
+                        "halkeye",
+                        "jberglund-BSFT",
+                        "kohsuke",
+                        "kohsuke2",
+                        "martinvanzijl",
+                        "PauloMigAlmeida",
+                        "Sage-Pierce",
+                        "timja"));
     }
 
     @Test
@@ -161,20 +163,22 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
 
         List<GHUser> admins = org.listMembersWithRole("admin").toList();
 
-        assertNotNull(admins);
-        assertTrue(admins.size() >= 12); // In case more are added in the future
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("alexanderrtaylor")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("asthinasthi")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("bitwiseman")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("farmdawgnation")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("halkeye")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("jberglund-BSFT")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("kohsuke")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("kohsuke2")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("martinvanzijl")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("PauloMigAlmeida")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("Sage-Pierce")));
-        assertTrue(admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("timja")));
+        assertThat(admins, notNullValue());
+        // In case more are added in the future
+        assertThat(admins.size(), greaterThanOrEqualTo(12));
+        assertThat(admins.stream().map(GHUser::getLogin).collect(Collectors.toList()),
+                hasItems("alexanderrtaylor",
+                        "asthinasthi",
+                        "bitwiseman",
+                        "farmdawgnation",
+                        "halkeye",
+                        "jberglund-BSFT",
+                        "kohsuke",
+                        "kohsuke2",
+                        "martinvanzijl",
+                        "PauloMigAlmeida",
+                        "Sage-Pierce",
+                        "timja"));
     }
 
     @Test
@@ -186,8 +190,8 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
 
         // Create team with access to repository. Check access was granted.
         GHTeam team = org.createTeam(TEAM_NAME_CREATE, GHOrganization.Permission.PUSH, repo);
-        Assert.assertTrue(team.getRepositories().containsKey(REPO_NAME));
-        assertEquals(Permission.PUSH.toString().toLowerCase(), team.getPermission());
+        assertThat(team.getRepositories().containsKey(REPO_NAME), is(true));
+        assertThat(team.getPermission(), equalTo(Permission.PUSH.toString().toLowerCase()));
     }
 
     @Test
@@ -200,8 +204,8 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
 
         // Create team with no permission field. Verify that default permission is pull
         GHTeam team = org.createTeam(TEAM_NAME_CREATE, repo);
-        Assert.assertTrue(team.getRepositories().containsKey(REPO_NAME));
-        assertEquals(DEFAULT_PERMISSION, team.getPermission());
+        assertThat(team.getRepositories().containsKey(REPO_NAME), is(true));
+        assertThat(team.getPermission(), equalTo(DEFAULT_PERMISSION));
     }
 
     @Test
@@ -209,7 +213,7 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
         GHOrganization org = gitHub.getOrganization(GITHUB_API_TEST_ORG);
 
         GHTeam team = org.createTeam(TEAM_NAME_CREATE).privacy(GHTeam.Privacy.CLOSED).create();
-        assertEquals(GHTeam.Privacy.CLOSED, team.getPrivacy());
+        assertThat(team.getPrivacy(), equalTo(GHTeam.Privacy.CLOSED));
     }
 
     @Test
@@ -224,7 +228,7 @@ public class GHOrganizationTest extends AbstractGitHubWireMockTest {
                 .privacy(GHTeam.Privacy.CLOSED)
                 .parentTeamId(3617900)
                 .create();
-        assertEquals("Team description", team.getDescription());
-        assertEquals(GHTeam.Privacy.CLOSED, team.getPrivacy());
+        assertThat(team.getDescription(), equalTo("Team description"));
+        assertThat(team.getPrivacy(), equalTo(GHTeam.Privacy.CLOSED));
     }
 }

src/test/java/org/kohsuke/github/GHPersonTest.java

@@ -4,6 +4,9 @@ import org.junit.Test;
 
 import java.io.IOException;
 
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.notNullValue;
+
 /**
  * @author Martin van Zijl
  */
@@ -12,15 +15,15 @@ public class GHPersonTest extends AbstractGitHubWireMockTest {
     public void testFieldsForOrganization() throws Exception {
         GHRepository repo = getRepository();
         GHUser owner = repo.getOwner();
-        assertEquals("Organization", owner.getType());
-        assertNotNull(owner.isSiteAdmin());
+        assertThat(owner.getType(), equalTo("Organization"));
+        assertThat(owner.isSiteAdmin(), notNullValue());
     }
 
     @Test
     public void testFieldsForUser() throws Exception {
         GHUser user = gitHub.getUser("kohsuke2");
-        assertEquals("User", user.getType());
-        assertNotNull(user.isSiteAdmin());
+        assertThat(user.getType(), equalTo("User"));
+        assertThat(user.isSiteAdmin(), notNullValue());
     }
 
     protected GHRepository getRepository() throws IOException {

src/test/java/org/kohsuke/github/GHProjectCardTest.java

@@ -1,13 +1,14 @@
 package org.kohsuke.github;
 
 import org.junit.After;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
 
+import static org.hamcrest.Matchers.*;
+
 /**
  * @author Gunnar Skjold
  */
@@ -27,24 +28,24 @@ public class GHProjectCardTest extends AbstractGitHubWireMockTest {
 
     @Test
     public void testCreatedCard() {
-        Assert.assertEquals("This is a card", card.getNote());
-        Assert.assertFalse(card.isArchived());
+        assertThat(card.getNote(), equalTo("This is a card"));
+        assertThat(card.isArchived(), is(false));
     }
 
     @Test
     public void testEditCardNote() throws IOException {
         card.setNote("New note");
         card = gitHub.getProjectCard(card.getId());
-        Assert.assertEquals("New note", card.getNote());
-        Assert.assertFalse(card.isArchived());
+        assertThat(card.getNote(), equalTo("New note"));
+        assertThat(card.isArchived(), is(false));
     }
 
     @Test
     public void testArchiveCard() throws IOException {
         card.setArchived(true);
         card = gitHub.getProjectCard(card.getId());
-        Assert.assertEquals("This is a card", card.getNote());
-        Assert.assertTrue(card.isArchived());
+        assertThat(card.getNote(), equalTo("This is a card"));
+        assertThat(card.isArchived(), is(true));
     }
 
     @Test
@@ -53,7 +54,7 @@ public class GHProjectCardTest extends AbstractGitHubWireMockTest {
         try {
             GHIssue issue = repo.createIssue("new-issue").body("With body").create();
             GHProjectCard card = column.createCard(issue);
-            Assert.assertEquals(issue.getUrl(), card.getContentUrl());
+            assertThat(card.getContentUrl(), equalTo(issue.getUrl()));
         } finally {
             repo.delete();
         }
@@ -64,7 +65,7 @@ public class GHProjectCardTest extends AbstractGitHubWireMockTest {
         card.delete();
         try {
             card = gitHub.getProjectCard(card.getId());
-            Assert.assertNull(card);
+            assertThat(card, nullValue());
         } catch (FileNotFoundException e) {
             card = null;
         }
@@ -74,7 +75,7 @@ public class GHProjectCardTest extends AbstractGitHubWireMockTest {
     public void after() throws IOException {
         if (mockGitHub.isUseProxy()) {
             if (card != null) {
-                card = getGitHubBeforeAfter().getProjectCard(card.getId());
+                card = getNonRecordingGitHub().getProjectCard(card.getId());
                 try {
                     card.delete();
                     card = null;
@@ -83,7 +84,7 @@ public class GHProjectCardTest extends AbstractGitHubWireMockTest {
                 }
             }
             if (column != null) {
-                column = getGitHubBeforeAfter().getProjectColumn(column.getId());
+                column = getNonRecordingGitHub().getProjectColumn(column.getId());
                 try {
                     column.delete();
                     column = null;
@@ -92,7 +93,7 @@ public class GHProjectCardTest extends AbstractGitHubWireMockTest {
                 }
             }
             if (project != null) {
-                project = getGitHubBeforeAfter().getProject(project.getId());
+                project = getNonRecordingGitHub().getProject(project.getId());
                 try {
                     project.delete();
                     project = null;

src/test/java/org/kohsuke/github/GHProjectColumnTest.java

@@ -1,13 +1,15 @@
 package org.kohsuke.github;
 
 import org.junit.After;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
 
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.nullValue;
+
 /**
  * @author Gunnar Skjold
  */
@@ -23,14 +25,14 @@ public class GHProjectColumnTest extends AbstractGitHubWireMockTest {
 
     @Test
     public void testCreatedColumn() {
-        Assert.assertEquals("column-one", column.getName());
+        assertThat(column.getName(), equalTo("column-one"));
     }
 
     @Test
     public void testEditColumnName() throws IOException {
         column.setName("new-name");
         column = gitHub.getProjectColumn(column.getId());
-        Assert.assertEquals("new-name", column.getName());
+        assertThat(column.getName(), equalTo("new-name"));
     }
 
     @Test
@@ -38,7 +40,7 @@ public class GHProjectColumnTest extends AbstractGitHubWireMockTest {
         column.delete();
         try {
             column = gitHub.getProjectColumn(column.getId());
-            Assert.assertNull(column);
+            assertThat(column, nullValue());
         } catch (FileNotFoundException e) {
             column = null;
         }
@@ -48,7 +50,7 @@ public class GHProjectColumnTest extends AbstractGitHubWireMockTest {
     public void after() throws IOException {
         if (mockGitHub.isUseProxy()) {
             if (column != null) {
-                column = getGitHubBeforeAfter().getProjectColumn(column.getId());
+                column = getNonRecordingGitHub().getProjectColumn(column.getId());
                 try {
                     column.delete();
                     column = null;
@@ -57,7 +59,7 @@ public class GHProjectColumnTest extends AbstractGitHubWireMockTest {
                 }
             }
             if (project != null) {
-                project = getGitHubBeforeAfter().getProject(project.getId());
+                project = getNonRecordingGitHub().getProject(project.getId());
                 try {
                     project.delete();
                     project = null;

src/test/java/org/kohsuke/github/GHProjectTest.java

@@ -1,13 +1,14 @@
 package org.kohsuke.github;
 
 import org.junit.After;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
 
+import static org.hamcrest.Matchers.*;
+
 /**
  * @author Gunnar Skjold
  */
@@ -21,37 +22,37 @@ public class GHProjectTest extends AbstractGitHubWireMockTest {
 
     @Test
     public void testCreatedProject() {
-        Assert.assertNotNull(project);
-        Assert.assertEquals("test-project", project.getName());
-        Assert.assertEquals("This is a test project", project.getBody());
-        Assert.assertEquals(GHProject.ProjectState.OPEN, project.getState());
+        assertThat(project, notNullValue());
+        assertThat(project.getName(), equalTo("test-project"));
+        assertThat(project.getBody(), equalTo("This is a test project"));
+        assertThat(project.getState(), equalTo(GHProject.ProjectState.OPEN));
     }
 
     @Test
     public void testEditProjectName() throws IOException {
         project.setName("new-name");
         project = gitHub.getProject(project.getId());
-        Assert.assertEquals("new-name", project.getName());
-        Assert.assertEquals("This is a test project", project.getBody());
-        Assert.assertEquals(GHProject.ProjectState.OPEN, project.getState());
+        assertThat(project.getName(), equalTo("new-name"));
+        assertThat(project.getBody(), equalTo("This is a test project"));
+        assertThat(project.getState(), equalTo(GHProject.ProjectState.OPEN));
     }
 
     @Test
     public void testEditProjectBody() throws IOException {
         project.setBody("New body");
         project = gitHub.getProject(project.getId());
-        Assert.assertEquals("test-project", project.getName());
-        Assert.assertEquals("New body", project.getBody());
-        Assert.assertEquals(GHProject.ProjectState.OPEN, project.getState());
+        assertThat(project.getName(), equalTo("test-project"));
+        assertThat(project.getBody(), equalTo("New body"));
+        assertThat(project.getState(), equalTo(GHProject.ProjectState.OPEN));
     }
 
     @Test
     public void testEditProjectState() throws IOException {
         project.setState(GHProject.ProjectState.CLOSED);
         project = gitHub.getProject(project.getId());
-        Assert.assertEquals("test-project", project.getName());
-        Assert.assertEquals("This is a test project", project.getBody());
-        Assert.assertEquals(GHProject.ProjectState.CLOSED, project.getState());
+        assertThat(project.getName(), equalTo("test-project"));
+        assertThat(project.getBody(), equalTo("This is a test project"));
+        assertThat(project.getState(), equalTo(GHProject.ProjectState.CLOSED));
     }
 
     @Test
@@ -59,7 +60,7 @@ public class GHProjectTest extends AbstractGitHubWireMockTest {
         project.delete();
         try {
             project = gitHub.getProject(project.getId());
-            Assert.assertNull(project);
+            assertThat(project, nullValue());
         } catch (FileNotFoundException e) {
             project = null;
         }
@@ -69,7 +70,7 @@ public class GHProjectTest extends AbstractGitHubWireMockTest {
     public void after() throws IOException {
         if (mockGitHub.isUseProxy()) {
             if (project != null) {
-                project = getGitHubBeforeAfter().getProject(project.getId());
+                project = getNonRecordingGitHub().getProject(project.getId());
                 try {
                     project.delete();
                     project = null;

src/test/java/org/kohsuke/github/GHPullRequestTest.java

@@ -9,14 +9,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasProperty;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.notNullValue;
-import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.Matchers.*;
 
 /**
  * @author Kohsuke Kawaguchi
@@ -31,7 +24,7 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
             return;
         }
 
-        for (GHPullRequest pr : getRepository(this.getGitHubBeforeAfter()).getPullRequests(GHIssueState.OPEN)) {
+        for (GHPullRequest pr : getRepository(this.getNonRecordingGitHub()).getPullRequests(GHIssueState.OPEN)) {
             pr.close();
         }
     }
@@ -40,8 +33,8 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     public void createPullRequest() throws Exception {
         String name = "createPullRequest";
         GHRepository repo = getRepository();
-        GHPullRequest p = repo.createPullRequest(name, "test/stable", "master", "## test");
-        assertEquals(name, p.getTitle());
+        GHPullRequest p = repo.createPullRequest(name, "test/stable", "main", "## test");
+        assertThat(p.getTitle(), equalTo(name));
         assertThat(p.canMaintainerModify(), is(false));
         assertThat(p.isDraft(), is(false));
     }
@@ -50,8 +43,8 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     public void createDraftPullRequest() throws Exception {
         String name = "createDraftPullRequest";
         GHRepository repo = getRepository();
-        GHPullRequest p = repo.createPullRequest(name, "test/stable", "master", "## test", false, true);
-        assertEquals(name, p.getTitle());
+        GHPullRequest p = repo.createPullRequest(name, "test/stable", "main", "## test", false, true);
+        assertThat(p.getTitle(), equalTo(name));
         assertThat(p.canMaintainerModify(), is(false));
         assertThat(p.isDraft(), is(true));
 
@@ -73,25 +66,25 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     @Test
     public void createPullRequestComment() throws Exception {
         String name = "createPullRequestComment";
-        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "main", "## test");
         p.comment("Some comment");
     }
 
     @Test
     public void closePullRequest() throws Exception {
         String name = "closePullRequest";
-        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "main", "## test");
         // System.out.println(p.getUrl());
-        assertEquals(name, p.getTitle());
-        assertEquals(GHIssueState.OPEN, getRepository().getPullRequest(p.getNumber()).getState());
+        assertThat(p.getTitle(), equalTo(name));
+        assertThat(getRepository().getPullRequest(p.getNumber()).getState(), equalTo(GHIssueState.OPEN));
         p.close();
-        assertEquals(GHIssueState.CLOSED, getRepository().getPullRequest(p.getNumber()).getState());
+        assertThat(getRepository().getPullRequest(p.getNumber()).getState(), equalTo(GHIssueState.CLOSED));
     }
 
     @Test
     public void pullRequestReviews() throws Exception {
         String name = "testPullRequestReviews";
-        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "main", "## test");
         GHPullRequestReview draftReview = p.createReview()
                 .body("Some draft review")
                 .comment("Some niggle", "README.md", 1)
@@ -107,9 +100,9 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
         assertThat(review.getCommitId(), notNullValue());
         draftReview.submit("Some review comment", GHPullRequestReviewEvent.COMMENT);
         List<GHPullRequestReviewComment> comments = review.listReviewComments().toList();
-        assertEquals(1, comments.size());
+        assertThat(comments.size(), equalTo(1));
         GHPullRequestReviewComment comment = comments.get(0);
-        assertEquals("Some niggle", comment.getBody());
+        assertThat(comment.getBody(), equalTo("Some niggle"));
         draftReview = p.createReview().body("Some new review").comment("Some niggle", "README.md", 1).create();
         draftReview.delete();
     }
@@ -117,15 +110,15 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     @Test
     public void pullRequestReviewComments() throws Exception {
         String name = "pullRequestReviewComments";
-        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "main", "## test");
         try {
             // System.out.println(p.getUrl());
-            assertTrue(p.listReviewComments().toList().isEmpty());
+            assertThat(p.listReviewComments().toList(), is(empty()));
             p.createReviewComment("Sample review comment", p.getHead().getSha(), "README.md", 1);
             List<GHPullRequestReviewComment> comments = p.listReviewComments().toList();
-            assertEquals(1, comments.size());
+            assertThat(comments.size(), equalTo(1));
             GHPullRequestReviewComment comment = comments.get(0);
-            assertEquals("Sample review comment", comment.getBody());
+            assertThat(comment.getBody(), equalTo("Sample review comment"));
             assertThat(comment.getInReplyToId(), equalTo(-1L));
             assertThat(comment.getPath(), equalTo("README.md"));
             assertThat(comment.getPosition(), equalTo(1));
@@ -136,7 +129,7 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
                     containsString("hub4j-test-org/github-api/pull/" + p.getNumber()));
 
             List<GHReaction> reactions = comment.listReactions().toList();
-            assertThat(reactions.size(), equalTo(0));
+            assertThat(reactions, is(empty()));
 
             GHReaction reaction = comment.createReaction(ReactionContent.CONFUSED);
             assertThat(reaction.getContent(), equalTo(ReactionContent.CONFUSED));
@@ -148,12 +141,12 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
             assertThat(reply.getInReplyToId(), equalTo(comment.getId()));
             comments = p.listReviewComments().toList();
 
-            assertEquals(2, comments.size());
+            assertThat(comments.size(), equalTo(2));
 
             comment.update("Updated review comment");
             comments = p.listReviewComments().toList();
             comment = comments.get(0);
-            assertEquals("Updated review comment", comment.getBody());
+            assertThat(comment.getBody(), equalTo("Updated review comment"));
 
             comment.delete();
             comments = p.listReviewComments().toList();
@@ -169,22 +162,22 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     @Test
     public void testPullRequestReviewRequests() throws Exception {
         String name = "testPullRequestReviewRequests";
-        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "main", "## test");
         // System.out.println(p.getUrl());
-        assertTrue(p.getRequestedReviewers().isEmpty());
+        assertThat(p.getRequestedReviewers(), is(empty()));
 
         GHUser kohsuke2 = gitHub.getUser("kohsuke2");
         p.requestReviewers(Collections.singletonList(kohsuke2));
         p.refresh();
-        assertFalse(p.getRequestedReviewers().isEmpty());
+        assertThat(p.getRequestedReviewers(), is(not(empty())));
     }
 
     @Test
     public void testPullRequestTeamReviewRequests() throws Exception {
         String name = "testPullRequestTeamReviewRequests";
-        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest(name, "test/stable", "main", "## test");
         // System.out.println(p.getUrl());
-        assertTrue(p.getRequestedReviewers().isEmpty());
+        assertThat(p.getRequestedReviewers(), is(empty()));
 
         GHOrganization testOrg = gitHub.getOrganization("hub4j-test-org");
         GHTeam testTeam = testOrg.getTeamBySlug("dummy-team");
@@ -212,7 +205,7 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     public void mergeCommitSHA() throws Exception {
         String name = "mergeCommitSHA";
         GHRepository repo = getRepository();
-        GHPullRequest p = repo.createPullRequest(name, "test/mergeable_branch", "master", "## test");
+        GHPullRequest p = repo.createPullRequest(name, "test/mergeable_branch", "main", "## test");
         int baseRequestCount = mockGitHub.getRequestCount();
         assertThat(p.getMergeableNoRefresh(), nullValue());
         assertThat("Used existing value", mockGitHub.getRequestCount() - baseRequestCount, equalTo(0));
@@ -227,7 +220,7 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
 
                 // make sure commit exists
                 GHCommit commit = repo.getCommit(p.getMergeCommitSha());
-                assertNotNull(commit);
+                assertThat(commit, notNullValue());
 
                 assertThat("Asked for PR information", mockGitHub.getRequestCount() - baseRequestCount, equalTo(i + 1));
 
@@ -244,33 +237,33 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     @Test
     public void setBaseBranch() throws Exception {
         String prName = "testSetBaseBranch";
-        String originalBaseBranch = "master";
+        String originalBaseBranch = "main";
         String newBaseBranch = "gh-pages";
 
-        GHPullRequest pullRequest = getRepository().createPullRequest(prName, "test/stable", "master", "## test");
+        GHPullRequest pullRequest = getRepository().createPullRequest(prName, "test/stable", "main", "## test");
 
-        assertEquals("Pull request base branch is supposed to be " + originalBaseBranch,
-                originalBaseBranch,
-                pullRequest.getBase().getRef());
+        assertThat("Pull request base branch is supposed to be " + originalBaseBranch,
+                pullRequest.getBase().getRef(),
+                equalTo(originalBaseBranch));
 
         GHPullRequest responsePullRequest = pullRequest.setBaseBranch(newBaseBranch);
 
-        assertEquals("Pull request base branch is supposed to be " + newBaseBranch,
-                newBaseBranch,
-                responsePullRequest.getBase().getRef());
+        assertThat("Pull request base branch is supposed to be " + newBaseBranch,
+                responsePullRequest.getBase().getRef(),
+                equalTo(newBaseBranch));
     }
 
     @Test
     public void setBaseBranchNonExisting() throws Exception {
         String prName = "testSetBaseBranchNonExisting";
-        String originalBaseBranch = "master";
+        String originalBaseBranch = "main";
         String newBaseBranch = "non-existing";
 
-        GHPullRequest pullRequest = getRepository().createPullRequest(prName, "test/stable", "master", "## test");
+        GHPullRequest pullRequest = getRepository().createPullRequest(prName, "test/stable", "main", "## test");
 
-        assertEquals("Pull request base branch is supposed to be " + originalBaseBranch,
-                originalBaseBranch,
-                pullRequest.getBase().getRef());
+        assertThat("Pull request base branch is supposed to be " + originalBaseBranch,
+                pullRequest.getBase().getRef(),
+                equalTo(originalBaseBranch));
 
         try {
             pullRequest.setBaseBranch(newBaseBranch);
@@ -291,16 +284,16 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
         GHRef outdatedRef = repository.getRef(outdatedRefName);
         outdatedRef.updateTo("6440189369f9f33b2366556a94dbc26f2cfdd969", true);
 
-        GHPullRequest outdatedPullRequest = repository.createPullRequest(prName, "outdated", "master", "## test");
+        GHPullRequest outdatedPullRequest = repository.createPullRequest(prName, "outdated", "main", "## test");
 
         do {
             Thread.sleep(5000);
             outdatedPullRequest.refresh();
         } while (outdatedPullRequest.getMergeableState().equalsIgnoreCase("unknown"));
 
-        assertEquals("Pull request is supposed to be not up to date",
-                "behind",
-                outdatedPullRequest.getMergeableState());
+        assertThat("Pull request is supposed to be not up to date",
+                outdatedPullRequest.getMergeableState(),
+                equalTo("behind"));
 
         outdatedRef.updateTo("f567328eb81270487864963b7d7446953353f2b5", true);
 
@@ -322,21 +315,21 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
 
         repository.getRef(outdatedRefName).updateTo("6440189369f9f33b2366556a94dbc26f2cfdd969", true);
 
-        GHPullRequest outdatedPullRequest = repository.createPullRequest(prName, "outdated", "master", "## test");
+        GHPullRequest outdatedPullRequest = repository.createPullRequest(prName, "outdated", "main", "## test");
 
         do {
             Thread.sleep(5000);
             outdatedPullRequest.refresh();
         } while (outdatedPullRequest.getMergeableState().equalsIgnoreCase("unknown"));
 
-        assertEquals("Pull request is supposed to be not up to date",
-                "behind",
-                outdatedPullRequest.getMergeableState());
+        assertThat("Pull request is supposed to be not up to date",
+                outdatedPullRequest.getMergeableState(),
+                equalTo("behind"));
 
         outdatedPullRequest.updateBranch();
         outdatedPullRequest.refresh();
 
-        assertNotEquals("Pull request is supposed to be up to date", "behind", outdatedPullRequest.getMergeableState());
+        assertThat("Pull request is supposed to be up to date", outdatedPullRequest.getMergeableState(), not("behind"));
 
         outdatedPullRequest.close();
     }
@@ -345,12 +338,12 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     public void squashMerge() throws Exception {
         String name = "squashMerge";
         String branchName = "test/" + name;
-        GHRef masterRef = getRepository().getRef("heads/master");
-        GHRef branchRef = getRepository().createRef("refs/heads/" + branchName, masterRef.getObject().getSha());
+        GHRef mainRef = getRepository().getRef("heads/main");
+        GHRef branchRef = getRepository().createRef("refs/heads/" + branchName, mainRef.getObject().getSha());
 
         getRepository().createContent(name, name, name, branchName);
         Thread.sleep(1000);
-        GHPullRequest p = getRepository().createPullRequest(name, branchName, "master", "## test squash");
+        GHPullRequest p = getRepository().createPullRequest(name, branchName, "main", "## test squash");
         Thread.sleep(1000);
         p.merge("squash merge", null, GHPullRequest.MergeMethod.SQUASH);
     }
@@ -360,8 +353,8 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
         String name = "updateContentSquashMerge";
         String branchName = "test/" + name;
 
-        GHRef masterRef = getRepository().getRef("heads/master");
-        GHRef branchRef = getRepository().createRef("refs/heads/" + branchName, masterRef.getObject().getSha());
+        GHRef mainRef = getRepository().getRef("heads/main");
+        GHRef branchRef = getRepository().createRef("refs/heads/" + branchName, mainRef.getObject().getSha());
 
         GHContentUpdateResponse response = getRepository().createContent(name, name, name, branchName);
         Thread.sleep(1000);
@@ -373,7 +366,7 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
                 .message(name)
                 .sha(response.getContent().getSha())
                 .commit();
-        GHPullRequest p = getRepository().createPullRequest(name, branchName, "master", "## test squash");
+        GHPullRequest p = getRepository().createPullRequest(name, branchName, "main", "## test squash");
         Thread.sleep(1000);
         p.merge("squash merge", null, GHPullRequest.MergeMethod.SQUASH);
     }
@@ -381,81 +374,84 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     @Test
     public void queryPullRequestsQualifiedHead() throws Exception {
         GHRepository repo = getRepository();
-        // Create PRs from two different branches to master
-        repo.createPullRequest("queryPullRequestsQualifiedHead_stable", "test/stable", "master", null);
-        repo.createPullRequest("queryPullRequestsQualifiedHead_rc", "test/rc", "master", null);
+        // Create PRs from two different branches to main
+        repo.createPullRequest("queryPullRequestsQualifiedHead_stable", "test/stable", "main", null);
+        repo.createPullRequest("queryPullRequestsQualifiedHead_rc", "test/rc", "main", null);
 
         // Query by one of the heads and make sure we only get that branch's PR back.
         List<GHPullRequest> prs = repo.queryPullRequests()
                 .state(GHIssueState.OPEN)
                 .head("hub4j-test-org:test/stable")
-                .base("master")
+                .base("main")
                 .list()
                 .toList();
-        assertNotNull(prs);
-        assertEquals(1, prs.size());
-        assertEquals("test/stable", prs.get(0).getHead().getRef());
+        assertThat(prs, notNullValue());
+        assertThat(prs.size(), equalTo(1));
+        assertThat(prs.get(0).getHead().getRef(), equalTo("test/stable"));
     }
 
     @Test
     public void queryPullRequestsUnqualifiedHead() throws Exception {
         GHRepository repo = getRepository();
-        // Create PRs from two different branches to master
-        repo.createPullRequest("queryPullRequestsUnqualifiedHead_stable", "test/stable", "master", null);
-        repo.createPullRequest("queryPullRequestsUnqualifiedHead_rc", "test/rc", "master", null);
+        // Create PRs from two different branches to main
+        repo.createPullRequest("queryPullRequestsUnqualifiedHead_stable", "test/stable", "main", null);
+        repo.createPullRequest("queryPullRequestsUnqualifiedHead_rc", "test/rc", "main", null);
 
         // Query by one of the heads and make sure we only get that branch's PR back.
         List<GHPullRequest> prs = repo.queryPullRequests()
                 .state(GHIssueState.OPEN)
                 .head("test/stable")
-                .base("master")
+                .base("main")
                 .list()
                 .toList();
-        assertNotNull(prs);
-        assertEquals(1, prs.size());
-        assertEquals("test/stable", prs.get(0).getHead().getRef());
+        assertThat(prs, notNullValue());
+        assertThat(prs.size(), equalTo(1));
+        assertThat(prs.get(0).getHead().getRef(), equalTo("test/stable"));
     }
 
     @Test
     // Requires push access to the test repo to pass
     public void setLabels() throws Exception {
-        GHPullRequest p = getRepository().createPullRequest("setLabels", "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest("setLabels", "test/stable", "main", "## test");
         String label = "setLabels_label_name";
         p.setLabels(label);
 
         Collection<GHLabel> labels = getRepository().getPullRequest(p.getNumber()).getLabels();
-        assertEquals(1, labels.size());
+        assertThat(labels.size(), equalTo(1));
         GHLabel savedLabel = labels.iterator().next();
-        assertEquals(label, savedLabel.getName());
-        assertNotNull(savedLabel.getId());
-        assertNotNull(savedLabel.getNodeId());
-        assertFalse(savedLabel.isDefault());
+        assertThat(savedLabel.getName(), equalTo(label));
+        assertThat(savedLabel.getId(), notNullValue());
+        assertThat(savedLabel.getNodeId(), notNullValue());
+        assertThat(savedLabel.isDefault(), is(false));
     }
 
     @Test
     // Requires push access to the test repo to pass
     public void addLabels() throws Exception {
-        GHPullRequest p = getRepository().createPullRequest("addLabels", "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest("addLabels", "test/stable", "main", "## test");
         String addedLabel1 = "addLabels_label_name_1";
         String addedLabel2 = "addLabels_label_name_2";
         String addedLabel3 = "addLabels_label_name_3";
 
-        p.addLabels(addedLabel1);
+        List<GHLabel> resultingLabels = p.addLabels(addedLabel1);
+        assertThat(resultingLabels.size(), equalTo(1));
+        GHLabel ghLabel = resultingLabels.get(0);
+        assertThat(ghLabel.getName(), equalTo(addedLabel1));
 
         int requestCount = mockGitHub.getRequestCount();
-        p.addLabels(addedLabel2, addedLabel3);
+        resultingLabels = p.addLabels(addedLabel2, addedLabel3);
         // multiple labels can be added with one api call
         assertThat(mockGitHub.getRequestCount(), equalTo(requestCount + 1));
 
-        Collection<GHLabel> labels = getRepository().getPullRequest(p.getNumber()).getLabels();
-        assertEquals(3, labels.size());
-        assertThat(labels,
+        assertThat(resultingLabels.size(), equalTo(3));
+        assertThat(resultingLabels,
                 containsInAnyOrder(hasProperty("name", equalTo(addedLabel1)),
                         hasProperty("name", equalTo(addedLabel2)),
                         hasProperty("name", equalTo(addedLabel3))));
 
         // Adding a label which is already present does not throw an error
-        p.addLabels(addedLabel1);
+        resultingLabels = p.addLabels(ghLabel);
+        assertThat(resultingLabels.size(), equalTo(3));
     }
 
     @Test
@@ -465,16 +461,15 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
         String addedLabel2 = "addLabelsConcurrencyIssue_label_name_2";
 
         GHPullRequest p1 = getRepository()
-                .createPullRequest("addLabelsConcurrencyIssue", "test/stable", "master", "## test");
+                .createPullRequest("addLabelsConcurrencyIssue", "test/stable", "main", "## test");
         p1.getLabels();
 
         GHPullRequest p2 = getRepository().getPullRequest(p1.getNumber());
         p2.addLabels(addedLabel2);
 
-        p1.addLabels(addedLabel1);
+        Collection<GHLabel> labels = p1.addLabels(addedLabel1);
 
-        Collection<GHLabel> labels = getRepository().getPullRequest(p1.getNumber()).getLabels();
-        assertEquals(2, labels.size());
+        assertThat(labels.size(), equalTo(2));
         assertThat(labels,
                 containsInAnyOrder(hasProperty("name", equalTo(addedLabel1)),
                         hasProperty("name", equalTo(addedLabel2))));
@@ -483,27 +478,27 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     @Test
     // Requires push access to the test repo to pass
     public void removeLabels() throws Exception {
-        GHPullRequest p = getRepository().createPullRequest("removeLabels", "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest("removeLabels", "test/stable", "main", "## test");
         String label1 = "removeLabels_label_name_1";
         String label2 = "removeLabels_label_name_2";
         String label3 = "removeLabels_label_name_3";
         p.setLabels(label1, label2, label3);
 
         Collection<GHLabel> labels = getRepository().getPullRequest(p.getNumber()).getLabels();
-        assertEquals(3, labels.size());
+        assertThat(labels.size(), equalTo(3));
+        GHLabel ghLabel3 = labels.stream().filter(label -> label3.equals(label.getName())).findFirst().get();
 
         int requestCount = mockGitHub.getRequestCount();
-        p.removeLabels(label2, label3);
+        List<GHLabel> resultingLabels = p.removeLabels(label2, label3);
         // each label deleted is a separate api call
         assertThat(mockGitHub.getRequestCount(), equalTo(requestCount + 2));
 
-        labels = getRepository().getPullRequest(p.getNumber()).getLabels();
-        assertEquals(1, labels.size());
-        assertEquals(label1, labels.iterator().next().getName());
+        assertThat(resultingLabels.size(), equalTo(1));
+        assertThat(resultingLabels.get(0).getName(), equalTo(label1));
 
         // Removing some labels that are not present does not throw
         // This is consistent with earlier behavior and with addLabels()
-        p.removeLabels(label3);
+        p.removeLabels(ghLabel3);
 
         // Calling removeLabel() on label that is not present will throw
         try {
@@ -517,26 +512,26 @@ public class GHPullRequestTest extends AbstractGitHubWireMockTest {
     @Test
     // Requires push access to the test repo to pass
     public void setAssignee() throws Exception {
-        GHPullRequest p = getRepository().createPullRequest("setAssignee", "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest("setAssignee", "test/stable", "main", "## test");
         GHMyself user = gitHub.getMyself();
         p.assignTo(user);
 
-        assertEquals(user, getRepository().getPullRequest(p.getNumber()).getAssignee());
+        assertThat(getRepository().getPullRequest(p.getNumber()).getAssignee(), equalTo(user));
     }
 
     @Test
     public void getUserTest() throws IOException {
-        GHPullRequest p = getRepository().createPullRequest("getUserTest", "test/stable", "master", "## test");
+        GHPullRequest p = getRepository().createPullRequest("getUserTest", "test/stable", "main", "## test");
         GHPullRequest prSingle = getRepository().getPullRequest(p.getNumber());
-        assertNotNull(prSingle.getUser().getRoot());
+        assertThat(prSingle.getUser().getRoot(), notNullValue());
         prSingle.getMergeable();
-        assertNotNull(prSingle.getUser().getRoot());
+        assertThat(prSingle.getUser().getRoot(), notNullValue());
 
         PagedIterable<GHPullRequest> ghPullRequests = getRepository().listPullRequests(GHIssueState.OPEN);
         for (GHPullRequest pr : ghPullRequests) {
-            assertNotNull(pr.getUser().getRoot());
+            assertThat(pr.getUser().getRoot(), notNullValue());
             pr.getMergeable();
-            assertNotNull(pr.getUser().getRoot());
+            assertThat(pr.getUser().getRoot(), notNullValue());
         }
     }
 

src/test/java/org/kohsuke/github/GHRateLimitTest.java

@@ -493,7 +493,7 @@ public class GHRateLimitTest extends AbstractGitHubWireMockTest {
         // This time, rateLimit() should find an expired record and get a new one.
         Thread.sleep(2500);
 
-        assertThat("Header instance has expired", gitHub.lastRateLimit().isExpired(), is(true));
+        assertThat("Header instance has expired", gitHub.lastRateLimit().isExpired());
 
         assertThat("rateLimit() will ask server when cached instance has expired",
                 gitHub.rateLimit(),

src/test/java/org/kohsuke/github/GHRepositoryStatisticsTest.java

@@ -6,6 +6,8 @@ import java.io.IOException;
 import java.util.List;
 import java.util.NoSuchElementException;
 
+import static org.hamcrest.Matchers.equalTo;
+
 public class GHRepositoryStatisticsTest extends AbstractGitHubWireMockTest {
 
     public static int MAX_ITERATIONS = 3;
@@ -25,7 +27,7 @@ public class GHRepositoryStatisticsTest extends AbstractGitHubWireMockTest {
 
         // check the statistics are accurate
         List<GHRepositoryStatistics.ContributorStats> list = stats.toList();
-        assertEquals(99, list.size());
+        assertThat(list.size(), equalTo(99));
 
         // find a particular developer
         // TODO: Add an accessor method for this instead of having use a loop.
@@ -33,22 +35,22 @@ public class GHRepositoryStatisticsTest extends AbstractGitHubWireMockTest {
         final String authorLogin = "kohsuke";
         for (GHRepositoryStatistics.ContributorStats statsForAuthor : list) {
             if (authorLogin.equals(statsForAuthor.getAuthor().getLogin())) {
-                assertEquals(715, statsForAuthor.getTotal());
-                assertEquals("kohsuke made 715 contributions over 494 weeks", statsForAuthor.toString());
+                assertThat(statsForAuthor.getTotal(), equalTo(715));
+                assertThat(statsForAuthor.toString(), equalTo("kohsuke made 715 contributions over 494 weeks"));
 
                 List<GHRepositoryStatistics.ContributorStats.Week> weeks = statsForAuthor.getWeeks();
-                assertEquals(494, weeks.size());
+                assertThat(weeks.size(), equalTo(494));
 
                 try {
                     // check a particular week
                     // TODO: Maybe add a convenience method to get the week
                     // containing a certain date (Java.Util.Date).
                     GHRepositoryStatistics.ContributorStats.Week week = statsForAuthor.getWeek(1541289600);
-                    assertEquals(63, week.getNumberOfAdditions());
-                    assertEquals(56, week.getNumberOfDeletions());
-                    assertEquals(5, week.getNumberOfCommits());
-                    assertEquals("Week starting 1541289600 - Additions: 63, Deletions: 56, Commits: 5",
-                            week.toString());
+                    assertThat(week.getNumberOfAdditions(), equalTo(63));
+                    assertThat(week.getNumberOfDeletions(), equalTo(56));
+                    assertThat(week.getNumberOfCommits(), equalTo(5));
+                    assertThat(week.toString(),
+                            equalTo("Week starting 1541289600 - Additions: 63, Deletions: 56, Commits: 5"));
                 } catch (NoSuchElementException e) {
                     fail("Did not find week 1546128000");
                 }
@@ -57,7 +59,7 @@ public class GHRepositoryStatisticsTest extends AbstractGitHubWireMockTest {
             }
         }
 
-        assertTrue("Did not find author " + authorLogin, developerFound);
+        assertThat("Did not find author " + authorLogin, developerFound);
     }
 
     @Test
@@ -89,20 +91,20 @@ public class GHRepositoryStatisticsTest extends AbstractGitHubWireMockTest {
         Boolean foundWeek = false;
         for (GHRepositoryStatistics.CommitActivity item : list) {
             if (item.getWeek() == 1566691200) {
-                assertEquals(6, item.getTotal());
+                assertThat(item.getTotal(), equalTo(6));
                 List<Integer> days = item.getDays();
-                assertEquals(0, (long) days.get(0));
-                assertEquals(0, (long) days.get(1));
-                assertEquals(1, (long) days.get(2));
-                assertEquals(0, (long) days.get(3));
-                assertEquals(0, (long) days.get(4));
-                assertEquals(1, (long) days.get(5));
-                assertEquals(4, (long) days.get(6));
+                assertThat((long) days.get(0), equalTo(0L));
+                assertThat((long) days.get(1), equalTo(0L));
+                assertThat((long) days.get(2), equalTo(1L));
+                assertThat((long) days.get(3), equalTo(0L));
+                assertThat((long) days.get(4), equalTo(0L));
+                assertThat((long) days.get(5), equalTo(1L));
+                assertThat((long) days.get(6), equalTo(4L));
                 foundWeek = true;
                 break;
             }
         }
-        assertTrue("Could not find week starting 1546128000", foundWeek);
+        assertThat("Could not find week starting 1546128000", foundWeek);
     }
 
     @Test
@@ -132,14 +134,14 @@ public class GHRepositoryStatisticsTest extends AbstractGitHubWireMockTest {
         Boolean foundWeek = false;
         for (GHRepositoryStatistics.CodeFrequency item : stats) {
             if (item.getWeekTimestamp() == 1535241600) {
-                assertEquals(185, item.getAdditions());
-                assertEquals(-243, item.getDeletions());
-                assertEquals("Week starting 1535241600 has 185 additions and 243 deletions", item.toString());
+                assertThat(item.getAdditions(), equalTo(185L));
+                assertThat(item.getDeletions(), equalTo(-243L));
+                assertThat(item.toString(), equalTo("Week starting 1535241600 has 185 additions and 243 deletions"));
                 foundWeek = true;
                 break;
             }
         }
-        assertTrue("Could not find week starting 1535241600", foundWeek);
+        assertThat("Could not find week starting 1535241600", foundWeek);
     }
 
     @Test
@@ -164,11 +166,11 @@ public class GHRepositoryStatisticsTest extends AbstractGitHubWireMockTest {
 
         // check the statistics are accurate
         List<Integer> allCommits = stats.getAllCommits();
-        assertEquals(52, allCommits.size());
-        assertEquals(2, (int) allCommits.get(2));
+        assertThat(allCommits.size(), equalTo(52));
+        assertThat((int) allCommits.get(2), equalTo(2));
 
         List<Integer> ownerCommits = stats.getOwnerCommits();
-        assertEquals(52, ownerCommits.size());
+        assertThat(ownerCommits.size(), equalTo(52));
         // The values depend on who is running the test.
     }
 
@@ -199,13 +201,13 @@ public class GHRepositoryStatisticsTest extends AbstractGitHubWireMockTest {
             if (item.getDayOfWeek() == 2 && item.getHourOfDay() == 10) {
                 // TODO: Make an easier access method. Perhaps wrap in an
                 // object and have a method such as GetCommits(1, 16).
-                assertEquals(16, item.getNumberOfCommits());
-                assertEquals("Day 2 Hour 10: 16 commits", item.toString());
+                assertThat(item.getNumberOfCommits(), equalTo(16L));
+                assertThat(item.toString(), equalTo("Day 2 Hour 10: 16 commits"));
                 hourFound = true;
                 break;
             }
         }
-        assertTrue("Hour 10 for Day 2 not found.", hourFound);
+        assertThat("Hour 10 for Day 2 not found.", hourFound);
     }
 
     protected GHRepository getRepository() throws IOException {

src/test/java/org/kohsuke/github/GHRepositoryTest.java

@@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.JsonMappingException;
 import org.apache.commons.io.IOUtils;
 import org.junit.Test;
 import org.kohsuke.github.GHCheckRun.Conclusion;
+import org.kohsuke.github.GHRepository.Visibility;
 
 import java.io.ByteArrayInputStream;
 import java.io.FileNotFoundException;
@@ -13,7 +14,9 @@ import java.net.URL;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import static org.hamcrest.Matchers.*;
 import static org.hamcrest.core.IsInstanceOf.instanceOf;
@@ -108,7 +111,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
                 .getCommitShortInfo()
                 .getVerification();
 
-        assertEquals(GPGVERIFY_ERROR, verification.getReason());
+        assertThat(verification.getReason(), equalTo(GPGVERIFY_ERROR));
     }
 
     @Test
@@ -125,13 +128,13 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
                 .getCommitShortInfo()
                 .getVerification();
 
-        assertEquals(UNKNOWN_SIGNATURE_TYPE, verification.getReason());
+        assertThat(verification.getReason(), equalTo(UNKNOWN_SIGNATURE_TYPE));
     }
 
     @Test
     public void listStargazers() throws IOException {
         GHRepository repository = getRepository();
-        assertThat(repository.listStargazers2().toList(), empty());
+        assertThat(repository.listStargazers2().toList(), is(empty()));
 
         repository = gitHub.getOrganization("hub4j").getRepository("github-api");
         Iterable<GHStargazer> stargazers = repository.listStargazers2();
@@ -165,11 +168,11 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
     @Test
     public void subscription() throws Exception {
         GHRepository r = getRepository();
-        assertNull(r.getSubscription());
+        assertThat(r.getSubscription(), nullValue());
         GHSubscription s = r.subscribe(true, false);
         try {
 
-            assertEquals(s.getRepository(), r);
+            assertThat(r, equalTo(s.getRepository()));
             assertThat(s.isIgnored(), equalTo(false));
             assertThat(s.isSubscribed(), equalTo(true));
             assertThat(s.getRepositoryUrl().toString(), containsString("/repos/hub4j-test-org/github-api"));
@@ -181,7 +184,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
             s.delete();
         }
 
-        assertNull(r.getSubscription());
+        assertThat(r.getSubscription(), nullValue());
     }
 
     @Test
@@ -191,11 +194,11 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         String repoName = "test-repo-public";
         GHRepository repo = gitHub.createRepository(repoName).private_(false).create();
         try {
-            assertFalse(repo.isPrivate());
+            assertThat(repo.isPrivate(), is(false));
             repo.setPrivate(true);
-            assertTrue(myself.getRepository(repoName).isPrivate());
+            assertThat(myself.getRepository(repoName).isPrivate(), is(true));
             repo.setPrivate(false);
-            assertFalse(myself.getRepository(repoName).isPrivate());
+            assertThat(myself.getRepository(repoName).isPrivate(), is(false));
         } finally {
             repo.delete();
         }
@@ -223,25 +226,25 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
                 .wiki(false)
                 .done();
 
-        assertTrue(updated.isAllowMergeCommit());
-        assertFalse(updated.isAllowRebaseMerge());
-        assertFalse(updated.isAllowSquashMerge());
-        assertTrue(updated.isDeleteBranchOnMerge());
-        assertTrue(updated.isPrivate());
-        assertFalse(updated.hasDownloads());
-        assertFalse(updated.hasIssues());
-        assertFalse(updated.hasProjects());
-        assertFalse(updated.hasWiki());
+        assertThat(updated.isAllowMergeCommit(), is(true));
+        assertThat(updated.isAllowRebaseMerge(), is(false));
+        assertThat(updated.isAllowSquashMerge(), is(false));
+        assertThat(updated.isDeleteBranchOnMerge(), is(true));
+        assertThat(updated.isPrivate(), is(true));
+        assertThat(updated.hasDownloads(), is(false));
+        assertThat(updated.hasIssues(), is(false));
+        assertThat(updated.hasProjects(), is(false));
+        assertThat(updated.hasWiki(), is(false));
 
-        assertEquals(homepage, updated.getHomepage());
-        assertEquals(description, updated.getDescription());
+        assertThat(updated.getHomepage(), equalTo(homepage));
+        assertThat(updated.getDescription(), equalTo(description));
 
         // test the other merge option and making the repo public again
         GHRepository redux = updated.update().allowMergeCommit(false).allowRebaseMerge(true).private_(false).done();
 
-        assertFalse(redux.isAllowMergeCommit());
-        assertTrue(redux.isAllowRebaseMerge());
-        assertFalse(redux.isPrivate());
+        assertThat(redux.isAllowMergeCommit(), is(false));
+        assertThat(redux.isAllowRebaseMerge(), is(true));
+        assertThat(redux.isPrivate(), is(false));
 
         String updatedDescription = "updated using set()";
         redux = redux.set().description(updatedDescription);
@@ -249,6 +252,30 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         assertThat(redux.getDescription(), equalTo(updatedDescription));
     }
 
+    @Test
+    public void testGetRepositoryWithVisibility() throws IOException {
+        snapshotNotAllowed();
+        final String repoName = "test-repo-visibility";
+        final GHRepository repo = getTempRepository(repoName);
+        assertThat(repo.getVisibility(), equalTo(Visibility.PUBLIC));
+
+        repo.setVisibility(Visibility.INTERNAL);
+        assertThat(gitHub.getRepository(repo.getOwnerName() + "/" + repo.getName()).getVisibility(),
+                equalTo(Visibility.INTERNAL));
+
+        repo.setVisibility(Visibility.PRIVATE);
+        assertThat(gitHub.getRepository(repo.getOwnerName() + "/" + repo.getName()).getVisibility(),
+                equalTo(Visibility.PRIVATE));
+
+        repo.setVisibility(Visibility.PUBLIC);
+        assertThat(gitHub.getRepository(repo.getOwnerName() + "/" + repo.getName()).getVisibility(),
+                equalTo(Visibility.PUBLIC));
+
+        // deliberately bogus response in snapshot
+        assertThat(gitHub.getRepository(repo.getOwnerName() + "/" + repo.getName()).getVisibility(),
+                equalTo(Visibility.UNKNOWN));
+    }
+
     @Test
     public void listContributors() throws IOException {
         GHRepository r = gitHub.getOrganization("hub4j").getRepository("github-api");
@@ -257,7 +284,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
 
         for (GHRepository.Contributor c : r.listContributors()) {
             if (c.getLogin().equals("kohsuke")) {
-                assertTrue(c.getContributions() > 0);
+                assertThat(c.getContributions(), greaterThan(0));
                 kohsuke = true;
             }
             if (i++ > 5) {
@@ -265,22 +292,22 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
             }
         }
 
-        assertTrue(kohsuke);
+        assertThat(kohsuke, is(true));
     }
 
     @Test
     public void getPermission() throws Exception {
         kohsuke();
         GHRepository r = gitHub.getRepository("hub4j-test-org/test-permission");
-        assertEquals(GHPermissionType.ADMIN, r.getPermission("kohsuke"));
-        assertEquals(GHPermissionType.READ, r.getPermission("dude"));
+        assertThat(r.getPermission("kohsuke"), equalTo(GHPermissionType.ADMIN));
+        assertThat(r.getPermission("dude"), equalTo(GHPermissionType.READ));
         r = gitHub.getOrganization("apache").getRepository("groovy");
         try {
             r.getPermission("jglick");
             fail();
         } catch (HttpException x) {
             // x.printStackTrace(); // good
-            assertEquals(403, x.getResponseCode());
+            assertThat(x.getResponseCode(), equalTo(403));
         }
 
         if (false) {
@@ -300,7 +327,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         try {
             // add the repository that have latest release
             GHRelease release = gitHub.getRepository("kamontat/CheckIDNumber").getLatestRelease();
-            assertEquals("v3.0", release.getTagName());
+            assertThat(release.getTagName(), equalTo("v3.0"));
         } catch (IOException e) {
             e.printStackTrace();
             fail();
@@ -321,7 +348,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
 
         GHUser colabUser = collabs.byLogin("jimmysombrero");
 
-        assertEquals(colabUser.getName(), user.getName());
+        assertThat(user.getName(), equalTo(colabUser.getName()));
     }
 
     @Test
@@ -329,7 +356,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         try {
             // add the repository that `NOT` have latest release
             GHRelease release = gitHub.getRepository("kamontat/Java8Example").getLatestRelease();
-            assertNull(release);
+            assertThat(release, nullValue());
         } catch (IOException e) {
             e.printStackTrace();
             fail();
@@ -339,39 +366,42 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
     @Test
     public void listReleases() throws IOException {
         PagedIterable<GHRelease> releases = gitHub.getOrganization("github").getRepository("hub").listReleases();
-        assertTrue(releases.iterator().hasNext());
+        assertThat(releases, is(not(emptyIterable())));
     }
 
     @Test
     public void getReleaseExists() throws IOException {
         GHRelease release = gitHub.getOrganization("github").getRepository("hub").getRelease(6839710);
-        assertEquals("v2.3.0-pre10", release.getTagName());
+        assertThat(release.getTagName(), equalTo("v2.3.0-pre10"));
     }
 
     @Test
     public void getReleaseDoesNotExist() throws IOException {
         GHRelease release = gitHub.getOrganization("github").getRepository("hub").getRelease(Long.MAX_VALUE);
-        assertNull(release);
+        assertThat(release, nullValue());
     }
 
     @Test
     public void getReleaseByTagNameExists() throws IOException {
         GHRelease release = gitHub.getOrganization("github").getRepository("hub").getReleaseByTagName("v2.3.0-pre10");
-        assertNotNull(release);
-        assertEquals("v2.3.0-pre10", release.getTagName());
+        assertThat(release, notNullValue());
+        assertThat(release.getTagName(), equalTo("v2.3.0-pre10"));
     }
 
     @Test
     public void getReleaseByTagNameDoesNotExist() throws IOException {
         GHRelease release = getRepository().getReleaseByTagName("foo-bar-baz");
-        assertNull(release);
+        assertThat(release, nullValue());
     }
 
     @Test
     public void listLanguages() throws IOException {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         String mainLanguage = r.getLanguage();
-        assertTrue(r.listLanguages().containsKey(mainLanguage));
+        assertThat(mainLanguage, equalTo("Java"));
+        Map<String, Long> languages = r.listLanguages();
+        assertThat(languages.containsKey(mainLanguage), is(true));
+        assertThat(languages.get("Java"), greaterThan(100000L));
     }
 
     @Test
@@ -389,17 +419,17 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
                 .listCommitComments("499d91f9f846b0087b2a20cf3648b49dc9c2eeef")
                 .toList();
 
-        assertThat("Two comments present", commitComments.size() == 2);
-        assertThat("Comment text found", commitComments.stream().anyMatch(it -> it.body.equals("comment 1")));
-        assertThat("Comment text found", commitComments.stream().anyMatch(it -> it.body.equals("comment 2")));
+        assertThat("Two comments present", commitComments.size(), equalTo(2));
+        assertThat("Comment text found",
+                commitComments.stream().map(GHCommitComment::getBody).collect(Collectors.toList()),
+                containsInAnyOrder("comment 1", "comment 2"));
     }
 
     @Test // Issue #261
     public void listEmptyContributors() throws IOException {
-        for (GHRepository.Contributor c : gitHub.getRepository(GITHUB_API_TEST_ORG + "/empty").listContributors()) {
-            // System.out.println(c);
-            fail("This list should be empty, but should return a valid empty iterable.");
-        }
+        assertThat("This list should be empty, but should return a valid empty iterable.",
+                gitHub.getRepository(GITHUB_API_TEST_ORG + "/empty").listContributors(),
+                is(emptyIterable()));
     }
 
     @Test
@@ -411,9 +441,9 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
                 .list();
         GHRepository u = r.iterator().next();
         // System.out.println(u.getName());
-        assertNotNull(u.getId());
-        assertEquals("Assembly", u.getLanguage());
-        assertTrue(r.getTotalCount() > 0);
+        assertThat(u.getId(), notNullValue());
+        assertThat(u.getLanguage(), equalTo("Assembly"));
+        assertThat(r.getTotalCount(), greaterThan(0));
     }
 
     @Test // issue #162
@@ -425,23 +455,24 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
                 String content1 = content.getContent();
                 String content2 = r.getFileContent(content.getPath(), "gh-pages").getContent();
                 // System.out.println(content.getPath());
-                assertEquals(content1, content2);
+                assertThat(content2, equalTo(content1));
             }
         }
     }
 
     @Test
     public void markDown() throws Exception {
-        assertEquals("<p><strong>Test日本語</strong></p>", IOUtils.toString(gitHub.renderMarkdown("**Test日本語**")).trim());
+        assertThat(IOUtils.toString(gitHub.renderMarkdown("**Test日本語**")).trim(),
+                equalTo("<p><strong>Test日本語</strong></p>"));
 
         String actual = IOUtils.toString(
                 gitHub.getRepository("hub4j/github-api").renderMarkdown("@kohsuke to fix issue #1", MarkdownMode.GFM));
         // System.out.println(actual);
-        assertTrue(actual.contains("href=\"https://github.com/kohsuke\""));
-        assertTrue(actual.contains("href=\"https://github.com/hub4j/github-api/pull/1\""));
-        assertTrue(actual.contains("class=\"user-mention\""));
-        assertTrue(actual.contains("class=\"issue-link "));
-        assertTrue(actual.contains("to fix issue"));
+        assertThat(actual, containsString("href=\"https://github.com/kohsuke\""));
+        assertThat(actual, containsString("href=\"https://github.com/hub4j/github-api/pull/1\""));
+        assertThat(actual, containsString("class=\"user-mention\""));
+        assertThat(actual, containsString("class=\"issue-link "));
+        assertThat(actual, containsString("to fix issue"));
     }
 
     @Test
@@ -457,9 +488,9 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         r.allowRebaseMerge(false);
 
         r = gitHub.getRepository(r.getFullName());
-        assertFalse(r.isAllowMergeCommit());
-        assertFalse(r.isAllowRebaseMerge());
-        assertTrue(r.isAllowSquashMerge());
+        assertThat(r.isAllowMergeCommit(), is(false));
+        assertThat(r.isAllowRebaseMerge(), is(false));
+        assertThat(r.isAllowSquashMerge(), is(true));
 
         // flip the last value
         r.allowMergeCommit(true);
@@ -467,15 +498,15 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         r.allowSquashMerge(false);
 
         r = gitHub.getRepository(r.getFullName());
-        assertTrue(r.isAllowMergeCommit());
-        assertTrue(r.isAllowRebaseMerge());
-        assertFalse(r.isAllowSquashMerge());
+        assertThat(r.isAllowMergeCommit(), is(true));
+        assertThat(r.isAllowRebaseMerge(), is(true));
+        assertThat(r.isAllowSquashMerge(), is(false));
     }
 
     @Test
     public void getDeleteBranchOnMerge() throws IOException {
         GHRepository r = getRepository();
-        assertNotNull(r.isDeleteBranchOnMerge());
+        assertThat(r.isDeleteBranchOnMerge(), notNullValue());
     }
 
     @Test
@@ -486,13 +517,13 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         r.deleteBranchOnMerge(true);
 
         r = gitHub.getRepository(r.getFullName());
-        assertTrue(r.isDeleteBranchOnMerge());
+        assertThat(r.isDeleteBranchOnMerge(), is(true));
 
         // flip the last value
         r.deleteBranchOnMerge(false);
 
         r = gitHub.getRepository(r.getFullName());
-        assertFalse(r.isDeleteBranchOnMerge());
+        assertThat(r.isDeleteBranchOnMerge(), is(false));
     }
 
     @Test
@@ -527,7 +558,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
 
         topics = new ArrayList<>();
         repo.setTopics(topics);
-        assertTrue("Topics can be set to empty", repo.listTopics().isEmpty());
+        assertThat("Topics can be set to empty", repo.listTopics(), is(empty()));
     }
 
     @Test
@@ -541,7 +572,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
     public void getPostCommitHooks() throws Exception {
         GHRepository repo = getRepository(gitHub);
         Set<URL> postcommitHooks = repo.getPostCommitHooks();
-        assertThat(postcommitHooks.size(), equalTo(0));
+        assertThat(postcommitHooks, is(empty()));
     }
 
     @Test
@@ -550,7 +581,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         GHRef[] refs = repo.getRefs();
         assertThat(refs, notNullValue());
         assertThat(refs.length, equalTo(1));
-        assertThat(refs[0].getRef(), equalTo("refs/heads/master"));
+        assertThat(refs[0].getRef(), equalTo("refs/heads/main"));
     }
 
     @Test
@@ -559,7 +590,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         GHRef[] refs = repo.getRefs("heads");
         assertThat(refs, notNullValue());
         assertThat(refs.length, equalTo(1));
-        assertThat(refs[0].getRef(), equalTo("refs/heads/master"));
+        assertThat(refs[0].getRef(), equalTo("refs/heads/main"));
     }
 
     @Test
@@ -668,7 +699,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         List<GHRef> refs = repo.listRefs("heads").toList();
         assertThat(refs, notNullValue());
         assertThat(refs.size(), equalTo(1));
-        assertThat(refs.get(0).getRef(), equalTo("refs/heads/master"));
+        assertThat(refs.get(0).getRef(), equalTo("refs/heads/main"));
     }
 
     @Test
@@ -688,7 +719,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         GHRepository repo = getTempRepository();
         List<GHTag> refs = repo.listTags().toList();
         assertThat(refs, notNullValue());
-        assertThat(refs.size(), equalTo(0));
+        assertThat(refs, is(empty()));
     }
 
     @Test
@@ -704,7 +735,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         snapshotNotAllowed();
         GHRepository repo = getTempRepository();
         int watchersCount = repo.getWatchersCount();
-        assertEquals(10, watchersCount);
+        assertThat(watchersCount, equalTo(10));
     }
 
     @Test
@@ -712,7 +743,7 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
         snapshotNotAllowed();
         GHRepository repo = getTempRepository();
         int stargazersCount = repo.getStargazersCount();
-        assertEquals(10, stargazersCount);
+        assertThat(stargazersCount, equalTo(10));
     }
 
     @Test
@@ -748,6 +779,11 @@ public class GHRepositoryTest extends AbstractGitHubWireMockTest {
             checkRunsCount++;
         }
         assertThat(checkRunsCount, equalTo(expectedCount));
+
+        // Check that we can call update on the results
+        for (GHCheckRun checkRun : checkRuns) {
+            checkRun.update();
+        }
     }
 
     @Test

src/test/java/org/kohsuke/github/GHTagTest.java

@@ -7,8 +7,6 @@ import org.junit.Test;
 import java.io.IOException;
 
 import static org.hamcrest.Matchers.*;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
 
 /**
  *
@@ -25,7 +23,7 @@ public class GHTagTest extends AbstractGitHubWireMockTest {
         }
 
         try {
-            GHRef ref = getRepository(this.getGitHubBeforeAfter()).getRef("tags/create_tag_test");
+            GHRef ref = getRepository(this.getNonRecordingGitHub()).getRef("tags/create_tag_test");
             if (ref != null) {
                 ref.delete();
             }
@@ -45,11 +43,11 @@ public class GHTagTest extends AbstractGitHubWireMockTest {
         String tagType = "commit";
 
         GHTagObject tag = repo.createTag(tagName, tagMessage, commitSha, tagType);
-        assertEquals(tagName, tag.getTag());
-        assertEquals(tagMessage, tag.getMessage());
-        assertEquals(commitSha, tag.getObject().getSha());
-        assertFalse(tag.getVerification().isVerified());
-        assertEquals(tag.getVerification().getReason(), GHVerification.Reason.UNSIGNED);
+        assertThat(tag.getTag(), equalTo(tagName));
+        assertThat(tag.getMessage(), equalTo(tagMessage));
+        assertThat(tag.getObject().getSha(), equalTo(commitSha));
+        assertThat(tag.getVerification().isVerified(), is(false));
+        assertThat(GHVerification.Reason.UNSIGNED, equalTo(tag.getVerification().getReason()));
         assertThat(tag.getUrl(),
                 containsString("/repos/hub4j-test-org/github-api/git/tags/e7aa6d4afbaa48669f0bbe11ca3c4d787b2b153c"));
         assertThat(tag.getOwner().getId(), equalTo(repo.getId()));
@@ -57,7 +55,7 @@ public class GHTagTest extends AbstractGitHubWireMockTest {
 
         // Make a reference to the newly created tag.
         GHRef ref = repo.createRef("refs/tags/" + tagName, tag.getSha());
-        assertNotNull(ref);
+        assertThat(ref, notNullValue());
     }
 
     protected GHRepository getRepository() throws IOException {

src/test/java/org/kohsuke/github/GHTeamBuilderTest.java

@@ -4,6 +4,8 @@ import org.junit.Test;
 
 import java.io.IOException;
 
+import static org.hamcrest.Matchers.equalTo;
+
 public class GHTeamBuilderTest extends AbstractGitHubWireMockTest {
 
     @Test
@@ -23,10 +25,10 @@ public class GHTeamBuilderTest extends AbstractGitHubWireMockTest {
                 .parentTeamId(parentTeam.getId())
                 .create();
 
-        assertEquals(description, childTeam.getDescription());
-        assertEquals(childTeamSlug, childTeam.getName());
-        assertEquals(childTeamSlug, childTeam.getSlug());
-        assertEquals(GHTeam.Privacy.CLOSED, childTeam.getPrivacy());
+        assertThat(childTeam.getDescription(), equalTo(description));
+        assertThat(childTeam.getName(), equalTo(childTeamSlug));
+        assertThat(childTeam.getSlug(), equalTo(childTeamSlug));
+        assertThat(childTeam.getPrivacy(), equalTo(GHTeam.Privacy.CLOSED));
 
     }
 }

src/test/java/org/kohsuke/github/GHTeamTest.java

@@ -7,7 +7,7 @@ import java.io.IOException;
 import java.util.List;
 import java.util.Set;
 
-import static org.junit.Assert.assertEquals;
+import static org.hamcrest.Matchers.*;
 
 public class GHTeamTest extends AbstractGitHubWireMockTest {
 
@@ -23,7 +23,7 @@ public class GHTeamTest extends AbstractGitHubWireMockTest {
 
         // Check that it was set correctly.
         team = gitHub.getOrganization(GITHUB_API_TEST_ORG).getTeamBySlug(teamSlug);
-        assertEquals(description, team.getDescription());
+        assertThat(team.getDescription(), equalTo(description));
 
         description += "Modified";
 
@@ -32,7 +32,7 @@ public class GHTeamTest extends AbstractGitHubWireMockTest {
 
         // Check that it was set correctly.
         team = gitHub.getOrganization(GITHUB_API_TEST_ORG).getTeamBySlug(teamSlug);
-        assertEquals(description, team.getDescription());
+        assertThat(team.getDescription(), equalTo(description));
     }
 
     @Test
@@ -43,8 +43,8 @@ public class GHTeamTest extends AbstractGitHubWireMockTest {
 
         List<GHUser> admins = team.listMembers("admin").toList();
 
-        assertNotNull(admins);
-        assertThat("One admin in dummy team", admins.size() == 1);
+        assertThat(admins, notNullValue());
+        assertThat("One admin in dummy team", admins.size(), equalTo(1));
         assertThat("Specific user in admin team",
                 admins.stream().anyMatch(ghUser -> ghUser.getLogin().equals("bitwiseman")));
     }
@@ -71,7 +71,7 @@ public class GHTeamTest extends AbstractGitHubWireMockTest {
 
         // Check that it was set correctly.
         team = gitHub.getOrganization(GITHUB_API_TEST_ORG).getTeamBySlug(teamSlug);
-        assertEquals(privacy, team.getPrivacy());
+        assertThat(team.getPrivacy(), equalTo(privacy));
 
         privacy = Privacy.SECRET;
 
@@ -80,7 +80,7 @@ public class GHTeamTest extends AbstractGitHubWireMockTest {
 
         // Check that it was set correctly.
         team = gitHub.getOrganization(GITHUB_API_TEST_ORG).getTeamBySlug(teamSlug);
-        assertEquals(privacy, team.getPrivacy());
+        assertThat(team.getPrivacy(), equalTo(privacy));
     }
 
     @Test
@@ -91,8 +91,8 @@ public class GHTeamTest extends AbstractGitHubWireMockTest {
         GHTeam team = org.getTeamBySlug(teamSlug);
         Set<GHTeam> result = team.listChildTeams().toSet();
 
-        assertEquals(1, result.size());
-        assertEquals("child-team-for-dummy", result.toArray(new GHTeam[]{})[0].getName());
+        assertThat(result.size(), equalTo(1));
+        assertThat(result.toArray(new GHTeam[]{})[0].getName(), equalTo("child-team-for-dummy"));
     }
 
     @Test
@@ -103,7 +103,7 @@ public class GHTeamTest extends AbstractGitHubWireMockTest {
         GHTeam team = org.getTeamBySlug(teamSlug);
         Set<GHTeam> result = team.listChildTeams().toSet();
 
-        assertEquals(0, result.size());
+        assertThat(result, is(empty()));
     }
 
 }

src/test/java/org/kohsuke/github/GHTreeBuilderTest.java

@@ -10,7 +10,6 @@ import java.util.Arrays;
 import java.util.Date;
 
 import static org.hamcrest.Matchers.*;
-import static org.junit.Assert.assertEquals;
 
 public class GHTreeBuilderTest extends AbstractGitHubWireMockTest {
     private static String REPO_NAME = "hub4j-test-org/GHTreeBuilderTest";
@@ -28,14 +27,14 @@ public class GHTreeBuilderTest extends AbstractGitHubWireMockTest {
     private static byte[] CONTENT_DATA2 = { 0x04, 0x05, 0x06, 0x07 };
 
     private GHRepository repo;
-    private GHRef masterRef;
+    private GHRef mainRef;
     private GHTreeBuilder treeBuilder;
 
     @Before
     @After
     public void cleanup() throws Exception {
         if (mockGitHub.isUseProxy()) {
-            repo = getGitHubBeforeAfter().getRepository(REPO_NAME);
+            repo = getNonRecordingGitHub().getRepository(REPO_NAME);
             Arrays.asList(PATH_SCRIPT, PATH_README, PATH_DATA1, PATH_DATA2).forEach(path -> {
                 try {
                     GHContent content = repo.getFileContent(path);
@@ -51,9 +50,9 @@ public class GHTreeBuilderTest extends AbstractGitHubWireMockTest {
     @Before
     public void setUp() throws Exception {
         repo = gitHub.getRepository(REPO_NAME);
-        masterRef = repo.getRef("heads/master");
-        String masterTreeSha = repo.getTreeRecursive("master", 1).getSha();
-        treeBuilder = repo.createTree().baseTree(masterTreeSha);
+        mainRef = repo.getRef("heads/main");
+        String mainTreeSha = repo.getTreeRecursive("main", 1).getSha();
+        treeBuilder = repo.createTree().baseTree(mainTreeSha);
     }
 
     @Test
@@ -64,8 +63,8 @@ public class GHTreeBuilderTest extends AbstractGitHubWireMockTest {
 
         updateTree();
 
-        assertEquals(CONTENT_SCRIPT.length(), getFileSize(PATH_SCRIPT));
-        assertEquals(CONTENT_README.length(), getFileSize(PATH_README));
+        assertThat(getFileSize(PATH_SCRIPT), equalTo(CONTENT_SCRIPT.length()));
+        assertThat(getFileSize(PATH_README), equalTo(CONTENT_README.length()));
     }
 
     @Test
@@ -78,8 +77,8 @@ public class GHTreeBuilderTest extends AbstractGitHubWireMockTest {
 
         updateTree();
 
-        assertEquals(CONTENT_DATA1.length, getFileSize(PATH_DATA1));
-        assertEquals(CONTENT_DATA2.length, getFileSize(PATH_DATA2));
+        assertThat(getFileSize(PATH_DATA1), equalTo((long) CONTENT_DATA1.length));
+        assertThat(getFileSize(PATH_DATA2), equalTo((long) CONTENT_DATA2.length));
     }
 
     @Test
@@ -91,10 +90,10 @@ public class GHTreeBuilderTest extends AbstractGitHubWireMockTest {
 
         GHCommit commit = updateTree();
 
-        assertEquals(CONTENT_SCRIPT.length(), getFileSize(PATH_SCRIPT));
-        assertEquals(CONTENT_README.length(), getFileSize(PATH_README));
-        assertEquals(CONTENT_DATA1.length, getFileSize(PATH_DATA1));
-        assertEquals(CONTENT_DATA2.length, getFileSize(PATH_DATA2));
+        assertThat(getFileSize(PATH_SCRIPT), equalTo((long) CONTENT_SCRIPT.length()));
+        assertThat(getFileSize(PATH_README), equalTo((long) CONTENT_README.length()));
+        assertThat(getFileSize(PATH_DATA1), equalTo((long) CONTENT_DATA1.length));
+        assertThat(getFileSize(PATH_DATA2), equalTo((long) CONTENT_DATA2.length));
 
         assertThat(commit.getCommitShortInfo().getAuthor().getEmail(), equalTo("author@author.com"));
         assertThat(commit.getCommitShortInfo().getCommitter().getEmail(), equalTo("committer@committer.com"));
@@ -107,11 +106,11 @@ public class GHTreeBuilderTest extends AbstractGitHubWireMockTest {
                 .tree(treeSha)
                 .author("author", "author@author.com", new Date(1611433225969L))
                 .committer("committer", "committer@committer.com", new Date(1611433225968L))
-                .parent(masterRef.getObject().getSha())
+                .parent(mainRef.getObject().getSha())
                 .create();
 
         String commitSha = commit.getSHA1();
-        masterRef.updateTo(commitSha);
+        mainRef.updateTo(commitSha);
         return commit;
     }
 

src/test/java/org/kohsuke/github/GHUserTest.java

@@ -1,19 +1,22 @@
 package org.kohsuke.github;
 
-import org.junit.Assert;
 import org.junit.Test;
 
 import java.io.IOException;
 import java.util.*;
 
 import static org.hamcrest.CoreMatchers.*;
+import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.notNullValue;
 
 public class GHUserTest extends AbstractGitHubWireMockTest {
     @Test
     public void listFollowsAndFollowers() throws IOException {
         GHUser u = gitHub.getUser("rtyler");
-        assertNotEquals(count30(u.listFollowers()), count30(u.listFollows()));
+        assertThat(count30(u.listFollows()), not(count30(u.listFollowers())));
     }
 
     private Set<GHUser> count30(PagedIterable<GHUser> l) {
@@ -22,7 +25,7 @@ public class GHUserTest extends AbstractGitHubWireMockTest {
         for (int i = 0; i < 30 && itr.hasNext(); i++) {
             users.add(itr.next());
         }
-        assertEquals(30, users.size());
+        assertThat(users.size(), equalTo(30));
         return users;
     }
 
@@ -31,14 +34,14 @@ public class GHUserTest extends AbstractGitHubWireMockTest {
         GHUser u = gitHub.getUser("rtyler");
         List<GHKey> ghKeys = new ArrayList<>(u.getKeys());
 
-        assertEquals(3, ghKeys.size());
+        assertThat(ghKeys.size(), equalTo(3));
         Collections.sort(ghKeys, new Comparator<GHKey>() {
             @Override
             public int compare(GHKey ghKey, GHKey t1) {
                 return ghKey.getId() - t1.getId();
             }
         });
-        assertEquals(1066173, ghKeys.get(0).getId());
+        assertThat(ghKeys.get(0).getId(), equalTo(1066173));
         assertThat(ghKeys.get(0).getTitle(), nullValue());
         assertThat(ghKeys.get(0).getUrl(), nullValue());
         assertThat(ghKeys.get(0).isVerified(), equalTo(false));
@@ -46,23 +49,20 @@ public class GHUserTest extends AbstractGitHubWireMockTest {
                 containsString(
                         "title=<null>,id=1066173,key=ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAueiy12T5bvFhsc9YjfLc3aVIxgySd3gDxQWy/bletIoZL8omKmzocBYJ7F58U1asoyfWsy2ToTOY8jJp1eToXmbD6L5+xvHba0A7djYh9aQRrFam7doKQ0zp0ZSUF6+R1v0OM4nnWqK4n2ECIYd+Bdzrp+xA5+XlW3ZSNzlnW2BeWznzmgRMcp6wI+zQ9GMHWviR1cxpml5Z6wrxTZ0aX91btvnNPqoOGva976B6e6403FOEkkIFTk6CC1TFKwc/VjbqxYBg4kU0JhiTP+iEZibcQrYjWdYUgAotYbFVe5/DneHMLNsMPdeihba4PUwt62rXyNegenuCRmCntLcaFQ=="));
 
-        assertEquals(
-                "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAueiy12T5bvFhsc9YjfLc3aVIxgySd3gDxQWy/bletIoZL8omKmzocBYJ7F58U1asoyfWsy2ToTOY8jJp1eToXmbD6L5+xvHba0A7djYh9aQRrFam7doKQ0zp0ZSUF6+R1v0OM4nnWqK4n2ECIYd+Bdzrp+xA5+XlW3ZSNzlnW2BeWznzmgRMcp6wI+zQ9GMHWviR1cxpml5Z6wrxTZ0aX91btvnNPqoOGva976B6e6403FOEkkIFTk6CC1TFKwc/VjbqxYBg4kU0JhiTP+iEZibcQrYjWdYUgAotYbFVe5/DneHMLNsMPdeihba4PUwt62rXyNegenuCRmCntLcaFQ==",
-                ghKeys.get(0).getKey());
-        assertEquals(28136459, ghKeys.get(1).getId());
+        assertThat(ghKeys.get(0).getKey(),
+                equalTo("ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAueiy12T5bvFhsc9YjfLc3aVIxgySd3gDxQWy/bletIoZL8omKmzocBYJ7F58U1asoyfWsy2ToTOY8jJp1eToXmbD6L5+xvHba0A7djYh9aQRrFam7doKQ0zp0ZSUF6+R1v0OM4nnWqK4n2ECIYd+Bdzrp+xA5+XlW3ZSNzlnW2BeWznzmgRMcp6wI+zQ9GMHWviR1cxpml5Z6wrxTZ0aX91btvnNPqoOGva976B6e6403FOEkkIFTk6CC1TFKwc/VjbqxYBg4kU0JhiTP+iEZibcQrYjWdYUgAotYbFVe5/DneHMLNsMPdeihba4PUwt62rXyNegenuCRmCntLcaFQ=="));
+        assertThat(ghKeys.get(1).getId(), equalTo(28136459));
         assertThat(ghKeys.get(1).getTitle(), nullValue());
         assertThat(ghKeys.get(1).getUrl(), nullValue());
         assertThat(ghKeys.get(1).isVerified(), equalTo(false));
-        assertEquals(
-                "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTU0s5OKCC6VpKZGL9NJD4mNLY0AtujkVB1JkkuQ4OkMi2YGUHJtGhTbTwEVhNxpm0x2dM5KSzse6MLDYuGBW0qkE/VVuD9+9I73hbq461KqP0+WlupNh+Qc86kbiLBDv64+vWc+50mp1dbINpoM5xvaPYxgjnemydPv7vu5bhCHBugW7aN8VcLgfFgcp8vZCEanMtd3hIRjRU8v8Skk233ZGu1bXkG8iIOBQPabvEtZ0VDMg9pT3Q1R6lnnKqfCwHXd6zP6uAtejFSxvKRGKpu3OLGQMHwk7NlImVuhkVdaEFBq7pQtpOaGuP2eLKcN1wy5jsTYE+ZB6pvHCi2ecb",
-                ghKeys.get(1).getKey());
-        assertEquals(31452581, ghKeys.get(2).getId());
+        assertThat(ghKeys.get(1).getKey(),
+                equalTo("ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTU0s5OKCC6VpKZGL9NJD4mNLY0AtujkVB1JkkuQ4OkMi2YGUHJtGhTbTwEVhNxpm0x2dM5KSzse6MLDYuGBW0qkE/VVuD9+9I73hbq461KqP0+WlupNh+Qc86kbiLBDv64+vWc+50mp1dbINpoM5xvaPYxgjnemydPv7vu5bhCHBugW7aN8VcLgfFgcp8vZCEanMtd3hIRjRU8v8Skk233ZGu1bXkG8iIOBQPabvEtZ0VDMg9pT3Q1R6lnnKqfCwHXd6zP6uAtejFSxvKRGKpu3OLGQMHwk7NlImVuhkVdaEFBq7pQtpOaGuP2eLKcN1wy5jsTYE+ZB6pvHCi2ecb"));
+        assertThat(ghKeys.get(2).getId(), equalTo(31452581));
         assertThat(ghKeys.get(2).getTitle(), nullValue());
         assertThat(ghKeys.get(2).getUrl(), nullValue());
         assertThat(ghKeys.get(2).isVerified(), equalTo(false));
-        assertEquals(
-                "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQC3JhH2FZBDmHLjXTcBoV6tdcYKmsQ7sgu8k1RsUhwxGsXm65+Cuas6GcMVoA1DncKfJGQkulHDFiTxIROIBmedh9/otHWBlZ4HqYZ4MQ1A8W5quULkXwX/kF+UdRBUxFvjigibEbuHB+LARVxRRzFlPnTSE9rAfAv8OOEsb3lNUGT/IGhN8w1vwe8GclB90tgqN1RBDgrVqwLFwn5AfrW9kUIa2f2oT4RjYu1OrhKhVIIzfHADo85aD+s8wEhqwI96BCJG3qTWrypoHwBUoj1O6Ak5CGc1iKz9o8XyTMjudRt2ddCjfOtxsuwSlTbVtQXJGIpgKviX1sgh4pPvGh7BVAFP+mdAK4F+mEugDnuj47GO/K5KGGDRCL56kh9+h28l4q/+fZvp7DhtmSN2EzrVAdQFskF8yY/6Xit/aAvjeKm03DcjbylSXbG26EJefaLHlwYFq2mUFRMak25wuuCZS71GF3RC3Sl/bMoxBKRYkyfYtGafeaYTFNGn8Dbd+hfVUCz31ebI8cvmlQR5b5AbCre3T7HTVgw8FKbAxWRf1Fio56PnqHsj+sT1KVj255Zo1F8iD9GrgERSVAlkh5bY/CKszQ8ZSd01c9Qp2a47/gR7XAAbxhzGHP+cSOlrqDlJ24fbPtcpVsM0llqKUcxpmoOBFNboRmE1QqnSmAf9ww==",
-                ghKeys.get(2).getKey());
+        assertThat(ghKeys.get(2).getKey(),
+                equalTo("ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQC3JhH2FZBDmHLjXTcBoV6tdcYKmsQ7sgu8k1RsUhwxGsXm65+Cuas6GcMVoA1DncKfJGQkulHDFiTxIROIBmedh9/otHWBlZ4HqYZ4MQ1A8W5quULkXwX/kF+UdRBUxFvjigibEbuHB+LARVxRRzFlPnTSE9rAfAv8OOEsb3lNUGT/IGhN8w1vwe8GclB90tgqN1RBDgrVqwLFwn5AfrW9kUIa2f2oT4RjYu1OrhKhVIIzfHADo85aD+s8wEhqwI96BCJG3qTWrypoHwBUoj1O6Ak5CGc1iKz9o8XyTMjudRt2ddCjfOtxsuwSlTbVtQXJGIpgKviX1sgh4pPvGh7BVAFP+mdAK4F+mEugDnuj47GO/K5KGGDRCL56kh9+h28l4q/+fZvp7DhtmSN2EzrVAdQFskF8yY/6Xit/aAvjeKm03DcjbylSXbG26EJefaLHlwYFq2mUFRMak25wuuCZS71GF3RC3Sl/bMoxBKRYkyfYtGafeaYTFNGn8Dbd+hfVUCz31ebI8cvmlQR5b5AbCre3T7HTVgw8FKbAxWRf1Fio56PnqHsj+sT1KVj255Zo1F8iD9GrgERSVAlkh5bY/CKszQ8ZSd01c9Qp2a47/gR7XAAbxhzGHP+cSOlrqDlJ24fbPtcpVsM0llqKUcxpmoOBFNboRmE1QqnSmAf9ww=="));
     }
 
     @Test
@@ -71,11 +71,11 @@ public class GHUserTest extends AbstractGitHubWireMockTest {
         Iterator<GHRepository> itr = user.listRepositories().iterator();
         int i = 0;
         for (; i < 115; i++) {
-            assertTrue(itr.hasNext());
+            assertThat(itr.hasNext(), is(true));
             GHRepository r = itr.next();
             // System.out.println(r.getFullName());
-            assertNotNull(r.getUrl());
-            assertNotEquals(0L, r.getId());
+            assertThat(r.getUrl(), notNullValue());
+            assertThat(r.getId(), not(0L));
         }
 
         assertThat(i, equalTo(115));
@@ -87,11 +87,11 @@ public class GHUserTest extends AbstractGitHubWireMockTest {
         Iterator<GHRepository> itr = user.listRepositories().withPageSize(62).iterator();
         int i = 0;
         for (; i < 115; i++) {
-            assertTrue(itr.hasNext());
+            assertThat(itr.hasNext(), is(true));
             GHRepository r = itr.next();
             // System.out.println(r.getFullName());
-            assertNotNull(r.getUrl());
-            assertNotEquals(0L, r.getId());
+            assertThat(r.getUrl(), notNullValue());
+            assertThat(r.getId(), not(0L));
         }
 
         assertThat(i, equalTo(115));
@@ -108,7 +108,7 @@ public class GHUserTest extends AbstractGitHubWireMockTest {
                 .create();
 
         try {
-            Assert.assertNotNull(repository);
+            assertThat(repository, notNullValue());
             GHUser ghUser = gitHub.getUser(login);
             assertThat(ghUser.getTotalPrivateRepoCount().orElse(-1), greaterThan(0));
         } finally {
@@ -120,8 +120,8 @@ public class GHUserTest extends AbstractGitHubWireMockTest {
     public void verifyBioAndHireable() throws IOException {
         GHUser u = gitHub.getUser("Chew");
         assertThat(u.getBio(), equalTo("I like to program things and I hope to program something cool one day :D"));
-        assertTrue(u.isHireable());
-        assertNotNull(u.getTwitterUsername());
+        assertThat(u.isHireable(), is(true));
+        assertThat(u.getTwitterUsername(), notNullValue());
         assertThat(u.getBlog(), equalTo("https://chew.pw"));
         assertThat(u.getCompany(), equalTo("@Memerator"));
         assertThat(u.getFollowersCount(), equalTo(29));

src/test/java/org/kohsuke/github/GHVerificationReasonTest.java

@@ -2,6 +2,8 @@ package org.kohsuke.github;
 
 import org.junit.Test;
 
+import static org.hamcrest.Matchers.*;
+
 /**
  * @author Sourabh Sarvotham Parkala
  */
@@ -11,121 +13,126 @@ public class GHVerificationReasonTest extends AbstractGitHubWireMockTest {
     public void testExpiredKey() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f01");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.EXPIRED_KEY);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(),
+                equalTo(GHVerification.Reason.EXPIRED_KEY));
     }
 
     @Test
     public void testNotSigningKey() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f02");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.NOT_SIGNING_KEY);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(),
+                equalTo(GHVerification.Reason.NOT_SIGNING_KEY));
     }
 
     @Test
     public void testGpgverifyError() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f03");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.GPGVERIFY_ERROR);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(),
+                equalTo(GHVerification.Reason.GPGVERIFY_ERROR));
     }
 
     @Test
     public void testGpgverifyUnavailable() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f04");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(),
-                GHVerification.Reason.GPGVERIFY_UNAVAILABLE);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(),
+                equalTo(GHVerification.Reason.GPGVERIFY_UNAVAILABLE));
     }
 
     @Test
     public void testUnsigned() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f05");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.UNSIGNED);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(), equalTo(GHVerification.Reason.UNSIGNED));
     }
 
     @Test
     public void testUnknownSignatureType() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f06");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(),
-                GHVerification.Reason.UNKNOWN_SIGNATURE_TYPE);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(),
+                equalTo(GHVerification.Reason.UNKNOWN_SIGNATURE_TYPE));
     }
 
     @Test
     public void testNoUser() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f07");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.NO_USER);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(), equalTo(GHVerification.Reason.NO_USER));
     }
 
     @Test
     public void testUnverifiedEmail() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f08");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.UNVERIFIED_EMAIL);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(),
+                equalTo(GHVerification.Reason.UNVERIFIED_EMAIL));
     }
 
     @Test
     public void testBadEmail() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f09");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.BAD_EMAIL);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(), equalTo(GHVerification.Reason.BAD_EMAIL));
     }
 
     @Test
     public void testUnknownKey() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f10");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.UNKNOWN_KEY);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(),
+                equalTo(GHVerification.Reason.UNKNOWN_KEY));
     }
 
     @Test
     public void testMalformedSignature() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f11");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(),
-                GHVerification.Reason.MALFORMED_SIGNATURE);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(),
+                equalTo(GHVerification.Reason.MALFORMED_SIGNATURE));
     }
 
     @Test
     public void testInvalid() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f12");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertFalse(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.INVALID);
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(false));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(), equalTo(GHVerification.Reason.INVALID));
     }
 
     @Test
     public void testValid() throws Exception {
         GHRepository r = gitHub.getRepository("hub4j/github-api");
         GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f13");
-        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Sourabh Parkala");
-        assertTrue(commit.getCommitShortInfo().getVerification().isVerified());
-        assertEquals(commit.getCommitShortInfo().getVerification().getReason(), GHVerification.Reason.VALID);
-        assertNotNull(commit.getCommitShortInfo().getVerification().getPayload());
-        assertNotNull(commit.getCommitShortInfo().getVerification().getSignature());
+        assertThat(commit.getCommitShortInfo().getAuthor().getName(), equalTo("Sourabh Parkala"));
+        assertThat(commit.getCommitShortInfo().getVerification().isVerified(), is(true));
+        assertThat(commit.getCommitShortInfo().getVerification().getReason(), equalTo(GHVerification.Reason.VALID));
+        assertThat(commit.getCommitShortInfo().getVerification().getPayload(), notNullValue());
+        assertThat(commit.getCommitShortInfo().getVerification().getSignature(), notNullValue());
     }
 }

src/test/java/org/kohsuke/github/GHWorkflowRunTest.java

@@ -1,17 +1,25 @@
 package org.kohsuke.github;
 
 import org.awaitility.Awaitility;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.kohsuke.github.GHWorkflowJob.Step;
 import org.kohsuke.github.GHWorkflowRun.Conclusion;
 import org.kohsuke.github.GHWorkflowRun.Status;
+import org.kohsuke.github.function.InputStreamFunction;
 
 import java.io.IOException;
 import java.time.Duration;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
+import java.util.Scanner;
 import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import static org.hamcrest.Matchers.*;
 
 public class GHWorkflowRunTest extends AbstractGitHubWireMockTest {
 
@@ -25,6 +33,13 @@ public class GHWorkflowRunTest extends AbstractGitHubWireMockTest {
     private static final String SLOW_WORKFLOW_PATH = "slow-workflow.yml";
     private static final String SLOW_WORKFLOW_NAME = "Slow workflow";
 
+    private static final String ARTIFACTS_WORKFLOW_PATH = "artifacts-workflow.yml";
+    private static final String ARTIFACTS_WORKFLOW_NAME = "Artifacts workflow";
+
+    private static final String MULTI_JOBS_WORKFLOW_PATH = "multi-jobs-workflow.yml";
+    private static final String MULTI_JOBS_WORKFLOW_NAME = "Multi jobs workflow";
+    private static final String RUN_A_ONE_LINE_SCRIPT_STEP_NAME = "Run a one-line script";
+
     private GHRepository repo;
 
     @Before
@@ -52,27 +67,30 @@ public class GHWorkflowRunTest extends AbstractGitHubWireMockTest {
                 latestPreexistingWorkflowRunId).orElseThrow(
                         () -> new IllegalStateException("We must have a valid workflow run starting from here"));
 
-        assertEquals(workflow.getId(), workflowRun.getWorkflowId());
-        assertTrue(workflowRun.getUrl().getPath().contains("/actions/runs/"));
-        assertTrue(workflowRun.getHtmlUrl().getPath().contains("/actions/runs/"));
-        assertTrue(workflowRun.getJobsUrl().getPath().endsWith("/jobs"));
-        assertTrue(workflowRun.getLogsUrl().getPath().endsWith("/logs"));
-        assertTrue(workflowRun.getCheckSuiteUrl().getPath().contains("/check-suites/"));
-        assertTrue(workflowRun.getArtifactsUrl().getPath().endsWith("/artifacts"));
-        assertTrue(workflowRun.getCancelUrl().getPath().endsWith("/cancel"));
-        assertTrue(workflowRun.getRerunUrl().getPath().endsWith("/rerun"));
-        assertTrue(workflowRun.getWorkflowUrl().getPath().contains("/actions/workflows/"));
-        assertEquals(MAIN_BRANCH, workflowRun.getHeadBranch());
-        assertNotNull(workflowRun.getHeadCommit().getId());
-        assertNotNull(workflowRun.getHeadCommit().getTreeId());
-        assertNotNull(workflowRun.getHeadCommit().getMessage());
-        assertNotNull(workflowRun.getHeadCommit().getTimestamp());
-        assertNotNull(workflowRun.getHeadCommit().getAuthor().getEmail());
-        assertNotNull(workflowRun.getHeadCommit().getCommitter().getEmail());
-        assertEquals(GHEvent.WORKFLOW_DISPATCH, workflowRun.getEvent());
-        assertEquals(Status.COMPLETED, workflowRun.getStatus());
-        assertEquals(Conclusion.SUCCESS, workflowRun.getConclusion());
-        assertNotNull(workflowRun.getHeadSha());
+        assertThat(workflowRun.getWorkflowId(), equalTo(workflow.getId()));
+        assertThat(workflowRun.getId(), notNullValue());
+        assertThat(workflowRun.getNodeId(), notNullValue());
+        assertThat(workflowRun.getRepository().getFullName(), equalTo(REPO_NAME));
+        assertThat(workflowRun.getUrl().getPath(), containsString("/actions/runs/"));
+        assertThat(workflowRun.getHtmlUrl().getPath(), containsString("/actions/runs/"));
+        assertThat(workflowRun.getJobsUrl().getPath(), endsWith("/jobs"));
+        assertThat(workflowRun.getLogsUrl().getPath(), endsWith("/logs"));
+        assertThat(workflowRun.getCheckSuiteUrl().getPath(), containsString("/check-suites/"));
+        assertThat(workflowRun.getArtifactsUrl().getPath(), endsWith("/artifacts"));
+        assertThat(workflowRun.getCancelUrl().getPath(), endsWith("/cancel"));
+        assertThat(workflowRun.getRerunUrl().getPath(), endsWith("/rerun"));
+        assertThat(workflowRun.getWorkflowUrl().getPath(), containsString("/actions/workflows/"));
+        assertThat(workflowRun.getHeadBranch(), equalTo(MAIN_BRANCH));
+        assertThat(workflowRun.getHeadCommit().getId(), notNullValue());
+        assertThat(workflowRun.getHeadCommit().getTreeId(), notNullValue());
+        assertThat(workflowRun.getHeadCommit().getMessage(), notNullValue());
+        assertThat(workflowRun.getHeadCommit().getTimestamp(), notNullValue());
+        assertThat(workflowRun.getHeadCommit().getAuthor().getEmail(), notNullValue());
+        assertThat(workflowRun.getHeadCommit().getCommitter().getEmail(), notNullValue());
+        assertThat(workflowRun.getEvent(), equalTo(GHEvent.WORKFLOW_DISPATCH));
+        assertThat(workflowRun.getStatus(), equalTo(Status.COMPLETED));
+        assertThat(workflowRun.getConclusion(), equalTo(Conclusion.SUCCESS));
+        assertThat(workflowRun.getHeadSha(), notNullValue());
     }
 
     @Test
@@ -96,7 +114,7 @@ public class GHWorkflowRunTest extends AbstractGitHubWireMockTest {
                 latestPreexistingWorkflowRunId).orElseThrow(
                         () -> new IllegalStateException("We must have a valid workflow run starting from here"));
 
-        assertNotNull(workflowRun.getId());
+        assertThat(workflowRun.getId(), notNullValue());
 
         workflowRun.cancel();
         long cancelledWorkflowRunId = workflowRun.getId();
@@ -106,7 +124,7 @@ public class GHWorkflowRunTest extends AbstractGitHubWireMockTest {
 
         // let's check that it has been properly cancelled
         workflowRun = repo.getWorkflowRun(cancelledWorkflowRunId);
-        assertEquals(Conclusion.CANCELLED, workflowRun.getConclusion());
+        assertThat(workflowRun.getConclusion(), equalTo(Conclusion.CANCELLED));
 
         // now let's rerun it
         workflowRun.rerun();
@@ -139,13 +157,13 @@ public class GHWorkflowRunTest extends AbstractGitHubWireMockTest {
                 latestPreexistingWorkflowRunId).orElseThrow(
                         () -> new IllegalStateException("We must have a valid workflow run starting from here"));
 
-        assertNotNull(workflowRunToDelete.getId());
+        assertThat(workflowRunToDelete.getId(), notNullValue());
 
         workflowRunToDelete.delete();
 
         try {
             repo.getWorkflowRun(workflowRunToDelete.getId());
-            Assert.fail("The workflow " + workflowRunToDelete.getId() + " should have been deleted.");
+            fail("The workflow " + workflowRunToDelete.getId() + " should have been deleted.");
         } catch (GHFileNotFoundException e) {
             // success
         }
@@ -171,11 +189,176 @@ public class GHWorkflowRunTest extends AbstractGitHubWireMockTest {
                 latestPreexistingWorkflowRunId).orElseThrow(
                         () -> new IllegalStateException("We must have a valid workflow run starting from here"));
 
-        assertEquals(workflow.getId(), workflowRun.getWorkflowId());
-        assertEquals(SECOND_BRANCH, workflowRun.getHeadBranch());
-        assertEquals(GHEvent.WORKFLOW_DISPATCH, workflowRun.getEvent());
-        assertEquals(Status.COMPLETED, workflowRun.getStatus());
-        assertEquals(Conclusion.SUCCESS, workflowRun.getConclusion());
+        assertThat(workflowRun.getWorkflowId(), equalTo(workflow.getId()));
+        assertThat(workflowRun.getHeadBranch(), equalTo(SECOND_BRANCH));
+        assertThat(workflowRun.getEvent(), equalTo(GHEvent.WORKFLOW_DISPATCH));
+        assertThat(workflowRun.getStatus(), equalTo(Status.COMPLETED));
+        assertThat(workflowRun.getConclusion(), equalTo(Conclusion.SUCCESS));
+    }
+
+    @Test
+    public void testLogs() throws IOException {
+        GHWorkflow workflow = repo.getWorkflow(FAST_WORKFLOW_PATH);
+
+        long latestPreexistingWorkflowRunId = getLatestPreexistingWorkflowRunId();
+
+        workflow.dispatch(MAIN_BRANCH);
+
+        await((nonRecordingRepo) -> getWorkflowRun(nonRecordingRepo,
+                FAST_WORKFLOW_NAME,
+                MAIN_BRANCH,
+                Status.COMPLETED,
+                latestPreexistingWorkflowRunId).isPresent());
+
+        GHWorkflowRun workflowRun = getWorkflowRun(FAST_WORKFLOW_NAME,
+                MAIN_BRANCH,
+                Status.COMPLETED,
+                latestPreexistingWorkflowRunId).orElseThrow(
+                        () -> new IllegalStateException("We must have a valid workflow run starting from here"));
+
+        List<String> logsArchiveEntries = new ArrayList<>();
+        String fullLogContent = workflowRun
+                .downloadLogs(getLogArchiveInputStreamFunction("1_build.txt", logsArchiveEntries));
+
+        assertThat(logsArchiveEntries, hasItems("1_build.txt", "build/9_Complete job.txt"));
+        assertThat(fullLogContent, containsString("Hello, world!"));
+
+        workflowRun.deleteLogs();
+
+        try {
+            workflowRun.downloadLogs((is) -> "");
+            fail("Downloading logs should not be possible as they were deleted");
+        } catch (GHFileNotFoundException e) {
+            assertThat(e.getMessage(), containsString("Not Found"));
+        }
+    }
+
+    @SuppressWarnings("resource")
+    @Test
+    public void testArtifacts() throws IOException {
+        GHWorkflow workflow = repo.getWorkflow(ARTIFACTS_WORKFLOW_PATH);
+
+        long latestPreexistingWorkflowRunId = getLatestPreexistingWorkflowRunId();
+
+        workflow.dispatch(MAIN_BRANCH);
+
+        await((nonRecordingRepo) -> getWorkflowRun(nonRecordingRepo,
+                ARTIFACTS_WORKFLOW_NAME,
+                MAIN_BRANCH,
+                Status.COMPLETED,
+                latestPreexistingWorkflowRunId).isPresent());
+
+        GHWorkflowRun workflowRun = getWorkflowRun(ARTIFACTS_WORKFLOW_NAME,
+                MAIN_BRANCH,
+                Status.COMPLETED,
+                latestPreexistingWorkflowRunId).orElseThrow(
+                        () -> new IllegalStateException("We must have a valid workflow run starting from here"));
+
+        List<GHArtifact> artifacts = new ArrayList<>(workflowRun.listArtifacts().toList());
+        artifacts.sort((a1, a2) -> a1.getName().compareTo(a2.getName()));
+
+        assertThat(artifacts.size(), is(2));
+
+        // Test properties
+        checkArtifactProperties(artifacts.get(0), "artifact1");
+        checkArtifactProperties(artifacts.get(1), "artifact2");
+
+        // Test download
+        String artifactContent = artifacts.get(0).download((is) -> {
+            try (ZipInputStream zis = new ZipInputStream(is)) {
+                StringBuilder sb = new StringBuilder();
+
+                ZipEntry ze = zis.getNextEntry();
+                assertThat(ze.getName(), is("artifact1.txt"));
+
+                // the scanner has to be kept open to avoid closing zis
+                Scanner scanner = new Scanner(zis);
+                while (scanner.hasNextLine()) {
+                    sb.append(scanner.nextLine());
+                }
+
+                return sb.toString();
+            }
+        });
+
+        assertThat(artifactContent, is("artifact1"));
+
+        // Test GHRepository#getArtifact(long) as we are sure we have artifacts around
+        GHArtifact artifactById = repo.getArtifact(artifacts.get(0).getId());
+        checkArtifactProperties(artifactById, "artifact1");
+
+        artifactById = repo.getArtifact(artifacts.get(1).getId());
+        checkArtifactProperties(artifactById, "artifact2");
+
+        // Test GHRepository#listArtifacts() as we are sure we have artifacts around
+        List<GHArtifact> artifactsFromRepo = new ArrayList<>(
+                repo.listArtifacts().withPageSize(2).iterator().nextPage());
+        artifactsFromRepo.sort((a1, a2) -> a1.getName().compareTo(a2.getName()));
+
+        // We have at least the two artifacts we just added
+        assertThat(artifactsFromRepo.size(), is(2));
+
+        // Test properties
+        checkArtifactProperties(artifactsFromRepo.get(0), "artifact1");
+        checkArtifactProperties(artifactsFromRepo.get(1), "artifact2");
+
+        // Now let's test the delete() method
+        GHArtifact artifact1 = artifacts.get(0);
+        artifact1.delete();
+
+        try {
+            repo.getArtifact(artifact1.getId());
+            fail("Getting the artifact should fail as it was deleted");
+        } catch (GHFileNotFoundException e) {
+            assertThat(e.getMessage(), containsString("Not Found"));
+        }
+    }
+
+    @Test
+    public void testJobs() throws IOException {
+        GHWorkflow workflow = repo.getWorkflow(MULTI_JOBS_WORKFLOW_PATH);
+
+        long latestPreexistingWorkflowRunId = getLatestPreexistingWorkflowRunId();
+
+        workflow.dispatch(MAIN_BRANCH);
+
+        await((nonRecordingRepo) -> getWorkflowRun(nonRecordingRepo,
+                MULTI_JOBS_WORKFLOW_NAME,
+                MAIN_BRANCH,
+                Status.COMPLETED,
+                latestPreexistingWorkflowRunId).isPresent());
+
+        GHWorkflowRun workflowRun = getWorkflowRun(MULTI_JOBS_WORKFLOW_NAME,
+                MAIN_BRANCH,
+                Status.COMPLETED,
+                latestPreexistingWorkflowRunId).orElseThrow(
+                        () -> new IllegalStateException("We must have a valid workflow run starting from here"));
+
+        List<GHWorkflowJob> jobs = workflowRun.listJobs()
+                .toList()
+                .stream()
+                .sorted((j1, j2) -> j1.getName().compareTo(j2.getName()))
+                .collect(Collectors.toList());
+
+        assertThat(jobs.size(), is(2));
+
+        GHWorkflowJob job1 = jobs.get(0);
+        checkJobProperties(workflowRun.getId(), job1, "job1");
+        String fullLogContent = job1.downloadLogs(getLogTextInputStreamFunction());
+        assertThat(fullLogContent, containsString("Hello from job1!"));
+
+        GHWorkflowJob job2 = jobs.get(1);
+        checkJobProperties(workflowRun.getId(), job2, "job2");
+        fullLogContent = job2.downloadLogs(getLogTextInputStreamFunction());
+        assertThat(fullLogContent, containsString("Hello from job2!"));
+
+        // while we have a job around, test GHRepository#getWorkflowJob(id)
+        GHWorkflowJob job1ById = repo.getWorkflowJob(job1.getId());
+        checkJobProperties(workflowRun.getId(), job1ById, "job1");
+
+        // Also test listAllJobs() works correctly
+        List<GHWorkflowJob> allJobs = workflowRun.listAllJobs().withPageSize(10).iterator().nextPage();
+        assertThat(allJobs.size(), greaterThanOrEqualTo(2));
     }
 
     private void await(Function<GHRepository, Boolean> condition) throws IOException {
@@ -183,7 +366,7 @@ public class GHWorkflowRunTest extends AbstractGitHubWireMockTest {
             return;
         }
 
-        GHRepository nonRecordingRepo = getGitHubBeforeAfter().getRepository(REPO_NAME);
+        GHRepository nonRecordingRepo = getNonRecordingGitHub().getRepository(REPO_NAME);
 
         Awaitility.await().pollInterval(Duration.ofSeconds(5)).atMost(Duration.ofSeconds(60)).until(() -> {
             return condition.apply(nonRecordingRepo);
@@ -230,4 +413,89 @@ public class GHWorkflowRunTest extends AbstractGitHubWireMockTest {
             throw new IllegalStateException("Unable to get workflow run status", e);
         }
     }
+
+    @SuppressWarnings("resource")
+    private static InputStreamFunction<String> getLogArchiveInputStreamFunction(String mainLogFileName,
+            List<String> logsArchiveEntries) {
+        return (is) -> {
+            try (ZipInputStream zis = new ZipInputStream(is)) {
+                StringBuilder sb = new StringBuilder();
+
+                ZipEntry ze;
+                while ((ze = zis.getNextEntry()) != null) {
+                    logsArchiveEntries.add(ze.getName());
+                    if (mainLogFileName.equals(ze.getName())) {
+                        // the scanner has to be kept open to avoid closing zis
+                        Scanner scanner = new Scanner(zis);
+                        while (scanner.hasNextLine()) {
+                            sb.append(scanner.nextLine()).append("\n");
+                        }
+                    }
+                }
+
+                return sb.toString();
+            }
+        };
+    }
+
+    @SuppressWarnings("resource")
+    private static InputStreamFunction<String> getLogTextInputStreamFunction() {
+        return (is) -> {
+            StringBuilder sb = new StringBuilder();
+            Scanner scanner = new Scanner(is);
+            while (scanner.hasNextLine()) {
+                sb.append(scanner.nextLine()).append("\n");
+            }
+            return sb.toString();
+        };
+    }
+
+    private static void checkArtifactProperties(GHArtifact artifact, String artifactName) throws IOException {
+        assertThat(artifact.getId(), notNullValue());
+        assertThat(artifact.getNodeId(), notNullValue());
+        assertThat(artifact.getRepository().getFullName(), equalTo(REPO_NAME));
+        assertThat(artifact.getName(), is(artifactName));
+        assertThat(artifact.getArchiveDownloadUrl().getPath(), containsString("actions/artifacts"));
+        assertThat(artifact.getCreatedAt(), notNullValue());
+        assertThat(artifact.getUpdatedAt(), notNullValue());
+        assertThat(artifact.getExpiresAt(), notNullValue());
+        assertThat(artifact.getSizeInBytes(), greaterThan(0L));
+        assertThat(artifact.isExpired(), is(false));
+    }
+
+    private static void checkJobProperties(long workflowRunId, GHWorkflowJob job, String jobName) throws IOException {
+        assertThat(job.getId(), notNullValue());
+        assertThat(job.getNodeId(), notNullValue());
+        assertThat(job.getRepository().getFullName(), equalTo(REPO_NAME));
+        assertThat(job.getName(), is(jobName));
+        assertThat(job.getStartedAt(), notNullValue());
+        assertThat(job.getCompletedAt(), notNullValue());
+        assertThat(job.getHeadSha(), notNullValue());
+        assertThat(job.getStatus(), is(Status.COMPLETED));
+        assertThat(job.getConclusion(), is(Conclusion.SUCCESS));
+        assertThat(job.getRunId(), is(workflowRunId));
+        assertThat(job.getUrl().getPath(), containsString("/actions/jobs/"));
+        assertThat(job.getHtmlUrl().getPath(), containsString("/runs/" + job.getId()));
+        assertThat(job.getCheckRunUrl().getPath(), containsString("/check-runs/"));
+
+        // we only test the step we have control over, the others are added by GitHub
+        Optional<Step> step = job.getSteps()
+                .stream()
+                .filter(s -> RUN_A_ONE_LINE_SCRIPT_STEP_NAME.equals(s.getName()))
+                .findFirst();
+        if (!step.isPresent()) {
+            fail("Unable to find " + RUN_A_ONE_LINE_SCRIPT_STEP_NAME + " step");
+        }
+
+        checkStepProperties(step.get(), RUN_A_ONE_LINE_SCRIPT_STEP_NAME, 2);
+    }
+
+    private static void checkStepProperties(Step step, String name, int number) {
+        assertThat(step.getName(), is(name));
+        assertThat(step.getNumber(), is(number));
+        assertThat(step.getStatus(), is(Status.COMPLETED));
+        assertThat(step.getConclusion(), is(Conclusion.SUCCESS));
+        assertThat(step.getStartedAt(), notNullValue());
+        assertThat(step.getCompletedAt(), notNullValue());
+    }
 }

src/test/java/org/kohsuke/github/GHWorkflowTest.java

@@ -12,6 +12,7 @@ import static com.github.tomakehurst.wiremock.client.WireMock.containing;
 import static com.github.tomakehurst.wiremock.client.WireMock.postRequestedFor;
 import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
 import static com.github.tomakehurst.wiremock.client.WireMock.verify;
+import static org.hamcrest.Matchers.equalTo;
 
 public class GHWorkflowTest extends AbstractGitHubWireMockTest {
 
@@ -23,7 +24,7 @@ public class GHWorkflowTest extends AbstractGitHubWireMockTest {
     @After
     public void cleanup() throws Exception {
         if (mockGitHub.isUseProxy()) {
-            repo = getGitHubBeforeAfter().getRepository(REPO_NAME);
+            repo = getNonRecordingGitHub().getRepository(REPO_NAME);
 
             // we need to make sure the workflow is enabled before the tests
             GHWorkflow workflow = repo.getWorkflow("test-workflow.yml");
@@ -42,34 +43,36 @@ public class GHWorkflowTest extends AbstractGitHubWireMockTest {
     public void testBasicInformation() throws IOException {
         GHWorkflow workflow = repo.getWorkflow("test-workflow.yml");
 
-        assertEquals("test-workflow", workflow.getName());
-        assertEquals(".github/workflows/test-workflow.yml", workflow.getPath());
-        assertEquals("active", workflow.getState());
-        assertEquals("/repos/hub4j-test-org/GHWorkflowTest/actions/workflows/6817859", workflow.getUrl().getPath());
-        assertEquals("/hub4j-test-org/GHWorkflowTest/blob/main/.github/workflows/test-workflow.yml",
-                workflow.getHtmlUrl().getPath());
-        assertEquals("/hub4j-test-org/GHWorkflowTest/workflows/test-workflow/badge.svg",
-                workflow.getBadgeUrl().getPath());
+        assertThat(workflow.getName(), equalTo("test-workflow"));
+        assertThat(workflow.getRepository().getFullName(), equalTo(REPO_NAME));
+        assertThat(workflow.getPath(), equalTo(".github/workflows/test-workflow.yml"));
+        assertThat(workflow.getState(), equalTo("active"));
+        assertThat(workflow.getUrl().getPath(),
+                equalTo("/repos/hub4j-test-org/GHWorkflowTest/actions/workflows/6817859"));
+        assertThat(workflow.getHtmlUrl().getPath(),
+                equalTo("/hub4j-test-org/GHWorkflowTest/blob/main/.github/workflows/test-workflow.yml"));
+        assertThat(workflow.getBadgeUrl().getPath(),
+                equalTo("/hub4j-test-org/GHWorkflowTest/workflows/test-workflow/badge.svg"));
 
         GHWorkflow workflowById = repo.getWorkflow(workflow.getId());
-        assertEquals(workflow.getNodeId(), workflowById.getNodeId());
+        assertThat(workflowById.getNodeId(), equalTo(workflow.getNodeId()));
     }
 
     @Test
     public void testDisableEnable() throws IOException {
         GHWorkflow workflow = repo.getWorkflow("test-workflow.yml");
 
-        assertEquals("active", workflow.getState());
+        assertThat(workflow.getState(), equalTo("active"));
 
         workflow.disable();
 
         workflow = repo.getWorkflow("test-workflow.yml");
-        assertEquals("disabled_manually", workflow.getState());
+        assertThat(workflow.getState(), equalTo("disabled_manually"));
 
         workflow.enable();
 
         workflow = repo.getWorkflow("test-workflow.yml");
-        assertEquals("active", workflow.getState());
+        assertThat(workflow.getState(), equalTo("active"));
     }
 
     @Test
@@ -93,15 +96,16 @@ public class GHWorkflowTest extends AbstractGitHubWireMockTest {
         List<GHWorkflow> workflows = repo.listWorkflows().toList();
 
         GHWorkflow workflow = workflows.get(0);
-        assertEquals(6817859L, workflow.getId());
-        assertEquals("MDg6V29ya2Zsb3c2ODE3ODU5", workflow.getNodeId());
-        assertEquals("test-workflow", workflow.getName());
-        assertEquals(".github/workflows/test-workflow.yml", workflow.getPath());
-        assertEquals("active", workflow.getState());
-        assertEquals("/repos/hub4j-test-org/GHWorkflowTest/actions/workflows/6817859", workflow.getUrl().getPath());
-        assertEquals("/hub4j-test-org/GHWorkflowTest/blob/main/.github/workflows/test-workflow.yml",
-                workflow.getHtmlUrl().getPath());
-        assertEquals("/hub4j-test-org/GHWorkflowTest/workflows/test-workflow/badge.svg",
-                workflow.getBadgeUrl().getPath());
+        assertThat(workflow.getId(), equalTo(6817859L));
+        assertThat(workflow.getNodeId(), equalTo("MDg6V29ya2Zsb3c2ODE3ODU5"));
+        assertThat(workflow.getName(), equalTo("test-workflow"));
+        assertThat(workflow.getPath(), equalTo(".github/workflows/test-workflow.yml"));
+        assertThat(workflow.getState(), equalTo("active"));
+        assertThat(workflow.getUrl().getPath(),
+                equalTo("/repos/hub4j-test-org/GHWorkflowTest/actions/workflows/6817859"));
+        assertThat(workflow.getHtmlUrl().getPath(),
+                equalTo("/hub4j-test-org/GHWorkflowTest/blob/main/.github/workflows/test-workflow.yml"));
+        assertThat(workflow.getBadgeUrl().getPath(),
+                equalTo("/hub4j-test-org/GHWorkflowTest/workflows/test-workflow/badge.svg"));
     }
 }

src/test/java/org/kohsuke/github/GitHubConnectionTest.java

@@ -10,11 +10,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.Matchers.lessThan;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.Matchers.*;
 
 /**
  * Unit test for {@link GitHub}.
@@ -28,37 +24,36 @@ public class GitHubConnectionTest extends AbstractGitHubWireMockTest {
     @Test
     public void testOffline() throws Exception {
         GitHub hub = GitHub.offline();
-        assertEquals("https://api.github.invalid/test",
-
-                GitHubRequest.getApiURL(hub.getClient().getApiUrl(), "/test").toString());
-        assertTrue(hub.isAnonymous());
+        assertThat(GitHubRequest.getApiURL(hub.getClient().getApiUrl(), "/test").toString(),
+                equalTo("https://api.github.invalid/test"));
+        assertThat(hub.isAnonymous(), is(true));
         try {
             hub.getRateLimit();
             fail("Offline instance should always fail");
         } catch (IOException e) {
-            assertEquals("Offline", e.getMessage());
+            assertThat(e.getMessage(), equalTo("Offline"));
         }
     }
 
     @Test
     public void testGitHubServerWithHttp() throws Exception {
         GitHub hub = GitHub.connectToEnterprise("http://enterprise.kohsuke.org/api/v3", "bogus", "bogus");
-        assertEquals("http://enterprise.kohsuke.org/api/v3/test",
-                GitHubRequest.getApiURL(hub.getClient().getApiUrl(), "/test").toString());
+        assertThat(GitHubRequest.getApiURL(hub.getClient().getApiUrl(), "/test").toString(),
+                equalTo("http://enterprise.kohsuke.org/api/v3/test"));
     }
 
     @Test
     public void testGitHubServerWithHttps() throws Exception {
         GitHub hub = GitHub.connectToEnterprise("https://enterprise.kohsuke.org/api/v3", "bogus", "bogus");
-        assertEquals("https://enterprise.kohsuke.org/api/v3/test",
-                GitHubRequest.getApiURL(hub.getClient().getApiUrl(), "/test").toString());
+        assertThat(GitHubRequest.getApiURL(hub.getClient().getApiUrl(), "/test").toString(),
+                equalTo("https://enterprise.kohsuke.org/api/v3/test"));
     }
 
     @Test
     public void testGitHubServerWithoutServer() throws Exception {
         GitHub hub = GitHub.connectUsingPassword("kohsuke", "bogus");
-        assertEquals("https://api.github.com/test",
-                GitHubRequest.getApiURL(hub.getClient().getApiUrl(), "/test").toString());
+        assertThat(GitHubRequest.getApiURL(hub.getClient().getApiUrl(), "/test").toString(),
+                equalTo("https://api.github.com/test"));
     }
 
     @Test
@@ -148,13 +143,13 @@ public class GitHubConnectionTest extends AbstractGitHubWireMockTest {
         GitHubBuilder builder = new GitHubBuilder().withAppInstallationToken("bogus app token");
         assertThat(builder.authorizationProvider, instanceOf(UserAuthorizationProvider.class));
         assertThat(builder.authorizationProvider.getEncodedAuthorization(), equalTo("token bogus app token"));
-        assertThat(((UserAuthorizationProvider) builder.authorizationProvider).getLogin(), equalTo(""));
+        assertThat(((UserAuthorizationProvider) builder.authorizationProvider).getLogin(), is(emptyString()));
 
         // test authorization header is set as in the RFC6749
         GitHub github = builder.build();
         // change this to get a request
-        assertEquals("token bogus app token", github.getClient().getEncodedAuthorization());
-        assertEquals("", github.getClient().login);
+        assertThat(github.getClient().getEncodedAuthorization(), equalTo("token bogus app token"));
+        assertThat(github.getClient().login, is(emptyString()));
     }
 
     @Test
@@ -164,10 +159,24 @@ public class GitHubConnectionTest extends AbstractGitHubWireMockTest {
         // GitHub hub = GitHub.connectAnonymously();
 
         GitHub hub = GitHub.connectToEnterpriseAnonymously(mockGitHub.apiServer().baseUrl());
+        hub.checkApiUrlValidity();
         try {
             hub.checkApiUrlValidity();
+            fail();
         } catch (IOException ioe) {
-            assertTrue(ioe.getMessage().contains("private mode enabled"));
+            assertThat(ioe.getMessage(), containsString("doesn't look like GitHub API URL"));
+        }
+        try {
+            hub.checkApiUrlValidity();
+            fail();
+        } catch (IOException ioe) {
+            assertThat(ioe.getMessage(), containsString("private mode enabled"));
+        }
+        try {
+            hub.getClient().requireCredential();
+            fail();
+        } catch (Exception e) {
+            assertThat(e.getMessage(), containsString("This operation requires a credential"));
         }
     }
 

src/test/java/org/kohsuke/github/GitHubStaticTest.java

@@ -139,8 +139,8 @@ public class GitHubStaticTest extends AbstractGitHubWireMockTest {
 
         assertThat(rateLimit_none, equalTo(rateLimit_core));
         assertThat(rateLimit_none, not(sameInstance(rateLimit_core)));
-        assertTrue(rateLimit_none.hashCode() == rateLimit_core.hashCode());
-        assertTrue(rateLimit_none.equals(rateLimit_core));
+        assertThat(rateLimit_none.hashCode(), equalTo(rateLimit_core.hashCode()));
+        assertThat(rateLimit_none, equalTo(rateLimit_core));
 
         assertThat(rateLimit_none, not(equalTo(rateLimit_search)));
 

src/test/java/org/kohsuke/github/GitHubTest.java

@@ -7,9 +7,7 @@ import org.kohsuke.github.example.dataobject.ReadOnlyObjects;
 import java.io.IOException;
 import java.util.*;
 
-import static org.hamcrest.CoreMatchers.*;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.*;
 import static org.kohsuke.github.GHMarketplaceAccountType.ORGANIZATION;
 
 /**
@@ -69,19 +67,19 @@ public class GitHubTest extends AbstractGitHubWireMockTest {
         PagedSearchIterable<GHUser> r = gitHub.searchUsers().q("tom").repos(">42").followers(">1000").list();
         GHUser u = r.iterator().next();
         // System.out.println(u.getName());
-        assertNotNull(u.getId());
-        assertTrue(r.getTotalCount() > 0);
+        assertThat(u.getId(), notNullValue());
+        assertThat(r.getTotalCount(), greaterThan(0));
     }
 
     @Test
     public void testListAllRepositories() throws Exception {
         Iterator<GHRepository> itr = gitHub.listAllPublicRepositories().iterator();
         for (int i = 0; i < 115; i++) {
-            assertTrue(itr.hasNext());
+            assertThat(itr.hasNext(), is(true));
             GHRepository r = itr.next();
             // System.out.println(r.getFullName());
-            assertNotNull(r.getUrl());
-            assertNotEquals(0L, r.getId());
+            assertThat(r.getUrl(), notNullValue());
+            assertThat(r.getId(), not(0L));
         }
 
         // ensure the iterator throws as expected
@@ -100,13 +98,60 @@ public class GitHubTest extends AbstractGitHubWireMockTest {
                 .in("file")
                 .language("js")
                 .repo("jquery/jquery")
+                // ignored unless sort is also set
+                .order(GHDirection.DESC)
                 .list();
         GHContent c = r.iterator().next();
+
         // System.out.println(c.getName());
-        assertNotNull(c.getDownloadUrl());
-        assertNotNull(c.getOwner());
-        assertEquals("jquery/jquery", c.getOwner().getFullName());
-        assertTrue(r.getTotalCount() > 0);
+        assertThat(c.getDownloadUrl(), notNullValue());
+        assertThat(c.getOwner(), notNullValue());
+        assertThat(c.getOwner().getFullName(), equalTo("jquery/jquery"));
+        assertThat(r.getTotalCount(), greaterThan(5));
+
+        PagedSearchIterable<GHContent> r2 = gitHub.searchContent()
+                .q("addClass")
+                .in("file")
+                .language("js")
+                .repo("jquery/jquery")
+                // resets query sort back to default
+                .sort(GHContentSearchBuilder.Sort.INDEXED)
+                .sort(GHContentSearchBuilder.Sort.BEST_MATCH)
+                // ignored unless sort is also set to non-default
+                .order(GHDirection.ASC)
+                .list();
+
+        GHContent c2 = r2.iterator().next();
+        assertThat(c2.getPath(), equalTo(c.getPath()));
+        assertThat(r2.getTotalCount(), equalTo(r.getTotalCount()));
+
+        PagedSearchIterable<GHContent> r3 = gitHub.searchContent()
+                .q("addClass")
+                .in("file")
+                .language("js")
+                .repo("jquery/jquery")
+                .sort(GHContentSearchBuilder.Sort.INDEXED)
+                .order(GHDirection.ASC)
+                .list();
+
+        GHContent c3 = r3.iterator().next();
+        assertThat(c3.getPath(), not(equalTo(c2.getPath())));
+        assertThat(r3.getTotalCount(), equalTo(r2.getTotalCount()));
+
+        PagedSearchIterable<GHContent> r4 = gitHub.searchContent()
+                .q("addClass")
+                .in("file")
+                .language("js")
+                .repo("jquery/jquery")
+                .sort(GHContentSearchBuilder.Sort.INDEXED)
+                .order(GHDirection.DESC)
+                .list();
+
+        GHContent c4 = r4.iterator().next();
+        assertThat(c4.getPath(), not(equalTo(c2.getPath())));
+        assertThat(c4.getPath(), not(equalTo(c3.getPath())));
+        assertThat(r4.getTotalCount(), equalTo(r2.getTotalCount()));
+
     }
 
     @Test
@@ -114,20 +159,20 @@ public class GitHubTest extends AbstractGitHubWireMockTest {
         PagedIterable<GHAuthorization> list = gitHub.listMyAuthorizations();
 
         for (GHAuthorization auth : list) {
-            assertNotNull(auth.getAppName());
+            assertThat(auth.getAppName(), notNullValue());
         }
     }
 
     @Test
     public void getMeta() throws IOException {
         GHMeta meta = gitHub.getMeta();
-        assertTrue(meta.isVerifiablePasswordAuthentication());
-        assertEquals(19, meta.getApi().size());
-        assertEquals(19, meta.getGit().size());
-        assertEquals(3, meta.getHooks().size());
-        assertEquals(6, meta.getImporter().size());
-        assertEquals(6, meta.getPages().size());
-        assertEquals(19, meta.getWeb().size());
+        assertThat(meta.isVerifiablePasswordAuthentication(), is(true));
+        assertThat(meta.getApi().size(), equalTo(19));
+        assertThat(meta.getGit().size(), equalTo(19));
+        assertThat(meta.getHooks().size(), equalTo(3));
+        assertThat(meta.getImporter().size(), equalTo(6));
+        assertThat(meta.getPages().size(), equalTo(6));
+        assertThat(meta.getWeb().size(), equalTo(19));
 
         // Also test examples here
         Class[] examples = new Class[]{ ReadOnlyObjects.GHMetaPublic.class, ReadOnlyObjects.GHMetaPackage.class,
@@ -138,58 +183,58 @@ public class GitHubTest extends AbstractGitHubWireMockTest {
             ReadOnlyObjects.GHMetaExample metaExample = gitHub.createRequest()
                     .withUrlPath("/meta")
                     .fetch((Class<ReadOnlyObjects.GHMetaExample>) metaClass);
-            assertTrue(metaExample.isVerifiablePasswordAuthentication());
-            assertEquals(19, metaExample.getApi().size());
-            assertEquals(19, metaExample.getGit().size());
-            assertEquals(3, metaExample.getHooks().size());
-            assertEquals(6, metaExample.getImporter().size());
-            assertEquals(6, metaExample.getPages().size());
-            assertEquals(19, metaExample.getWeb().size());
+            assertThat(metaExample.isVerifiablePasswordAuthentication(), is(true));
+            assertThat(metaExample.getApi().size(), equalTo(19));
+            assertThat(metaExample.getGit().size(), equalTo(19));
+            assertThat(metaExample.getHooks().size(), equalTo(3));
+            assertThat(metaExample.getImporter().size(), equalTo(6));
+            assertThat(metaExample.getPages().size(), equalTo(6));
+            assertThat(metaExample.getWeb().size(), equalTo(19));
         }
     }
 
     @Test
     public void getMyMarketplacePurchases() throws IOException {
         List<GHMarketplaceUserPurchase> userPurchases = gitHub.getMyMarketplacePurchases().toList();
-        assertEquals(2, userPurchases.size());
+        assertThat(userPurchases.size(), equalTo(2));
 
         for (GHMarketplaceUserPurchase userPurchase : userPurchases) {
-            assertFalse(userPurchase.isOnFreeTrial());
-            assertNull(userPurchase.getFreeTrialEndsOn());
-            assertEquals("monthly", userPurchase.getBillingCycle());
+            assertThat(userPurchase.isOnFreeTrial(), is(false));
+            assertThat(userPurchase.getFreeTrialEndsOn(), nullValue());
+            assertThat(userPurchase.getBillingCycle(), equalTo("monthly"));
 
             GHMarketplacePlan plan = userPurchase.getPlan();
             // GHMarketplacePlan - Non-nullable fields
-            assertNotNull(plan.getUrl());
-            assertNotNull(plan.getAccountsUrl());
-            assertNotNull(plan.getName());
-            assertNotNull(plan.getDescription());
-            assertNotNull(plan.getPriceModel());
-            assertNotNull(plan.getState());
+            assertThat(plan.getUrl(), notNullValue());
+            assertThat(plan.getAccountsUrl(), notNullValue());
+            assertThat(plan.getName(), notNullValue());
+            assertThat(plan.getDescription(), notNullValue());
+            assertThat(plan.getPriceModel(), notNullValue());
+            assertThat(plan.getState(), notNullValue());
 
             // GHMarketplacePlan - primitive fields
-            assertNotEquals(0L, plan.getId());
-            assertNotEquals(0L, plan.getNumber());
-            assertTrue(plan.getMonthlyPriceInCents() >= 0);
+            assertThat(plan.getId(), not(0L));
+            assertThat(plan.getNumber(), not(0L));
+            assertThat(plan.getMonthlyPriceInCents(), greaterThanOrEqualTo(0L));
 
             // GHMarketplacePlan - list
-            assertEquals(2, plan.getBullets().size());
+            assertThat(plan.getBullets().size(), equalTo(2));
 
             GHMarketplaceAccount account = userPurchase.getAccount();
             // GHMarketplaceAccount - Non-nullable fields
-            assertNotNull(account.getLogin());
-            assertNotNull(account.getUrl());
-            assertNotNull(account.getType());
+            assertThat(account.getLogin(), notNullValue());
+            assertThat(account.getUrl(), notNullValue());
+            assertThat(account.getType(), notNullValue());
 
             // GHMarketplaceAccount - primitive fields
-            assertNotEquals(0L, account.getId());
+            assertThat(account.getId(), not(0L));
 
             /* logical combination tests */
             // Rationale: organization_billing_email is only set when account type is ORGANIZATION.
             if (account.getType() == ORGANIZATION)
-                assertNotNull(account.getOrganizationBillingEmail());
+                assertThat(account.getOrganizationBillingEmail(), notNullValue());
             else
-                assertNull(account.getOrganizationBillingEmail());
+                assertThat(account.getOrganizationBillingEmail(), nullValue());
         }
     }
 
@@ -214,13 +259,11 @@ public class GitHubTest extends AbstractGitHubWireMockTest {
         // getResponseHeaderFields is deprecated but we'll use it for testing.
         assertThat(org.getResponseHeaderFields(), notNullValue());
 
-        // Header field names must be case-insensitive
-        assertThat(org.getResponseHeaderFields().containsKey("CacHe-ContrOl"), is(true));
-
-        // The KeySet from header fields should also be case-insensitive
-        assertThat(org.getResponseHeaderFields().keySet().contains("CacHe-ControL"), is(true));
-        assertThat(org.getResponseHeaderFields().keySet().contains("CacHe-ControL"), is(true));
+        assertThat("Header field names must be case-insensitive",
+                org.getResponseHeaderFields().containsKey("CacHe-ContrOl"));
 
+        assertThat("KeySet from header fields should also be case-insensitive",
+                org.getResponseHeaderFields().keySet().contains("CacHe-ControL"));
         assertThat(org.getResponseHeaderFields().get("cachE-cOntrol").get(0), is("private, max-age=60, s-maxage=60"));
 
         // GitHub has started changing their headers to all lowercase.

src/test/java/org/kohsuke/github/Github2faTest.java

@@ -7,8 +7,6 @@ import java.util.Arrays;
 import java.util.List;
 
 import static org.hamcrest.Matchers.*;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 
 /**
  * @author Kevin Harrington mad.hephaestus@gmail.com
@@ -17,7 +15,7 @@ public class Github2faTest extends AbstractGitHubWireMockTest {
 
     @Test
     public void test2faToken() throws IOException {
-        assertFalse("Test only valid when not proxying", mockGitHub.isUseProxy());
+        assertThat("Test only valid when not proxying", mockGitHub.isUseProxy(), is(false));
 
         List<String> asList = Arrays
                 .asList("repo", "gist", "write:packages", "read:packages", "delete:packages", "user", "delete_repo");
@@ -33,10 +31,7 @@ public class Github2faTest extends AbstractGitHubWireMockTest {
                 });
 
         assertThat(token, notNullValue());
-
-        for (int i = 0; i < asList.size(); i++) {
-            assertTrue(token.getScopes().get(i).contentEquals(asList.get(i)));
-        }
+        assertThat(token.getScopes(), contains(asList.toArray()));
 
         assertThat(token.getToken(), equalTo("63042a99d88bf138e6d6cf5788e0dc4e7a5d7309"));
         assertThat(token.getTokenLastEight(), equalTo("7a5d7309"));

src/test/java/org/kohsuke/github/LifecycleTest.java

@@ -10,8 +10,7 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.List;
 
-import static org.hamcrest.CoreMatchers.*;
-import static org.hamcrest.core.Is.is;
+import static org.hamcrest.Matchers.*;
 
 public class LifecycleTest extends AbstractGitHubWireMockTest {
     @Test
@@ -22,7 +21,7 @@ public class LifecycleTest extends AbstractGitHubWireMockTest {
         // GHOrganization org = gitHub.getOrganization(GITHUB_API_TEST_ORG);
 
         GHRepository repository = getTempRepository();
-        assertTrue(repository.getReleases().isEmpty());
+        assertThat(repository.getReleases(), is(empty()));
 
         GHMilestone milestone = repository.createMilestone("Initial Release", "first one");
         GHIssue issue = repository.createIssue("Test Issue")
@@ -45,22 +44,22 @@ public class LifecycleTest extends AbstractGitHubWireMockTest {
 
     private void updateAsset(GHRelease release, GHAsset asset) throws IOException {
         asset.setLabel("test label");
-        assertEquals("test label", release.getAssets().get(0).getLabel());
+        assertThat(release.getAssets().get(0).getLabel(), equalTo("test label"));
     }
 
     private void deleteAsset(GHRelease release, GHAsset asset) throws IOException {
         asset.delete();
-        assertEquals(0, release.getAssets().size());
+        assertThat(release.getAssets(), is(empty()));
     }
 
     private GHAsset uploadAsset(GHRelease release) throws IOException {
         GHAsset asset = release.uploadAsset(new File("LICENSE.txt"), "application/text");
-        assertNotNull(asset);
+        assertThat(asset, notNullValue());
         List<GHAsset> cachedAssets = release.assets();
-        assertEquals(0, cachedAssets.size());
+        assertThat(cachedAssets, is(empty()));
         List<GHAsset> assets = release.getAssets();
-        assertEquals(1, assets.size());
-        assertEquals("LICENSE.txt", assets.get(0).getName());
+        assertThat(assets.size(), equalTo(1));
+        assertThat(assets.get(0).getName(), equalTo("LICENSE.txt"));
         assertThat(assets.get(0).getSize(), equalTo(1104L));
         assertThat(assets.get(0).getContentType(), equalTo("application/text"));
         assertThat(assets.get(0).getState(), equalTo("uploaded"));
@@ -78,16 +77,16 @@ public class LifecycleTest extends AbstractGitHubWireMockTest {
                 .body("How exciting!  To be able to programmatically create releases is a dream come true!")
                 .create();
         List<GHRelease> releases = repository.getReleases();
-        assertEquals(1, releases.size());
+        assertThat(releases.size(), equalTo(1));
         GHRelease release = releases.get(0);
-        assertEquals("Test Release", release.getName());
+        assertThat(release.getName(), equalTo("Test Release"));
         assertThat(release.getBody(), startsWith("How exciting!"));
         assertThat(release.getOwner(), sameInstance(repository));
         assertThat(release.getZipballUrl(),
                 endsWith("/repos/hub4j-test-org/temp-testCreateRepository/zipball/release_tag"));
         assertThat(release.getTarballUrl(),
                 endsWith("/repos/hub4j-test-org/temp-testCreateRepository/tarball/release_tag"));
-        assertThat(release.getTargetCommitish(), equalTo("master"));
+        assertThat(release.getTargetCommitish(), equalTo("main"));
         assertThat(release.getHtmlUrl().toString(),
                 endsWith("/hub4j-test-org/temp-testCreateRepository/releases/tag/release_tag"));
 

src/test/java/org/kohsuke/github/RepositoryTrafficTest.java

@@ -1,6 +1,6 @@
 package org.kohsuke.github;
 
-import org.junit.Assert;
+import org.hamcrest.Matchers;
 import org.junit.Test;
 import org.kohsuke.github.GHRepositoryTraffic.DailyInfo;
 
@@ -14,24 +14,24 @@ public class RepositoryTrafficTest extends AbstractGitHubWireMockTest {
 
     @SuppressWarnings("unchecked")
     private <T extends GHRepositoryTraffic> void checkResponse(T expected, T actual) {
-        Assert.assertEquals(expected.getCount(), actual.getCount());
-        Assert.assertEquals(expected.getUniques(), actual.getUniques());
+        assertThat(actual.getCount(), Matchers.equalTo(expected.getCount()));
+        assertThat(actual.getUniques(), Matchers.equalTo(expected.getUniques()));
 
         List<? extends DailyInfo> expectedList = expected.getDailyInfo();
         List<? extends DailyInfo> actualList = actual.getDailyInfo();
         Iterator<? extends DailyInfo> expectedIt;
         Iterator<? extends DailyInfo> actualIt;
 
-        Assert.assertEquals(expectedList.size(), actualList.size());
+        assertThat(actualList.size(), Matchers.equalTo(expectedList.size()));
         expectedIt = expectedList.iterator();
         actualIt = actualList.iterator();
 
         while (expectedIt.hasNext() && actualIt.hasNext()) {
             DailyInfo expectedDailyInfo = expectedIt.next();
             DailyInfo actualDailyInfo = actualIt.next();
-            Assert.assertEquals(expectedDailyInfo.getCount(), actualDailyInfo.getCount());
-            Assert.assertEquals(expectedDailyInfo.getUniques(), actualDailyInfo.getUniques());
-            Assert.assertEquals(expectedDailyInfo.getTimestamp(), actualDailyInfo.getTimestamp());
+            assertThat(actualDailyInfo.getCount(), Matchers.equalTo(expectedDailyInfo.getCount()));
+            assertThat(actualDailyInfo.getUniques(), Matchers.equalTo(expectedDailyInfo.getUniques()));
+            assertThat(actualDailyInfo.getTimestamp(), Matchers.equalTo(expectedDailyInfo.getTimestamp()));
         }
     }
 
@@ -100,12 +100,12 @@ public class RepositoryTrafficTest extends AbstractGitHubWireMockTest {
         GHRepository repo = gitHub.getOrganization(GITHUB_API_TEST_ORG).getRepository(repositoryName);
         try {
             repo.getViewTraffic();
-            Assert.fail(errorMsg);
+            fail(errorMsg);
         } catch (HttpException ex) {
         }
         try {
             repo.getCloneTraffic();
-            Assert.fail(errorMsg);
+            fail(errorMsg);
         } catch (HttpException ex) {
         }
     }

src/test/java/org/kohsuke/github/RequesterRetryTest.java

@@ -97,7 +97,7 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
             try {
                 gitHub.checkApiUrlValidity();
             } catch (IOException ioe) {
-                assertTrue(ioe.getMessage().contains("private mode enabled"));
+                assertThat(ioe.getMessage(), containsString("private mode enabled"));
             }
             Thread.sleep(100);
         }
@@ -127,8 +127,8 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
         }
 
         String capturedLog = getTestCapturedLog();
-        assertTrue(capturedLog.contains("will try 2 more time"));
-        assertTrue(capturedLog.contains("will try 1 more time"));
+        assertThat(capturedLog.contains("will try 2 more time"), is(true));
+        assertThat(capturedLog.contains("will try 1 more time"), is(true));
 
         assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + 6));
     }
@@ -156,8 +156,8 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
         }
 
         String capturedLog = getTestCapturedLog();
-        assertTrue(capturedLog.contains("will try 2 more time"));
-        assertTrue(capturedLog.contains("will try 1 more time"));
+        assertThat(capturedLog.contains("will try 2 more time"), is(true));
+        assertThat(capturedLog.contains("will try 1 more time"), is(true));
 
         assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + 6));
     }
@@ -206,8 +206,8 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
         GHBranch branch = repo.getBranch("test/timeout");
         assertThat(branch, notNullValue());
         String capturedLog = getTestCapturedLog();
-        assertTrue(capturedLog.contains("will try 2 more time"));
-        assertTrue(capturedLog.contains("will try 1 more time"));
+        assertThat(capturedLog.contains("will try 2 more time"), is(true));
+        assertThat(capturedLog.contains("will try 1 more time"), is(true));
 
         assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + 6));
     }
@@ -232,8 +232,8 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
             assertThat(e.getCause(), instanceOf(IOException.class));
             assertThat(e.getCause().getMessage(), is("Custom"));
             String capturedLog = getTestCapturedLog();
-            assertFalse(capturedLog.contains("will try 2 more time"));
-            assertFalse(capturedLog.contains("will try 1 more time"));
+            assertThat(capturedLog.contains("will try 2 more time"), is(false));
+            assertThat(capturedLog.contains("will try 1 more time"), is(false));
             assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount));
         }
 
@@ -253,8 +253,8 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
             assertThat(e, instanceOf(FileNotFoundException.class));
             assertThat(e.getMessage(), is("Custom"));
             String capturedLog = getTestCapturedLog();
-            assertFalse(capturedLog.contains("will try 2 more time"));
-            assertFalse(capturedLog.contains("will try 1 more time"));
+            assertThat(capturedLog.contains("will try 2 more time"), is(false));
+            assertThat(capturedLog.contains("will try 1 more time"), is(false));
             assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount));
         }
     }
@@ -279,8 +279,8 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
             assertThat(e.getCause(), instanceOf(IOException.class));
             assertThat(e.getCause().getMessage(), is("Custom"));
             String capturedLog = getTestCapturedLog();
-            assertFalse(capturedLog.contains("will try 2 more time"));
-            assertFalse(capturedLog.contains("will try 1 more time"));
+            assertThat(capturedLog.contains("will try 2 more time"), is(false));
+            assertThat(capturedLog.contains("will try 1 more time"), is(false));
             assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + 1));
         }
 
@@ -297,8 +297,8 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
             assertThat(e.getCause(), instanceOf(FileNotFoundException.class));
             assertThat(e.getCause().getMessage(), containsString("hub4j-test-org-missing"));
             String capturedLog = getTestCapturedLog();
-            assertFalse(capturedLog.contains("will try 2 more time"));
-            assertFalse(capturedLog.contains("will try 1 more time"));
+            assertThat(capturedLog.contains("will try 2 more time"), is(false));
+            assertThat(capturedLog.contains("will try 1 more time"), is(false));
             assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + 1));
         }
 
@@ -313,8 +313,8 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
                         .fetchHttpStatusCode(),
                 equalTo(404));
         String capturedLog = getTestCapturedLog();
-        assertFalse(capturedLog.contains("will try 2 more time"));
-        assertFalse(capturedLog.contains("will try 1 more time"));
+        assertThat(capturedLog.contains("will try 2 more time"), is(false));
+        assertThat(capturedLog.contains("will try 1 more time"), is(false));
         assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + 1));
     }
 
@@ -373,16 +373,16 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
         baseRequestCount = this.mockGitHub.getRequestCount();
         assertThat(this.gitHub.getOrganization(GITHUB_API_TEST_ORG), is(notNullValue()));
         String capturedLog = getTestCapturedLog();
-        assertTrue(capturedLog.contains("will try 2 more time"));
-        assertTrue(capturedLog.contains("will try 1 more time"));
+        assertThat(capturedLog, containsString("will try 2 more time"));
+        assertThat(capturedLog, containsString("will try 1 more time"));
         assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + expectedRequestCount));
 
         resetTestCapturedLog();
         baseRequestCount = this.mockGitHub.getRequestCount();
         this.gitHub.createRequest().withUrlPath("/orgs/" + GITHUB_API_TEST_ORG).send();
         capturedLog = getTestCapturedLog();
-        assertTrue(capturedLog.contains("will try 2 more time"));
-        assertTrue(capturedLog.contains("will try 1 more time"));
+        assertThat(capturedLog, containsString("will try 2 more time"));
+        assertThat(capturedLog, containsString("will try 1 more time"));
         assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + expectedRequestCount));
     }
 
@@ -399,13 +399,13 @@ public class RequesterRetryTest extends AbstractGitHubWireMockTest {
                 equalTo(200));
         String capturedLog = getTestCapturedLog();
         if (expectedRequestCount > 0) {
-            assertTrue(capturedLog.contains("will try 2 more time"));
-            assertTrue(capturedLog.contains("will try 1 more time"));
+            assertThat(capturedLog, containsString("will try 2 more time"));
+            assertThat(capturedLog, containsString("will try 1 more time"));
             assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + expectedRequestCount));
         } else {
             // Success without retries
-            assertFalse(capturedLog.contains("will try 2 more time"));
-            assertFalse(capturedLog.contains("will try 1 more time"));
+            assertThat(capturedLog, not(containsString("will try 2 more time")));
+            assertThat(capturedLog, not(containsString("will try 1 more time")));
             assertThat(this.mockGitHub.getRequestCount(), equalTo(baseRequestCount + 1));
         }
     }

src/test/java/org/kohsuke/github/WireMockStatusReporterTest.java

@@ -4,10 +4,7 @@ import org.hamcrest.Matchers;
 import org.junit.Ignore;
 import org.junit.Test;
 
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.*;
 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;
 
@@ -133,7 +130,7 @@ public class WireMockStatusReporterTest extends AbstractGitHubWireMockTest {
         assumeTrue("Test only valid when Snapshotting (-Dtest.github.takeSnapshot to enable)",
                 mockGitHub.isTakeSnapshot());
 
-        assertTrue("When taking a snapshot, proxy should automatically be enabled", mockGitHub.isUseProxy());
+        assertThat("When taking a snapshot, proxy should automatically be enabled", mockGitHub.isUseProxy());
     }
 
     @Ignore("Not implemented yet")

src/test/java/org/kohsuke/github/extras/GitHubCachingTest.java

@@ -43,11 +43,11 @@ public class GitHubCachingTest extends AbstractGitHubWireMockTest {
     @Before
     public void setupRepo() throws Exception {
         if (mockGitHub.isUseProxy()) {
-            for (GHPullRequest pr : getRepository(this.getGitHubBeforeAfter()).getPullRequests(GHIssueState.OPEN)) {
+            for (GHPullRequest pr : getRepository(this.getNonRecordingGitHub()).getPullRequests(GHIssueState.OPEN)) {
                 pr.close();
             }
             try {
-                GHRef ref = getRepository(this.getGitHubBeforeAfter()).getRef(testRefName);
+                GHRef ref = getRepository(this.getNonRecordingGitHub()).getRef(testRefName);
                 ref.delete();
             } catch (IOException e) {
             }

src/test/java/org/kohsuke/github/extras/OkHttpConnectorTest.java

@@ -73,7 +73,7 @@ public class OkHttpConnectorTest extends AbstractGitHubWireMockTest {
     @Before
     public void setupRepo() throws Exception {
         if (mockGitHub.isUseProxy()) {
-            GHRepository repo = getRepository(getGitHubBeforeAfter());
+            GHRepository repo = getRepository(getNonRecordingGitHub());
             repo.setDescription("Resetting");
 
             // Let things settle a bit between tests when working against the live site
@@ -252,7 +252,7 @@ public class OkHttpConnectorTest extends AbstractGitHubWireMockTest {
 
         // Get Tricky - make a change via a different client
         if (mockGitHub.isUseProxy()) {
-            GHRepository altRepo = getRepository(getGitHubBeforeAfter());
+            GHRepository altRepo = getRepository(getNonRecordingGitHub());
             altRepo.setDescription("Tricky");
         }
 

src/test/java/org/kohsuke/github/extras/okhttp3/GitHubCachingTest.java

@@ -45,11 +45,11 @@ public class GitHubCachingTest extends AbstractGitHubWireMockTest {
     @Before
     public void setupRepo() throws Exception {
         if (mockGitHub.isUseProxy()) {
-            for (GHPullRequest pr : getRepository(this.getGitHubBeforeAfter()).getPullRequests(GHIssueState.OPEN)) {
+            for (GHPullRequest pr : getRepository(this.getNonRecordingGitHub()).getPullRequests(GHIssueState.OPEN)) {
                 pr.close();
             }
             try {
-                GHRef ref = getRepository(this.getGitHubBeforeAfter()).getRef(testRefName);
+                GHRef ref = getRepository(this.getNonRecordingGitHub()).getRef(testRefName);
                 ref.delete();
             } catch (IOException e) {
             }

src/test/java/org/kohsuke/github/extras/okhttp3/OkHttpConnectorTest.java

@@ -79,7 +79,7 @@ public class OkHttpConnectorTest extends AbstractGitHubWireMockTest {
     @Before
     public void setupRepo() throws Exception {
         if (mockGitHub.isUseProxy()) {
-            GHRepository repo = getRepository(getGitHubBeforeAfter());
+            GHRepository repo = getRepository(getNonRecordingGitHub());
             repo.setDescription("Resetting");
 
             // Let things settle a bit between tests when working against the live site
@@ -261,7 +261,7 @@ public class OkHttpConnectorTest extends AbstractGitHubWireMockTest {
 
         // Get Tricky - make a change via a different client
         if (mockGitHub.isUseProxy()) {
-            GHRepository altRepo = getRepository(getGitHubBeforeAfter());
+            GHRepository altRepo = getRepository(getNonRecordingGitHub());
             altRepo.setDescription("Tricky");
         }
 

src/test/java/org/kohsuke/github/junit/GitHubWireMockRule.java

@@ -69,6 +69,10 @@ public class GitHubWireMockRule extends WireMockMultiServerRule {
         return servers.get("codeload");
     }
 
+    public WireMockServer actionsUserContentServer() {
+        return servers.get("actions-user-content");
+    }
+
     public boolean isUseProxy() {
         return GitHubWireMockRule.useProxy;
     }
@@ -97,6 +101,11 @@ public class GitHubWireMockRule extends WireMockMultiServerRule {
         if (new File(apiServer().getOptions().filesRoot().getPath() + "_codeload").exists() || isUseProxy()) {
             initializeServer("codeload");
         }
+
+        if (new File(apiServer().getOptions().filesRoot().getPath() + "_actions-user-content").exists()
+                || isUseProxy()) {
+            initializeServer("actions-user-content");
+        }
     }
 
     @Override
@@ -120,6 +129,11 @@ public class GitHubWireMockRule extends WireMockMultiServerRule {
             this.codeloadServer().stubFor(proxyAllTo("https://codeload.github.com").atPriority(100));
         }
 
+        if (this.actionsUserContentServer() != null) {
+            this.actionsUserContentServer()
+                    .stubFor(proxyAllTo("https://pipelines.actions.githubusercontent.com").atPriority(100));
+        }
+
     }
 
     @Override
@@ -137,12 +151,17 @@ public class GitHubWireMockRule extends WireMockMultiServerRule {
         recordSnapshot(this.uploadsServer(), "https://uploads.github.com", false);
 
         recordSnapshot(this.codeloadServer(), "https://codeload.github.com", true);
+
+        recordSnapshot(this.actionsUserContentServer(), "https://pipelines.actions.githubusercontent.com", true);
     }
 
     private void recordSnapshot(WireMockServer server, String target, boolean isRawServer) {
         if (server != null) {
 
             server.snapshotRecord(recordSpec().forTarget(target)
+                    // "X-HTTP-Method-Override" is used to send http methods not supported by
+                    // HttpURLConnection without using hacky Java reflection techniques
+                    .captureHeader("X-HTTP-Method-Override")
                     // "If-None-Match" header used for ETag matching for caching connections
                     .captureHeader("If-None-Match")
                     // "If-Modified-Since" header used for ETag matching for caching connections
@@ -233,6 +252,11 @@ public class GitHubWireMockRule extends WireMockMultiServerRule {
                             fileText = fileText.replace(this.codeloadServer().baseUrl(), "https://codeload.github.com");
                         }
 
+                        if (this.actionsUserContentServer() != null) {
+                            fileText = fileText.replace(this.actionsUserContentServer().baseUrl(),
+                                    "https://pipelines.actions.githubusercontent.com");
+                        }
+
                         // point bodyFile in the mapping to the renamed body file
                         if (entry != null && filePath.toString().contains("mappings")) {
                             fileText = fileText.replace("-" + entry.getKey(), "-" + entry.getValue());
@@ -288,6 +312,11 @@ public class GitHubWireMockRule extends WireMockMultiServerRule {
         body = replaceTargetServerUrl(body, this.uploadsServer(), "https://uploads.github.com", "/uploads");
 
         body = replaceTargetServerUrl(body, this.codeloadServer(), "https://codeload.github.com", "/codeload");
+
+        body = replaceTargetServerUrl(body,
+                this.actionsUserContentServer(),
+                "https://pipelines.actions.githubusercontent.com",
+                "/actions-user-content");
         return body;
     }
 

src/test/resources/org/kohsuke/github/AbuseLimitHandlerTest/wiremock/testHandler_Fail/__files/repos_hub4j-test-org_temp-testratelimithandler_fail-3.json

@@ -90,7 +90,7 @@
   "forks": 0,
   "open_issues": 0,
   "watchers": 0,
-  "default_branch": "master",
+  "default_branch": "main",
   "permissions": {
     "admin": true,
     "push": true,

src/test/resources/org/kohsuke/github/AbuseLimitHandlerTest/wiremock/testHandler_HttpStatus_Fail/__files/repos_hub4j-test-org_temp-testratelimithandler_fail-3.json

@@ -90,7 +90,7 @@
   "forks": 0,
   "open_issues": 0,
   "watchers": 0,
-  "default_branch": "master",
+  "default_branch": "main",
   "permissions": {
     "admin": true,
     "push": true,

src/test/resources/org/kohsuke/github/AbuseLimitHandlerTest/wiremock/testHandler_Wait/__files/repos_hub4j-test-org_temp-testratelimithandler_fail-3.json

@@ -90,7 +90,7 @@
   "forks": 0,
   "open_issues": 0,
   "watchers": 0,
-  "default_branch": "master",
+  "default_branch": "main",
   "permissions": {
     "admin": true,
     "push": true,

src/test/resources/org/kohsuke/github/AppTest/wiremock/blob/__files/repos_hub4j_github-api-2.json

@@ -96,7 +96,7 @@
   "forks": 433,
   "open_issues": 64,
   "watchers": 565,
-  "default_branch": "master",
+  "default_branch": "main",
   "permissions": {
     "admin": true,
     "push": true,

src/test/resources/org/kohsuke/github/AppTest/wiremock/directoryListing/__files/repos_jenkinsci_jenkins-2.json

@@ -96,7 +96,7 @@
   "forks": 5807,
   "open_issues": 74,
   "watchers": 14167,
-  "default_branch": "master",
+  "default_branch": "main",
   "permissions": {
     "admin": false,
     "push": false,

src/test/resources/org/kohsuke/github/AppTest/wiremock/directoryListing/__files/repos_jenkinsci_jenkins_contents_core-3.json

@@ -4,15 +4,15 @@
     "path": "core/move-l10n.groovy",
     "sha": "8d002348827a6c76ec3b4832278384c74a91d692",
     "size": 1560,
-    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/move-l10n.groovy?ref=master",
-    "html_url": "https://github.com/jenkinsci/jenkins/blob/master/core/move-l10n.groovy",
+    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/move-l10n.groovy?ref=main",
+    "html_url": "https://github.com/jenkinsci/jenkins/blob/main/core/move-l10n.groovy",
     "git_url": "https://api.github.com/repos/jenkinsci/jenkins/git/blobs/8d002348827a6c76ec3b4832278384c74a91d692",
-    "download_url": "https://raw.githubusercontent.com/jenkinsci/jenkins/master/core/move-l10n.groovy",
+    "download_url": "https://raw.githubusercontent.com/jenkinsci/jenkins/main/core/move-l10n.groovy",
     "type": "file",
     "_links": {
-      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/move-l10n.groovy?ref=master",
+      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/move-l10n.groovy?ref=main",
       "git": "https://api.github.com/repos/jenkinsci/jenkins/git/blobs/8d002348827a6c76ec3b4832278384c74a91d692",
-      "html": "https://github.com/jenkinsci/jenkins/blob/master/core/move-l10n.groovy"
+      "html": "https://github.com/jenkinsci/jenkins/blob/main/core/move-l10n.groovy"
     }
   },
   {
@@ -20,15 +20,15 @@
     "path": "core/pom.xml",
     "sha": "0402553742ec270b65e5ea4c0851088659987183",
     "size": 28950,
-    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/pom.xml?ref=master",
-    "html_url": "https://github.com/jenkinsci/jenkins/blob/master/core/pom.xml",
+    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/pom.xml?ref=main",
+    "html_url": "https://github.com/jenkinsci/jenkins/blob/main/core/pom.xml",
     "git_url": "https://api.github.com/repos/jenkinsci/jenkins/git/blobs/0402553742ec270b65e5ea4c0851088659987183",
-    "download_url": "https://raw.githubusercontent.com/jenkinsci/jenkins/master/core/pom.xml",
+    "download_url": "https://raw.githubusercontent.com/jenkinsci/jenkins/main/core/pom.xml",
     "type": "file",
     "_links": {
-      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/pom.xml?ref=master",
+      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/pom.xml?ref=main",
       "git": "https://api.github.com/repos/jenkinsci/jenkins/git/blobs/0402553742ec270b65e5ea4c0851088659987183",
-      "html": "https://github.com/jenkinsci/jenkins/blob/master/core/pom.xml"
+      "html": "https://github.com/jenkinsci/jenkins/blob/main/core/pom.xml"
     }
   },
   {
@@ -36,15 +36,15 @@
     "path": "core/report-l10n.rb",
     "sha": "d48bf4d2f9ed5de92f6d4a9864ecc168d15e3420",
     "size": 17290,
-    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/report-l10n.rb?ref=master",
-    "html_url": "https://github.com/jenkinsci/jenkins/blob/master/core/report-l10n.rb",
+    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/report-l10n.rb?ref=main",
+    "html_url": "https://github.com/jenkinsci/jenkins/blob/main/core/report-l10n.rb",
     "git_url": "https://api.github.com/repos/jenkinsci/jenkins/git/blobs/d48bf4d2f9ed5de92f6d4a9864ecc168d15e3420",
-    "download_url": "https://raw.githubusercontent.com/jenkinsci/jenkins/master/core/report-l10n.rb",
+    "download_url": "https://raw.githubusercontent.com/jenkinsci/jenkins/main/core/report-l10n.rb",
     "type": "file",
     "_links": {
-      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/report-l10n.rb?ref=master",
+      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/report-l10n.rb?ref=main",
       "git": "https://api.github.com/repos/jenkinsci/jenkins/git/blobs/d48bf4d2f9ed5de92f6d4a9864ecc168d15e3420",
-      "html": "https://github.com/jenkinsci/jenkins/blob/master/core/report-l10n.rb"
+      "html": "https://github.com/jenkinsci/jenkins/blob/main/core/report-l10n.rb"
     }
   },
   {
@@ -52,15 +52,15 @@
     "path": "core/src",
     "sha": "11d50acb5fba7764e8ef1c230aac16aa9aa0ef31",
     "size": 0,
-    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src?ref=master",
-    "html_url": "https://github.com/jenkinsci/jenkins/tree/master/core/src",
+    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src?ref=main",
+    "html_url": "https://github.com/jenkinsci/jenkins/tree/main/core/src",
     "git_url": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/11d50acb5fba7764e8ef1c230aac16aa9aa0ef31",
     "download_url": null,
     "type": "dir",
     "_links": {
-      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src?ref=master",
+      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src?ref=main",
       "git": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/11d50acb5fba7764e8ef1c230aac16aa9aa0ef31",
-      "html": "https://github.com/jenkinsci/jenkins/tree/master/core/src"
+      "html": "https://github.com/jenkinsci/jenkins/tree/main/core/src"
     }
   }
 ]

src/test/resources/org/kohsuke/github/AppTest/wiremock/directoryListing/__files/repos_jenkinsci_jenkins_contents_core_src-4.json

@@ -4,15 +4,15 @@
     "path": "core/src/filter",
     "sha": "5f087f4c3dd2690948371b4f867087d36fdbb19d",
     "size": 0,
-    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/filter?ref=master",
-    "html_url": "https://github.com/jenkinsci/jenkins/tree/master/core/src/filter",
+    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/filter?ref=main",
+    "html_url": "https://github.com/jenkinsci/jenkins/tree/main/core/src/filter",
     "git_url": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/5f087f4c3dd2690948371b4f867087d36fdbb19d",
     "download_url": null,
     "type": "dir",
     "_links": {
-      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/filter?ref=master",
+      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/filter?ref=main",
       "git": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/5f087f4c3dd2690948371b4f867087d36fdbb19d",
-      "html": "https://github.com/jenkinsci/jenkins/tree/master/core/src/filter"
+      "html": "https://github.com/jenkinsci/jenkins/tree/main/core/src/filter"
     }
   },
   {
@@ -20,15 +20,15 @@
     "path": "core/src/main",
     "sha": "7334485bc5155447be2692f1d4acf9c717335d7b",
     "size": 0,
-    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/main?ref=master",
-    "html_url": "https://github.com/jenkinsci/jenkins/tree/master/core/src/main",
+    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/main?ref=main",
+    "html_url": "https://github.com/jenkinsci/jenkins/tree/main/core/src/main",
     "git_url": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/7334485bc5155447be2692f1d4acf9c717335d7b",
     "download_url": null,
     "type": "dir",
     "_links": {
-      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/main?ref=master",
+      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/main?ref=main",
       "git": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/7334485bc5155447be2692f1d4acf9c717335d7b",
-      "html": "https://github.com/jenkinsci/jenkins/tree/master/core/src/main"
+      "html": "https://github.com/jenkinsci/jenkins/tree/main/core/src/main"
     }
   },
   {
@@ -36,15 +36,15 @@
     "path": "core/src/site",
     "sha": "59d5107eeacdac5a50a2e2eb3592d79c9a8f8743",
     "size": 0,
-    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/site?ref=master",
-    "html_url": "https://github.com/jenkinsci/jenkins/tree/master/core/src/site",
+    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/site?ref=main",
+    "html_url": "https://github.com/jenkinsci/jenkins/tree/main/core/src/site",
     "git_url": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/59d5107eeacdac5a50a2e2eb3592d79c9a8f8743",
     "download_url": null,
     "type": "dir",
     "_links": {
-      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/site?ref=master",
+      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/site?ref=main",
       "git": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/59d5107eeacdac5a50a2e2eb3592d79c9a8f8743",
-      "html": "https://github.com/jenkinsci/jenkins/tree/master/core/src/site"
+      "html": "https://github.com/jenkinsci/jenkins/tree/main/core/src/site"
     }
   },
   {
@@ -52,15 +52,15 @@
     "path": "core/src/test",
     "sha": "d600ddfd8eebaf8b605d9f99d3a9f117fac2eb2b",
     "size": 0,
-    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/test?ref=master",
-    "html_url": "https://github.com/jenkinsci/jenkins/tree/master/core/src/test",
+    "url": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/test?ref=main",
+    "html_url": "https://github.com/jenkinsci/jenkins/tree/main/core/src/test",
     "git_url": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/d600ddfd8eebaf8b605d9f99d3a9f117fac2eb2b",
     "download_url": null,
     "type": "dir",
     "_links": {
-      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/test?ref=master",
+      "self": "https://api.github.com/repos/jenkinsci/jenkins/contents/core/src/test?ref=main",
       "git": "https://api.github.com/repos/jenkinsci/jenkins/git/trees/d600ddfd8eebaf8b605d9f99d3a9f117fac2eb2b",
-      "html": "https://github.com/jenkinsci/jenkins/tree/master/core/src/test"
+      "html": "https://github.com/jenkinsci/jenkins/tree/main/core/src/test"
     }
   }
 ]

src/test/resources/org/kohsuke/github/AppTest/wiremock/directoryListing/mappings/repos_jenkinsci_jenkins_contents_core_src-4.json

@@ -2,7 +2,7 @@
   "id": "0566ab8b-d260-47cb-a6e6-fafa6fc2836c",
   "name": "repos_jenkinsci_jenkins_contents_core_src",
   "request": {
-    "url": "/repos/jenkinsci/jenkins/contents/core/src?ref=master",
+    "url": "/repos/jenkinsci/jenkins/contents/core/src?ref=main",
     "method": "GET",
     "headers": {
       "Accept": {

src/test/resources/org/kohsuke/github/AppTest/wiremock/notifications/__files/notifications-16.json

@@ -827,15 +827,15 @@
     "last_read_at": "2019-09-11T00:03:20Z",
     "subject": {
       "title": "[CPLT2-5785] Define jenkins.hook.url when appropriate",
-      "url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/pulls/15",
-      "latest_comment_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/pulls/15",
+      "url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/pulls/15",
+      "latest_comment_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/pulls/15",
       "type": "PullRequest"
     },
     "repository": {
       "id": 202214807,
       "node_id": "MDEwOlJlcG9zaXRvcnkyMDIyMTQ4MDc=",
-      "name": "managed-master-hibernation-plugin",
-      "full_name": "cloudbees/managed-master-hibernation-plugin",
+      "name": "managed-main-hibernation-plugin",
+      "full_name": "cloudbees/managed-main-hibernation-plugin",
       "private": true,
       "owner": {
         "login": "cloudbees",
@@ -857,46 +857,46 @@
         "type": "Organization",
         "site_admin": false
       },
-      "html_url": "https://github.com/cloudbees/managed-master-hibernation-plugin",
-      "description": "CPLT2-5737: Allows a managed master to indicate that it is ready to be hibernated.",
+      "html_url": "https://github.com/cloudbees/managed-main-hibernation-plugin",
+      "description": "CPLT2-5737: Allows a managed main to indicate that it is ready to be hibernated.",
       "fork": false,
-      "url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin",
-      "forks_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/forks",
-      "keys_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/keys{/key_id}",
-      "collaborators_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/collaborators{/collaborator}",
-      "teams_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/teams",
-      "hooks_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/hooks",
-      "issue_events_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/issues/events{/number}",
-      "events_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/events",
-      "assignees_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/assignees{/user}",
-      "branches_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/branches{/branch}",
-      "tags_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/tags",
-      "blobs_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/git/blobs{/sha}",
-      "git_tags_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/git/tags{/sha}",
-      "git_refs_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/git/refs{/sha}",
-      "trees_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/git/trees{/sha}",
-      "statuses_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/statuses/{sha}",
-      "languages_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/languages",
-      "stargazers_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/stargazers",
-      "contributors_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/contributors",
-      "subscribers_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/subscribers",
-      "subscription_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/subscription",
-      "commits_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/commits{/sha}",
-      "git_commits_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/git/commits{/sha}",
-      "comments_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/comments{/number}",
-      "issue_comment_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/issues/comments{/number}",
-      "contents_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/contents/{+path}",
-      "compare_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/compare/{base}...{head}",
-      "merges_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/merges",
-      "archive_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/{archive_format}{/ref}",
-      "downloads_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/downloads",
-      "issues_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/issues{/number}",
-      "pulls_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/pulls{/number}",
-      "milestones_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/milestones{/number}",
-      "notifications_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/notifications{?since,all,participating}",
-      "labels_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/labels{/name}",
-      "releases_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/releases{/id}",
-      "deployments_url": "https://api.github.com/repos/cloudbees/managed-master-hibernation-plugin/deployments"
+      "url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin",
+      "forks_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/forks",
+      "keys_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/keys{/key_id}",
+      "collaborators_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/collaborators{/collaborator}",
+      "teams_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/teams",
+      "hooks_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/hooks",
+      "issue_events_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/issues/events{/number}",
+      "events_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/events",
+      "assignees_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/assignees{/user}",
+      "branches_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/branches{/branch}",
+      "tags_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/tags",
+      "blobs_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/git/blobs{/sha}",
+      "git_tags_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/git/tags{/sha}",
+      "git_refs_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/git/refs{/sha}",
+      "trees_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/git/trees{/sha}",
+      "statuses_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/statuses/{sha}",
+      "languages_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/languages",
+      "stargazers_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/stargazers",
+      "contributors_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/contributors",
+      "subscribers_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/subscribers",
+      "subscription_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/subscription",
+      "commits_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/commits{/sha}",
+      "git_commits_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/git/commits{/sha}",
+      "comments_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/comments{/number}",
+      "issue_comment_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/issues/comments{/number}",
+      "contents_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/contents/{+path}",
+      "compare_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/compare/{base}...{head}",
+      "merges_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/merges",
+      "archive_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/{archive_format}{/ref}",
+      "downloads_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/downloads",
+      "issues_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/issues{/number}",
+      "pulls_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/pulls{/number}",
+      "milestones_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/milestones{/number}",
+      "notifications_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/notifications{?since,all,participating}",
+      "labels_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/labels{/name}",
+      "releases_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/releases{/id}",
+      "deployments_url": "https://api.github.com/repos/cloudbees/managed-main-hibernation-plugin/deployments"
     },
     "url": "https://api.github.com/notifications/threads/581645707",
     "subscription_url": "https://api.github.com/notifications/threads/581645707/subscription"

src/test/resources/org/kohsuke/github/AppTest/wiremock/notifications/__files/notifications-6.json

@@ -4024,7 +4024,7 @@
     "updated_at": "2019-10-14T21:06:40Z",
     "last_read_at": "2019-10-18T20:02:08Z",
     "subject": {
-      "title": "CSDOCS-206 - Adjust Jenkinsfile to only deploy master commits",
+      "title": "CSDOCS-206 - Adjust Jenkinsfile to only deploy main commits",
       "url": "https://api.github.com/repos/cloudbees/docsite-engine/pulls/121",
       "latest_comment_url": "https://api.github.com/repos/cloudbees/docsite-engine/issues/comments/541921810",
       "type": "PullRequest"

src/test/resources/org/kohsuke/github/AppTest/wiremock/notifications/mappings/notifications_threads_523050578-25.json

@@ -3,7 +3,6 @@
   "name": "notifications_threads_523050578",
   "request": {
     "url": "/notifications/threads/523050578",
-    "method": "PATCH",
     "bodyPatterns": [
       {
         "equalToJson": "{}",
@@ -11,7 +10,11 @@
         "ignoreExtraElements": true
       }
     ],
+    "method": "POST",
     "headers": {
+      "X-HTTP-Method-Override": {
+        "equalTo": "PATCH"
+      },
       "Accept": {
         "equalTo": "text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2"
       }

src/test/resources/org/kohsuke/github/AppTest/wiremock/reactions/__files/repos_hub4j_github-api-2.json

@@ -96,7 +96,7 @@
   "forks": 456,
   "open_issues": 57,
   "watchers": 613,
-  "default_branch": "master",
+  "default_branch": "main",
   "permissions": {
     "admin": true,
     "push": true,

src/test/resources/org/kohsuke/github/AppTest/wiremock/testCommit/__files/repos_jenkinsci_jenkins-3.json

@@ -96,7 +96,7 @@
   "forks": 5807,
   "open_issues": 74,
   "watchers": 14167,
-  "default_branch": "master",
+  "default_branch": "main",
   "permissions": {
     "admin": false,
     "push": false,

src/test/resources/org/kohsuke/github/AppTest/wiremock/testCommitComment/__files/repos_jenkinsci_jenkins-3.json

@@ -96,7 +96,7 @@
   "forks": 5807,
   "open_issues": 74,
   "watchers": 14167,
-  "default_branch": "master",
+  "default_branch": "main",
   "permissions": {
     "admin": false,
     "push": false,