GithubTicketSystemBuilderTest.java

package de.hftstuttgart.unifiedticketing.systems.github;

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

import de.hftstuttgart.unifiedticketing.core.Logging;
import de.hftstuttgart.unifiedticketing.exceptions.AssertionException;
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.Mockito;

import java.util.logging.Level;
import java.util.regex.Pattern;

public class GithubTicketSystemBuilderTest
{
    public GithubTicketSystemBuilder instance;

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

    @BeforeEach
    public void initBeforeEach()
    {
        instance = Mockito.spy(new GithubTicketSystemBuilder());
    }

    @Test
    public void testInit()
    {
        assertAll(
            () -> assertEquals("application/vnd.github.v3+json", instance.acceptHeader),
            () -> assertNull(instance.apiKey),
            () -> assertNull(instance.owner),
            () -> assertNull(instance.repo),
            () -> assertTrue(instance.https),
            () -> assertNull(instance.username)
        );
    }

    @Test
    public void testWithApiKey()
    {
        String username = "someUser";
        String apiKey = "asoashdboahasjhdfbeuazhvfef4q34v3h4v435v2";
        instance.withAuthentication(username, apiKey);
        assertAll(
            () -> assertEquals(username, instance.username),
            () -> assertEquals(apiKey, instance.apiKey)
        );
    }

    @Test
    public void testWithHttp()
    {
        instance.https = true;
        instance.withHttp();

        assertFalse(instance.https);
    }

    @Test
    public void testWithHttps()
    {
        instance.https = false;
        instance.withHttps();
        assertTrue(instance.https);
    }

    @Test
    public void testWithProjectIdByInt()
    {
        String expected = "255254123";
        instance.withRepo(expected);

        assertEquals(expected, instance.repo);
    }

    @Test
    public void testBuild()
    {
        instance.withBaseUrl("blabla.tld");
        assertThrows(AssertionException.class, () -> instance.build());

        String apiKey = "aaesfsef32qqfq3f";
        String baseUrl = "api.github.com";
        String owner = "someOwner";
        String repo = "42";
        String username = "someUsername";
        instance = new GithubTicketSystemBuilder();
        instance.withOwner(owner);
        instance.withRepo(repo);
        assertThrows(AssertionException.class, () -> instance.build());

        instance = new GithubTicketSystemBuilder();
        String regex = "^%s://%s/repos/%s/%s/issues$";
        Pattern pattern = Pattern.compile(
            String.format(regex, "https", baseUrl, owner, repo));

        instance.withBaseUrl(baseUrl)
            .withOwner(owner)
            .withRepo(repo);
        GithubTicketSystem system = instance.build();
        assertTrue(pattern.matcher(system.baseUrl).matches());

        pattern = Pattern.compile(String.format(regex, "http", baseUrl, owner, repo));
        instance
            .withHttp()
            .withAuthentication(username, apiKey);
        system = instance.build();
        assertTrue(pattern.matcher(system.baseUrl).matches());
        assertEquals(username, system.username);
        assertEquals(apiKey, system.apiKey);
    }
}