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

Conflicts:
	src/main/java/org/kohsuke/github/GHOrganization.java
	src/main/java/org/kohsuke/github/Requester.java
	src/test/java/org/kohsuke/AppTest.java

LICENSE.txt

@@ -0,0 +1,22 @@
+ Copyright (c) 2011- Kohsuke Kawaguchi and other contributors
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.

pom.xml

@@ -7,7 +7,7 @@
   </parent>
 
   <artifactId>github-api</artifactId>
-  <version>1.49</version>
+  <version>1.52</version>
   <name>GitHub API for Java</name>
   <url>http://github-api.kohsuke.org/</url>
   <description>GitHub API for Java</description>
@@ -16,7 +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>github-api-1.49</tag>
+    <tag>HEAD</tag>
   </scm>
 
   <distributionManagement>
@@ -61,7 +61,7 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>3.8.1</version>
+      <version>4.11</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -92,6 +92,12 @@
       <version>3.1.0.201310021548-r</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>com.squareup.okhttp</groupId>
+      <artifactId>okhttp</artifactId>
+      <version>1.5.3</version>
+      <optional>true</optional>
+    </dependency>
   </dependencies>
   <repositories>
     <repository>
@@ -115,4 +121,11 @@
     </plugins>
   </reporting>
 
+  <licenses>
+    <license>
+      <name>The MIT license</name>
+      <url>http://www.opensource.org/licenses/mit-license.php</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
 </project>

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

@@ -0,0 +1,105 @@
+package org.kohsuke.github;
+
+import java.util.Date;
+
+/**
+ * Builds up query for listing commits.
+ *
+ * <p>
+ * Call various methods that set the filter criteria, then {@link #list()} method to actually list up the commit.
+ *
+ * <pre>
+ * GHRepository r = ...;
+ * for (GHCommit c : r.queryCommits().since(x).until(y).author("kohsuke")) {
+ *     ...
+ * }
+ * </pre>
+ *
+ * @author Kohsuke Kawaguchi
+ * @see GHRepository#queryCommits()
+*/
+public class GHCommitQueryBuilder {
+    private final Requester req;
+    private final GHRepository repo;
+
+    /*package*/ GHCommitQueryBuilder(GHRepository repo) {
+        this.repo = repo;
+        this.req = repo.root.retrieve();    // requester to build up
+    }
+
+    /**
+     * GItHub login or email address by which to filter by commit author.
+     */
+    public GHCommitQueryBuilder author(String author) {
+        req.with("author",author);
+        return this;
+    }
+
+    /**
+     * Only commits containing this file path will be returned.
+     */
+    public GHCommitQueryBuilder path(String path) {
+        req.with("path",path);
+        return this;
+    }
+
+    /**
+     * Specifies the SHA1 commit / tag / branch / etc to start listing commits from.
+     *
+     */
+    public GHCommitQueryBuilder from(String ref) {
+        req.with("sha",ref);
+        return this;
+    }
+
+    public GHCommitQueryBuilder pageSize(int pageSize) {
+        req.with("per_page",pageSize);
+        return this;
+    }
+
+    /**
+     * Only commits after this date will be returned
+     */
+    public GHCommitQueryBuilder since(Date dt) {
+        req.with("since",GitHub.printDate(dt));
+        return this;
+    }
+
+    /**
+     * Only commits after this date will be returned
+     */
+    public GHCommitQueryBuilder since(long timestamp) {
+        return since(new Date(timestamp));
+    }
+
+    /**
+     * Only commits before this date will be returned
+     */
+    public GHCommitQueryBuilder until(Date dt) {
+        req.with("until",GitHub.printDate(dt));
+        return this;
+    }
+
+    /**
+     * Only commits before this date will be returned
+     */
+    public GHCommitQueryBuilder until(long timestamp) {
+        return until(new Date(timestamp));
+    }
+
+    /**
+     * Lists up the commits with the criteria built so far.
+     */
+    public PagedIterable<GHCommit> list() {
+        return new PagedIterable<GHCommit>() {
+            public PagedIterator<GHCommit> iterator() {
+                return new PagedIterator<GHCommit>(req.asIterator(repo.getApiTailUrl("commits"), GHCommit[].class)) {
+                    protected void wrapUp(GHCommit[] page) {
+                        for (GHCommit c : page)
+                            c.wrapUp(repo);
+                    }
+                };
+            }
+        };
+    }
+}

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

@@ -9,7 +9,7 @@ import javax.xml.bind.DatatypeConverter;
  *
  * @author Alexandre COLLIGNON
  */
