embulk-input-zendesk 0.2.14 → 0.3.0

data/src/test/java/org/embulk/input/zendesk/clients/TestZendeskRestClient.java

@@ -0,0 +1,351 @@
+package org.embulk.input.zendesk.clients;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import org.apache.http.Header;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.StatusLine;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpRequestBase;
+import org.apache.http.entity.StringEntity;
+
+import org.embulk.config.ConfigException;
+import org.embulk.config.ConfigSource;
+import org.embulk.input.zendesk.ZendeskInputPlugin;
+import org.embulk.input.zendesk.ZendeskInputPlugin.PluginTask;
+import org.embulk.input.zendesk.utils.ZendeskPluginTestRuntime;
+import org.embulk.input.zendesk.utils.ZendeskTestHelper;
+
+import org.embulk.input.zendesk.utils.ZendeskUtils;
+import org.embulk.spi.InputPlugin;
+import org.embulk.test.TestingEmbulk;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import org.junit.rules.ExpectedException;
+import org.junit.rules.RuleChain;
+import org.junit.rules.TestRule;
+
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import static org.apache.http.HttpHeaders.AUTHORIZATION;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.util.Optional;
+
+public class TestZendeskRestClient
+{
+    private final ExpectedException thrown = ExpectedException.none();
+    private final TestingEmbulk embulk = TestingEmbulk.builder()
+            .registerPlugin(InputPlugin.class, "zendesk", ZendeskInputPlugin.class)
+            .build();
+    public ZendeskPluginTestRuntime runtime = new ZendeskPluginTestRuntime();
+
+    @Rule
+    @SuppressFBWarnings("URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+    public TestRule chain = RuleChain.outerRule(embulk).around(runtime).around(thrown);
+
+    private ZendeskRestClient zendeskRestClient;
+    private PluginTask task = ZendeskTestHelper.getConfigSource("incremental.yml").loadConfig(PluginTask.class);
+    private JsonNode data = ZendeskTestHelper.getJsonFromFile("data/client.json");
+
+    private HttpClient client = Mockito.mock(HttpClient.class);
+    private HttpResponse response = Mockito.mock(HttpResponse.class);
+    private Header header =  mock(Header.class);
+    private StatusLine statusLine = Mockito.mock(StatusLine.class);
+
+    @Before
+    public void prepare() throws IOException
+    {
+        zendeskRestClient = spy(new ZendeskRestClient());
+
+        when(zendeskRestClient.createHttpClient()).thenReturn(client);
+        when(client.execute(any())).thenReturn(response);
+        when(response.getStatusLine()).thenReturn(statusLine);
+    }
+
+    @Test
+    public void doGetSuccess()
+    {
+        setup("doGet200");
+        JsonNode expectedResult = ZendeskTestHelper.getJsonFromFile("data/tickets.json");
+        String result = zendeskRestClient.doGet("dummyString", task, false);
+        assertEquals(expectedResult.toString(), result);
+    }
+
+    @Test
+    public void doGetRetryFail429WithoutRetryAfter()
+    {
+        String expectedMessage = "Number of allowed incremental export API requests per minute exceeded";
+        int expectedRetryTime = 3;
+        testExceptionMessageForDoGet("doGet429", expectedMessage, expectedRetryTime);
+    }
+
+    @Test
+    public void doGetRetryFail429WithRetryAfter()
+    {
+        String expectedMessage = "Number of allowed incremental export API requests per minute exceeded";
+        int expectedRetryTime = 3;
+
+        when(response.containsHeader("x-rate-limit")).thenReturn(true);
+        when(response.getFirstHeader("x-rate-limit")).thenReturn(header);
+        when(response.getFirstHeader("Retry-After")).thenReturn(header);
+        when(header.getValue())
+                .thenReturn("5");
+
+        setupData("doGet429");
+        verifyData(expectedMessage, expectedRetryTime);
+    }
+
+    @Test
+    public void doGetRetry405()
+    {
+        String expectedMessage = "Status '405', message 'dummy text'";
+        int expectedRetryTime = 1;
+
+        testExceptionMessageForDoGet("doGet405", expectedMessage, expectedRetryTime);
+    }
+
+    @Test
+    public void doGetRetry422FailBecauseNotContainTooRecentStartTime()
+    {
+        String expectedMessage = "Status: '422', error message 'dummy text'";
+        int expectedRetryTime = 1;
+        testExceptionMessageForDoGet("doGet422NotContainTooRecentStartTime", expectedMessage, expectedRetryTime);
+    }
+
+    @Test
+    public void doGetNotRetry422BecauseContainTooRecentStartTime()
+    {
+        String expectedMessage = "Status: '422', error message 'dummy text'";
+        int expectedRetryTime = 1;
+        testExceptionMessageForDoGet("doGet422ContainTooRecentStartTime", expectedMessage, expectedRetryTime);
+    }
+
+    @Test
+    public void doGetRetrySuccess429()
+    {
+        setupReTrySuccess("doGet429");
+    }
+
+    @Test
+    public void doGetRetry500()
+    {
+        setupReTrySuccess("doGet500");
+    }
+
+    @Test
+    public void doGetRetry503()
+    {
+        setupReTrySuccess("doGet503");
+    }
+
+    @Test
+    public void doGetRetry404()
+    {
+        setup("doGet404");
+        String expectedMessage = "dummy text";
+        int expectedRetryTime = 1;
+        try {
+            zendeskRestClient.doGet("any", task, false);
+            fail("Should not reach here");
+        }
+        catch (final Exception e) {
+            assertEquals(expectedMessage, e.getMessage());
+        }
+        verify(zendeskRestClient, times(expectedRetryTime)).createHttpClient();
+    }
+
+    @Test
+    public void doGetRetry409()
+    {
+        setupReTrySuccess("doGet409");
+    }
+
+    @Test
+    public void doGetRetryWhenStatusNot400s()
+    {
+        setupReTrySuccess("doGet502");
+    }
+
+    @Test
+    public void doGetRetry503WithRetryAfterNegative()
+    {
+        setup("doGet503");
+
+        int expectedRetryTime = 3;
+        when(response.getFirstHeader("Retry-After")).thenReturn(header);
+        when(header.getValue())
+                .thenReturn("5")
+                .thenReturn("-5");
+
+        try {
+            zendeskRestClient.doGet("any", task, false);
+        }
+        catch (final Exception e) {
+        }
+        verify(zendeskRestClient, times(expectedRetryTime)).createHttpClient();
+    }
+
+    @Test
+    public void doGetRetryWhenThrowIOException() throws IOException
+    {
+        setupRateLimit();
+
+        when(client.execute(any()))
+                .thenThrow(new IOException());
+
+        int expectedRetryTime = 3;
+        assertThrows(ConfigException.class, () -> zendeskRestClient.doGet("any", task, false));
+        verify(zendeskRestClient, times(expectedRetryTime)).createHttpClient();
+    }
+
+    @Test
+    public void authenticationOauthSuccess() throws IOException
+    {
+        setup("doGet200");
+
+        String accessToken = "testzendesk";
+
+        ConfigSource configSource = ZendeskTestHelper.getConfigSource("incremental.yml");
+        configSource.set("auth_method", "oauth");
+        configSource.set("access_token", accessToken);
+        PluginTask pluginTask = configSource.loadConfig(PluginTask.class);
+
+        String expectedValue = "Bearer " + accessToken;
+        setupAndVerifyAuthenticationString(expectedValue, pluginTask);
+    }
+
+    @Test
+    public void authenticationBasicSuccess() throws IOException
+    {
+        setup("doGet200");
+
+        String username = "zendesk_username";
+        String password = "zendesk_password";
+
+        ConfigSource configSource = ZendeskTestHelper.getConfigSource("incremental.yml");
+        configSource.set("auth_method", "basic");
+        configSource.set("username", Optional.of(username));
+        configSource.set("password", password);
+        PluginTask pluginTask = configSource.loadConfig(PluginTask.class);
+
+        String expectedValue = "Basic " + ZendeskUtils.convertBase64(String.format("%s:%s", username, password));
+        setupAndVerifyAuthenticationString(expectedValue, pluginTask);
+    }
+
+    @Test
+    public void authenticationTokenSuccess() throws IOException
+    {
+        setup("doGet200");
+
+        String username = "zendesk_username";
+        String token = "zendesk_token";
+
+        ConfigSource configSource = ZendeskTestHelper.getConfigSource("incremental.yml");
+        configSource.set("auth_method", "token");
+        configSource.set("username", username);
+        configSource.set("token", token);
+        PluginTask pluginTask = configSource.loadConfig(PluginTask.class);
+
+        String expectedValue = "Basic " + ZendeskUtils.convertBase64(String.format("%s/token:%s", username, token));
+        setupAndVerifyAuthenticationString(expectedValue, pluginTask);
+    }
+
+    private void setupRateLimit()
+    {
+        when(response.containsHeader("x-rate-limit")).thenReturn(true);
+        when(response.getFirstHeader("x-rate-limit")).thenReturn(header);
+        when(header.getValue()).thenReturn("400");
+    }
+
+    private void setup(String name)
+    {
+        setupRateLimit();
+        setupData(name);
+    }
+
+    private void setupData(String name)
+    {
+        JsonNode messageResponse = data.get(name);
+        when(statusLine.getStatusCode()).thenReturn(messageResponse.get("statusCode").asInt());
+        try {
+            if (name.equals("doGet200")) {
+                doReturn(new StringEntity(messageResponse.get("body").toString())).when(response).getEntity();
+            }
+            else {
+                doReturn(new StringEntity(messageResponse.get("description").asText())).when(response).getEntity();
+            }
+        }
+        catch (Exception e) {
+            fail("fail to setup client for UT");
+        }
+    }
+
+    private void testExceptionMessageForDoGet(String name, String expectedMessage, int expectedRetryTime)
+    {
+        setup(name);
+        verifyData(expectedMessage, expectedRetryTime);
+    }
+
+    private void verifyData(String expectedMessage, int expectedRetryTime)
+    {
+        try {
+            zendeskRestClient.doGet("any", task, false);
+            fail("Should not reach here");
+        }
+        catch (final Exception e) {
+            assertEquals(expectedMessage, e.getMessage());
+        }
+        verify(zendeskRestClient, times(expectedRetryTime)).createHttpClient();
+    }
+
+    private void setupReTrySuccess(String entityName)
+    {
+        setupRateLimit();
+
+        JsonNode messageResponse = data.get(entityName);
+        JsonNode messageResponseSuccess = data.get("doGet200");
+
+        when(statusLine.getStatusCode())
+                .thenReturn(messageResponse.get("statusCode").asInt())
+                .thenReturn(messageResponseSuccess.get("statusCode").asInt());
+
+        try {
+            when(response.getEntity())
+                    .thenReturn(new StringEntity(messageResponse.get("description").asText()))
+                    .thenReturn(new StringEntity(messageResponseSuccess.get("body").toString()));
+        }
+        catch (Exception e) {
+            fail("fail to setup client for UT");
+        }
+
+        int expectedRetryTime = 2;
+        zendeskRestClient.doGet("any", task, false);
+        verify(zendeskRestClient, times(expectedRetryTime)).createHttpClient();
+    }
+
+    private void setupAndVerifyAuthenticationString(String expectedString, PluginTask pluginTask) throws IOException
+    {
+        zendeskRestClient.doGet("any", pluginTask, false);
+        final ArgumentCaptor<HttpRequestBase> request = ArgumentCaptor.forClass(HttpRequestBase.class);
+        verify(client).execute(request.capture());
+
+        String credential = request.getValue().getFirstHeader(AUTHORIZATION).getValue();
+        assertEquals(expectedString, credential);
+    }
+}

data/src/test/java/org/embulk/input/zendesk/services/TestZendeskSupportAPIService.java

@@ -0,0 +1,172 @@
+package org.embulk.input.zendesk.services;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import org.embulk.EmbulkTestRuntime;
+import org.embulk.config.ConfigSource;
+import org.embulk.input.zendesk.ZendeskInputPlugin;
+import org.embulk.input.zendesk.clients.ZendeskRestClient;
+import org.embulk.input.zendesk.utils.ZendeskTestHelper;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Collections;
+
+public class TestZendeskSupportAPIService
+{
+    @Rule
+    @SuppressFBWarnings("URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+    public EmbulkTestRuntime runtime = new EmbulkTestRuntime();
+
+    private ZendeskRestClient zendeskRestClient;
+
+    private ZendeskSupportAPIService zendeskSupportAPIService;
+
+    @Before
+    public void prepare()
+    {
+        zendeskRestClient = mock(ZendeskRestClient.class);
+    }
+
+    @Test
+    public void buildPathWithIncrementalForPreview()
+    {
+        String expectURL = "https://abc.zendesk.com/api/v2/incremental/tickets.json?start_time=0";
+        setup("incremental.yml");
+        loadData("data/tickets.json");
+        setupTestAndVerifyURL(expectURL, 0, true);
+    }
+
+    @Test
+    public void buildPathWithNonIncrementalForPreview()
+    {
+        String expectURL = "https://abc.zendesk.com/api/v2/ticket_fields.json?sort_by=id&per_page=100&page=0";
+        setup("non-incremental.yml");
+        loadData("data/ticket_fields.json");
+        setupTestAndVerifyURL(expectURL, 0, true);
+    }
+
+    @Test
+    public void buildPathWithIncrementalForPreviewWithTicketMetrics()
+    {
+        String expectURL = "https://abc.zendesk.com/api/v2/incremental/tickets.json?start_time=0&include=metric_sets";
+        loadData("data/ticket_metrics.json");
+
+        ConfigSource src = ZendeskTestHelper.getConfigSource("incremental.yml");
+        src.set("target", "ticket_metrics");
+        ZendeskInputPlugin.PluginTask task = src.loadConfig(ZendeskInputPlugin.PluginTask.class);
+        setupZendeskSupportAPIService(task);
+
+        setupTestAndVerifyURL(expectURL, 0, true);
+    }
+
+    @Test
+    public void buildPathWithIncrementalForRun()
+    {
+        String expectURL = "https://abc.zendesk.com/api/v2/incremental/tickets.json?start_time=0";
+        setup("incremental.yml");
+        loadData("data/tickets.json");
+        setupTestAndVerifyURL(expectURL, 0, false);
+    }
+
+    @Test
+    public void buildPathWithIncrementalForRunWithTicketMetrics()
+    {
+        String expectURL = "https://abc.zendesk.com/api/v2/incremental/tickets.json?start_time=0&include=metric_sets";
+        loadData("data/ticket_metrics.json");
+
+        ConfigSource src = ZendeskTestHelper.getConfigSource("incremental.yml");
+        src.set("target", "ticket_metrics");
+        ZendeskInputPlugin.PluginTask task = src.loadConfig(ZendeskInputPlugin.PluginTask.class);
+        setupZendeskSupportAPIService(task);
+
+        setupTestAndVerifyURL(expectURL, 0, false);
+    }
+
+    @Test
+    public void buildPathWithIncrementalForRunIncludeRelatedObject()
+    {
+        String expectURL = "https://abc.zendesk.com/api/v2/incremental/tickets.json?start_time=0";
+        loadData("data/tickets.json");
+
+        ConfigSource src = ZendeskTestHelper.getConfigSource("incremental.yml");
+        src.set("includes", Collections.singletonList("organizations"));
+        ZendeskInputPlugin.PluginTask task = src.loadConfig(ZendeskInputPlugin.PluginTask.class);
+        setupZendeskSupportAPIService(task);
+
+        setupTestAndVerifyURL(expectURL, 0, false);
+    }
+
+    @Test
+    public void buildPathWithIncrementalForRunTimeChange()
+    {
+        long time = 100;
+        String expectURL = "https://abc.zendesk.com/api/v2/incremental/tickets.json?start_time=100";
+        loadData("data/tickets.json");
+
+        ConfigSource src = ZendeskTestHelper.getConfigSource("incremental.yml");
+        ZendeskInputPlugin.PluginTask task = src.loadConfig(ZendeskInputPlugin.PluginTask.class);
+        setupZendeskSupportAPIService(task);
+
+        zendeskSupportAPIService.getData("", 0, false, time);
+        final ArgumentCaptor<String> url = ArgumentCaptor.forClass(String.class);
+        verify(zendeskRestClient).doGet(url.capture(), any(), anyBoolean());
+        assertEquals(expectURL, url.getValue());
+    }
+
+    @Test
+    public void buildPathWithNonIncrementalForRun()
+    {
+        String expectURL = "https://abc.zendesk.com/api/v2/ticket_fields.json?sort_by=id&per_page=100&page=0";
+        setup("non-incremental.yml");
+        loadData("data/ticket_fields.json");
+
+        setupTestAndVerifyURL(expectURL, 0, false);
+    }
+
+    @Test
+    public void buildPathWithNonIncrementalForRunChangePageNumber()
+    {
+        String expectURL = "https://abc.zendesk.com/api/v2/ticket_fields.json?sort_by=id&per_page=100&page=2";
+        setup("non-incremental.yml");
+        loadData("data/ticket_fields.json");
+        setupTestAndVerifyURL(expectURL, 2, false);
+    }
+
+    private void loadData(String fileName)
+    {
+        JsonNode dataJson = ZendeskTestHelper.getJsonFromFile(fileName);
+        when(zendeskRestClient.doGet(any(), any(), anyBoolean())).thenReturn(dataJson.toString());
+    }
+
+    private void setupZendeskSupportAPIService(ZendeskInputPlugin.PluginTask task)
+    {
+        zendeskSupportAPIService = spy(new ZendeskSupportAPIService(task));
+        when(zendeskSupportAPIService.getZendeskRestClient()).thenReturn(zendeskRestClient);
+    }
+
+    private void setup(String file)
+    {
+        ZendeskInputPlugin.PluginTask task = ZendeskTestHelper.getConfigSource(file)
+                .loadConfig(ZendeskInputPlugin.PluginTask.class);
+        setupZendeskSupportAPIService(task);
+    }
+
+    private void setupTestAndVerifyURL(String expectURL, int page, boolean isPreview)
+    {
+        zendeskSupportAPIService.getData("", page, isPreview, 0);
+        final ArgumentCaptor<String> url = ArgumentCaptor.forClass(String.class);
+        verify(zendeskRestClient).doGet(url.capture(), any(), anyBoolean());
+        assertEquals(expectURL, url.getValue());
+    }
+}