embulk-input-marketo-through-proxy 0.6.20

data/src/test/java/org/embulk/input/marketo/delegate/LeadWithListInputPluginTest.java

@@ -0,0 +1,132 @@
+package org.embulk.input.marketo.delegate;
+
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.apache.commons.lang3.StringUtils;
+import org.embulk.EmbulkTestRuntime;
+import org.embulk.base.restclient.ServiceResponseMapper;
+import org.embulk.base.restclient.record.RecordImporter;
+import org.embulk.base.restclient.record.ValueLocator;
+import org.embulk.config.ConfigLoader;
+import org.embulk.config.ConfigSource;
+import org.embulk.input.marketo.MarketoService;
+import org.embulk.input.marketo.MarketoUtils;
+import org.embulk.input.marketo.model.MarketoField;
+import org.embulk.input.marketo.rest.MarketoRestClient;
+import org.embulk.input.marketo.rest.RecordPagingIterable;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.Schema;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anySet;
+import static org.mockito.ArgumentMatchers.eq;
+
+/**
+ * Created by tai.khuu on 10/10/17.
+ */
+public class LeadWithListInputPluginTest
+{
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+    @Rule
+    public EmbulkTestRuntime embulkTestRuntime = new EmbulkTestRuntime();
+
+    private ConfigSource configSource;
+
+    private LeadWithListInputPlugin leadWithListInputPlugin;
+
+    private MarketoRestClient mockMarketoRestClient;
+
+    @Before
+    public void setUp() throws Exception
+    {
+        leadWithListInputPlugin = Mockito.spy(new LeadWithListInputPlugin());
+        ConfigLoader configLoader = embulkTestRuntime.getInjector().getInstance(ConfigLoader.class);
+        configSource = configLoader.fromYaml(this.getClass().getResourceAsStream("/config/rest_config.yaml"));
+        mockMarketoRestClient = Mockito.mock(MarketoRestClient.class);
+        Mockito.doReturn(mockMarketoRestClient).when(leadWithListInputPlugin).createMarketoRestClient(any(LeadWithListInputPlugin.PluginTask.class));
+    }
+
+    @Test
+    public void testRun() throws IOException
+    {
+        RecordPagingIterable<ObjectNode> mockLeadRecordPagingIterable = Mockito.mock(RecordPagingIterable.class);
+        RecordPagingIterable<ObjectNode> mockLeadEmptyRecordPagingIterable = Mockito.mock(RecordPagingIterable.class);
+        RecordPagingIterable<ObjectNode> mocklistRecords = Mockito.mock(RecordPagingIterable.class);
+
+        Mockito.when(mockLeadEmptyRecordPagingIterable.iterator()).thenReturn(new ArrayList<ObjectNode>().iterator());
+        JavaType objectNodeListType = OBJECT_MAPPER.getTypeFactory().constructParametrizedType(List.class, List.class, ObjectNode.class);
+        JavaType marketoFieldsType = OBJECT_MAPPER.getTypeFactory().constructParametrizedType(List.class, List.class, MarketoField.class);
+        List<ObjectNode> leads = OBJECT_MAPPER.readValue(this.getClass().getResourceAsStream("/fixtures/lead_response_full.json"), objectNodeListType);
+        List<ObjectNode> lists = OBJECT_MAPPER.readValue(this.getClass().getResourceAsStream("/fixtures/list_reponse_full.json"), objectNodeListType);
+        Mockito.when(mocklistRecords.iterator()).thenReturn(lists.iterator());
+        List<MarketoField> marketoFields = OBJECT_MAPPER.readValue(this.getClass().getResourceAsStream("/fixtures/lead_describe_marketo_fields_full.json"), marketoFieldsType);
+        Mockito.when(mockLeadRecordPagingIterable.iterator()).thenReturn(leads.iterator());
+        Mockito.when(mockMarketoRestClient.describeLead()).thenReturn(marketoFields);
+        Mockito.when(mockMarketoRestClient.getLists()).thenReturn(mocklistRecords);
+        List<String> fieldNameFromMarketoFields = MarketoUtils.getFieldNameFromMarketoFields(marketoFields);
+        String fieldNameString = StringUtils.join(fieldNameFromMarketoFields, ",");
+        Mockito.when(mockMarketoRestClient.getLeadsByList(Mockito.anyString(), eq(fieldNameString))).thenReturn(mockLeadEmptyRecordPagingIterable);
+        Mockito.when(mockMarketoRestClient.getLeadsByList("1009", fieldNameString)).thenReturn(mockLeadRecordPagingIterable);
+
+        LeadWithListInputPlugin.PluginTask task = configSource.loadConfig(LeadWithListInputPlugin.PluginTask.class);
+        ServiceResponseMapper<? extends ValueLocator> mapper = leadWithListInputPlugin.buildServiceResponseMapper(task);
+
+        RecordImporter recordImporter = mapper.createRecordImporter();
+        PageBuilder mockPageBuilder = Mockito.mock(PageBuilder.class);
+        leadWithListInputPlugin.ingestServiceData(task, recordImporter, 1, mockPageBuilder);
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).getLists();
+        Mockito.verify(mockMarketoRestClient, Mockito.times(24)).getLeadsByList(Mockito.anyString(), eq(fieldNameString));
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).describeLead();
+
+        Schema embulkSchema = mapper.getEmbulkSchema();
+        ArgumentCaptor<Long> longArgumentCaptor = ArgumentCaptor.forClass(Long.class);
+
+        Mockito.verify(mockPageBuilder, Mockito.times(300)).setLong(eq(embulkSchema.lookupColumn("mk_id")), longArgumentCaptor.capture());
+        Mockito.verify(mockPageBuilder, Mockito.times(300)).setString(eq(embulkSchema.lookupColumn("mk_listId")), eq("1009"));
+
+        List<Long> allValues = longArgumentCaptor.getAllValues();
+        long actualValue = allValues.get(0);
+        assertEquals(103280L, actualValue);
+    }
+
+    @Test
+    public void testGetListsByIds()
+    {
+        ConfigSource cfgWithInputIds = configSource.set("list_ids", "123,12333").set("skip_invalid_list_id", true);
+        LeadWithListInputPlugin.PluginTask task = cfgWithInputIds.loadConfig(LeadWithListInputPlugin.PluginTask.class);
+        MarketoService service = Mockito.mock(MarketoService.class);
+        Mockito.doReturn(Arrays.asList(new ObjectMapper().createObjectNode().put("id", "123"))).when(service).getListsByIds(anySet());
+
+        leadWithListInputPlugin.getServiceRecords(service, task);
+
+        Mockito.verify(service, Mockito.times(1)).getListsByIds(anySet());
+        Mockito.verify(service, Mockito.never()).getLists();
+        Mockito.verify(service, Mockito.times(1)).getAllListLead(anyList(), anyList());
+    }
+
+    @Test
+    public void testGetAllLists()
+    {
+        LeadWithListInputPlugin.PluginTask task = configSource.loadConfig(LeadWithListInputPlugin.PluginTask.class);
+        MarketoService service = Mockito.mock(MarketoService.class);
+        leadWithListInputPlugin.getServiceRecords(service, task);
+
+        Mockito.verify(service, Mockito.never()).getListsByIds(anySet());
+        Mockito.verify(service, Mockito.times(1)).getLists();
+        Mockito.verify(service, Mockito.times(1)).getAllListLead(anyList(), anyList());
+    }
+}

