embulk-input-marketo-through-proxy 0.6.20

data/src/main/java/org/embulk/input/marketo/rest/RecordPagingIterable.java

@@ -0,0 +1,180 @@
+package org.embulk.input.marketo.rest;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/**
+ * Record Iterable class that will go through Marketo Paging
+ * Warning this iterator implementation do not cached page due to reduce memory usage. So iterate through a
+ * RecordIterate multiple time is not recommended since it will sent query to Marketo on every call.
+ * Created by tai.khuu on 9/5/17.
+ */
+public class RecordPagingIterable<T> implements Iterable<T>
+{
+    private PagingFunction<Page<T>> pagingFunction;
+
+    public RecordPagingIterable(PagingFunction pagingFunction)
+    {
+        this.pagingFunction = pagingFunction;
+    }
+
+    @Override
+    public Iterator<T> iterator()
+    {
+        return this.new RecordIterator();
+    }
+
+    private class RecordIterator implements Iterator<T>
+    {
+        Page<T> currentPage;
+        private Iterator<T> currentIterator;
+
+        public RecordIterator()
+        {
+        }
+
+        @Override
+        public boolean hasNext()
+        {
+            if (currentPage == null) {
+                currentPage = pagingFunction.getFirstPage();
+                this.currentIterator = currentPage.getRecordsIter();
+            }
+            if (currentIterator.hasNext()) {
+                return true;
+            }
+            if (!currentPage.hasNext) {
+                return false;
+            }
+            Page<T> nextPage = pagingFunction.getNextPage(currentPage);
+            currentIterator = nextPage.getRecordsIter();
+            currentPage = nextPage;
+            return currentIterator.hasNext();
+        }
+
+        @Override
+        public T next()
+        {
+            if (!hasNext()) {
+                throw new NoSuchElementException("Call next on an empty iterator");
+            }
+            return currentIterator.next();
+        }
+
+        @Override
+        public void remove()
+        {
+            throw new UnsupportedOperationException("RecordIterator not support remove");
+        }
+    }
+
+    public interface PagingFunction<P extends Page>
+    {
+        P getNextPage(P currentPage);
+        /**
+         * All implementation must make sure calling get first page multiple time should always return.
+         * @return P
+         */
+        P getFirstPage();
+    }
+
+    public static class Page<T>
+    {
+        private Iterable<T> records;
+
+        private boolean hasNext;
+
+        public Page(Iterable<T> records, boolean hasNext)
+        {
+            this.records = records;
+            this.hasNext = hasNext;
+        }
+
+        public Iterable<T> getRecords()
+        {
+            return records;
+        }
+        public Iterator<T> getRecordsIter()
+        {
+            return records.iterator();
+        }
+        public void setRecords(List<T> records)
+        {
+            this.records = records;
+        }
+
+        public boolean isHasNext()
+        {
+            return hasNext;
+        }
+
+        public void setHasNext(boolean hasNext)
+        {
+            this.hasNext = hasNext;
+        }
+    }
+
+    public static class TokenPage<T> extends Page<T>
+    {
+        private String nextPageToken;
+
+        public TokenPage(Iterable<T> records, String nextPageToken, boolean moreResult)
+        {
+            super(records, moreResult);
+            this.nextPageToken = nextPageToken;
+        }
+
+        public String getNextPageToken()
+        {
+            return nextPageToken;
+        }
+
+        public void setNextPageToken(String nextPageToken)
+        {
+            this.nextPageToken = nextPageToken;
+        }
+    }
+
+    public static class OffsetPage<T> extends Page<T>
+    {
+        private int nextOffSet;
+
+        public OffsetPage(Iterable<T> records, int nextOffSet, boolean moreResult)
+        {
+            super(records, moreResult);
+            this.nextOffSet = nextOffSet;
+        }
+
+        public int getNextOffSet()
+        {
+            return nextOffSet;
+        }
+    }
+    public static class OffsetWithTokenPage<T> extends Page<T>
+    {
+        private int nextOffSet;
+        private String nextPageToken;
+        public OffsetWithTokenPage(Iterable<T> records, int nextOffSet, String nextPageToken, boolean moreResult)
+        {
+            super(records, moreResult);
+            this.nextOffSet = nextOffSet;
+            this.nextPageToken = nextPageToken;
+        }
+
+        public int getNextOffSet()
+        {
+            return nextOffSet;
+        }
+
+        public String getNextPageToken()
+        {
+            return nextPageToken;
+        }
+
+        public void setNextPageToken(String nextPageToken)
+        {
+            this.nextPageToken = nextPageToken;
+        }
+    }
+}

