embulk-input-jira 0.2.5 → 0.2.6

data/src/test/java/org/embulk/input/jira/JiraInputPluginTest.java

@@ -0,0 +1,204 @@
+package org.embulk.input.jira;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.apache.http.HttpResponse;
+import org.apache.http.StatusLine;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.entity.StringEntity;
+import org.embulk.config.ConfigDiff;
+import org.embulk.config.ConfigSource;
+import org.embulk.config.TaskReport;
+import org.embulk.config.TaskSource;
+import org.embulk.input.jira.JiraInputPlugin.PluginTask;
+import org.embulk.input.jira.client.JiraClient;
+import org.embulk.spi.InputPlugin;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.Schema;
+import org.embulk.spi.TestPageBuilderReader.MockPageOutput;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class JiraInputPluginTest
+{
+    @Rule
+    public JiraPluginTestRuntime runtime = new JiraPluginTestRuntime();
+
+    private JiraInputPlugin plugin;
+    private JiraClient jiraClient;
+    private JsonObject data;
+    private ConfigSource config;
+    private HttpClient client = Mockito.mock(HttpClient.class);
+    private HttpResponse response = Mockito.mock(HttpResponse.class);
+    private StatusLine statusLine = Mockito.mock(StatusLine.class);
+
+    private MockPageOutput output = new MockPageOutput();
+    private PageBuilder pageBuilder;
+
+    @Before
+    public void setUp() throws IOException
+    {
+        if (plugin == null) {
+            plugin = Mockito.spy(new JiraInputPlugin());
+            jiraClient = Mockito.spy(new JiraClient());
+            data = TestHelpers.getJsonFromFile("jira_input_plugin.json");
+            config = TestHelpers.config();
+            config.loadConfig(PluginTask.class);
+            pageBuilder = Mockito.mock(PageBuilder.class);
+            //pageBuilder = new PageBuilder(Exec.getBufferAllocator(), config.loadConfig(PluginTask.class).getColumns().toSchema(), output);
+        }
+        when(plugin.getJiraClient()).thenReturn(jiraClient);
+        when(jiraClient.createHttpClient()).thenReturn(client);
+        when(client.execute(Mockito.any(HttpUriRequest.class))).thenReturn(response);
+        when(response.getStatusLine()).thenReturn(statusLine);
+        doReturn(pageBuilder).when(plugin).getPageBuilder(Mockito.any(), Mockito.any());
+    }
+
+    @Test
+    public void test_run_withEmptyResult() throws IOException
+    {
+        JsonObject authorizeResponse = data.get("authenticateSuccess").getAsJsonObject();
+        JsonObject searchResponse = data.get("emptyResult").getAsJsonObject();
+
+        when(statusLine.getStatusCode())
+            .thenReturn(authorizeResponse.get("statusCode").getAsInt())
+            .thenReturn(searchResponse.get("statusCode").getAsInt());
+        when(response.getEntity())
+            .thenReturn(new StringEntity(authorizeResponse.get("body").toString()))
+            .thenReturn(new StringEntity(searchResponse.get("body").toString()));
+
+        plugin.transaction(config, new Control());
+     // Check credential 1 + getTotal 1 + loadData 0
+        verify(jiraClient, times(2)).createHttpClient();
+        verify(pageBuilder, times(0)).addRecord();
+        verify(pageBuilder, times(1)).finish();
+    }
+
+    @Test
+    public void test_run_with1RecordsResult() throws IOException
+    {
+        JsonObject authorizeResponse = data.get("authenticateSuccess").getAsJsonObject();
+        JsonObject searchResponse = data.get("oneRecordResult").getAsJsonObject();
+
+        when(statusLine.getStatusCode())
+            .thenReturn(authorizeResponse.get("statusCode").getAsInt())
+            .thenReturn(searchResponse.get("statusCode").getAsInt());
+        when(response.getEntity())
+            .thenReturn(new StringEntity(authorizeResponse.get("body").toString()))
+            .thenReturn(new StringEntity(searchResponse.get("body").toString()));
+
+        plugin.transaction(config, new Control());
+        // Check credential 1 + getTotal 1 + loadData 1
+        verify(jiraClient, times(3)).createHttpClient();
+        verify(pageBuilder, times(1)).addRecord();
+        verify(pageBuilder, times(1)).finish();
+    }
+
+    @Test
+    public void test_run_with2PagesResult() throws IOException
+    {
+        JsonObject authorizeResponse = data.get("authenticateSuccess").getAsJsonObject();
+        JsonObject searchResponse = data.get("2PagesResult").getAsJsonObject();
+
+        when(statusLine.getStatusCode())
+            .thenReturn(authorizeResponse.get("statusCode").getAsInt())
+            .thenReturn(searchResponse.get("statusCode").getAsInt());
+        when(response.getEntity())
+            .thenReturn(new StringEntity(authorizeResponse.get("body").toString()))
+            .thenReturn(new StringEntity(searchResponse.get("body").toString()));
+
+        plugin.transaction(config, new Control());
+        // Check credential 1 + getTotal 1 + loadData 2
+        verify(jiraClient, times(4)).createHttpClient();
+        verify(pageBuilder, times(2)).addRecord();
+        verify(pageBuilder, times(1)).finish();
+    }
+
+    @Test
+    public void test_preview_withEmptyResult() throws IOException
+    {
+        when(plugin.isPreview()).thenReturn(true);
+        JsonObject authorizeResponse = data.get("authenticateSuccess").getAsJsonObject();
+        JsonObject searchResponse = data.get("emptyResult").getAsJsonObject();
+
+        when(statusLine.getStatusCode())
+            .thenReturn(authorizeResponse.get("statusCode").getAsInt())
+            .thenReturn(searchResponse.get("statusCode").getAsInt());
+        when(response.getEntity())
+            .thenReturn(new StringEntity(searchResponse.get("body").toString()));
+
+        plugin.transaction(config, new Control());
+        // Check credential 1 + loadData 1
+        verify(jiraClient, times(2)).createHttpClient();
+        verify(pageBuilder, times(0)).addRecord();
+        verify(pageBuilder, times(1)).finish();
+    }
+
+    @Test
+    public void test_preview_with1RecordsResult() throws IOException
+    {
+        when(plugin.isPreview()).thenReturn(true);
+        JsonObject authorizeResponse = data.get("authenticateSuccess").getAsJsonObject();
+        JsonObject searchResponse = data.get("oneRecordResult").getAsJsonObject();
+
+        when(statusLine.getStatusCode())
+            .thenReturn(authorizeResponse.get("statusCode").getAsInt())
+            .thenReturn(searchResponse.get("statusCode").getAsInt());
+        when(response.getEntity())
+            .thenReturn(new StringEntity(authorizeResponse.get("body").toString()))
+            .thenReturn(new StringEntity(searchResponse.get("body").toString()));
+
+        plugin.transaction(config, new Control());
+        // Check credential 1 + loadData 1
+        verify(jiraClient, times(2)).createHttpClient();
+        verify(pageBuilder, times(1)).addRecord();
+        verify(pageBuilder, times(1)).finish();
+    }
+
+    @Test
+    public void test_guess() throws IOException
+    {
+        ConfigSource configSource = TestHelpers.config();
+        JsonObject authorizeResponse = data.get("authenticateSuccess").getAsJsonObject();
+        JsonObject searchResponse = data.get("guessDataResult").getAsJsonObject();
+
+        when(statusLine.getStatusCode())
+            .thenReturn(authorizeResponse.get("statusCode").getAsInt())
+            .thenReturn(searchResponse.get("statusCode").getAsInt());
+        when(response.getEntity())
+            .thenReturn(new StringEntity(searchResponse.get("body").toString()))
+            .thenReturn(new StringEntity(searchResponse.get("body").toString()));
+
+        ConfigDiff result = plugin.guess(configSource);
+        JsonElement expected = data.get("guessResult").getAsJsonObject();
+        JsonElement actual = new JsonParser().parse(result.toString());
+        assertEquals(expected, actual);
+    }
+
+    private class Control implements InputPlugin.Control
+    {
+        @Override
+        public List<TaskReport> run(final TaskSource taskSource, final Schema schema, final int taskCount)
+        {
+            List<TaskReport> reports = new ArrayList<>();
+            for (int i = 0; i < taskCount; i++) {
+                reports.add(plugin.run(taskSource, schema, i, output));
+            }
+            return reports;
+        }
+    }
+}