data/src/test/java/org/embulk/input/marketo/delegate/LeadWithProgramInputPluginTest.java

@@ -0,0 +1,134 @@
+package org.embulk.input.marketo.delegate;
+
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.apache.commons.lang3.StringUtils;
+import org.embulk.EmbulkTestRuntime;
+import org.embulk.base.restclient.ServiceResponseMapper;
+import org.embulk.base.restclient.record.RecordImporter;
+import org.embulk.base.restclient.record.ValueLocator;
+import org.embulk.config.ConfigLoader;
+import org.embulk.config.ConfigSource;
+import org.embulk.input.marketo.MarketoService;
+import org.embulk.input.marketo.MarketoUtils;
+import org.embulk.input.marketo.model.MarketoField;
+import org.embulk.input.marketo.rest.MarketoRestClient;
+import org.embulk.input.marketo.rest.RecordPagingIterable;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.Schema;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anySet;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+
+/**
+ * Created by tai.khuu on 10/10/17.
+ */
+public class LeadWithProgramInputPluginTest
+{
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+    @Rule
+    public EmbulkTestRuntime embulkTestRuntime = new EmbulkTestRuntime();
+
+    private ConfigSource configSource;
+
+    private LeadWithProgramInputPlugin leadWithProgramInputPlugin;
+
+    private MarketoRestClient mockMarketoRestClient;
+
+    @Before
+    public void setUp() throws Exception
+    {
+        leadWithProgramInputPlugin = Mockito.spy(new LeadWithProgramInputPlugin());
+        ConfigLoader configLoader = embulkTestRuntime.getInjector().getInstance(ConfigLoader.class);
+        configSource = configLoader.fromYaml(this.getClass().getResourceAsStream("/config/rest_config.yaml"));
+        mockMarketoRestClient = Mockito.mock(MarketoRestClient.class);
+        Mockito.doReturn(mockMarketoRestClient).when(leadWithProgramInputPlugin).createMarketoRestClient(any(LeadWithProgramInputPlugin.PluginTask.class));
+    }
+
+    @Test
+    public void testRun() throws IOException
+    {
+        RecordPagingIterable<ObjectNode> mockLeadRecordPagingIterable = Mockito.mock(RecordPagingIterable.class);
+        RecordPagingIterable<ObjectNode> mockLeadEmptyRecordPagingIterable = Mockito.mock(RecordPagingIterable.class);
+        RecordPagingIterable<ObjectNode> mockProgramRecords = Mockito.mock(RecordPagingIterable.class);
+
+        Mockito.when(mockLeadEmptyRecordPagingIterable.iterator()).thenReturn(new ArrayList<ObjectNode>().iterator());
+        JavaType objectNodeListType = OBJECT_MAPPER.getTypeFactory().constructParametrizedType(List.class, List.class, ObjectNode.class);
+        JavaType marketoFieldsType = OBJECT_MAPPER.getTypeFactory().constructParametrizedType(List.class, List.class, MarketoField.class);
+        List<ObjectNode> leads = OBJECT_MAPPER.readValue(this.getClass().getResourceAsStream("/fixtures/lead_with_program_full.json"), objectNodeListType);
+        List<ObjectNode> programs = OBJECT_MAPPER.readValue(this.getClass().getResourceAsStream("/fixtures/all_program_full.json"), objectNodeListType);
+        Mockito.when(mockProgramRecords.iterator()).thenReturn(programs.iterator());
+        List<MarketoField> marketoFields = OBJECT_MAPPER.readValue(this.getClass().getResourceAsStream("/fixtures/lead_describe_marketo_fields_full.json"), marketoFieldsType);
+        Mockito.when(mockLeadRecordPagingIterable.iterator()).thenReturn(leads.iterator());
+        Mockito.when(mockMarketoRestClient.describeLead()).thenReturn(marketoFields);
+        Mockito.when(mockMarketoRestClient.getPrograms()).thenReturn(mockProgramRecords);
+        List<String> fieldNameFromMarketoFields = MarketoUtils.getFieldNameFromMarketoFields(marketoFields);
+        String fieldNameString = StringUtils.join(fieldNameFromMarketoFields, ",");
+        Mockito.when(mockMarketoRestClient.getLeadsByProgram(anyString(), eq(fieldNameString))).thenReturn(mockLeadEmptyRecordPagingIterable);
+        Mockito.when(mockMarketoRestClient.getLeadsByProgram("1003", fieldNameString)).thenReturn(mockLeadRecordPagingIterable);
+
+        LeadWithProgramInputPlugin.PluginTask task = configSource.loadConfig(LeadWithProgramInputPlugin.PluginTask.class);
+        ServiceResponseMapper<? extends ValueLocator> mapper = leadWithProgramInputPlugin.buildServiceResponseMapper(task);
+
+        RecordImporter recordImporter = mapper.createRecordImporter();
+        PageBuilder mockPageBuilder = Mockito.mock(PageBuilder.class);
+
+        leadWithProgramInputPlugin.ingestServiceData(task, recordImporter, 1, mockPageBuilder);
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).getPrograms();
+        Mockito.verify(mockMarketoRestClient, Mockito.times(3)).getLeadsByProgram(anyString(), eq(fieldNameString));
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).describeLead();
+
+        Schema embulkSchema = mapper.getEmbulkSchema();
+        ArgumentCaptor<Long> longArgumentCaptor = ArgumentCaptor.forClass(Long.class);
+
+        Mockito.verify(mockPageBuilder, Mockito.times(1)).setLong(eq(embulkSchema.lookupColumn("mk_id")), longArgumentCaptor.capture());
+        Mockito.verify(mockPageBuilder, Mockito.times(1)).setString(eq(embulkSchema.lookupColumn("mk_programId")), eq("1003"));
+
+        List<Long> allValues = longArgumentCaptor.getAllValues();
+        long actualValue = allValues.get(0);
+        assertEquals(102519L, actualValue);
+    }
+
+    @Test
+    public void testGetProgramsByIds()
+    {
+        ConfigSource cfgWithInputIds = configSource.set("program_ids", "123,12333").set("skip_invalid_program_id", true);
+        LeadWithProgramInputPlugin.PluginTask task = cfgWithInputIds.loadConfig(LeadWithProgramInputPlugin.PluginTask.class);
+        MarketoService service = Mockito.mock(MarketoService.class);
+        Mockito.doReturn(Arrays.asList(new ObjectMapper().createObjectNode().put("id", "123"))).when(service).getProgramsByIds(anySet());
+
+        leadWithProgramInputPlugin.getServiceRecords(service, task);
+
+        Mockito.verify(service, Mockito.times(1)).getProgramsByIds(anySet());
+        Mockito.verify(service, Mockito.never()).getPrograms();
+        Mockito.verify(service, Mockito.times(1)).getAllProgramLead(anyList(), anyList());
+    }
+
+    @Test
+    public void testGetAllLists()
+    {
+        LeadWithProgramInputPlugin.PluginTask task = configSource.loadConfig(LeadWithProgramInputPlugin.PluginTask.class);
+        MarketoService service = Mockito.mock(MarketoService.class);
+        leadWithProgramInputPlugin.getServiceRecords(service, task);
+
+        Mockito.verify(service, Mockito.never()).getProgramsByIds(anySet());
+        Mockito.verify(service, Mockito.times(1)).getPrograms();
+        Mockito.verify(service, Mockito.times(1)).getAllProgramLead(anyList(), anyList());
+    }
+}

