getCredentials() {
return credentials;
}
@Override
public boolean configure(StaplerRequest req, JSONObject json) throws FormException {
JSONObject hookMode = json.getJSONObject("hookMode");
manageHook = "auto".equals(hookMode.getString("value"));
JSONObject o = hookMode.getJSONObject("hookUrl");
if (o!=null && !o.isNullObject()) {
hookUrl = o.getString("url");
} else {
hookUrl = null;
}
credentials = req.bindJSONToList(Credential.class,hookMode.get("credentials"));
save();
return true;
}
public static DescriptorImpl get() {
return Trigger.all().get(DescriptorImpl.class);
}
public static boolean allowsHookUrlOverride() {
return ALLOW_HOOKURL_OVERRIDE;
}
}
/**
* Set to false to prevent the user from overriding the hook URL.
*/
public static boolean ALLOW_HOOKURL_OVERRIDE = !Boolean.getBoolean(GitHubPushTrigger.class.getName()+".disableOverride");
private static final Logger LOGGER = Logger.getLogger(GitHubPushTrigger.class.getName());
}
github-plugin-github-1.4/src/main/java/com/cloudbees/jenkins/GitHubRepositoryName.java 0000664 0000000 0000000 00000013213 11766134601 0031167 0 ustar 00root root 0000000 0000000 package com.cloudbees.jenkins;
import hudson.util.AdaptedIterator;
import hudson.util.Iterators.FilterIterator;
import org.kohsuke.github.GHCommitPointer;
import org.kohsuke.github.GHOrganization;
import org.kohsuke.github.GHPerson;
import org.kohsuke.github.GHRepository;
import org.kohsuke.github.GitHub;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Uniquely identifies a repository on GitHub.
*
* @author Kohsuke Kawaguchi
*/
public class GitHubRepositoryName {
private static final Pattern[] URL_PATTERNS = {
Pattern.compile("git@(.+):([^/]+)/([^/]+).git"),
Pattern.compile("https://[^/]+@([^/]+)/([^/]+)/([^/]+).git"),
Pattern.compile("https://([^/]+)/([^/]+)/([^/]+).git"),
Pattern.compile("git://([^/]+)/([^/]+)/([^/]+).git"),
Pattern.compile("ssh://git@([^/]+)/([^/]+)/([^/]+).git")
};
/**
* Create {@link GitHubRepositoryName} from URL
*
* @param url
* must be non-null
* @return parsed {@link GitHubRepositoryName} or null if it cannot be
* parsed from the specified URL
*/
public static GitHubRepositoryName create(final String url) {
for (Pattern p : URL_PATTERNS) {
Matcher m = p.matcher(url);
if (m.matches())
return new GitHubRepositoryName(m.group(1), m.group(2),
m.group(3));
}
return null;
}
public final String host, userName, repositoryName;
public GitHubRepositoryName(String host, String userName, String repositoryName) {
this.host = host;
this.userName = userName;
this.repositoryName = repositoryName;
}
/**
* Resolves this name to the actual reference by {@link GHRepository}.
*
*
* Since the system can store multiple credentials, and only some of them might be able to see this name in question,
* this method uses {@link GitHubWebHook#login(String, String)} and attempt to find the right credential that can
* access this repository.
*
*
* This method walks multiple repositories for each credential that can access the repository. Depending on
* what you are trying to do with the repository, you might have to keep trying until a {@link GHRepository}
* with suitable permission is returned.
*/
public Iterable resolve() {
return new Iterable() {
public Iterator iterator() {
return filterNull(new AdaptedIterator(GitHubWebHook.get().login(host,userName)) {
protected GHRepository adapt(GitHub item) {
try {
GHRepository repo = item.getUser(userName).getRepository(repositoryName);
if (repo == null) {
repo = item.getOrganization(userName).getRepository(repositoryName);
}
return repo;
} catch (IOException e) {
LOGGER.log(Level.WARNING,"Failed to obtain repository "+this,e);
return null;
}
}
});
}
};
}
/**
* Variation of {@link #resolve()} method that just returns the first valid repository object.
*
* This is useful if the caller only relies on the read access to the repository and doesn't need to
* walk possible candidates.
*/
public GHRepository resolveOne() {
for (GHRepository r : resolve())
return r;
return null;
}
private Iterator filterNull(Iterator itr) {
return new FilterIterator(itr) {
@Override
protected boolean filter(V v) {
return v!=null;
}
};
}
/**
* Does this repository match the repository referenced in the given {@link GHCommitPointer}?
*/
public boolean matches(GHCommitPointer commit) {
try {
return userName.equals(commit.getUser().getLogin())
&& repositoryName.equals(commit.getRepository().getName())
&& host.equals(new URL(commit.getRepository().getUrl()).getHost());
} catch (MalformedURLException e) {
return false;
}
}
/**
* Does this repository match the repository referenced in the given {@link GHCommitPointer}?
*/
public boolean matches(GHRepository repo) throws IOException {
return userName.equals(repo.getOwner().getLogin()) // TODO: use getOwnerName
&& repositoryName.equals(repo.getName())
&& host.equals(new URL(repo.getUrl()).getHost());
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GitHubRepositoryName that = (GitHubRepositoryName) o;
return repositoryName.equals(that.repositoryName) && userName.equals(that.userName) && host.equals(that.host);
}
@Override
public int hashCode() {
return Arrays.hashCode(new Object[] {host, userName, repositoryName});
}
@Override
public String toString() {
return "GitHubRepository[host="+host+",username="+userName+",repository="+repositoryName+"]";
}
private static final Logger LOGGER = Logger.getLogger(GitHubRepositoryName.class.getName());
}
github-plugin-github-1.4/src/main/java/com/cloudbees/jenkins/GitHubTrigger.java 0000664 0000000 0000000 00000000514 11766134601 0027612 0 ustar 00root root 0000000 0000000 package com.cloudbees.jenkins;
import hudson.model.AbstractProject;
import hudson.triggers.Trigger;
import java.util.Set;
/**
* Used to trigger builds that use github repos
*
* @author aaronwalker
*/
public interface GitHubTrigger {
public void onPost();
public Set getGitHubRepositories();
}
github-plugin-github-1.4/src/main/java/com/cloudbees/jenkins/GitHubWebHook.java 0000664 0000000 0000000 00000017406 11766134601 0027555 0 ustar 00root root 0000000 0000000 package com.cloudbees.jenkins;
import com.cloudbees.jenkins.GitHubPushTrigger.DescriptorImpl;
import hudson.Extension;
import hudson.model.AbstractProject;
import hudson.model.Hudson;
import hudson.model.RootAction;
import hudson.model.UnprotectedRootAction;
import hudson.security.ACL;
import hudson.triggers.Trigger;
import hudson.util.AdaptedIterator;
import hudson.util.Iterators.FilterIterator;
import net.sf.json.JSONObject;
import org.acegisecurity.Authentication;
import org.acegisecurity.context.SecurityContextHolder;
import org.kohsuke.github.GitHub;
import org.kohsuke.stapler.StaplerRequest;
import java.io.IOException;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static java.util.logging.Level.*;
/**
* Receives github hook.
*
* @author Kohsuke Kawaguchi
*/
@Extension
public class GitHubWebHook implements UnprotectedRootAction {
private static final Pattern REPOSITORY_NAME_PATTERN = Pattern.compile("https?://([^/]+)/([^/]+)/([^/]+)");
public String getIconFileName() {
return null;
}
public String getDisplayName() {
return null;
}
public String getUrlName() {
return "github-webhook";
}
/**
* Logs in as the given user and returns the connection object.
*/
public Iterable login(String host, String userName) {
if (host.equals("github.com")) {
final List l = DescriptorImpl.get().getCredentials();
// if the username is not an organization, we should have the right user account on file
for (Credential c : l) {
if (c.username.equals(userName))
try {
return Collections.singleton(c.login());
} catch (IOException e) {
LOGGER.log(WARNING,"Failed to login with username="+c.username,e);
return Collections.emptyList();
}
}
// otherwise try all the credentials since we don't know which one would work
return new Iterable() {
public Iterator iterator() {
return new FilterIterator(
new AdaptedIterator(l) {
protected GitHub adapt(Credential c) {
try {
return c.login();
} catch (IOException e) {
LOGGER.log(WARNING,"Failed to login with username="+c.username,e);
return null;
}
}
}) {
protected boolean filter(GitHub g) {
return g!=null;
}
};
}
};
} else {
return Collections. emptyList();
}
}
/*
{
"after":"ea50ac0026d6d9c284e04afba1cc95d86dc3d976",
"before":"501f46e557f8fc5e0fa4c88a7f4597ef597dd1bf",
"commits":[
{
"added":["b"],
"author":{"email":"kk@kohsuke.org","name":"Kohsuke Kawaguchi","username":"kohsuke"},
"id":"3c696af1225e63ed531f5656e8f9cc252e4c96a2",
"message":"another commit",
"modified":[],
"removed":[],
"timestamp":"2010-12-08T14:31:24-08:00",
"url":"https://github.com/kohsuke/foo/commit/3c696af1225e63ed531f5656e8f9cc252e4c96a2"
},{
"added":["d"],
"author":{"email":"kk@kohsuke.org","name":"Kohsuke Kawaguchi","username":"kohsuke"},
"id":"ea50ac0026d6d9c284e04afba1cc95d86dc3d976",
"message":"new commit",
"modified":[],
"removed":[],
"timestamp":"2010-12-08T14:32:11-08:00",
"url":"https://github.com/kohsuke/foo/commit/ea50ac0026d6d9c284e04afba1cc95d86dc3d976"
}
],
"compare":"https://github.com/kohsuke/foo/compare/501f46e...ea50ac0",
"forced":false,
"pusher":{"email":"kk@kohsuke.org","name":"kohsuke"},
"ref":"refs/heads/master",
"repository":{
"created_at":"2010/12/08 12:44:13 -0800",
"description":"testing",
"fork":false,
"forks":1,
"has_downloads":true,
"has_issues":true,
"has_wiki":true,
"homepage":"testing",
"name":"foo",
"open_issues":0,
"owner":{"email":"kk@kohsuke.org","name":"kohsuke"},
"private":false,
"pushed_at":"2010/12/08 14:32:23 -0800",
"url":"https://github.com/kohsuke/foo","watchers":1
}
}
*/
/**
* 1 push to 2 branches will result in 2 pushes.
*/
public void doIndex(StaplerRequest req) {
processGitHubPayload(req.getParameter("payload"),GitHubPushTrigger.class);
}
public void processGitHubPayload(String payload, Class triggerClass) {
JSONObject o = JSONObject.fromObject(payload);
JSONObject repository = o.getJSONObject("repository");
String repoUrl = repository.getString("url"); // something like 'https://github.com/kohsuke/foo'
String repoName = repository.getString("name"); // 'foo' portion of the above URL
String ownerName = repository.getJSONObject("owner").getString("name"); // 'kohsuke' portion of the above URL
LOGGER.info("Received POST for "+repoUrl);
LOGGER.fine("Full details of the POST was "+o.toString());
Matcher matcher = REPOSITORY_NAME_PATTERN.matcher(repoUrl);
if (matcher.matches()) {
// run in high privilege to see all the projects anonymous users don't see.
// this is safe because when we actually schedule a build, it's a build that can
// happen at some random time anyway.
Authentication old = SecurityContextHolder.getContext().getAuthentication();
SecurityContextHolder.getContext().setAuthentication(ACL.SYSTEM);
try {
GitHubRepositoryName changedRepository = new GitHubRepositoryName(matcher.group(1), ownerName, repoName);
for (AbstractProject job : Hudson.getInstance().getAllItems(AbstractProject.class)) {
GitHubTrigger trigger = (GitHubTrigger) job.getTrigger(triggerClass);
if (trigger!=null) {
LOGGER.fine("Considering to poke "+job.getFullDisplayName());
if (trigger.getGitHubRepositories().contains(changedRepository)) {
LOGGER.info("Poked "+job.getFullDisplayName());
trigger.onPost();
} else
LOGGER.fine("Skipped "+job.getFullDisplayName()+" because it doesn't have a matching repository.");
}
}
} finally {
SecurityContextHolder.getContext().setAuthentication(old);
}
} else {
LOGGER.warning("Malformed repo url "+repoUrl);
}
}
private static final Logger LOGGER = Logger.getLogger(GitHubWebHook.class.getName());
public static GitHubWebHook get() {
return Hudson.getInstance().getExtensionList(RootAction.class).get(GitHubWebHook.class);
}
static {
// hide "Bad input type: "search", creating a text input" from createElementNS
Logger.getLogger(com.gargoylesoftware.htmlunit.html.InputElementFactory.class.getName()).setLevel(WARNING);
}
}
github-plugin-github-1.4/src/main/java/com/coravy/ 0000775 0000000 0000000 00000000000 11766134601 0022136 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/java/com/coravy/hudson/ 0000775 0000000 0000000 00000000000 11766134601 0023436 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/java/com/coravy/hudson/plugins/ 0000775 0000000 0000000 00000000000 11766134601 0025117 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/java/com/coravy/hudson/plugins/github/ 0000775 0000000 0000000 00000000000 11766134601 0026401 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/java/com/coravy/hudson/plugins/github/GithubLinkAction.java 0000664 0000000 0000000 00000001660 11766134601 0032445 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import hudson.model.Action;
/**
* Add the Github Logo/Icon to the sidebar.
*
* @author Stefan Saasen
*/
public final class GithubLinkAction implements Action {
private final transient GithubProjectProperty projectProperty;
public GithubLinkAction(GithubProjectProperty githubProjectProperty) {
this.projectProperty = githubProjectProperty;
}
/*
* (non-Javadoc)
* @see hudson.model.Action#getDisplayName()
*/
public String getDisplayName() {
return "GitHub";
}
/*
* (non-Javadoc)
* @see hudson.model.Action#getIconFileName()
*/
public String getIconFileName() {
return "/plugin/github/logov3.png";
}
/*
* (non-Javadoc)
* @see hudson.model.Action#getUrlName()
*/
public String getUrlName() {
return projectProperty.getProjectUrl().baseUrl();
}
}
github-plugin-github-1.4/src/main/java/com/coravy/hudson/plugins/github/GithubLinkAnnotator.java 0000664 0000000 0000000 00000005063 11766134601 0033176 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import hudson.Extension;
import hudson.MarkupText;
import hudson.MarkupText.SubText;
import hudson.model.AbstractBuild;
import hudson.plugins.git.GitChangeSet;
import hudson.scm.ChangeLogAnnotator;
import hudson.scm.ChangeLogSet.Entry;
import java.util.regex.Pattern;
/**
* This class annotates changelog links.
*
* It's based on the TracLinkAnnotator.
*
*
* @todo Change the annotator to use GithubUrl instead of the String url.
* Knowledge about the github url structure should be encapsulated in
* GithubUrl.
* @author Stefan Saasen
*/
@Extension
public class GithubLinkAnnotator extends ChangeLogAnnotator {
@Override
public void annotate(AbstractBuild build, Entry change,
MarkupText text) {
final GithubProjectProperty p = build.getProject().getProperty(
GithubProjectProperty.class);
if (null == p || null == p.getProjectUrl()) {
return;
}
annotate(p.getProjectUrl(), text, change);
}
void annotate(final GithubUrl url, final MarkupText text, final Entry change) {
final String base = url.baseUrl();
for (LinkMarkup markup : MARKUPS) {
markup.process(text, base);
}
if(change instanceof GitChangeSet) {
GitChangeSet cs = (GitChangeSet)change;
text.wrapBy("", " (commit: "+cs.getId()+")");
}
}
private static final class LinkMarkup {
private final Pattern pattern;
private final String href;
LinkMarkup(String pattern, String href) {
// \\\\d becomes \\d when in the expanded text.
pattern = NUM_PATTERN.matcher(pattern).replaceAll("(\\\\d+)");
pattern = ANYWORD_PATTERN.matcher(pattern).replaceAll(
"((?:\\\\w|[._-])+)");
this.pattern = Pattern.compile(pattern);
this.href = href;
}
void process(MarkupText text, String url) {
for (SubText st : text.findTokens(pattern)) {
st.surroundWith("", "");
}
}
private static final Pattern NUM_PATTERN = Pattern.compile("NUM");
private static final Pattern ANYWORD_PATTERN = Pattern
.compile("ANYWORD");
}
private static final LinkMarkup[] MARKUPS = new LinkMarkup[] { new LinkMarkup(
"(?:C|c)lose(?:s?)\\s(?
* As of now this is only the URL to the github project.
*
* @todo Should we store the GithubUrl instead of the String?
* @author Stefan Saasen
*/
public final class GithubProjectProperty extends
JobProperty> {
/**
* This will the URL to the project main branch.
*/
private String projectUrl;
@DataBoundConstructor
public GithubProjectProperty(String projectUrl) {
this.projectUrl = new GithubUrl(projectUrl).baseUrl();
}
/**
* @return the projectUrl
*/
public GithubUrl getProjectUrl() {
return new GithubUrl(projectUrl);
}
@Override
public Collection getJobActions(AbstractProject job) {
if (null != projectUrl) {
return Collections.singleton(new GithubLinkAction(this));
}
return Collections.emptyList();
}
/*
@Override
public JobPropertyDescriptor getDescriptor() {
return DESCRIPTOR;
}
public static final DescriptorImpl DESCRIPTOR = new DescriptorImpl();
*/
@Extension
public static final class DescriptorImpl extends JobPropertyDescriptor {
public DescriptorImpl() {
super(GithubProjectProperty.class);
load();
}
public boolean isApplicable(Class jobType) {
return AbstractProject.class.isAssignableFrom(jobType);
}
public String getDisplayName() {
return "GitHub project page";
}
@Override
public JobProperty newInstance(StaplerRequest req,
JSONObject formData) throws FormException {
GithubProjectProperty tpp = req.bindJSON(
GithubProjectProperty.class, formData);
if (tpp.projectUrl == null) {
tpp = null; // not configured
}
return tpp;
}
}
}
github-plugin-github-1.4/src/main/java/com/coravy/hudson/plugins/github/GithubUrl.java 0000664 0000000 0000000 00000002752 11766134601 0031157 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import org.apache.commons.lang.StringUtils;
/**
*
* @author Stefan Saasen
*/
public final class GithubUrl {
/**
* Normalizes the github URL.
*
* Removes unwanted path elements (e.g. tree/master).
*
* @param input
* @return URL to the project or null if input is invalid.
*/
private static String normalize(String url) {
if (StringUtils.isBlank(url)) {
return null;
}
// Strip "/tree/..."
if (url.contains("/tree/")) {
url = url.replaceFirst("/tree/.*$", "");
}
if (!url.endsWith("/")) {
url += '/';
}
return url;
}
private final String baseUrl;
GithubUrl(final String input) {
this.baseUrl = normalize(input);
}
/*
* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return this.baseUrl;
}
/**
*
* @return
*/
public String baseUrl() {
return this.baseUrl;
}
/**
* Returns the URL to a particular commit.
*
* @param id - the git SHA1 hash
* @return URL String (e.g. http://github.com/juretta/hudson-github-plugin/commit/5e31203faea681c41577b685818a361089fac1fc)
*/
public String commitId(final String id) {
return new StringBuilder().append(baseUrl).append("commit/").append(id).toString();
}
}
github-plugin-github-1.4/src/main/resources/ 0000775 0000000 0000000 00000000000 11766134601 0021146 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/resources/com/ 0000775 0000000 0000000 00000000000 11766134601 0021724 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/resources/com/cloudbees/ 0000775 0000000 0000000 00000000000 11766134601 0023671 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/resources/com/cloudbees/jenkins/ 0000775 0000000 0000000 00000000000 11766134601 0025332 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/resources/com/cloudbees/jenkins/Credential/ 0000775 0000000 0000000 00000000000 11766134601 0027404 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/resources/com/cloudbees/jenkins/Credential/config.jelly 0000664 0000000 0000000 00000000640 11766134601 0031712 0 ustar 00root root 0000000 0000000
github-plugin-github-1.4/src/main/resources/com/cloudbees/jenkins/Credential/help-username.html 0000664 0000000 0000000 00000000506 11766134601 0033040 0 ustar 00root root 0000000 0000000
Credentials used to access GitHub to install/remove hooks. Because GitHub doesn't have an API for managing
hooks, we also need to ask you to provide password, in addition to the API key.
If your Jenkins uses multiple repositories that spread across different user accounts, you can list them all here.
github-plugin-github-1.4/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger/ 0000775 0000000 0000000 00000000000 11766134601 0030700 5 ustar 00root root 0000000 0000000 GitHubWebHookPollingAction/ 0000775 0000000 0000000 00000000000 11766134601 0035745 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger index.jelly 0000664 0000000 0000000 00000003400 11766134601 0040112 0 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger/GitHubWebHookPollingAction
${%Last GitHub Push}
${%Polling has not run yet.}
${it.writeLogTo(output)}
github-plugin-github-1.4/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger/global.jelly 0000664 0000000 0000000 00000003241 11766134601 0033201 0 ustar 00root root 0000000 0000000
github-plugin-github-1.4/src/main/resources/com/cloudbees/jenkins/GitHubPushTrigger/help-auto.jelly 0000664 0000000 0000000 00000001576 11766134601 0033650 0 ustar 00root root 0000000 0000000
In this mode, Jenkins will add/remove hook URLs to GitHub based on the project configuration of Jenkins.
Jenkins has a single post-commit hook URL for all the repositories, and this URL will be added to
all the GitHub repositories Jenkins is interested in.
This URL is ${app.rootUrl}github-webhook/,
and it needs to be accessible from the internet. If you have a firewall and such between GitHub
and Jenkins, you can set up a reverse proxy and override the hook URL that Jenkins registers to GitHub,
by checking "override hook URL" and specify the URL GitHub should POST to.
If your Jenkins runs inside the firewall and not directly reachable from the internet,
set up a reverse proxy, port tunneling, and so on so that GitHub can deliver a POST request
to your Jenkins at
${app.rootUrl}github-webhook/.
Then specify the URL that GitHub should POST to here.
Don't let Jenkins talk to GitHub and manage post commit hook URLs, and opt to do it manually.
In this mode, in addition to configure projects with "Build when a change is pushed to GitHub",
you need to ensure that Jenkins gets a POST to its
${app.rootUrl}github-webhook/
This plugin integrates
GitHub to Jenkins.
Enter the URL for the GitHub hosted project (without the tree/master or tree/branch part).
For example:
http://github.com/rails/rails for the Rails project.
github-plugin-github-1.4/src/main/webapp/help-global_de.html 0000664 0000000 0000000 00000000373 11766134601 0024141 0 ustar 00root root 0000000 0000000
URL des GitHub-Projektes (ohne den Pfad der den Zweig des Repositories angibt - also ohne tree/master oder tree/branch).
Zum Beispiel http://github.com/rails/rails für das Rails-Projekt.
github-plugin-github-1.4/src/main/webapp/logov3.png 0000664 0000000 0000000 00000003020 11766134601 0022324 0 ustar 00root root 0000000 0000000 PNG
IHDR w= tEXtSoftware Adobe ImageReadyqe< "iTXtXML:com.adobe.xmp =r IDATxڬkKQr۲0$B
͂",^4[bҋ^FDve +X]
w[ qfΜrs+/DX+V4bD<OxSJb91,y_*VeE.[[ C-b'Ex-NzIǨߒp]qFlY#Z9Q7 gdBqHe` G FĸW̭Ҧ 37=%YEKh1oRM;) c,AMnf}eP s$glFe(
^|Y<ۆ)9ô$ zAi$9xX L?i
bA }ꖱB|)ivA@y..`I%R0*PF ^p$7G,j
\c)}>a#5
!u'4j$ҟ`#S v)+am|7V@Fv j7(?H? JwP> &,EY( . vm@q
I credentials = d.getCredentials();
assertNotNull(credentials);
assertEquals(1, credentials.size());
Credential credential = credentials.get(0);
assertEquals("jenkins", credential.username);
assertEquals("password", Secret.toString(credential.password));
}
public void testConfigSubmit_ManuallyManageHook() throws Exception {
WebClient client = configureWebClient();
HtmlPage p = client.goTo("configure");
HtmlForm f = p.getFormByName("config");
f.getInputByValue("none").setChecked(true);
submit(f);
GitHubPushTrigger.DescriptorImpl d = getDescriptor();
assertFalse(d.isManageHook());
}
private GitHubPushTrigger.DescriptorImpl getDescriptor() {
return (GitHubPushTrigger.DescriptorImpl) GitHubPushTrigger.DescriptorImpl.get();
}
private WebClient configureWebClient() {
WebClient client = new WebClient();
client.setThrowExceptionOnFailingStatusCode(false);
client.setCssEnabled(false);
client.setJavaScriptEnabled(true);
return client;
}
// workaround
static {
Stapler.CONVERT_UTILS.register(new org.apache.commons.beanutils.Converter() {
public Secret convert(Class type, Object value) {
return Secret.fromString(value.toString());
}
}, Secret.class);
}
}
github-plugin-github-1.4/src/test/java/com/coravy/ 0000775 0000000 0000000 00000000000 11766134601 0022171 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/test/java/com/coravy/hudson/ 0000775 0000000 0000000 00000000000 11766134601 0023471 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/test/java/com/coravy/hudson/plugins/ 0000775 0000000 0000000 00000000000 11766134601 0025152 5 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/test/java/com/coravy/hudson/plugins/github/ 0000775 0000000 0000000 00000000000 11766134601 0026434 5 ustar 00root root 0000000 0000000 GitHubRepositoryNameTest.java 0000664 0000000 0000000 00000005534 11766134601 0034152 0 ustar 00root root 0000000 0000000 github-plugin-github-1.4/src/test/java/com/coravy/hudson/plugins/github package com.coravy.hudson.plugins.github;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import com.cloudbees.jenkins.GitHubRepositoryName;
import org.junit.Test;
/**
* Unit tests of {@link GitHubRepositoryName}
*/
public class GitHubRepositoryNameTest {
@Test
public void gitAtUrlGitHub() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("git@github.com:jenkinsci/jenkins.git");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("github.com", repo.host);
}
@Test
public void gitAtUrlOtherHost() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("git@gh.company.com:jenkinsci/jenkins.git");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("gh.company.com", repo.host);
}
@Test
public void gitColonUrlGitHub() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("git://github.com/jenkinsci/jenkins.git");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("github.com", repo.host);
}
@Test
public void gitColonUrlOtherHost() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("git://company.net/jenkinsci/jenkins.git");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("company.net", repo.host);
}
@Test
public void httpsUrlGitHub() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("https://user@github.com/jenkinsci/jenkins.git");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("github.com", repo.host);
}
@Test
public void httpsUrlGitHubWithoutUser() {
//this is valid for anonymous usage
GitHubRepositoryName repo = GitHubRepositoryName
.create("https://github.com/jenkinsci/jenkins.git");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("github.com", repo.host);
}
@Test
public void httpsUrlOtherHost() {
GitHubRepositoryName repo = GitHubRepositoryName
.create("https://employee@gh.company.com/jenkinsci/jenkins.git");
assertNotNull(repo);
assertEquals("jenkinsci", repo.userName);
assertEquals("jenkins", repo.repositoryName);
assertEquals("gh.company.com", repo.host);
}
}
github-plugin-github-1.4/src/test/java/com/coravy/hudson/plugins/github/GithubLinkAnnotatorTest.java0000664 0000000 0000000 00000002663 11766134601 0034074 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import static org.junit.Assert.assertEquals;
import hudson.MarkupText;
import org.junit.Test;
public class GithubLinkAnnotatorTest {
private final static String GITHUB_URL = "http://github.com/juretta/iphone-project-tools/";
@Test
public final void testAnnotateStringMarkupText() {
assertAnnotatedTextEquals("An issue Closes #1 link",
"An issue Closes #1 link");
assertAnnotatedTextEquals("An issue Close #1 link",
"An issue Close #1 link");
assertAnnotatedTextEquals("An issue closes #123 link",
"An issue closes #123 link");
assertAnnotatedTextEquals("An issue close #9876 link",
"An issue close #9876 link");
}
private void assertAnnotatedTextEquals(final String originalText,
final String expectedAnnotatedText) {
MarkupText markupText = new MarkupText(originalText);
GithubLinkAnnotator annotator = new GithubLinkAnnotator();
annotator.annotate(new GithubUrl(GITHUB_URL), markupText, null);
assertEquals(expectedAnnotatedText, markupText.toString());
}
}
github-plugin-github-1.4/src/test/java/com/coravy/hudson/plugins/github/GithubUrlTest.java 0000664 0000000 0000000 00000002664 11766134601 0032054 0 ustar 00root root 0000000 0000000 package com.coravy.hudson.plugins.github;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class GithubUrlTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public final void testBaseUrlWithTree() {
GithubUrl url = new GithubUrl(
"http://github.com/juretta/iphone-project-tools/tree/master");
assertEquals("http://github.com/juretta/iphone-project-tools/", url
.baseUrl());
url = new GithubUrl(
"http://github.com/juretta/iphone-project-tools/tree/unstable");
assertEquals("http://github.com/juretta/iphone-project-tools/", url
.baseUrl());
}
@Test
public final void testBaseUrl() {
GithubUrl url = new GithubUrl(
"http://github.com/juretta/iphone-project-tools");
assertEquals("http://github.com/juretta/iphone-project-tools/", url
.baseUrl());
}
@Test
public final void testCommitId() {
GithubUrl url = new GithubUrl(
"http://github.com/juretta/hudson-github-plugin/tree/master");
assertEquals(
"http://github.com/juretta/hudson-github-plugin/commit/5e31203faea681c41577b685818a361089fac1fc",
url.commitId("5e31203faea681c41577b685818a361089fac1fc"));
}
}