data/src/test/java/org/embulk/input/jira/JiraPluginTestRuntime.java

@@ -0,0 +1,133 @@
+package org.embulk.input.jira;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.inject.Binder;
+import com.google.inject.Injector;
+import com.google.inject.Module;
+import org.embulk.GuiceBinder;
+import org.embulk.RandomManager;
+import org.embulk.TestPluginSourceModule;
+import org.embulk.TestUtilityModule;
+import org.embulk.config.ConfigSource;
+import org.embulk.config.DataSourceImpl;
+import org.embulk.config.ModelManager;
+import org.embulk.exec.ExecModule;
+import org.embulk.exec.ExtensionServiceLoaderModule;
+import org.embulk.exec.SystemConfigModule;
+import org.embulk.jruby.JRubyScriptingModule;
+import org.embulk.plugin.BuiltinPluginSourceModule;
+import org.embulk.plugin.PluginClassLoaderFactory;
+import org.embulk.plugin.PluginClassLoaderModule;
+import org.embulk.spi.BufferAllocator;
+import org.embulk.spi.Exec;
+import org.embulk.spi.ExecAction;
+import org.embulk.spi.ExecSession;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+import java.util.Random;
+
+/**
+ * This is a clone from {@link org.embulk.EmbulkTestRuntime}, since there is no easy way to extend it.
+ * The only modification is on the provided systemConfig, enable tests to run `embulk/guess/jira.rb`
+ */
+public class JiraPluginTestRuntime extends GuiceBinder
+{
+    private static ConfigSource getSystemConfig()
+    {
+        ObjectNode configNode = JsonNodeFactory.instance.objectNode();
+        configNode.set("jruby_load_path", JsonNodeFactory.instance.arrayNode().add("lib"));
+
+        return new DataSourceImpl(new ModelManager(null, new ObjectMapper()), configNode);
+    }
+
+    public static class TestRuntimeModule implements Module
+    {
+        @Override
+        public void configure(Binder binder)
+        {
+            ConfigSource systemConfig = getSystemConfig();
+            new SystemConfigModule(systemConfig).configure(binder);
+            new ExecModule().configure(binder);
+            new ExtensionServiceLoaderModule(systemConfig).configure(binder);
+            new BuiltinPluginSourceModule().configure(binder);
+            new JRubyScriptingModule(systemConfig).configure(binder);
+            new PluginClassLoaderModule(systemConfig).configure(binder);
+            new TestUtilityModule().configure(binder);
+            new TestPluginSourceModule().configure(binder);
+        }
+    }
+
+    private ExecSession exec;
+
+    public JiraPluginTestRuntime()
+    {
+        super(new TestRuntimeModule());
+        Injector injector = getInjector();
+        ConfigSource execConfig = new DataSourceImpl(injector.getInstance(ModelManager.class));
+        this.exec = ExecSession.builder(injector).fromExecConfig(execConfig).build();
+    }
+
+    public ExecSession getExec()
+    {
+        return exec;
+    }
+
+    public BufferAllocator getBufferAllocator()
+    {
+        return getInstance(BufferAllocator.class);
+    }
+
+    public ModelManager getModelManager()
+    {
+        return getInstance(ModelManager.class);
+    }
+
+    public Random getRandom()
+    {
+        return getInstance(RandomManager.class).getRandom();
+    }
+
+    public PluginClassLoaderFactory getPluginClassLoaderFactory()
+    {
+        return getInstance(PluginClassLoaderFactory.class);
+    }
+
+    @Override
+    public Statement apply(Statement base, Description description)
+    {
+        final Statement superStatement = JiraPluginTestRuntime.super.apply(base, description);
+        return new Statement() {
+            public void evaluate() throws Throwable
+            {
+                try {
+                    Exec.doWith(exec, (ExecAction<Void>) () -> {
+                        try {
+                            superStatement.evaluate();
+                        }
+                        catch (Throwable ex) {
+                            throw new RuntimeExecutionException(ex);
+                        }
+                        return null;
+                    });
+                }
+                catch (RuntimeException ex) {
+                    throw ex.getCause();
+                }
+                finally {
+                    exec.cleanup();
+                }
+            }
+        };
+    }
+
+    private static class RuntimeExecutionException extends RuntimeException
+    {
+        public RuntimeExecutionException(Throwable cause)
+        {
+            super(cause);
+        }
+    }
+}