data/src/test/java/org/embulk/input/marketo/delegate/MarketoBaseBulkExtractInputPluginTest.java

@@ -0,0 +1,171 @@
+package org.embulk.input.marketo.delegate;
+
+import com.google.common.base.Optional;
+import org.embulk.EmbulkTestRuntime;
+import org.embulk.config.ConfigDiff;
+import org.embulk.config.ConfigException;
+import org.embulk.config.ConfigLoader;
+import org.embulk.config.ConfigSource;
+import org.embulk.config.TaskReport;
+import org.embulk.input.marketo.MarketoInputPluginDelegate;
+import org.embulk.input.marketo.MarketoUtils;
+import org.embulk.spi.Schema;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.time.Instant;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
+import java.util.Date;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Created by khuutantaitai on 10/3/17.
+ */
+public class MarketoBaseBulkExtractInputPluginTest
+{
+    @Rule
+    public EmbulkTestRuntime embulkTestRuntime = new EmbulkTestRuntime();
+
+    private MarketoBaseBulkExtractInputPlugin<MarketoBaseBulkExtractInputPlugin.PluginTask> baseBulkExtractInputPlugin;
+    private MarketoBaseBulkExtractInputPlugin.PluginTask validBaseTask;
+
+    @Before
+    public void prepare() throws IOException
+    {
+        baseBulkExtractInputPlugin = Mockito.mock(MarketoBaseBulkExtractInputPlugin.class, Mockito.CALLS_REAL_METHODS);
+        ConfigLoader configLoader = embulkTestRuntime.getInjector().getInstance(ConfigLoader.class);
+        ConfigSource configSource = configLoader.fromYaml(
+                this.getClass().getResourceAsStream("/config/activity_bulk_extract_config.yaml"));
+        validBaseTask = configSource.loadConfig(MarketoBaseBulkExtractInputPlugin.PluginTask.class);
+    }
+
+    @Test(expected = ConfigException.class)
+    public void validateInputTaskError()
+    {
+        MarketoBaseBulkExtractInputPlugin.PluginTask pluginTask = Mockito.mock(MarketoBaseBulkExtractInputPlugin.PluginTask.class);
+        Mockito.when(pluginTask.getFromDate()).thenReturn(null);
+        baseBulkExtractInputPlugin.validateInputTask(pluginTask);
+    }
+
+    @Test(expected = ConfigException.class)
+    public void invalidInputTaskWhenIncrementalByUpdatedAt()
+    {
+        MarketoBaseBulkExtractInputPlugin.PluginTask task = mock(
+                MarketoBaseBulkExtractInputPlugin.PluginTask.class,
+                delegatesTo(validBaseTask));
+        when(task.getIncrementalColumn()).thenReturn(Optional.of("updatedAt"));
+        when(task.getIncremental()).thenReturn(true);
+        baseBulkExtractInputPlugin.validateInputTask(task);
+    }
+
+    @Test
+    public void validInputTaskWhenIncrementalOtherThanUpdatedAt()
+    {
+        MarketoBaseBulkExtractInputPlugin.PluginTask task = mock(
+                MarketoBaseBulkExtractInputPlugin.PluginTask.class,
+                delegatesTo(validBaseTask));
+        when(task.getIncremental()).thenReturn(true);
+        when(task.getIncrementalColumn()).thenReturn(Optional.of("anythingButUpdatedAt"));
+        baseBulkExtractInputPlugin.validateInputTask(task);  // should not throw
+    }
+
+    @Test
+    public void validInputTaskWhenNonIncrementalWhileSetUpdatedAt()
+    {
+        MarketoBaseBulkExtractInputPlugin.PluginTask task = mock(
+                MarketoBaseBulkExtractInputPlugin.PluginTask.class,
+                delegatesTo(validBaseTask));
+        when(task.getIncremental()).thenReturn(false);
+        when(task.getIncrementalColumn()).thenReturn(Optional.of("updatedAt"));
+        baseBulkExtractInputPlugin.validateInputTask(task);  // should not throw
+    }
+
+    @Test()
+    public void validateInputTaskToDateLessThanJobStartTime()
+    {
+        Date fromDate = new Date(1504224000000L);
+        OffsetDateTime jobStartTime = OffsetDateTime.ofInstant(Instant.ofEpochMilli(1506842144000L), ZoneOffset.UTC);
+        MarketoBaseBulkExtractInputPlugin.PluginTask pluginTask = Mockito.mock(MarketoBaseBulkExtractInputPlugin.PluginTask.class);
+        Mockito.when(pluginTask.getFromDate()).thenReturn(fromDate);
+        Mockito.when(pluginTask.getJobStartTime()).thenReturn(jobStartTime.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME));
+        Mockito.when(pluginTask.getFetchDays()).thenReturn(7);
+        baseBulkExtractInputPlugin.validateInputTask(pluginTask);
+        ArgumentCaptor<Optional<Date>> argumentCaptor = ArgumentCaptor.forClass(Optional.class);
+        Mockito.verify(pluginTask, Mockito.times(1)).setToDate(argumentCaptor.capture());
+        assertEquals(1504828800000L, argumentCaptor.getValue().get().getTime());
+    }
+
+    @Test()
+    public void validateInputTaskFromDateMoreThanJobStartTime()
+    {
+        Date fromDate = new Date(1507619744000L);
+        OffsetDateTime jobStartTime = OffsetDateTime.ofInstant(Instant.ofEpochMilli(1506842144000L), ZoneOffset.UTC);
+        MarketoBaseBulkExtractInputPlugin.PluginTask pluginTask = Mockito.mock(MarketoBaseBulkExtractInputPlugin.PluginTask.class);
+        Mockito.when(pluginTask.getFromDate()).thenReturn(fromDate);
+        Mockito.when(pluginTask.getJobStartTime()).thenReturn(jobStartTime.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME));
+
+        try {
+            baseBulkExtractInputPlugin.validateInputTask(pluginTask);
+        }
+        catch (ConfigException ex) {
+            return;
+        }
+        fail();
+    }
+
+    @Test()
+    public void validateInputTaskToDateMoreThanJobStartTime()
+    {
+        Date fromDate = new Date(1504224000000L);
+        OffsetDateTime jobStartTime = OffsetDateTime.ofInstant(Instant.ofEpochMilli(1504396800000L), ZoneOffset.UTC);
+        MarketoBaseBulkExtractInputPlugin.PluginTask pluginTask = Mockito.mock(MarketoBaseBulkExtractInputPlugin.PluginTask.class);
+        Mockito.when(pluginTask.getFromDate()).thenReturn(fromDate);
+        Mockito.when(pluginTask.getFetchDays()).thenReturn(7);
+        Mockito.when(pluginTask.getJobStartTime()).thenReturn(jobStartTime.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME));
+        baseBulkExtractInputPlugin.validateInputTask(pluginTask);
+        ArgumentCaptor<Optional<Date>> toDateArgumentCaptor = ArgumentCaptor.forClass(Optional.class);
+        Mockito.verify(pluginTask, Mockito.times(1)).setToDate(toDateArgumentCaptor.capture());
+        assertEquals(jobStartTime.toInstant().toEpochMilli(), toDateArgumentCaptor.getValue().get().getTime());
+    }
+
+    @Test
+    public void getToDate()
+    {
+        OffsetDateTime date = OffsetDateTime.ofInstant(Instant.ofEpochMilli(1505033728000L), ZoneOffset.UTC);
+        OffsetDateTime jobStartTime = OffsetDateTime.ofInstant(Instant.ofEpochMilli(1507625728000L), ZoneOffset.UTC);
+        MarketoBaseBulkExtractInputPlugin.PluginTask pluginTask = Mockito.mock(MarketoInputPluginDelegate.PluginTask.class);
+        Mockito.when(pluginTask.getFromDate()).thenReturn(Date.from(date.toInstant()));
+        Mockito.when(pluginTask.getFetchDays()).thenReturn(30);
+        Mockito.when(pluginTask.getJobStartTime()).thenReturn(jobStartTime.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME));
+        OffsetDateTime toDate = baseBulkExtractInputPlugin.getToDate(pluginTask);
+        assertEquals(toDate, jobStartTime);
+    }
+
+    @Test
+    public void buildConfigDiff()
+    {
+        TaskReport taskReport1 = Mockito.mock(TaskReport.class);
+        MarketoInputPluginDelegate.PluginTask task = Mockito.mock(MarketoInputPluginDelegate.PluginTask.class);
+        Mockito.when(task.getIncremental()).thenReturn(true);
+        Mockito.when(task.getIncrementalColumn()).thenReturn(Optional.of("createdAt"));
+        Date toDate = new Date(1507625728000L);
+        Mockito.when(task.getToDate()).thenReturn(Optional.of(toDate));
+        ConfigDiff configDiff = baseBulkExtractInputPlugin.buildConfigDiff(task, Mockito.mock(Schema.class), 1, Arrays.asList(taskReport1));
+        DateFormat df = new SimpleDateFormat(MarketoUtils.MARKETO_DATE_SIMPLE_DATE_FORMAT);
+        assertEquals(df.format(toDate), configDiff.get(String.class, "from_date"));
+    }
+}

