GithubTicketSystemTest.java

package de.hftstuttgart.unifiedticketing.systems.github;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import de.hftstuttgart.unifiedticketing.core.Logging;
import de.hftstuttgart.unifiedticketing.core.TicketSystem;
import de.hftstuttgart.unifiedticketing.exceptions.AssertionException;
import de.hftstuttgart.unifiedticketing.exceptions.DeserializationException;
import de.hftstuttgart.unifiedticketing.exceptions.HttpResponseException;
import okhttp3.*;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;

import java.io.IOException;
import java.util.*;
import java.util.logging.Level;
import java.util.stream.Collectors;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

public class GithubTicketSystemTest
{
    public GithubTicketSystem instance;
    public Call call;
    public ArgumentCaptor<Request> requestCaptor;
    public Response.Builder responseBuilder;

    @BeforeAll
    public static void initBeforeAll()
    {
        Logging.setLevel(Level.ALL);
    }

    @BeforeEach
    public void initBeforeEach()
    {
        instance = spy(new GithubTicketSystem("someHeader", "https://api.github.com"));

        OkHttpClient client = mock(OkHttpClient.class);
        call = mock(Call.class);
        requestCaptor = ArgumentCaptor.forClass(Request.class);
        responseBuilder = new Response.Builder()
            .request(new Request.Builder().url("http://test.some.tld/").build())
            .protocol(Protocol.HTTP_1_1)
            .message("some message");

        doReturn(client).when(instance).getHttpClient();
        doReturn(call).when(client).newCall(requestCaptor.capture());
    }

    @Test
    public void testFromUri()
    {
        String base = "api.github.com";
        String owner = "myOwner";
        String repo = "myRepo";
        String username = "someUser";
        String apikey = "afdaf3aqraf3afafmyxcbvmyxvbas3wrawra";
        GithubTicketSystem actual = (GithubTicketSystem) TicketSystem.fromUri(buildTestUri(true, base, owner, repo, username, apikey));

        assertEquals(buildFinalBaseurl(true, base, owner, repo), actual.baseUrl);
        assertEquals(username, actual.username);
        assertEquals(apikey, actual.apiKey);
        assertEquals(GithubTicketSystem.class, actual.getClass());

        base = "api.github.somedomain.tld:8080";
        owner = "otherOwner";
        repo = "otherRepo";
        username = "me";
        apikey = "a34adfae3ra3rasd";
        actual = (GithubTicketSystem) TicketSystem.fromUri(buildTestUri(false, base, owner, repo, username, apikey));

        assertEquals(buildFinalBaseurl(false, base, owner, repo), actual.baseUrl);
        assertEquals(username, actual.username);
        assertEquals(apikey, actual.apiKey);
        assertEquals(GithubTicketSystem.class, actual.getClass());

        actual = (GithubTicketSystem) TicketSystem.fromUri(buildTestUri(false, base, owner, repo, null, null));
        assertEquals(buildFinalBaseurl(false, base, owner, repo), actual.baseUrl);
        assertNull(actual.username);
        assertNull(actual.apiKey);
        assertEquals(GithubTicketSystem.class, actual.getClass());

        assertThrows(AssertionException.class, () -> TicketSystem.fromUri("unifiedticketing:github:blablabal"));
    }

    @Test
    public void testCreateTicket()
    {
        assertEquals(GithubTicketBuilder.class, instance.createTicket().getClass());
        assertSame(instance, instance.createTicket().parent);
    }

    @Test
    public void testFind()
    {
        assertEquals(GithubFilter.class, instance.find().getClass());
        assertSame(instance, instance.find().parent);
    }

    @Test
    public void testGetServerError() throws IOException
    {
        doReturn(responseBuilder.code(500).build()).when(call).execute();
        assertThrows(HttpResponseException.class, () -> instance.getTicketById("bla"));
    }

    @Test
    public void testGetClientError() throws IOException
    {
        doReturn(responseBuilder.code(400).build()).when(call).execute();
        assertThrows(HttpResponseException.class, () -> instance.getTicketById("bla"));
    }

    @Test
    public void testGetNullBody() throws IOException
    {
        doReturn(responseBuilder.code(200).build()).when(call).execute();
        assertThrows(HttpResponseException.class, () -> instance.getTicketById("bla"));
    }

    @Test
    public void testGetNoJsonBody() throws IOException
    {
        doReturn(
            responseBuilder
                .code(200)
                .body(ResponseBody.create("somestrangething", MediaType.get("application/json")))
                .build())
            .when(call).execute();
        assertThrows(DeserializationException.class, () -> instance.getTicketById("bla"));
    }

    @Test
    public void testGetTicketById() throws IOException
    {
        GithubTicketResponse res = new GithubTicketResponse();
        res.number = 99;
        res.title = "some title";
        res.body = "descriptive text";
        res.assignees = new HashSet<>();
        res.state = "open";
        res.labels = Arrays.stream(new String[]{"unifiedticketing", "feature-request"})
            .map(l -> {
                GithubTicketResponse.Label label = new GithubTicketResponse.Label();
                label.name = l;
                return label;
            })
            .collect(Collectors.toSet());

        ObjectMapper mapper = new ObjectMapper();

        doReturn(
            responseBuilder
                .code(200)
                .body(ResponseBody.create(mapper.writeValueAsString(res), MediaType.get("application/json")))
                .build())
            .when(call).execute();

        GithubTicket expected = GithubTicket.fromTicketResponse(instance, res);
        GithubTicket actual = instance.getTicketById(res.number);

        assertEquals(expected, actual);
        assertTrue(expected.deepEquals(actual));
    }

    @Test
    public void testSupport()
    {
        assertAll(
            () -> assertTrue(instance.hasAssigneeSupport()),
            () -> assertTrue(instance.hasDefaultPagination()),
            () -> assertTrue(instance.hasLabelSupport()),
            () -> assertTrue(instance.hasPaginationSupport()),
            () -> assertTrue(instance.hasReturnNullOnErrorSupport())
        );
    }

    private static String buildTestUri(boolean https, String base, String owner, String repo, String username, String apikey)
    {
        return String.format(
            "unifiedticketing:github:%s://%s::%s:%s%s",
            (https) ? "https": "http",
            base,
            owner,
            repo,
            (username == null || apikey == null) ? "" : ":" + username + ":" + apikey);
    }

    private static String buildFinalBaseurl(boolean https, String base, String owner, String repo)
    {
        return String.format("%s://%s/repos/%s/%s/issues", (https) ? "https" : "http", base, owner, repo);
    }
}