data/src/test/java/org/embulk/input/jira/TestHelpers.java

@@ -0,0 +1,41 @@
+package org.embulk.input.jira;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.guava.GuavaModule;
+import com.fasterxml.jackson.datatype.joda.JodaModule;
+import com.google.common.io.Resources;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.stream.JsonReader;
+
+import org.embulk.config.ConfigLoader;
+import org.embulk.config.ConfigSource;
+import org.embulk.config.ModelManager;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+
+public final class TestHelpers
+{
+    private TestHelpers() {}
+
+    public static JsonObject getJsonFromFile(String fileName) throws IOException
+     {
+        String path = Resources.getResource(fileName).getPath();
+        try (JsonReader reader = new JsonReader(new FileReader(path))) {
+            JsonParser parser = new JsonParser();
+            return parser.parse(reader).getAsJsonObject();
+        }
+    }
+
+    public static ConfigSource config() throws IOException
+    {
+        String path = Resources.getResource("config.yml").getPath();
+        ObjectMapper mapper = new ObjectMapper()
+                .registerModule(new GuavaModule())
+                .registerModule(new JodaModule());
+        ConfigLoader configLoader = new ConfigLoader(new ModelManager(null, mapper));
+        return configLoader.fromYamlFile(new File(path));
+    }
+}