data/src/test/java/org/embulk/input/marketo/MarketoServiceImplTest.java

@@ -0,0 +1,147 @@
+package org.embulk.input.marketo;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.io.ByteStreams;
+import org.embulk.EmbulkTestRuntime;
+import org.embulk.input.marketo.model.BulkExtractRangeHeader;
+import org.embulk.input.marketo.rest.MarketoRestClient;
+import org.embulk.input.marketo.rest.RecordPagingIterable;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+import static org.mockito.ArgumentMatchers.any;
+
+/**
+ * Created by tai.khuu on 10/9/17.
+ */
+public class MarketoServiceImplTest
+{
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+    @Rule
+    public EmbulkTestRuntime embulkTestRuntime = new EmbulkTestRuntime();
+    private MarketoService marketoService;
+
+    private MarketoRestClient mockMarketoRestClient;
+    @Before
+    public void prepare()
+    {
+        mockMarketoRestClient = Mockito.mock(MarketoRestClient.class);
+        marketoService = new MarketoServiceImpl(mockMarketoRestClient);
+    }
+
+    @Test
+    public void extractLead() throws Exception
+    {
+        Date startDate = new Date(1507223374000L);
+        Date endDate = new Date(1507655374000L);
+        List<String> extractedFields = Arrays.asList("field1", "fActivityBulkExtractInputPluginTest.java:78ield2");
+        String filerField = "field1";
+        String exportId = "exportId";
+        Mockito.when(mockMarketoRestClient.createLeadBulkExtract(Mockito.eq(startDate), Mockito.eq(endDate), Mockito.eq(extractedFields), Mockito.eq(filerField))).thenReturn(exportId);
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream("Test File Content".getBytes());
+        Mockito.when(mockMarketoRestClient.getLeadBulkExtractResult(Mockito.eq(exportId), any(BulkExtractRangeHeader.class))).thenReturn(byteArrayInputStream);
+        File file = marketoService.extractLead(startDate, endDate, extractedFields, filerField, 1, 3);
+        Assert.assertEquals("Test File Content", new String(ByteStreams.toByteArray(new FileInputStream(file))));
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).startLeadBulkExtract(Mockito.eq(exportId));
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).waitLeadExportJobComplete(Mockito.eq(exportId), Mockito.eq(1), Mockito.eq(3));
+    }
+
+    @Test
+    public void extractAllActivity() throws Exception
+    {
+        Date startDate = new Date(1507223374000L);
+        Date endDate = new Date(1507655374000L);
+        List<Integer> activityTypeIds = new ArrayList<>();
+        String exportId = "exportId";
+        Mockito.when(mockMarketoRestClient.createActivityExtract(any(List.class), Mockito.eq(startDate), Mockito.eq(endDate))).thenReturn(exportId);
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream("Test File Content".getBytes());
+        Mockito.when(mockMarketoRestClient.getActivitiesBulkExtractResult(Mockito.eq(exportId), any(BulkExtractRangeHeader.class))).thenReturn(byteArrayInputStream);
+        File file = marketoService.extractAllActivity(activityTypeIds, startDate, endDate, 1, 3);
+        Assert.assertEquals("Test File Content", new String(ByteStreams.toByteArray(new FileInputStream(file))));
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).startActitvityBulkExtract(Mockito.eq(exportId));
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).waitActitvityExportJobComplete(Mockito.eq(exportId), Mockito.eq(1), Mockito.eq(3));
+    }
+
+    @Test
+    public void getAllListLead() throws Exception
+    {
+        List<String> extractFields = Arrays.asList("field1", "field2");
+        List<ObjectNode> allLists = mockParent();
+
+        List<ObjectNode> lead1 = new ArrayList<>();
+        lead1.add((ObjectNode) OBJECT_MAPPER.readTree("{\"id\":\"lead1\"}"));
+        List<ObjectNode> lead2 = new ArrayList<>();
+        lead2.add((ObjectNode) OBJECT_MAPPER.readTree("{\"id\":\"lead2\"}"));
+
+        RecordPagingIterable leadIterable1 = Mockito.mock(RecordPagingIterable.class);
+        RecordPagingIterable leadsIterable2 = Mockito.mock(RecordPagingIterable.class);
+        Mockito.when(leadIterable1.iterator()).thenReturn(lead1.iterator());
+        Mockito.when(leadsIterable2.iterator()).thenReturn(lead2.iterator());
+
+        Mockito.when(mockMarketoRestClient.getLeadsByList(Mockito.eq("1"), Mockito.eq("field1,field2"))).thenReturn(leadIterable1);
+        Mockito.when(mockMarketoRestClient.getLeadsByList(Mockito.eq("2"), Mockito.eq("field1,field2"))).thenReturn(leadsIterable2);
+
+        Iterable<ObjectNode> allListLead = marketoService.getAllListLead(extractFields, allLists);
+        Assert.assertEquals(lead1.get(0), allListLead.iterator().next());
+        Assert.assertEquals(lead2.get(0), allListLead.iterator().next());
+    }
+
+    private List<ObjectNode> mockParent() throws IOException
+    {
+        List<ObjectNode> allLists = new ArrayList<>();
+        allLists.add((ObjectNode) OBJECT_MAPPER.readTree("{\"id\": 1}"));
+        allLists.add((ObjectNode) OBJECT_MAPPER.readTree("{\"id\": 2}"));
+        return allLists;
+    }
+
+    @Test
+    public void getAllProgramLead() throws Exception
+    {
+        RecordPagingIterable<ObjectNode> listObjectNodes = Mockito.mock(RecordPagingIterable.class);
+        Iterable listIterator = mockParent();
+
+        List<ObjectNode> leadList1 = new ArrayList<>();
+        leadList1.add((ObjectNode) OBJECT_MAPPER.readTree("{\"id\":\"lead1\"}"));
+        List<ObjectNode> leadList2 = new ArrayList<>();
+        leadList2.add((ObjectNode) OBJECT_MAPPER.readTree("{\"id\":\"lead2\"}"));
+        Mockito.when(mockMarketoRestClient.getPrograms()).thenReturn(listObjectNodes);
+        RecordPagingIterable leadIterable1 = Mockito.mock(RecordPagingIterable.class);
+        RecordPagingIterable leadsIterable2 = Mockito.mock(RecordPagingIterable.class);
+        Mockito.when(leadIterable1.iterator()).thenReturn(leadList1.iterator());
+        Mockito.when(leadsIterable2.iterator()).thenReturn(leadList2.iterator());
+
+        Mockito.when(mockMarketoRestClient.getLeadsByProgram(Mockito.eq("1"), Mockito.eq("field1,field2"))).thenReturn(leadIterable1);
+        Mockito.when(mockMarketoRestClient.getLeadsByProgram(Mockito.eq("2"), Mockito.eq("field1,field2"))).thenReturn(leadsIterable2);
+
+        Iterable<ObjectNode> allListLead = marketoService.getAllProgramLead(Arrays.asList("field1", "field2"), listIterator);
+        Assert.assertEquals(leadList1.get(0), allListLead.iterator().next());
+        Assert.assertEquals(leadList2.get(0), allListLead.iterator().next());
+    }
+
+    @Test
+    public void getCampaign() throws Exception
+    {
+        marketoService.getCampaign();
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).getCampaign();
+    }
+
+    @Test
+    public void describeLead() throws Exception
+    {
+        marketoService.describeLead();
+        Mockito.verify(mockMarketoRestClient, Mockito.times(1)).describeLead();
+    }
+}

