Java Repo类代码示例

import com.jcabi.github.Repo; //导入依赖的package包/类
@Override
public void perform(
    final Command command, final Log log) throws IOException {
    try {
        log.logger().info("Starring repository...");
        final Repo repo = command.issue().repo();
        if(!repo.stars().starred()) {
            repo.stars().star();
        }
        log.logger().info("Repository starred!");
    } catch (final IOException ex) {
        log.logger().warn(
            "IOException when starring repository, could not star the repo."
        );
    }
    this.next().perform(command, log);
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * CloneRepo provides the scripts necessary to clone the Github Repo.
 */
@Test
public void clonesRepo() {
    final Repo repo = Mockito.mock(Repo.class);
    Mockito.when(repo.coordinates()).thenReturn(
        new Coordinates.Simple("amihaiemil/testrepo")
    );
    final Scripts original = Mockito.mock(Scripts.class);
    Mockito.when(original.asText()).thenReturn("cloc .");

    final Scripts clone = new CloneRepo(repo, original);

    final StringBuilder expected = new StringBuilder();
    expected.append("git clone [email protected]:amihaiemil/testrepo.git")
        .append("\n")
        .append("cd testrepo").append("\n")
        .append("pwd").append("\n")
        .append("cloc .").append("\n");

    MatcherAssert.assertThat(
        clone.asText(), Matchers.equalTo(expected.toString())
    );
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * JsonMention can return the .comdor.yml
 * if it is missing from the repository.
 * @throws Exception If something goes wrong.
 */
@Test
public void returnsMissingComdorYaml() throws Exception {
    final MkGithub gh = new MkGithub("amihaiemil");
    final Repo repo = gh.repos().create(
        new Repos.RepoCreate("charlesrepo", false)
    );
    final Command mention = new MockConcrete(
        Json.createObjectBuilder().build(),
        repo.issues().create("for test", "body")
    );
    final ComdorYaml yaml = mention.comdorYaml();
    MatcherAssert.assertThat(yaml, Matchers.notNullValue());
    MatcherAssert.assertThat(
        yaml instanceof ComdorYaml.Missing,
        Matchers.is(true)
    );
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * Star the repository.
 * @return Always returns true, since it's not a critical step.
 */
public void perform(Command command, Logger logger) throws IOException {
    try {
        logger.info("Starring repository...");
        Repo repo = command.issue().repo();
        if(!repo.stars().starred()) {
            repo.stars().star();
        }
        logger.info("Repository starred!");
    } catch (IOException e) {
        logger.error("Error when starring repository: " + e.getMessage(), e);
        //We do not rethrow it here since starring the repo is not
        //a critical matter
    }
    this.next().perform(command, logger);
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * CommandedRepo can tell when the repo has a gh-pages branch.
 * @throws Exception If something goes wrong.
 */
@Test
public void repoHasGhPagesBranch() throws Exception {
    int port = this.port();
    MkContainer server = new MkGrizzlyContainer()
        .next(new MkAnswer.Simple(HttpURLConnection.HTTP_OK))
        .start(port);
    try {
        CachedRepo crepo = Mockito.spy(
            new CachedRepo(Mockito.mock(Repo.class))
        );
        Mockito.when(crepo.json()).thenReturn(Json
            .createObjectBuilder()
            .add(
                "branches_url",
                "http://localhost:" + port + "/branches{/branch}"
            ).build()
        );
        assertTrue(
            "Expected a gh-pages branch!",
            crepo.hasGhPagesBranch()
        );
    } finally {
        server.stop();
    }
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * CommandedRepo can tell when the repo doesn't
 * have a gh-pages branch.
 * @throws Exception If something goes wrong.
 */
@Test
public void repoHasNoGhPagesBranch() throws Exception {
    int port = this.port();
    MkContainer server = new MkGrizzlyContainer()
        .next(new MkAnswer.Simple(HttpURLConnection.HTTP_NOT_FOUND))
        .start(port);
    try {
        CachedRepo crepo = Mockito.spy(
            new CachedRepo(Mockito.mock(Repo.class))
        );
        Mockito.when(crepo.json()).thenReturn(Json
            .createObjectBuilder()
            .add(
                "branches_url",
                "http://localhost:" + port + "/branches{/branch}"
            ).build()
        );
        assertFalse(
            "Unexpected gh-pages branch!",
            crepo.hasGhPagesBranch()
        );
    } finally {
        server.stop();
    }
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
@Test
public void getsAuthorEmail() throws Exception {
    MkStorage storage = new MkStorage.Synced(new MkStorage.InFile());
    
    MkGithub authorGh = new MkGithub(storage, "amihaiemil");
    authorGh.users().self().emails().add(Arrays.asList("[email protected]"));
    Repo authorRepo = authorGh.randomRepo();
    Comment com = authorRepo.issues().create("", "").comments().post("@charlesmike do something");

    Github agentGh = new MkGithub(storage, "charlesmike");
    Issue issue = agentGh.repos().get(authorRepo.coordinates()).issues().get(com.issue().number());
    Command comm = Mockito.mock(Command.class);
    
    JsonObject authorInfo = Json.createObjectBuilder().add("login", "amihaiemil").build();
    JsonObject json = Json.createObjectBuilder()
        .add("user", authorInfo)
        .add("body", com.json().getString("body"))
        .add("id", 2)
        .build();
    Mockito.when(comm.json()).thenReturn(json);
    Mockito.when(comm.issue()).thenReturn(issue);

    ValidCommand vc = new ValidCommand(comm);
    assertTrue(vc.authorEmail().equals("[email protected]"));
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * StarRepo can successfully star a given repository.
 * @throws Exception If something goes wrong.
 */
@Test
public void starsRepo() throws Exception {
    Logger logger = Mockito.mock(Logger.class);
    Mockito.doNothing().when(logger).info(Mockito.anyString());
    Mockito.doThrow(new IllegalStateException("Unexpected error; test failed")).when(logger).error(Mockito.anyString());
    
    Github gh = new MkGithub("amihaiemil");
    Repo repo =  gh.repos().create(
        new RepoCreate("amihaiemil.github.io", false)
    );
    Command com = Mockito.mock(Command.class);
    Issue issue = Mockito.mock(Issue.class);
    Mockito.when(issue.repo()).thenReturn(repo);
    Mockito.when(com.issue()).thenReturn(issue);
    
    Step sr = new StarRepo(Mockito.mock(Step.class));
    assertFalse(com.issue().repo().stars().starred());
    sr.perform(com, logger);
    assertTrue(com.issue().repo().stars().starred());
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * StarRepo tries to star a repo twice.
 * @throws Exception If something goes wrong.
 */
@Test
public void starsRepoTwice() throws Exception {
    Logger logger = Mockito.mock(Logger.class);
    Mockito.doNothing().when(logger).info(Mockito.anyString());
    Mockito.doThrow(new IllegalStateException("Unexpected error; test failed")).when(logger).error(Mockito.anyString());

    Github gh = new MkGithub("amihaiemil");
    Repo repo =  gh.repos().create(
        new RepoCreate("amihaiemil.github.io", false)
    );
    Command com = Mockito.mock(Command.class);
    Issue issue = Mockito.mock(Issue.class);
    Mockito.when(issue.repo()).thenReturn(repo);
    Mockito.when(com.issue()).thenReturn(issue);

    Step sr = new StarRepo(Mockito.mock(Step.class));
    assertFalse(com.issue().repo().stars().starred());
    sr.perform(com, logger);
    sr.perform(com, logger);
    assertTrue(com.issue().repo().stars().starred());
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * StarRepo did not star the repository due to an IOException. 
 * StarRepo.perform() should return true anyway because it's not a critical operation and we
 * shouldn't fail the whole process just because of this.
 * 
 * This test expects an RuntimeException (we mock the logger in such a way) because it's the easiest way
 * to find out if the flow entered the catch block.
 * @throws IOException If something goes wrong.
 */
@Test(expected = RuntimeException.class)
public void repoStarringFails() throws IOException {
    Logger logger = Mockito.mock(Logger.class);
    Mockito.doNothing().when(logger).info(Mockito.anyString());
    Mockito.doThrow(new RuntimeException("Excpected excetion; all is ok!")).when(logger).error(
        Mockito.anyString(), Mockito.any(IOException.class)
    );
    
    Repo repo = Mockito.mock(Repo.class);
    Stars stars = Mockito.mock(Stars.class);
    Mockito.when(stars.starred()).thenReturn(false);
    Mockito.doThrow(new IOException()).when(stars).star();
    Mockito.when(repo.stars()).thenReturn(stars);
    Command com = Mockito.mock(Command.class);
    Issue issue = Mockito.mock(Issue.class);
    Mockito.when(issue.repo()).thenReturn(repo);
    Mockito.when(com.issue()).thenReturn(issue);
    
    StarRepo sr = new StarRepo(Mockito.mock(Step.class));
    sr.perform(com, logger);
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * Agent already replied once to the last comment.
 * @throws Exception if something goes wrong.
 */
@Test
public void agentRepliedAlreadyToTheLastComment() throws Exception {
    final MkStorage storage = new MkStorage.Synced(new MkStorage.InFile());
    final Repo repoMihai = new MkGithub(storage, "amihaiemil").repos().create( new RepoCreate("amihaiemil.github.io", false));
    final Issue issue = repoMihai.issues().create("test issue", "body");
    issue.comments().post("@charlesmike hello!");
    
    final Github charlesmike = new MkGithub(storage, "charlesmike");
    Issue issueCharlesmike = charlesmike.repos().get(repoMihai.coordinates()).issues().get(issue.number());
    issueCharlesmike.comments().post("@amihaiemil hi there, I can help you index... ");

    issue.comments().post("@someoneelse, please check that...");
    
    LastComment lastComment = new LastComment(issueCharlesmike);
    JsonObject jsonComment = lastComment.json();
    JsonObject emptyMentionComment = Json.createObjectBuilder().add("id", "-1").add("body", "").build();
    assertTrue(emptyMentionComment.equals(jsonComment)); 
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * There is more than 1 mention of the agent in the issue and it has already 
 * replied to others, but the last one is not replied to yet.
 * @throws Exception if something goes wrong.
 */
@Test
public void agentRepliedToPreviousMention() throws Exception {
    final MkStorage storage = new MkStorage.Synced(new MkStorage.InFile());
    final Repo repoMihai = new MkGithub(storage, "amihaiemil").repos().create( new RepoCreate("amihaiemil.github.io", false));
    final Issue issue = repoMihai.issues().create("test issue", "body");
    issue.comments().post("@charlesmike hello!");//first mention
    
    final Github charlesmike = new MkGithub(storage, "charlesmike");
    Issue issueCharlesmike = charlesmike.repos().get(repoMihai.coordinates()).issues().get(issue.number());
    issueCharlesmike.comments().post("@amihaiemil hi there, I can help you index... "); //first reply

    Comment lastMention = issue.comments().post("@charlesmike hello again!!");//second mention
    issue.comments().post("@someoneelse, please check that..."); //some other comment that is the last on the ticket.
    
    LastComment lastComment = new LastComment(issueCharlesmike);
    JsonObject jsonComment = lastComment.json();
    assertTrue(lastMention.json().equals(jsonComment)); 
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
@Override
@NotNull(message = "repo is never NULL")
public Repo create(
    @NotNull(message = "settings can't be NULL")
    final RepoCreate settings
) throws IOException {
    final Coordinates coords = new Coordinates.Simple(
        this.self,
        settings.name()
    );
    this.storage.apply(
        new Directives().xpath(this.xpath()).add("repo")
            .attr("coords", coords.toString())
            .add("name").set(settings.name()).up()
            .add("description").set("test repository").up()
            .add("private").set("false").up()
    );
    final Repo repo = this.get(coords);
    repo.patch(settings.json());
    Logger.info(
        this, "repository %s created by %s",
        coords, this.self
    );
    return repo;
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
@Override
@NotNull(message = "Repo is never NULL")
public Repo get(
    @NotNull(message = "coords can't be NULL") final Coordinates coords
) {
    try {
        final String xpath = String.format(
            "%s/repo[@coords='%s']", this.xpath(), coords
        );
        if (this.storage.xml().nodes(xpath).isEmpty()) {
            throw new IllegalArgumentException(
                String.format("repository %s doesn't exist", coords)
            );
        }
    } catch (final IOException ex) {
        throw new IllegalStateException(ex);
    }
    return new MkRepo(this.storage, this.self, coords);
}
 

import com.jcabi.github.Repo; //导入依赖的package包/类
/**
 * Iterate all public repos, starting with the one you've seen already.
 * @param identifier The integer ID of the last Repo that you’ve seen.
 * @return Iterator of repo
 */
@Override
public Iterable<Repo> iterate(
    @NotNull(message = "identifier can't be NULL")
    final String identifier) {
    return new MkIterable<Repo>(
        this.storage,
        "/github/repos/repo",
        new MkIterable.Mapping<Repo>() {
            @Override
            public Repo map(final XML xml) {
                return new MkRepo(
                    MkRepos.this.storage, MkRepos.this.self,
                    new Coordinates.Simple(xml.xpath("@coords").get(0))
                );
            }
        }
    );
}