data/src/test/java/org/embulk/input/jira/client/JiraClientTest.java

@@ -0,0 +1,222 @@
+package org.embulk.input.jira.client;
+
+import com.google.gson.JsonObject;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.StatusLine;
+import org.apache.http.client.HttpClient;
+import org.apache.http.entity.StringEntity;
+import org.embulk.EmbulkTestRuntime;
+import org.embulk.config.ConfigException;
+import org.embulk.input.jira.Issue;
+import org.embulk.input.jira.JiraInputPlugin.PluginTask;
+import org.embulk.input.jira.TestHelpers;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class JiraClientTest
+{
+    @Rule
+    public EmbulkTestRuntime runtime = new EmbulkTestRuntime();
+    private JiraClient jiraClient;
+    private PluginTask task;
+
+    private HttpClient client = Mockito.mock(HttpClient.class);
+    private HttpResponse response = Mockito.mock(HttpResponse.class);
+    private StatusLine statusLine = Mockito.mock(StatusLine.class);
+    private JsonObject data;
+
+    @Before
+    public void setUp() throws IOException
+    {
+        if (jiraClient == null) {
+            jiraClient = Mockito.spy(new JiraClient());
+            response = Mockito.mock(HttpResponse.class);
+            task = TestHelpers.config().loadConfig(PluginTask.class);
+            data = TestHelpers.getJsonFromFile("jira_client.json");
+        }
+        when(jiraClient.createHttpClient()).thenReturn(client);
+        when(client.execute(Mockito.any())).thenReturn(response);
+        when(response.getStatusLine()).thenReturn(statusLine);
+    }
+
+    @Test
+    public void test_checkUserCredentials_success() throws IOException
+    {
+        String dataName =  "credentialSuccess";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        jiraClient.checkUserCredentials(task);
+    }
+
+    @Test
+    public void test_checkUserCredentials_failOn400() throws IOException
+    {
+        String dataName =  "credentialFail400";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        assertThrows("Could not authorize with your credential.", ConfigException.class, () -> jiraClient.checkUserCredentials(task));
+    }
+
+    @Test
+    public void test_checkUserCredentials_failOn401() throws IOException
+    {
+        String dataName =  "credentialFail401";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        assertThrows("Could not authorize with your credential.", ConfigException.class, () -> jiraClient.checkUserCredentials(task));
+    }
+
+    @Test
+    public void test_checkUserCredentials_failOn429() throws IOException
+    {
+        String dataName =  "credentialFail429";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        assertThrows("Could not authorize with your credential due to problems when contacting JIRA API.", ConfigException.class, () -> jiraClient.checkUserCredentials(task));
+    }
+
+    @Test
+    public void test_checkUserCredentials_failOn500() throws IOException
+    {
+        String dataName =  "credentialFail500";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        assertThrows("Could not authorize with your credential due to problems when contacting JIRA API.", ConfigException.class, () -> jiraClient.checkUserCredentials(task));
+    }
+
+    @Test
+    public void test_getTotalCount_success() throws IOException
+    {
+        String dataName =  "totalCountSuccess";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        int totalCount = jiraClient.getTotalCount(task);
+        assertEquals(totalCount, messageResponse.get("body").getAsJsonObject().get("total").getAsInt());
+    }
+
+    @Test
+    public void test_getTotalCount_failOnRetry() throws IOException
+    {
+        String dataName =  "totalCountFailAllTime";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        assertThrows(RuntimeException.class, () -> jiraClient.getTotalCount(task));
+
+        // First try + 3 retry_limit
+        int expectedInvocation = 3 + 1;
+        verify(jiraClient, times(expectedInvocation)).createHttpClient();
+        verify(statusLine, times(expectedInvocation)).getStatusCode();
+    }
+
+    @Test
+    public void test_getTotalCount_doNotRetryOn400Status() throws IOException
+    {
+        String dataName =  "totalCountFail400";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        assertThrows(RuntimeException.class, () -> jiraClient.getTotalCount(task));
+
+        // No retry
+        int expectedInvocation = 1;
+        verify(jiraClient, times(expectedInvocation)).createHttpClient();
+        verify(statusLine, times(expectedInvocation)).getStatusCode();
+    }
+
+    @Test
+    public void test_getTotalCount_retryOnIOException() throws IOException
+    {
+        when(client.execute(Mockito.any())).thenThrow(new IOException("test exeception"));
+
+        assertThrows(RuntimeException.class, () -> jiraClient.getTotalCount(task));
+
+        // First try + 3 retry_limit
+        int expectedInvocation = 3 + 1;
+        verify(jiraClient, times(expectedInvocation)).createHttpClient();
+        // getStatusCode is not triggered
+        verify(statusLine, times(0)).getStatusCode();
+    }
+
+    @Test
+    public void test_searchIssues() throws IOException
+    {
+        String dataName =  "searchIssuesSuccess";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        List<Issue> issues = jiraClient.searchIssues(task, 0, 50);
+        assertEquals(issues.size(), 2);
+    }
+
+    @Test
+    public void test_searchIssues_failJql() throws IOException
+    {
+        String dataName =  "searchIssuesFailJql";
+        JsonObject messageResponse = data.get(dataName).getAsJsonObject();
+
+        int statusCode = messageResponse.get("statusCode").getAsInt();
+        String body = messageResponse.get("body").toString();
+
+        when(statusLine.getStatusCode()).thenReturn(statusCode);
+        when(response.getEntity()).thenReturn(new StringEntity(body));
+
+        assertThrows(ConfigException.class, () -> jiraClient.searchIssues(task, 0, 50));
+    }
+}