data/src/test/java/org/embulk/input/marketo/MarketoUtilsTest.java

@@ -0,0 +1,89 @@
+package org.embulk.input.marketo;
+
+import org.embulk.base.restclient.ServiceResponseMapper;
+import org.embulk.base.restclient.record.ValueLocator;
+import org.embulk.input.marketo.model.MarketoField;
+import org.embulk.spi.Column;
+import org.embulk.spi.type.Types;
+import org.junit.Test;
+
+import java.time.Instant;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * Created by tai.khuu on 10/7/17.
+ */
+public class MarketoUtilsTest
+{
+    @Test
+    public void buildDynamicResponseMapper()
+    {
+        List<MarketoField> marketoFields = new ArrayList<>();
+        marketoFields.add(new MarketoField("marketoField1", "text"));
+        marketoFields.add(new MarketoField("marketoField2", "date"));
+        marketoFields.add(new MarketoField("marketoField3", "datetime"));
+        ServiceResponseMapper<? extends ValueLocator> mapper = MarketoUtils.buildDynamicResponseMapper("marketo", marketoFields);
+        List<Column> columns = mapper.getEmbulkSchema().getColumns();
+        Column column1 = columns.get(0);
+        assertEquals("marketo_marketoField1", column1.getName());
+        assertEquals(Types.STRING, column1.getType());
+        Column column2 = columns.get(1);
+        assertEquals(Types.TIMESTAMP, column2.getType());
+        assertEquals("marketo_marketoField2", column2.getName());
+        Column column3 = columns.get(2);
+        assertEquals("marketo_marketoField3", column3.getName());
+        assertEquals(Types.TIMESTAMP, column3.getType());
+    }
+
+    @Test
+    public void getFieldNameFromMarketoFields()
+    {
+        List<MarketoField> marketoFields = new ArrayList<>();
+        marketoFields.add(new MarketoField("marketoField1", "text"));
+        marketoFields.add(new MarketoField("marketoField2", "date"));
+        marketoFields.add(new MarketoField("marketoField3", "datetime"));
+        List<String> marketoFieldList = MarketoUtils.getFieldNameFromMarketoFields(marketoFields, "marketoField2");
+        assertEquals(2, marketoFieldList.size());
+        assertFalse(marketoFieldList.contains("marketoField2"));
+    }
+
+    @Test
+    public void buildColumnName()
+    {
+        String columnName = MarketoUtils.buildColumnName("prefix", "columnName");
+        assertEquals("prefix_columnName", columnName);
+    }
+
+    @Test
+    public void getIdentityEndPoint()
+    {
+        String identityEndPoint = MarketoUtils.getIdentityEndPoint("accountId");
+        assertEquals("https://accountId.mktorest.com/identity", identityEndPoint);
+    }
+
+    @Test
+    public void getEndPoint()
+    {
+        String endPoint = MarketoUtils.getEndPoint("accountId");
+        assertEquals("https://accountId.mktorest.com", endPoint);
+    }
+
+    @Test
+    public void sliceRange()
+    {
+        OffsetDateTime startDate = OffsetDateTime.ofInstant(Instant.ofEpochMilli(1507369760000L), ZoneOffset.UTC);
+        List<MarketoUtils.DateRange> dateRanges1 = MarketoUtils.sliceRange(startDate, startDate.plusDays(7), 2);
+        assertEquals(4, dateRanges1.size());
+        assertEquals(startDate.plusDays(7), dateRanges1.get(3).toDate);
+
+        List<MarketoUtils.DateRange> dateRanges2 = MarketoUtils.sliceRange(startDate, startDate.plusDays(1), 2);
+        assertEquals(1, dateRanges2.size());
+        assertEquals(startDate.plusDays(1), dateRanges2.get(0).toDate);
+    }
+}

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