data/src/test/java/org/embulk/input/marketo/delegate/MarketoBaseInputPluginDelegateTest.java

@@ -0,0 +1,60 @@
+package org.embulk.input.marketo.delegate;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.collect.Lists;
+import org.apache.commons.lang3.StringUtils;
+import org.embulk.EmbulkTestRuntime;
+import org.embulk.config.ConfigException;
+import org.embulk.input.marketo.MarketoService;
+import org.junit.Rule;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+
+import static org.embulk.input.marketo.delegate.MarketoBaseInputPluginDelegate.ID_LIST_SEPARATOR_CHAR;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.anySet;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+
+public class MarketoBaseInputPluginDelegateTest
+{
+    @Rule
+    public EmbulkTestRuntime embulkTestRuntime = new EmbulkTestRuntime();
+    private final ObjectMapper mapper = new ObjectMapper();
+    private MarketoService service = mock(MarketoService.class);
+    MarketoBaseInputPluginDelegate delegate = spy(MarketoBaseInputPluginDelegate.class);
+
+    @Test
+    public void testInputIds()
+    {
+        doReturn(getSampleResp(), Collections.emptyList(), Collections.emptyList()).when(service).getListsByIds(anySet());
+        Function<Set<String>, Iterable<ObjectNode>> getListIds = (ids) -> service.getListsByIds(ids);
+
+        final String[] ids = StringUtils.split("123,abc,,123.45,1002 ", ID_LIST_SEPARATOR_CHAR);
+        Iterable<ObjectNode> rs1 = delegate.getObjectsByIds(ids, getListIds);
+        assertEquals(Lists.newArrayList(rs1).size(), 1);
+
+        final String[] nullIds = StringUtils.split("  , ,  ,, ", ID_LIST_SEPARATOR_CHAR);
+        ConfigException exception = assertThrows(ConfigException.class, () -> delegate.getObjectsByIds(nullIds, getListIds));
+        assertEquals("No valid Id specified", exception.getMessage());
+
+        final String[] notExist = StringUtils.split(" 123 ,3453 ,  234234,,", ID_LIST_SEPARATOR_CHAR);
+        exception = assertThrows(ConfigException.class, () -> delegate.getObjectsByIds(notExist, getListIds));
+        assertEquals("No valid Id found", exception.getMessage());
+    }
+
+    private Iterable<ObjectNode> getSampleResp()
+    {
+        List<ObjectNode> objects = new ArrayList<>();
+        objects.add(mapper.createObjectNode().put("id", 1002));
+        return objects;
+    }
+}