| /******************************************************************************* |
| * Copyright (c) 2011 Christian Trutz |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Christian Trutz - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.egit.github.core.tests; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.mockito.Matchers.any; |
| import static org.mockito.Mockito.doReturn; |
| import static org.mockito.Mockito.verify; |
| |
| import java.io.IOException; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.egit.github.core.Comment; |
| import org.eclipse.egit.github.core.Gist; |
| import org.eclipse.egit.github.core.client.GitHubClient; |
| import org.eclipse.egit.github.core.client.GitHubRequest; |
| import org.eclipse.egit.github.core.client.GitHubResponse; |
| import org.eclipse.egit.github.core.client.PageIterator; |
| import org.eclipse.egit.github.core.service.GistService; |
| import org.eclipse.egit.github.core.service.IssueService; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.mockito.Mock; |
| import org.mockito.runners.MockitoJUnitRunner; |
| |
| /** |
| * Unit tests of {@link GistService} |
| */ |
| @RunWith(MockitoJUnitRunner.class) |
| public class GistServiceTest { |
| |
| @Mock |
| private GitHubClient gitHubClient; |
| |
| @Mock |
| private GitHubResponse response; |
| |
| private GistService gistService; |
| |
| /** |
| * Test case set up |
| * |
| * @throws IOException |
| */ |
| @Before |
| public void before() throws IOException { |
| doReturn(response).when(gitHubClient).get(any(GitHubRequest.class)); |
| gistService = new GistService(gitHubClient); |
| } |
| |
| /** |
| * Create service with null client |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void constructorNullArgument() { |
| new GistService(null); |
| } |
| |
| /** |
| * Create default service |
| */ |
| @Test |
| public void defaultContructor() { |
| assertNotNull(new GistService().getClient()); |
| } |
| |
| /** |
| * Get gist with null id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void getGistNullId() throws IOException { |
| gistService.getGist(null); |
| } |
| |
| /** |
| * Get gist with empty id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void getGistEmptyId() throws IOException { |
| gistService.getGist(""); |
| } |
| |
| /** |
| * Get gist with valid id |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void getGist() throws IOException { |
| gistService.getGist("1"); |
| GitHubRequest request = new GitHubRequest(); |
| request.setUri("/gists/1"); |
| verify(gitHubClient).get(request); |
| } |
| |
| /** |
| * Delete gist with null id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void deleteGistNullId() throws IOException { |
| gistService.deleteGist(null); |
| } |
| |
| /** |
| * Delete gist with empty id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void deleteGistEmptyId() throws IOException { |
| gistService.deleteGist(""); |
| } |
| |
| /** |
| * Delete gist with valid id |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void deleteGist() throws IOException { |
| gistService.deleteGist("1"); |
| verify(gitHubClient).delete("/gists/1"); |
| } |
| |
| /** |
| * Star gist with null id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void starGistNullId() throws IOException { |
| gistService.starGist(null); |
| } |
| |
| /** |
| * Star gist with empty id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void starGistEmptyId() throws IOException { |
| gistService.starGist(""); |
| } |
| |
| /** |
| * Star gist with valid id |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void starGist() throws IOException { |
| gistService.starGist("1"); |
| verify(gitHubClient).put("/gists/1/star"); |
| } |
| |
| /** |
| * Unstar gist with null id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void unstarGistNullId() throws IOException { |
| gistService.unstarGist(null); |
| } |
| |
| /** |
| * Unstar gist with empty id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void unstarGistEmptyId() throws IOException { |
| gistService.unstarGist(""); |
| } |
| |
| /** |
| * Unstar gist with valid id |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void unstarGist() throws IOException { |
| gistService.unstarGist("1"); |
| verify(gitHubClient).delete("/gists/1/star"); |
| } |
| |
| /** |
| * Is gist starred with null id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void isStarredGistNullId() throws IOException { |
| gistService.isStarred(null); |
| } |
| |
| /** |
| * Is gist starred with empty id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void isStarredGistEmptyId() throws IOException { |
| gistService.isStarred(""); |
| } |
| |
| /** |
| * Is gist starred with valid id |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void isStarredGist() throws IOException { |
| gistService.isStarred("1"); |
| GitHubRequest request = new GitHubRequest(); |
| request.setUri("/gists/1/star"); |
| verify(gitHubClient).get(request); |
| } |
| |
| /** |
| * Fork gist with null id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void forkGistNullId() throws IOException { |
| gistService.forkGist(null); |
| } |
| |
| /** |
| * Fork gist with empty id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void forkGistEmptyId() throws IOException { |
| gistService.forkGist(""); |
| } |
| |
| /** |
| * Fork gist with valid id |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void forkGist() throws IOException { |
| gistService.forkGist("1"); |
| verify(gitHubClient).post("/gists/1/fork", null, Gist.class); |
| } |
| |
| /** |
| * Edit comment with null comment |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void editGistCommentNullComment() throws IOException { |
| gistService.editComment(null); |
| } |
| |
| /** |
| * Edit comment |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void editGistComment() throws IOException { |
| Comment comment = new Comment(); |
| comment.setId(48).setBody("new body"); |
| gistService.editComment(comment); |
| verify(gitHubClient).post("/gists/comments/48", comment, Comment.class); |
| } |
| |
| /** |
| * Get gist comment |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void getGistComment() throws IOException { |
| gistService.getComment(59); |
| GitHubRequest request = new GitHubRequest(); |
| request.setUri("/gists/comments/59"); |
| verify(gitHubClient).get(request); |
| } |
| |
| /** |
| * Delete gist comment |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void deleteGistComment() throws IOException { |
| gistService.deleteComment(1234); |
| verify(gitHubClient).delete("/gists/comments/1234"); |
| } |
| |
| /** |
| * Get starred gists |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void getStarredGists() throws IOException { |
| List<Gist> starred = gistService.getStarredGists(); |
| assertNotNull(starred); |
| assertEquals(0, starred.size()); |
| } |
| |
| /** |
| * Get iterator for starred gists |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void pageStarredGists() throws IOException { |
| PageIterator<Gist> iterator = gistService.pageStarredGists(); |
| assertNotNull(iterator); |
| assertTrue(iterator.hasNext()); |
| assertEquals(Utils.page("/gists/starred"), iterator.getRequest() |
| .generateUri()); |
| } |
| |
| /** |
| * Get gists for null login name |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void getGistsNullUser() throws IOException { |
| gistService.getGists(null); |
| } |
| |
| /** |
| * Get gists for empty login name |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void getGistsEmptyUser() throws IOException { |
| gistService.getGists(""); |
| } |
| |
| /** |
| * Get gists for valid login name |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void getGistsOK() throws IOException { |
| gistService.getGists("test_user"); |
| GitHubRequest request = new GitHubRequest(); |
| request.setUri(Utils.page("/users/test_user/gists")); |
| verify(gitHubClient).get(request); |
| } |
| |
| /** |
| * Create gist with null model |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void createGistNullGist() throws IOException { |
| gistService.createGist(null); |
| } |
| |
| /** |
| * Get gist with null user |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void createGistNullUser() throws IOException { |
| Gist gist = new Gist(); |
| gist.setUser(null); |
| gistService.createGist(gist); |
| verify(gitHubClient).post("/gists", gist, Gist.class); |
| } |
| |
| /** |
| * Update null gist |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void updateGistNullGist() throws IOException { |
| gistService.updateGist(null); |
| } |
| |
| /** |
| * Update gist with null id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void updateGistNullId() throws IOException { |
| Gist gist = new Gist(); |
| gist.setId(null); |
| gistService.updateGist(gist); |
| } |
| |
| /** |
| * Update valid gist |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void updateGistOK() throws IOException { |
| Gist gist = new Gist(); |
| gist.setId("123"); |
| gistService.updateGist(gist); |
| verify(gitHubClient).post("/gists/123", gist, Gist.class); |
| } |
| |
| /** |
| * Create comment for with null gist id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void createCommentNullGistId() throws IOException { |
| gistService.createComment(null, "not null"); |
| } |
| |
| /** |
| * Create null comment |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void createCommentNullComment() throws IOException { |
| gistService.createComment("not null", null); |
| } |
| |
| /** |
| * Create valid comment |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void createCommentOK() throws IOException { |
| gistService.createComment("1", "test_comment"); |
| |
| Map<String, String> params = new HashMap<String, String>(1, 1); |
| params.put(IssueService.FIELD_BODY, "test_comment"); |
| verify(gitHubClient).post("/gists/1/comments", params, Comment.class); |
| } |
| |
| /** |
| * Get comments for null gist id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void getCommentsNullGistId() throws IOException { |
| gistService.getComments(null); |
| } |
| |
| /** |
| * Get comment with valid gist id |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void getCommentsOK() throws IOException { |
| gistService.getComments("1"); |
| GitHubRequest request = new GitHubRequest(); |
| request.setUri(Utils.page("/gists/1/comments")); |
| verify(gitHubClient).get(request); |
| } |
| |
| /** |
| * Page gists with null user |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void pageUserGistsNullId() throws IOException { |
| gistService.pageGists(null); |
| } |
| |
| /** |
| * Page gists with empty id |
| * |
| * @throws IOException |
| */ |
| @Test(expected = IllegalArgumentException.class) |
| public void pageUserGistsEmptyId() throws IOException { |
| gistService.pageGists(""); |
| } |
| |
| /** |
| * Page gists with valid user |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void pageUserGists() throws IOException { |
| PageIterator<Gist> iterator = gistService.pageGists("user"); |
| assertNotNull(iterator); |
| assertTrue(iterator.hasNext()); |
| assertEquals(Utils.page("/users/user/gists"), iterator.getRequest() |
| .generateUri()); |
| } |
| |
| /** |
| * Page public gists |
| * |
| * @throws IOException |
| */ |
| @Test |
| public void pagePublicGists() throws IOException { |
| PageIterator<Gist> iterator = gistService.pagePublicGists(); |
| assertNotNull(iterator); |
| assertTrue(iterator.hasNext()); |
| } |
| } |