@@ -0,0 +1,129 @@
+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.embulk.EmbulkTestRuntime;
+import org.embulk.base.restclient.ServiceResponseMapper;
+import org.embulk.base.restclient.record.ValueLocator;
+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.MarketoUtils;
+import org.embulk.input.marketo.model.BulkExtractRangeHeader;
+import org.embulk.input.marketo.rest.MarketoRestClient;
+import org.embulk.input.marketo.rest.RecordPagingIterable;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.Schema;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+import static org.mockito.ArgumentMatchers.any;
+
+/**
+ * Created by khuutantaitai on 10/3/17.
+ */
+public class ActivityBulkExtractInputPluginTest
+{
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+    @Rule
+    public EmbulkTestRuntime embulkTestRuntime = new EmbulkTestRuntime();
+
+    private ActivityBulkExtractInputPlugin activityBulkExtractInputPlugin;
+
+    private ConfigSource configSource;
+
+    private MarketoRestClient mockMarketoRestclient;
+
+    @Before
+    public void prepare() throws IOException
+    {
+        activityBulkExtractInputPlugin = Mockito.spy(new ActivityBulkExtractInputPlugin());
+        ConfigLoader configLoader = embulkTestRuntime.getInjector().getInstance(ConfigLoader.class);
+        configSource = configLoader.fromYaml(this.getClass().getResourceAsStream("/config/activity_bulk_extract_config.yaml"));
+        mockMarketoRestclient = Mockito.mock(MarketoRestClient.class);
+        Mockito.doReturn(mockMarketoRestclient).when(activityBulkExtractInputPlugin).createMarketoRestClient(any(ActivityBulkExtractInputPlugin.PluginTask.class));
+    }
+
+    @Test
+    public void testInvalidActivityTypeIds()
+    {
+        configSource.set("activity_type_ids", Arrays.asList(" ", "abc", "123"));
+        final ActivityBulkExtractInputPlugin.PluginTask task = configSource.loadConfig(ActivityBulkExtractInputPlugin.PluginTask.class);
+
+        Assert.assertThrows("Invalid activity type id: [ , abc]", ConfigException.class, new ThrowingRunnable()
+        {
+            @Override
+            public void run() throws Throwable
+            {
+                activityBulkExtractInputPlugin.validateInputTask(task);
+            }
+        });
+    }
+
+    @Test
+    public void testActivityTypeIdsValid() throws IOException
+    {
+        configSource.set("activity_type_ids", Arrays.asList("1", "2", "3 "));
+        final ActivityBulkExtractInputPlugin.PluginTask task = configSource.loadConfig(ActivityBulkExtractInputPlugin.PluginTask.class);
+
+        RecordPagingIterable<ObjectNode> mockRecordPagingIterable = Mockito.mock(RecordPagingIterable.class);
+        JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametrizedType(List.class, List.class, ObjectNode.class);
+        List<ObjectNode> objectNodeList = OBJECT_MAPPER.readValue(this.getClass().getResourceAsStream("/fixtures/activity_types.json"), javaType);
+        Mockito.when(mockRecordPagingIterable.iterator()).thenReturn(objectNodeList.iterator());
+
+        Mockito.when(mockMarketoRestclient.getActivityTypes()).thenReturn(mockRecordPagingIterable);
+        activityBulkExtractInputPlugin.validateInputTask(task);
+    }
+
+    @Test
+    public void testRun() throws InterruptedException
+    {
+        ActivityBulkExtractInputPlugin.PluginTask task = configSource.loadConfig(ActivityBulkExtractInputPlugin.PluginTask.class);
+
+        OffsetDateTime startDate = OffsetDateTime.ofInstant(task.getFromDate().toInstant(), ZoneOffset.UTC);
+        List<Integer> activityTypeIds = new ArrayList<>();
+
+        PageBuilder pageBuilder = Mockito.mock(PageBuilder.class);
+        String exportId1 = "exportId1";
+        String exportId2 = "exportId2";
+        Mockito.when(mockMarketoRestclient.createActivityExtract(any(List.class), any(Date.class), any(Date.class))).thenReturn(exportId1).thenReturn(exportId2).thenReturn(null);
+        Mockito.when(mockMarketoRestclient.getActivitiesBulkExtractResult(Mockito.eq(exportId1), any(BulkExtractRangeHeader.class))).thenReturn(this.getClass().getResourceAsStream("/fixtures/activity_extract1.csv"));
+        Mockito.when(mockMarketoRestclient.getActivitiesBulkExtractResult(Mockito.eq(exportId2), any(BulkExtractRangeHeader.class))).thenReturn(this.getClass().getResourceAsStream("/fixtures/activity_extract2.csv"));
+        ServiceResponseMapper<? extends ValueLocator> mapper = activityBulkExtractInputPlugin.buildServiceResponseMapper(task);
+        activityBulkExtractInputPlugin.validateInputTask(task);
+        TaskReport taskReport = activityBulkExtractInputPlugin.ingestServiceData(task, mapper.createRecordImporter(), 1, pageBuilder);
+        ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
+        Column marketoGUID = mapper.getEmbulkSchema().lookupColumn("marketoGUID");
+        Mockito.verify(pageBuilder, Mockito.times(55)).setString(Mockito.eq(marketoGUID), argumentCaptor.capture());
+        Mockito.verify(mockMarketoRestclient, Mockito.times(1)).startActitvityBulkExtract(Mockito.eq(exportId1));
+        Mockito.verify(mockMarketoRestclient, Mockito.times(1)).waitActitvityExportJobComplete(Mockito.eq(exportId1), Mockito.eq(task.getPollingIntervalSecond()), Mockito.eq(task.getBulkJobTimeoutSecond()));
+        Mockito.verify(mockMarketoRestclient, Mockito.times(1)).startActitvityBulkExtract(Mockito.eq(exportId2));
+        Mockito.verify(mockMarketoRestclient, Mockito.times(1)).waitActitvityExportJobComplete(Mockito.eq(exportId2), Mockito.eq(task.getPollingIntervalSecond()), Mockito.eq(task.getBulkJobTimeoutSecond()));
+        Mockito.verify(mockMarketoRestclient, Mockito.times(1)).createActivityExtract(activityTypeIds, Date.from(startDate.toInstant()), Date.from(startDate.plusDays(30).toInstant()));
+        OffsetDateTime startDate2 = startDate.plusDays(30).plusSeconds(1);
+        Mockito.verify(mockMarketoRestclient, Mockito.times(1)).createActivityExtract(activityTypeIds, Date.from(startDate2.toInstant()), Date.from(startDate.plusDays(task.getFetchDays()).toInstant()));
+        ConfigDiff configDiff = activityBulkExtractInputPlugin.buildConfigDiff(task, Mockito.mock(Schema.class), 1, Arrays.asList(taskReport));
+        DateFormat df = new SimpleDateFormat(MarketoUtils.MARKETO_DATE_SIMPLE_DATE_FORMAT);
+        Assert.assertEquals(df.format(Date.from(startDate.plusDays(task.getFetchDays()).toInstant())), configDiff.get(String.class, "from_date"));
+    }
+}