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

Support the check-user-team-membership API call

pom.xml

@@ -7,7 +7,7 @@
   </parent>
 
   <artifactId>github-api</artifactId>
-  <version>1.46</version>
+  <version>1.50</version>
   <name>GitHub API for Java</name>
   <url>http://github-api.kohsuke.org/</url>
   <description>GitHub API for Java</description>
@@ -16,6 +16,7 @@
     <connection>scm:git:git@github.com/kohsuke/${project.artifactId}.git</connection>
     <developerConnection>scm:git:ssh://git@github.com/kohsuke/${project.artifactId}.git</developerConnection>
     <url>http://${project.artifactId}.kohsuke.org/</url>
+    <tag>HEAD</tag>
   </scm>
 
   <distributionManagement>
@@ -60,7 +61,7 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>3.8.1</version>
+      <version>4.11</version>
       <scope>test</scope>
     </dependency>
     <dependency>

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

@@ -0,0 +1,171 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+
+import javax.xml.bind.DatatypeConverter;
+
+/**
+ * A Content of a repository.
+ *
+ * @author Alexandre COLLIGNON
+ */
+public class GHContent {
+    private GHRepository owner;
+
+    private String type;
+    private String encoding;
+    private long size;
+    private String sha;
+    private String name;
+    private String path;
+    private String content;
+    private String url; // this is the API url
+    private String git_url;    // this is the Blob url
+    private String html_url;    // this is the UI
+
+    public GHRepository getOwner() {
+        return owner;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public String getEncoding() {
+        return encoding;
+    }
+
+    public long getSize() {
+        return size;
+    }
+
+    public String getSha() {
+        return sha;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    /**
+     * Retrieve the decoded content that is stored at this location.
+     *
+     * Due to the nature of GitHub's API, you're not guaranteed that
+     * the content will already be populated, so this may trigger
+     * network activity, and can throw an IOException.
+    **/
+    public String getContent() throws IOException {
+        return new String(DatatypeConverter.parseBase64Binary(getEncodedContent()));
+    }
+
+    /**
+     * Retrieve the raw content that is stored at this location.
+     *
+     * Due to the nature of GitHub's API, you're not guaranteed that
+     * the content will already be populated, so this may trigger
+     * network activity, and can throw an IOException.
+    **/
+    public String getEncodedContent() throws IOException {
+        if (content != null)
+            return content;
+
+        GHContent retrievedContent = owner.getFileContent(path);
+
+        this.size = retrievedContent.size;
+        this.sha = retrievedContent.sha;
+        this.content = retrievedContent.content;
+        this.url = retrievedContent.url;
+        this.git_url = retrievedContent.git_url;
+        this.html_url = retrievedContent.html_url;
+
+        return content;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public String getGitUrl() {
+        return git_url;
+    }
+
+    public String getHtmlUrl() {
+        return html_url;
+    }
+
+    public boolean isFile() {
+        return "file".equals(type);
+    }
+
+    public boolean isDirectory() {
+        return "dir".equals(type);
+    }
+
+    public GHContentUpdateResponse update(String newContent, String commitMessage) throws IOException {
+        return update(newContent, commitMessage, null);
+    }
+
+    public GHContentUpdateResponse update(String newContent, String commitMessage, String branch) throws IOException {
+        String encodedContent = DatatypeConverter.printBase64Binary(newContent.getBytes());
+
+        Requester requester = new Requester(owner.root)
+            .with("path", path)
+            .with("message", commitMessage)
+            .with("sha", sha)
+            .with("content", encodedContent)
+            .method("PUT");
+
+        if (branch != null) {
+            requester.with("branch", branch);
+        }
+
+        GHContentUpdateResponse response = requester.to(getApiRoute(), GHContentUpdateResponse.class);
+
+        response.getContent().wrap(owner);
+        response.getCommit().wrapUp(owner);
+
+        this.content = encodedContent;
+        return response;
+    }
+
+    public GHContentUpdateResponse delete(String message) throws IOException {
+        return delete(message, null);
+    }
+
+    public GHContentUpdateResponse delete(String commitMessage, String branch) throws IOException {
+        Requester requester = new Requester(owner.root)
+            .with("path", path)
+            .with("message", commitMessage)
+            .with("sha", sha)
+            .method("DELETE");
+
+        if (branch != null) {
+            requester.with("branch", branch);
+        }
+
+        GHContentUpdateResponse response = requester.to(getApiRoute(), GHContentUpdateResponse.class);
+
+        response.getCommit().wrapUp(owner);
+        return response;
+    }
+
+    private String getApiRoute() {
+        return "/repos/" + owner.getOwnerName() + "/" + owner.getName() + "/contents/" + path;
+    }
+
+    GHContent wrap(GHRepository owner) {
+        this.owner = owner;
+        return this;
+    }
+
+    public static GHContent[] wrap(GHContent[] contents, GHRepository repository) {
+        for (GHContent unwrappedContent : contents) {
+            unwrappedContent.wrap(repository);
+        }
+        return contents;
+    }
+}

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

@@ -0,0 +1,18 @@
+package org.kohsuke.github;
+
+/**
+ * The response that is returned when updating
+ * repository content.
+**/
+public final class GHContentUpdateResponse {
+    private GHContent content;
+    private GHCommit commit;
+
+    public GHContent getContent() {
+        return content;
+    }
+
+    public GHCommit getCommit() {
+        return commit;
+    }
+}

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

@@ -6,6 +6,7 @@ package org.kohsuke.github;
  * See http://developer.github.com/v3/events/types/
  *
  * @author Kohsuke Kawaguchi
+ * @see GHEventInfo
  */
 public enum GHEvent {
     COMMIT_COMMENT,
@@ -22,6 +23,7 @@ public enum GHEvent {
     MEMBER,
     PUBLIC,
     PULL_REQUEST,
+    PULL_REQUEST_REVIEW_COMMENT,
     PUSH,
     TEAM_ADD,
     WATCH

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

@@ -34,7 +34,7 @@ public final class GHHook {
     public EnumSet<GHEvent> getEvents() {
         EnumSet<GHEvent> s = EnumSet.noneOf(GHEvent.class);
         for (String e : events)
-            Enum.valueOf(GHEvent.class,e.toUpperCase(Locale.ENGLISH));
+            s.add(Enum.valueOf(GHEvent.class,e.toUpperCase(Locale.ENGLISH)));
         return s;
     }
 

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

@@ -190,7 +190,7 @@ public class GHIssue {
     }
 
     public void setLabels(String... labels) throws IOException {
-        edit("assignee",labels);
+        edit("labels",labels);
     }
 
     /**

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

@@ -10,9 +10,9 @@ import org.apache.commons.lang.builder.ToStringBuilder;
 public class GHKey {
     /*package almost final*/ GitHub root;
 
-    private String url, key, title;
-    private boolean verified;
-    private int id;
+    protected String url, key, title;
+    protected boolean verified;
+    protected int id;
 
     public int getId() {
         return id;

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

@@ -1,5 +1,6 @@
 package org.kohsuke.github;
 
+import java.io.IOException;
 import java.util.Date;
 import java.util.Locale;
 
@@ -65,6 +66,21 @@ public class GHMilestone {
 		return Enum.valueOf(GHMilestoneState.class, state.toUpperCase(Locale.ENGLISH));
 	}
 
+    /**
+     * Closes this issue.
+     */
+    public void close() throws IOException {
+        edit("state", "closed");
+    }
+
+    private void edit(String key, Object value) throws IOException {
+        new Requester(root)._with(key, value).method("PATCH").to(getApiRoute());
+    }
+
+    protected String getApiRoute() {
+        return "/repos/"+owner.getOwnerName()+"/"+owner.getName()+"/milestones/"+number;
+    }
+
 	public GHMilestone wrap(GHRepository repo) {
 		this.owner = repo;
 		this.root = repo.root;

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

@@ -34,6 +34,9 @@ public class GHMyself extends GHUser {
     /**
      * Returns the read-only list of all the pulic keys of the current user.
      *
+     * NOTE: When using OAuth authenticaiton, the READ/WRITE User scope is
+     * required by the GitHub APIs, otherwise you will get a 404 NOT FOUND.
+     *
      * @return
      *      Always non-null.
      */
@@ -41,6 +44,21 @@ public class GHMyself extends GHUser {
         return Collections.unmodifiableList(Arrays.asList(root.retrieve().to("/user/keys", GHKey[].class)));
     }
 
+    /**
+     * Returns the read-only list of all the public verified keys of the current user.
+     *
+     * Differently from the getPublicKeys() method, the retrieval of the user's
+     * verified public keys does not require any READ/WRITE OAuth Scope to the
+     * user's profile.
+     *
+     * @return
+     *      Always non-null.
+     */
+  public List<GHVerifiedKey> getPublicVerifiedKeys() throws IOException {
+    return Collections.unmodifiableList(Arrays.asList(root.retrieve().to(
+        "/users/" + getLogin() + "/keys", GHVerifiedKey[].class)));
+  }
+
     /**
      * Gets the organization that this user belongs to.
      */

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

@@ -1,7 +1,6 @@
 package org.kohsuke.github;
 
 import java.io.IOException;
-import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -78,26 +77,44 @@ public class GHOrganization extends GHPerson {
     }
 
     /**
-     * All the members of this organization.
+     * @deprecated use {@link #listMembers()}
      */
     public List<GHUser> getMembers() throws IOException {
-        return new AbstractList<GHUser>() {
-            // these are shallow objects with only some limited values filled out
-            // TODO: it's better to allow objects to fill themselves in later when missing values are requested
-            final GHUser[] shallow = root.retrieve().to("/orgs/" + login + "/members", GHUser[].class);
+        return listMembers().asList();
+    }
 
-            @Override
-            public GHUser get(int index) {
-                try {
-                    return root.getUser(shallow[index].getLogin());
-                } catch (IOException e) {
-                    throw new RuntimeException(e);
-                }
-            }
+    /**
+     * All the members of this organization.
+     */
+    public PagedIterable<GHUser> listMembers() throws IOException {
+        return listMembers("members");
+    }
 
-            @Override
-            public int size() {
-                return shallow.length;
+    /**
+     * All the public members of this organization.
+     */
+    public PagedIterable<GHUser> listPublicMembers() throws IOException {
+        return listMembers("public_members");
+    }
+
+    private PagedIterable<GHUser> listMembers(String suffix) throws IOException {
+        return listMembers(suffix, null);
+    }
+
+    public PagedIterable<GHUser> listMembersWithFilter(String filter) throws IOException {
+        return listMembers("members", filter);
+    }
+
+    private PagedIterable<GHUser> listMembers(final String suffix, final String filter) throws IOException {
+        return new PagedIterable<GHUser>() {
+            public PagedIterator<GHUser> iterator() {
+                String filterParams = (filter == null) ? "" : ("?filter=" + filter);
+                return new PagedIterator<GHUser>(root.retrieve().asIterator(String.format("/orgs/%s/%s%s", login, suffix, filterParams), GHUser[].class)) {
+                    @Override
+                    protected void wrapUp(GHUser[] users) {
+                        GHUser.wrap(users, root);
+                    }
+                };
             }
         };
     }
@@ -173,4 +190,26 @@ public class GHOrganization extends GHPerson {
             }
         };
     }
+
+    /**
+     * Lists up all the repositories using the specified page size.
+     *
+     * @param pageSize size for each page of items returned by GitHub. Maximum page size is 100.
+     *
+     * Unlike {@link #getRepositories()}, this does not wait until all the repositories are returned.
+     */
+    @Override
+    public PagedIterable<GHRepository> listRepositories(final int pageSize) {
+        return new PagedIterable<GHRepository>() {
+            public PagedIterator<GHRepository> iterator() {
+                return new PagedIterator<GHRepository>(root.retrieve().asIterator("/orgs/" + login + "/repos?per_page=" + pageSize, GHRepository[].class)) {
+                    @Override
+                    protected void wrapUp(GHRepository[] page) {
+                        for (GHRepository c : page)
+                            c.wrap(root);
+                    }
+                };
+            }
+        };
+    }
 }

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

@@ -191,18 +191,30 @@ public class GHPullRequest extends GHIssue {
     /**
      * Retrieves all the commits associated to this pull request.
      */
-  public PagedIterable<GHPullRequestCommitDetail> listCommits() {
-    return new PagedIterable<GHPullRequestCommitDetail>() {
-      public PagedIterator<GHPullRequestCommitDetail> iterator() {
-        return new PagedIterator<GHPullRequestCommitDetail>(root.retrieve().asIterator(
-            String.format("%s/commits", getApiURL().getPath()),
-            GHPullRequestCommitDetail[].class)) {
-          @Override
-          protected void wrapUp(GHPullRequestCommitDetail[] page) {
-          }
+    public PagedIterable<GHPullRequestCommitDetail> listCommits() {
+        return new PagedIterable<GHPullRequestCommitDetail>() {
+            public PagedIterator<GHPullRequestCommitDetail> iterator() {
+                return new PagedIterator<GHPullRequestCommitDetail>(root.retrieve().asIterator(
+                        String.format("%s/commits", getApiURL().getPath()),
+                        GHPullRequestCommitDetail[].class)) {
+                    @Override
+                    protected void wrapUp(GHPullRequestCommitDetail[] page) {
+                    }
+                };
+            }
         };
-      }
-    };
-  }
+    }
+
+    /**
+     * Merge this pull request.
+     *
+     * The equivalent of the big green "Merge pull request" button.
+     *
+     * @param msg
+     *      Commit message. If null, the default one will be used.
+     */
+    public void merge(String msg) throws IOException {
+        new Requester(root).method("PUT").with("commit_message",msg).to(getApiRoute()+"/merge");
+    }
 
 }

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

@@ -23,8 +23,10 @@
  */
 package org.kohsuke.github;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
 
+import javax.xml.bind.DatatypeConverter;
 import java.io.IOException;
 import java.io.InterruptedIOException;
 import java.net.URL;
@@ -58,7 +60,9 @@ public class GHRepository {
     private String url; // this is the API url
     private String html_url;    // this is the UI
     private GHUser owner;   // not fully populated. beware.
-    private boolean has_issues, has_wiki, fork, _private, has_downloads;
+    private boolean has_issues, has_wiki, fork, has_downloads;
+    @JsonProperty("private")
+    private boolean _private;
     private int watchers,forks,open_issues,size;
     private String created_at, pushed_at;
     private Map<Integer,GHMilestone> milestones = new HashMap<Integer, GHMilestone>();
@@ -143,7 +147,31 @@ public class GHRepository {
     }
 
     public List<GHIssue> getIssues(GHIssueState state) throws IOException {
-        return Arrays.asList(GHIssue.wrap(root.retrieve().to("/repos/" + owner.login + "/" + name + "/issues?state=" + state.toString().toLowerCase(), GHIssue[].class), this));
+        return listIssues(state).asList();
+    }
+
+    public List<GHIssue> getIssues(GHIssueState state, GHMilestone milestone) throws IOException {
+        return Arrays.asList(GHIssue.wrap(root.retrieve()
+                .to(String.format("/repos/%s/%s/issues?state=%s&milestone=%s", owner.login, name,
+                        state.toString().toLowerCase(), milestone == null ? "none" : "" + milestone.getNumber()),
+                        GHIssue[].class), this));
+    }
+
+    /**
+     * Lists up all the issues in this repository.
+     */
+    public PagedIterable<GHIssue> listIssues(final GHIssueState state) {
+        return new PagedIterable<GHIssue>() {
+            public PagedIterator<GHIssue> iterator() {
+                return new PagedIterator<GHIssue>(root.retrieve().asIterator(getApiTailUrl("issues?state="+state.toString().toLowerCase(Locale.ENGLISH)), GHIssue[].class)) {
+                    @Override
+                    protected void wrapUp(GHIssue[] page) {
+                        for (GHIssue c : page)
+                            c.wrap(GHRepository.this);
+                    }
+                };
+            }
+        };
     }
 
     public GHReleaseBuilder createRelease(String tag) {
@@ -716,7 +744,66 @@ public class GHRepository {
 		}
 		return m;
 	}
-	
+
+    public GHContent getFileContent(String path) throws IOException {
+        return getFileContent(path, null);
+    }
+
+    public GHContent getFileContent(String path, String ref) throws IOException {
+        Requester requester = root.retrieve();
+        String target = String.format("/repos/%s/%s/contents/%s", owner.login, name, path);
+
+        if (ref != null)
+            target = target + "?ref=" + ref;
+
+        return requester.to(target, GHContent.class).wrap(this);
+    }
+
+    public List<GHContent> getDirectoryContent(String path) throws IOException {
+        return getDirectoryContent(path, null);
+    }
+
+    public List<GHContent> getDirectoryContent(String path, String ref) throws IOException {
+        Requester requester = root.retrieve();
+        String target = String.format("/repos/%s/%s/contents/%s", owner.login, name, path);
+
+        if (ref != null)
+            target = target + "?ref=" + ref;
+
+        GHContent[] files = requester.to(target, GHContent[].class);
+
+        GHContent.wrap(files, this);
+
+        return Arrays.asList(files);
+    }
+
+    public GHContent getReadme() throws Exception {
+        return getFileContent("readme");
+    }
+
+    public GHContentUpdateResponse createContent(String content, String commitMessage, String path) throws IOException {
+        return createContent(content, commitMessage, path, null);
+    }
+
+    public GHContentUpdateResponse createContent(String content, String commitMessage, String path, String branch) throws IOException {
+        Requester requester = new Requester(root)
+            .with("path", path)
+            .with("message", commitMessage)
+            .with("content", DatatypeConverter.printBase64Binary(content.getBytes()))
+            .method("PUT");
+
+        if (branch != null) {
+            requester.with("branch", branch);
+        }
+
+        GHContentUpdateResponse response = requester.to(getApiTailUrl("contents/" + path), GHContentUpdateResponse.class);
+
+        response.getContent().wrap(this);
+        response.getCommit().wrapUp(this);
+
+        return response;
+    }
+
 	public GHMilestone createMilestone(String title, String description) throws IOException {
         return new Requester(root)
                 .with("title", title).with("description", description).method("POST").to(getApiTailUrl("milestones"), GHMilestone.class).wrap(this);

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

@@ -49,6 +49,18 @@ public class GHTeam {
         return new HashSet<GHUser>(Arrays.asList(GHUser.wrap(org.root.retrieve().to(api("/members"), GHUser[].class), org.root)));
     }
 
+    /**
+     * Checks if this team has the specified user as a member.
+     */
+    public boolean hasMember(GHUser user) {
+        try {
+            org.root.retrieve().to("/teams/" + id + "/members/"  + user.getLogin());
+            return true;
+        } catch (IOException ignore) {
+            return false;
+        }
+    }
+
     public Map<String,GHRepository> getRepositories() throws IOException {
         GHRepository[] repos = org.root.retrieve().to(api("/repos"), GHRepository[].class);
         Map<String,GHRepository> m = new TreeMap<String, GHRepository>();

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

@@ -76,6 +76,13 @@ public class GHUser extends GHPerson {
         return org.hasMember(this);
     }
 
+    /**
+     * Returns true if this user belongs to the specified team.
+     */
+    public boolean isMemberOf(GHTeam team) {
+        return team.hasMember(this);
+    }
+
     /**
      * Returns true if this user belongs to the specified organization as a public member.
      */

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

@@ -0,0 +1,13 @@
+package org.kohsuke.github;
+
+public class GHVerifiedKey extends GHKey {
+
+  public GHVerifiedKey() {
+    this.verified = true;
+  }
+
+  @Override
+  public String getTitle() {
+    return (title == null ? "key-" + id : title);
+  }
+}

src/test/java/Foo.java

@@ -7,7 +7,6 @@ import java.util.Arrays;
  */
 public class Foo {
     public static void main(String[] args) throws Exception {
-        System.out.println(GitHub.connect().createToken(
-                Arrays.asList("user", "repo", "delete_repo", "notifications", "gist"), "GitHub API", null).getToken());
+        System.out.println(GitHub.connect().getOrganization("cloudbees").getRepository("grandcentral").isPrivate());
     }
 }

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

@@ -1,15 +1,30 @@
 package org.kohsuke;
 
-import junit.framework.TestCase;
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.Test;
+import org.kohsuke.github.GHBranch;
 import org.kohsuke.github.GHCommit;
 import org.kohsuke.github.GHCommit.File;
 import org.kohsuke.github.GHCommitComment;
+import org.kohsuke.github.GHCommitState;
 import org.kohsuke.github.GHCommitStatus;
 import org.kohsuke.github.GHEvent;
 import org.kohsuke.github.GHEventInfo;
 import org.kohsuke.github.GHEventPayload;
 import org.kohsuke.github.GHHook;
-import org.kohsuke.github.GHBranch;
 import org.kohsuke.github.GHIssue;
 import org.kohsuke.github.GHIssueComment;
 import org.kohsuke.github.GHIssueState;
@@ -25,40 +40,51 @@ import org.kohsuke.github.GHUser;
 import org.kohsuke.github.GitHub;
 import org.kohsuke.github.PagedIterable;
 
-import java.io.IOException;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.Set;
-import java.util.List;
-
 /**
  * Unit test for simple App.
  */
-public class AppTest extends TestCase {
+public class AppTest {
 
     private GitHub gitHub;
 
-    @Override
+    @Before
     public void setUp() throws Exception {
-        super.setUp();
         gitHub = GitHub.connect();
     }
 
+    private String getTestRepositoryName() throws IOException {
+        return getUser().getLogin() + "/github-api-test";
+    }
+
+    @Test
     public void testRepoCRUD() throws Exception {
-        GHRepository r = gitHub.createRepository("github-api-test", "a test repository", "http://github-api.kohsuke.org/", true);
+        String targetName = "github-api-test-rename2";
+
+        deleteRepository("github-api-test-rename");
+        deleteRepository(targetName);
+        GHRepository r = gitHub.createRepository("github-api-test-rename", "a test repository", "http://github-api.kohsuke.org/", true);
         r.enableIssueTracker(false);
         r.enableDownloads(false);
         r.enableWiki(false);
-        r.renameTo("github-api-test2");
-        gitHub.getMyself().getRepository("github-api-test2").delete();
+        r.renameTo(targetName);
+        getUser().getRepository(targetName).delete();
     }
 
+    private void deleteRepository(final String name) throws IOException {
+        GHRepository repository = getUser().getRepository(name);
+        if(repository != null) {
+            repository.delete();
+        }
+    }
+
+    @Test
     public void testCredentialValid() throws IOException {
         assertTrue(gitHub.isCredentialValid());
-        assertFalse(GitHub.connect("totally", "bogus").isCredentialValid());
+        GitHub connect = GitHub.connect("totally", "bogus");
+        assertFalse(connect.isCredentialValid());
     }
 
+    @Test
     public void testIssueWithNoComment() throws IOException {
         GHRepository repository = gitHub.getRepository("kohsuke/test");
         List<GHIssueComment> v = repository.getIssue(4).getComments();
@@ -70,25 +96,103 @@ public class AppTest extends TestCase {
         assertTrue(v.size() == 3);
     }
 
+    @Test
     public void testCreateIssue() throws IOException {
-        GHUser u = gitHub.getUser("kohsuke");
-        GHRepository r = u.getRepository("test");
-        GHMilestone someMilestone = r.listMilestones(GHIssueState.CLOSED).iterator().next();
-        GHIssue o = r.createIssue("testing").body("this is body").assignee(u).label("bug").label("question").milestone(someMilestone).create();
-        System.out.println(o.getUrl());
+        GHUser u = getUser();
+        GHRepository repository = getTestRepository();
+        GHMilestone milestone = repository.createMilestone(System.currentTimeMillis() + "", "Test Milestone");
+        GHIssue o = repository.createIssue("testing")
+                .body("this is body")
+                .assignee(u)
+                .label("bug")
+                .label("question")
+                .milestone(milestone)
+                .create();
+        assertNotNull(o);
         o.close();
     }
 
+    @Test
+    public void testGetIssues() throws Exception {
+        List<GHIssue> closedIssues = gitHub.getUser("kohsuke").getRepository("github-api").getIssues(GHIssueState.CLOSED);
+        // prior to using PagedIterable GHRepository.getIssues(GHIssueState) would only retrieve 30 issues
+        assertTrue(closedIssues.size() > 30);
+    }
+
+
+    private GHRepository getTestRepository() throws IOException {
+        GHRepository repository;
+        try {
+            repository = gitHub.getRepository(getTestRepositoryName());
+        } catch (IOException e) {
+            repository = gitHub.createRepository("github-api-test", "A test repository for testing" +
+                    "the github-api project", "http://github-api.kohsuke.org/", true);
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException e1) {
+                throw new RuntimeException(e.getMessage(), e);
+            }
+            repository.enableIssueTracker(true);
+            repository.enableDownloads(true);
+            repository.enableWiki(true);
+        }
+        return repository;
+    }
+
+    private GHUser getUser() {
+        try {
+            return gitHub.getMyself();
+        } catch (IOException e) {
+            throw new RuntimeException(e.getMessage(), e);
+        }
+    }
+
+    @Test
+    public void testListIssues() throws IOException {
+        GHUser u = getUser();
+        GHRepository repository = getTestRepository();
+
+        GHMilestone milestone = repository.createMilestone(System.currentTimeMillis() + "", "Test Milestone");
+        milestone.close();
+        GHIssue unhomed = null;
+        GHIssue homed = null;
+        try {
+            unhomed = repository.createIssue("testing").body("this is body")
+                    .assignee(u)
+                    .label("bug")
+                    .label("question")
+                    .create();
+            assertEquals(unhomed.getNumber(), repository.getIssues(GHIssueState.OPEN, null).get(0).getNumber());
+            homed = repository.createIssue("testing").body("this is body")
+                    .assignee(u)
+                    .label("bug")
+                    .label("question")
+                    .milestone(milestone)
+                    .create();
+            assertEquals(homed.getNumber(), repository.getIssues(GHIssueState.OPEN, milestone).get(0).getNumber());
+        } finally {
+            if (unhomed != null) {
+                unhomed.close();
+            }
+            if (homed != null) {
+                homed.close();
+            }
+        }
+    }
+
+    @Test
     public void testRateLimit() throws IOException {
         System.out.println(gitHub.getRateLimit());
     }
 
+    @Test
     public void testMyOrganizations() throws IOException {
         Map<String, GHOrganization> org = gitHub.getMyOrganizations();
         assertFalse(org.keySet().contains(null));
         System.out.println(org);
     }
 
+    @Test
     public void testFetchPullRequest() throws Exception {
         GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("jenkins");
         assertEquals("master",r.getMasterBranch());
@@ -96,8 +200,9 @@ public class AppTest extends TestCase {
         r.getPullRequests(GHIssueState.OPEN);
     }
 
+    @Test
     public void testFetchPullRequestAsList() throws Exception {
-        GHRepository r = gitHub.getOrganization("symfony").getRepository("symfony-docs");
+        GHRepository r = gitHub.getRepository("kohsuke/github-api");
         assertEquals("master", r.getMasterBranch());
         PagedIterable<GHPullRequest> i = r.listPullRequests(GHIssueState.CLOSED);
         List<GHPullRequest> prs = i.asList();
@@ -105,50 +210,56 @@ public class AppTest extends TestCase {
         assertTrue(prs.size() > 0);
     }
 
+    @Test
     public void testRepoPermissions() throws Exception {
+        kohsuke();
         GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("jenkins");
         assertTrue(r.hasPullAccess());
 
-        r = gitHub.getOrganization("github").getRepository("tire");
+        r = gitHub.getOrganization("github").getRepository("hub");
         assertFalse(r.hasAdminAccess());
     }
     
+    @Test
     public void testGetMyself() throws Exception {
         GHMyself me = gitHub.getMyself();
-        System.out.println(me);
-        GHUser u = gitHub.getUser("kohsuke2");
-        System.out.println(u);
-        for (List<GHRepository> lst : me.iterateRepositories(100)) {
-            for (GHRepository r : lst) {
-                System.out.println(r.getPushedAt());
-            }
-        }
+        assertNotNull(me);
+        assertNotNull(gitHub.getUser("kohsuke2"));
+        PagedIterable<GHRepository> ghRepositories = me.listRepositories();
+        assertTrue(ghRepositories.iterator().hasNext());
     }
 
+    @Test
     public void testPublicKeys() throws Exception {
         List<GHKey> keys = gitHub.getMyself().getPublicKeys();
-        System.out.println(keys);
+        assertFalse(keys.isEmpty());
     }
 
-    public void tryOrgFork() throws Exception {
-        gitHub.getUser("kohsuke").getRepository("rubywm").forkTo(gitHub.getOrganization("jenkinsci"));
+    @Test
+    public void testOrgFork() throws Exception {
+        kohsuke();
+        getUser().getRepository("rubywm").forkTo(gitHub.getOrganization("jenkinsci"));
     }
 
-    public void tryGetTeamsForRepo() throws Exception {
-        Set<GHTeam> o = gitHub.getOrganization("jenkinsci").getRepository("rubywm").getTeams();
-        System.out.println(o);
+    @Test
+    public void testGetTeamsForRepo() throws Exception {
+        kohsuke();
+        assertEquals(1,gitHub.getOrganization("stapler").getRepository("stapler").getTeams().size());
     }
 
+    @Test
     public void testMembership() throws Exception {
         Set<String> members = gitHub.getOrganization("jenkinsci").getRepository("violations-plugin").getCollaboratorNames();
         System.out.println(members.contains("kohsuke"));
     }
     
+    @Test
     public void testMemberOrgs() throws Exception {
         Set<GHOrganization> o = gitHub.getUser("kohsuke").getOrganizations();
         System.out.println(o);
     }
 
+    @Test
     public void testCommit() throws Exception {
         GHCommit commit = gitHub.getUser("jenkinsci").getRepository("jenkins").getCommit("08c1c9970af4d609ae754fbe803e06186e3206f7");
         System.out.println(commit);
@@ -161,6 +272,7 @@ public class AppTest extends TestCase {
         assertEquals("changelog.html", f.getFileName());
     }
 
+    @Test
     public void testListCommits() throws Exception {
         List<String> sha1 = new ArrayList<String>();
         for (GHCommit c : gitHub.getUser("kohsuke").getRepository("empty-commit").listCommits()) {
@@ -171,12 +283,14 @@ public class AppTest extends TestCase {
         assertEquals(1,sha1.size());
     }
 
+    @Test
     public void testBranches() throws Exception {
         Map<String,GHBranch> b =
                 gitHub.getUser("jenkinsci").getRepository("jenkins").getBranches();
         System.out.println(b);
     }
 
+    @Test
     public void testCommitComment() throws Exception {
         GHRepository r = gitHub.getUser("jenkinsci").getRepository("jenkins");
         PagedIterable<GHCommitComment> comments = r.listCommitComments();
@@ -187,6 +301,7 @@ public class AppTest extends TestCase {
         }
     }
 
+    @Test
     public void testCreateCommitComment() throws Exception {
         GHCommit commit = gitHub.getUser("kohsuke").getRepository("sandbox-ant").getCommit("8ae38db0ea5837313ab5f39d43a6f73de3bd9000");
         GHCommitComment c = commit.createComment("[testing](http://kohsuse.org/)");
@@ -196,7 +311,9 @@ public class AppTest extends TestCase {
         c.delete();
     }
 
+    @Test
     public void tryHook() throws Exception {
+        kohsuke();
         GHRepository r = gitHub.getMyself().getRepository("test2");
         GHHook hook = r.createWebHook(new URL("http://www.google.com/"));
         System.out.println(hook);
@@ -205,6 +322,7 @@ public class AppTest extends TestCase {
             h.delete();
     }
     
+    @Test
     public void testEventApi() throws Exception {
         for (GHEventInfo ev : gitHub.getEvents()) {
             System.out.println(ev);
@@ -216,6 +334,7 @@ public class AppTest extends TestCase {
         }
     }
 
+    @Test
     public void testApp() throws IOException {
         System.out.println(gitHub.getMyself().getEmails());
 
@@ -304,7 +423,9 @@ public class AppTest extends TestCase {
         System.out.println(hooks);
     }
 
+    @Test
     public void testOrgRepositories() throws IOException {
+        kohsuke();
         GHOrganization j = gitHub.getOrganization("jenkinsci");
         long start = System.currentTimeMillis();
         Map<String, GHRepository> repos = j.getRepositories();
@@ -312,7 +433,9 @@ public class AppTest extends TestCase {
         System.out.printf("%d repositories in %dms\n",repos.size(),end-start);
     }
     
+    @Test
     public void testOrganization() throws IOException {
+        kohsuke();
         GHOrganization j = gitHub.getOrganization("jenkinsci");
         GHTeam t = j.getTeams().get("Core Developers");
 
@@ -321,24 +444,30 @@ public class AppTest extends TestCase {
 //        t.add(labs.getRepository("xyz"));
     }
 
+    @Test
     public void testCommitStatus() throws Exception {
-        GHRepository r = gitHub.getUser("kohsuke").getRepository("test");
-        GHCommitStatus state;
-//        state = r.createCommitStatus("edacdd76b06c5f3f0697a22ca75803169f25f296", GHCommitState.FAILURE, "http://jenkins-ci.org/", "oops!");
+        GHRepository r = gitHub.getRepository("kohsuke/github-api");
 
-        List<GHCommitStatus> lst = r.listCommitStatuses("edacdd76b06c5f3f0697a22ca75803169f25f296").asList();
+        GHCommitStatus state;
+
+//        state = r.createCommitStatus("ecbfdd7315ef2cf04b2be7f11a072ce0bd00c396", GHCommitState.FAILURE, "http://kohsuke.org/", "testing!");
+
+        List<GHCommitStatus> lst = r.listCommitStatuses("ecbfdd7315ef2cf04b2be7f11a072ce0bd00c396").asList();
         state = lst.get(0);
         System.out.println(state);
-        assertEquals("oops!",state.getDescription());
-        assertEquals("http://jenkins-ci.org/",state.getTargetUrl());
+        assertEquals("testing!",state.getDescription());
+        assertEquals("http://kohsuke.org/",state.getTargetUrl());
     }
     
+    @Test
     public void testCommitShortInfo() throws Exception {
-        GHCommit commit = gitHub.getUser("kohsuke").getRepository("test").getCommit("c77360d6f2ff2c2e6dd11828ad5dccf72419fa1b");
+        GHRepository r = gitHub.getRepository("kohsuke/github-api");
+        GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f23");
         assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Kohsuke Kawaguchi");
-        assertEquals(commit.getCommitShortInfo().getMessage(), "Added a file");
+        assertEquals(commit.getCommitShortInfo().getMessage(), "doc");
     }
 
+    @Test
     public void testPullRequestPopulate() throws Exception {
         GHRepository r = gitHub.getUser("kohsuke").getRepository("github-api");
         GHPullRequest p = r.getPullRequest(17);
@@ -346,15 +475,21 @@ public class AppTest extends TestCase {
         assertNotNull(u.getName());
     }
 
+    @Test
     public void testCheckMembership() throws Exception {
+        kohsuke();
         GHOrganization j = gitHub.getOrganization("jenkinsci");
         GHUser kohsuke = gitHub.getUser("kohsuke");
-        GHUser a = gitHub.getUser("a");
+        GHUser b = gitHub.getUser("b");
 
         assertTrue(j.hasMember(kohsuke));
-        assertFalse(j.hasMember(a));
+        assertFalse(j.hasMember(b));
 
         assertTrue(j.hasPublicMember(kohsuke));
-        assertFalse(j.hasPublicMember(a));
+        assertFalse(j.hasPublicMember(b));
+    }
+
+    private void kohsuke() {
+        Assume.assumeTrue(getUser().getLogin().equals("kohsuke"));
     }
 }

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

@@ -31,11 +31,12 @@ public class LifecycleTest extends TestCase {
         gitHub = GitHub.connect();
     }
 
-    public void testCreateRepository() throws IOException, GitAPIException {
+    public void testCreateRepository() throws IOException, GitAPIException, InterruptedException {
         GHMyself myself = gitHub.getMyself();
         GHRepository repository = myself.getRepository("github-api-test");
         if (repository != null) {
             repository.delete();
+            Thread.sleep(1000);
         }
         repository = gitHub.createRepository("github-api-test",
                 "a test repository used to test kohsuke's github-api", "http://github-api.kohsuke.org/", true);

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

@@ -0,0 +1,67 @@
+package org.kohsuke.github;
+
+import junit.framework.TestCase;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Integration test for {@link GHContent}.
+ */
+public class GHContentIntegrationTest extends TestCase {
+
+    private GitHub gitHub;
+    private GHRepository repo;
+    private String createdFilename;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+
+        gitHub = GitHub.connect();
+        repo = gitHub.getRepository("acollign/github-api-test").fork();
+        createdFilename = UUID.randomUUID().toString();
+    }
+
+    public void testGetFileContent() throws Exception {
+        GHContent content = repo.getFileContent("ghcontent-ro/a-file-with-content");
+
+        assertTrue(content.isFile());
+        assertEquals("thanks for reading me\n", content.getContent());
+    }
+
+    public void testGetEmptyFileContent() throws Exception {
+        GHContent content = repo.getFileContent("ghcontent-ro/an-empty-file");
+
+        assertTrue(content.isFile());
+        assertEquals("", content.getContent());
+    }
+
+    public void testGetDirectoryContent() throws Exception {
+        List<GHContent> entries = repo.getDirectoryContent("ghcontent-ro/a-dir-with-3-entries");
+
+        assertTrue(entries.size() == 3);
+    }
+
+    public void testCRUDContent() throws Exception {
+        GHContentUpdateResponse created = repo.createContent("this is an awesome file I created\n", "Creating a file for integration tests.", createdFilename);
+        GHContent createdContent = created.getContent();
+
+        assertNotNull(created.getCommit());
+        assertNotNull(created.getContent());
+        assertNotNull(createdContent.getContent());
+        assertEquals("this is an awesome file I created\n", createdContent.getContent());
+
+        GHContentUpdateResponse updatedContentResponse = createdContent.update("this is some new content\n", "Updated file for integration tests.");
+        GHContent updatedContent = updatedContentResponse.getContent();
+
+        assertNotNull(updatedContentResponse.getCommit());
+        assertNotNull(updatedContentResponse.getContent());
+        assertEquals("this is some new content\n", updatedContent.getContent());
+
+        GHContentUpdateResponse deleteResponse = updatedContent.delete("Enough of this foolishness!");
+
+        assertNotNull(deleteResponse.getCommit());
+        assertNull(deleteResponse.getContent());
+    }
+}