-public final class GHContent {
+public class GHContent {
     private GHRepository owner;
 
     private String type;

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

@@ -0,0 +1,69 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2010, Kohsuke Kawaguchi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package org.kohsuke.github;
+
+
+/**
+ * Represents an email of GitHub.
+ *
+ * @author Kelly Campbell
+ */
+public class GHEmail {
+
+    protected String email;
+    protected boolean primary;
+    protected boolean verified;
+
+    public String getEmail() {
+        return email;
+    }
+
+    public boolean isPrimary() {
+        return primary;
+    }
+
+    public boolean isVerified() {
+        return verified;
+    }
+
+
+    @Override
+    public String toString() {
+        return "Email:"+email;
+    }
+
+    @Override
+    public int hashCode() {
+        return email.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof GHEmail) {
+            GHEmail that = (GHEmail) obj;
+            return this.email.equals(that.email);
+        }
+        return false;
+    }
+}

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

@@ -51,6 +51,8 @@ public abstract class GHEventPayload {
         @Override
         void wrapUp(GitHub root) {
             super.wrapUp(root);
+            if (pull_request==null)
+                throw new IllegalStateException("Expected pull_request payload, but got something else. Maybe we've got another type of event?");
             if (repository!=null) {
                 repository.wrap(root);
                 pull_request.wrap(repository);

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/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

@@ -1,6 +1,7 @@
 package org.kohsuke.github;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
@@ -16,18 +17,31 @@ import java.util.TreeMap;
  * @author Kohsuke Kawaguchi
  */
 public class GHMyself extends GHUser {
+    /**
+     * @deprecated
+     *      Use {@link #getEmails2()}
+     */
+    public List<String> getEmails() throws IOException {
+        List<GHEmail> src = getEmails2();
+        List<String> r = new ArrayList<String>(src.size());
+        for (GHEmail e : src) {
+            r.add(e.getEmail());
+        }
+        return r;
+    }
+
     /**
      * Returns the read-only list of e-mail addresses configured for you.
      *
      * This corresponds to the stuff you configure in https://github.com/settings/emails,
      * and not to be confused with {@link #getEmail()} that shows your public e-mail address
      * set in https://github.com/settings/profile
-     * 
+     *
      * @return
      *      Always non-null.
      */
-    public List<String> getEmails() throws IOException {
-        String[] addresses = root.retrieve().to("/user/emails", String[].class);
+    public List<GHEmail> getEmails2() throws IOException {
+        GHEmail[] addresses = root.retrieve().to("/user/emails", GHEmail[].class);
         return Collections.unmodifiableList(Arrays.asList(addresses));
     }
 
@@ -45,7 +59,7 @@ public class GHMyself extends GHUser {
     }
 
     /**
-     * Returns the read-only list of all the pulic verified keys of the current user.
+     * 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

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;
@@ -24,10 +23,15 @@ public class GHOrganization extends GHPerson {
      *      Newly created repository.
      */
     public GHRepository createRepository(String name, String description, String homepage, String team, boolean isPublic) throws IOException {
-        return createRepository(name,description,homepage,getTeams().get(team),isPublic);
+        GHTeam t = getTeams().get(team);
+        if (t==null)
+            throw new IllegalArgumentException("No such team: "+team);
+        return createRepository(name,description,homepage,t,isPublic);
     }
 
     public GHRepository createRepository(String name, String description, String homepage, GHTeam team, boolean isPublic) throws IOException {
+        if (team==null)
+            throw new IllegalArgumentException("Invalid team");
         // such API doesn't exist, so fall back to HTML scraping
         return new Requester(root)
                 .with("name", name).with("description", description).with("homepage", homepage)
@@ -38,14 +42,41 @@ public class GHOrganization extends GHPerson {
      * Teams by their names.
      */
     public Map<String,GHTeam> getTeams() throws IOException {
-        GHTeam[] teams = root.retrieve().to("/orgs/" + login + "/teams", GHTeam[].class);
         Map<String,GHTeam> r = new TreeMap<String, GHTeam>();
-        for (GHTeam t : teams) {
-            r.put(t.getName(),t.wrapUp(this));
+        for (GHTeam t : listTeams()) {
+            r.put(t.getName(),t);
         }
         return r;
     }
 
+    /**
+     * List up all the teams.
+     */
+    public PagedIterable<GHTeam> listTeams() throws IOException {
+        return new PagedIterable<GHTeam>() {
+            public PagedIterator<GHTeam> iterator() {
+                return new PagedIterator<GHTeam>(root.retrieve().asIterator(String.format("/orgs/%s/teams", login), GHTeam[].class)) {
+                    @Override
+                    protected void wrapUp(GHTeam[] page) {
+                        for (GHTeam c : page)
+                            c.wrapUp(GHOrganization.this);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Finds a team that has the given name in its {@link GHTeam#getName()}
+     */
+    public GHTeam getTeamByName(String name) throws IOException {
+        for (GHTeam t : listTeams()) {
+            if(t.getName().equals(name))
+                return t;
+        }
+        return null;
+    }
+
     /**
      * Checks if this organization has the specified user as a member.
      */
@@ -58,6 +89,14 @@ public class GHOrganization extends GHPerson {
         }
     }
 
+    /**
+     * Remove a member of the organisation - which will remove them from
+     * all teams, and remove their access to the organization’s repositories.
+     */
+    public void remove(GHUser user) throws IOException {
+        root.retrieve().method("DELETE").to("/orgs/" + login + "/members/"  + user.getLogin());
+    }
+
     /**
      * Checks if this organization has the specified user as a public member.
      */
@@ -78,26 +117,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 +230,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

@@ -33,6 +33,7 @@ import java.util.Locale;
  * A pull request.
  * 
  * @author Kohsuke Kawaguchi
+ * @see GHRepository#getPullRequest(int)
  */
 @SuppressWarnings({"UnusedDeclaration"})
 public class GHPullRequest extends GHIssue {
@@ -191,18 +192,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/GHRelease.java

@@ -32,6 +32,8 @@ public class GHRelease {
     private boolean prerelease;
     private Date created_at;
     private Date published_at;
+    private String tarball_url;
+    private String zipball_url;
 
     public String getAssetsUrl() {
         return assets_url;
@@ -153,6 +155,22 @@ public class GHRelease {
         this.url = url;
     }
 
+    public String getZipballUrl() {
+        return zipball_url;
+    }
+
+    public void setZipballUrl(String zipballUrl) {
+        this.zipball_url = zipballUrl;
+    }
+
+    public String getTarballUrl() {
+        return tarball_url;
+    }
+
+    public void setTarballUrl(String tarballUrl) {
+        this.tarball_url = tarballUrl;
+    }
+
     GHRelease wrap(GHRepository owner) {
         this.owner = owner;
         this.root = owner.root;

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;
@@ -42,7 +44,6 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
-import javax.xml.bind.DatatypeConverter;
 
 import static java.util.Arrays.*;
 
@@ -59,12 +60,14 @@ 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 int watchers,forks,open_issues,size;
+    private boolean has_issues, has_wiki, fork, has_downloads;
+    @JsonProperty("private")
+    private boolean _private;
+    private int watchers,forks,open_issues,size,network_count,subscribers_count;
     private String created_at, pushed_at;
     private Map<Integer,GHMilestone> milestones = new HashMap<Integer, GHMilestone>();
     
-    private String master_branch,language;
+    private String default_branch,language;
     private Map<String,GHCommit> commits = new HashMap<String, GHCommit>();
 
     private GHRepoPermission permissions;
@@ -147,6 +150,14 @@ public class GHRepository {
         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.
      */
@@ -209,6 +220,14 @@ public class GHRepository {
         return open_issues;
     }
 
+    public int getNetworkCount() {
+        return network_count;
+    }
+
+    public int getSubscribersCount() {
+        return subscribers_count;
+    }
+
     /**
      *
      * @return
@@ -229,7 +248,7 @@ public class GHRepository {
      *      This field is null until the user explicitly configures the master branch.
      */
     public String getMasterBranch() {
-        return master_branch;
+        return default_branch;
     }
 
     public int getSize() {
@@ -488,6 +507,13 @@ public class GHRepository {
         };
     }
 
+    /**
+     * Search commits by specifying filters through a builder pattern.
+     */
+    public GHCommitQueryBuilder queryCommits() {
+        return new GHCommitQueryBuilder(this);
+    }
+
     /**
      * Lists up all the commit comments in this repository.
      */

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/GitHub.java

@@ -68,6 +68,8 @@ public class GitHub {
 
     private final String apiUrl;
 
+    private HttpConnector connector = HttpConnector.DEFAULT;
+
     /**
      * Connects to GitHub.com
      */
@@ -201,6 +203,17 @@ public class GitHub {
         return login==null && encodedAuthorization==null;
     }
 
+    public HttpConnector getConnector() {
+        return connector;
+    }
+
+    /**
+     * Sets the custom connector used to make requests to GitHub.
+     */
+    public void setConnector(HttpConnector connector) {
+        this.connector = connector;
+    }
+
     /*package*/ void requireCredential() {
         if (isAnonymous())
             throw new IllegalStateException("This operation requires a credential but none is given to the GitHub constructor");
@@ -392,6 +405,10 @@ public class GitHub {
         throw new IllegalStateException("Unable to parse the timestamp: "+timestamp);
     }
 
+    /*package*/ static String printDate(Date dt) {
+        return new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'").format(dt);
+    }
+
     /*package*/ static final ObjectMapper MAPPER = new ObjectMapper();
 
     private static final String[] TIME_FORMATS = {"yyyy/MM/dd HH:mm:ss ZZZZ","yyyy-MM-dd'T'HH:mm:ss'Z'"};

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

@@ -0,0 +1,29 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+/**
+ * Pluggability for customizing HTTP request behaviors or using altogether different library.
+ *
+ * <p>
+ * For example, you can implement this to st custom timeouts.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public interface HttpConnector {
+    /**
+     * Opens a connection to the given URL.
+     */
+    HttpURLConnection connect(URL url) throws IOException;
+
+    /**
+     * Default implementation that uses {@link URL#openConnection()}.
+     */
+    HttpConnector DEFAULT = new HttpConnector() {
+        public HttpURLConnection connect(URL url) throws IOException {
+            return (HttpURLConnection) url.openConnection();
+        }
+    };
+}

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

@@ -23,20 +23,21 @@
  */
 package org.kohsuke.github;
 
-import org.apache.commons.io.IOUtils;
+import static org.kohsuke.github.GitHub.MAPPER;
 
-import javax.net.ssl.HttpsURLConnection;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.InterruptedIOException;
 import java.io.Reader;
+import java.io.UnsupportedEncodingException;
 import java.lang.reflect.Field;
 import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
 import java.net.ProtocolException;
 import java.net.URL;
+import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -48,7 +49,7 @@ import java.util.NoSuchElementException;
 import java.util.Set;
 import java.util.zip.GZIPInputStream;
 
-import static org.kohsuke.github.GitHub.MAPPER;
+import org.apache.commons.io.IOUtils;
 
 /**
  * A builder pattern for making HTTP call and parsing its output.
@@ -209,9 +210,23 @@ class Requester {
      *
      * Every iterator call reports a new batch.
      */
-    /*package*/ <T> Iterator<T> asIterator(final String tailApiUrl, final Class<T> type) {
+    /*package*/ <T> Iterator<T> asIterator(String _tailApiUrl, final Class<T> type) {
         method("GET");
-        if (!args.isEmpty())    throw new IllegalStateException();
+
+        if (!args.isEmpty()) {
+            boolean first=true;
+            try {
+                for (Entry a : args) {
+                    _tailApiUrl += first ? '?' : '&';
+                    first = false;
+                    _tailApiUrl += URLEncoder.encode(a.key,"UTF-8")+'='+URLEncoder.encode(a.value.toString(),"UTF-8");
+                }
+            } catch (UnsupportedEncodingException e) {
+                throw new AssertionError(e);    // UTF-8 is mandatory
+            }
+        }
+
+        final String tailApiUrl = _tailApiUrl;
 
         return new Iterator<T>() {
             /**
@@ -294,7 +309,7 @@ class Requester {
 
 
     private HttpURLConnection setupConnection(URL url) throws IOException {
-        HttpsURLConnection uc = (HttpsURLConnection) url.openConnection();
+        HttpURLConnection uc = root.getConnector().connect(url);
 
         // if the authentication is needed but no credential is given, try it anyway (so that some calls
         // that do work with anonymous access in the reduced form should still work.)

src/main/java/org/kohsuke/github/extras/OkHttpConnector.java

@@ -0,0 +1,31 @@
+package org.kohsuke.github.extras;
+
+import com.squareup.okhttp.OkHttpClient;
+import org.kohsuke.github.HttpConnector;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+/**
+ * {@link HttpConnector} for {@link OkHttpClient}.
+ *
+ * Unlike {@link #DEFAULT}, OkHttp does response caching.
+ * Making a conditional request against GitHubAPI and receiving a 304
+ * response does not count against the rate limit.
+ * See http://developer.github.com/v3/#conditional-requests
+ *
+ * @author Roberto Tyley
+ * @author Kohsuke Kawaguchi
+ */
+public class OkHttpConnector implements HttpConnector {
+    private final OkHttpClient client;
+
+    public OkHttpConnector(OkHttpClient client) {
+        this.client = client;
+    }
+
+    public HttpURLConnection connect(URL url) throws IOException {
+        return client.open(url);
+    }
+}

src/site/markdown/index.md

@@ -7,6 +7,8 @@ operations that act on them as defined as methods (such as `GHUser.follow()`), a
 are used in favor of using string handle (such as `GHUser.isMemberOf(GHOrganization)` instead of
 `GHUser.isMemberOf(String)`)
 
+The library supports both github.com and GitHub Enterprise.
+
 There are some corners of the GitHub API that's not yet implemented, but
 the library is implemented with the right abstractions and libraries to make it very easy to improve the coverage.
 
@@ -34,3 +36,10 @@ Alternatively, you can have just the OAuth token in this file:
 
     oauth=4d98173f7c075527cb64878561d1fe70
 
+OkHttp
+----
+This library comes with a pluggable connector to use different HTTP client implementations
+through `HttpConnector`. In particular, this means you can use [OkHttp](http://square.github.io/okhttp/),
+so we can make use of it's HTTP response cache.
+Making a conditional request against the GitHub API and receiving a 304 response
+[does not count against the rate limit](http://developer.github.com/v3/#conditional-requests).

src/test/java/Foo.java

@@ -1,13 +1,23 @@
+import org.kohsuke.github.GHOrganization;
+import org.kohsuke.github.GHTeam;
 import org.kohsuke.github.GitHub;
 
 import java.util.Arrays;
+import java.util.Map;
 
 /**
  * @author Kohsuke Kawaguchi
  */
 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());
+        GHOrganization org = GitHub.connect().getOrganization("jenkinsci");
+        Map<String, GHTeam> teams = org.getTeams();
+        System.out.println(teams.size());
+
+        int sz = 0;
+        for (GHTeam t : org.listTeams()) {
+            sz++;
+        }
+        System.out.println(sz);
     }
 }

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;
@@ -28,6 +43,7 @@ import org.kohsuke.github.PagedIterable;
 import java.io.IOException;
 import java.net.URL;
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.Map;
 import java.util.Set;
 import java.util.List;
@@ -35,33 +51,48 @@ 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 existing = gitHub.getMyself().getRepository("github-api-test");
-        if (existing!=null)
-            existing.delete();
-        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();
@@ -73,31 +104,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());
@@ -105,8 +208,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();
@@ -114,50 +218,73 @@ 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 testOrgTeams() throws Exception {
+        kohsuke();
+        int sz=0;
+        for (GHTeam t : gitHub.getOrganization("jenkinsci").listTeams()) {
+            assertNotNull(t.getName());
+            sz++;
+        }
+        assertTrue(sz>1000);
+    }
+
+    public void testOrgTeamByName() throws Exception {
+        kohsuke();
+        GHTeam e = gitHub.getOrganization("jenkinsci").getTeamByName("Everyone");
+        assertNotNull(e);
+    }
+
+    @Test
     public void testCommit() throws Exception {
         GHCommit commit = gitHub.getUser("jenkinsci").getRepository("jenkins").getCommit("08c1c9970af4d609ae754fbe803e06186e3206f7");
         System.out.println(commit);
@@ -170,22 +297,36 @@ 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()) {
             System.out.println(c.getSHA1());
             sha1.add(c.getSHA1());
         }
-        assertEquals("fdfad6be4db6f96faea1f153fb447b479a7a9cb7",sha1.get(0));
-        assertEquals(1,sha1.size());
+        assertEquals("fdfad6be4db6f96faea1f153fb447b479a7a9cb7", sha1.get(0));
+        assertEquals(1, sha1.size());
     }
 
+    public void testQueryCommits() throws Exception {
+        List<String> sha1 = new ArrayList<String>();
+        for (GHCommit c : gitHub.getUser("jenkinsci").getRepository("jenkins").queryCommits()
+                .since(new Date(1199174400000L)).until(1201852800000L).path("pom.xml").list()) {
+            System.out.println(c.getSHA1());
+            sha1.add(c.getSHA1());
+        }
+        assertEquals("1cccddb22e305397151b2b7b87b4b47d74ca337b",sha1.get(0));
+        assertEquals(29,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();
@@ -196,6 +337,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/)");
@@ -205,7 +347,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);
@@ -214,6 +358,7 @@ public class AppTest extends TestCase {
             h.delete();
     }
     
+    @Test
     public void testEventApi() throws Exception {
         for (GHEventInfo ev : gitHub.getEvents()) {
             System.out.println(ev);
@@ -225,6 +370,7 @@ public class AppTest extends TestCase {
         }
     }
 
+    @Test
     public void testApp() throws IOException {
         System.out.println(gitHub.getMyself().getEmails());
 
@@ -313,7 +459,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();
@@ -321,7 +469,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");
 
@@ -330,24 +480,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);
@@ -355,15 +511,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);