embulk-input-marketo 0.6.0 → 0.6.1.alpha.1

data/src/test/java/org/embulk/input/marketo/rest/MarketoBaseRestClientTest.java

@@ -19,18 +19,17 @@ import org.embulk.spi.DataException;
 import org.embulk.util.retryhelper.jetty92.Jetty92RetryHelper;
 import org.embulk.util.retryhelper.jetty92.Jetty92SingleRequester;
 import org.embulk.util.retryhelper.jetty92.StringJetty92ResponseEntityReader;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
 
 import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
 /**
  * Created by tai.khuu on 9/21/17.
  */
@@ -49,48 +48,48 @@ public class MarketoBaseRestClientTest
     @Before
     public void prepare()
     {
-        mockJetty92 = mock(Jetty92RetryHelper.class);
+        mockJetty92 = Mockito.mock(Jetty92RetryHelper.class);
         marketoBaseRestClient = new MarketoBaseRestClient("identityEndPoint", "clientId", "clientSecret", MARKETO_LIMIT_INTERVAL_MILIS, mockJetty92);
     }
 
     @Test
     public void testGetAccessToken()
     {
-        when(mockJetty92.requestWithRetry(any(StringJetty92ResponseEntityReader.class), any(Jetty92SingleRequester.class))).thenReturn("{\n" +
+        Mockito.when(mockJetty92.requestWithRetry(Mockito.any(StringJetty92ResponseEntityReader.class), Mockito.any(Jetty92SingleRequester.class))).thenReturn("{\n" +
                 "    \"access_token\": \"access_token\",\n" +
                 "    \"token_type\": \"bearer\",\n" +
                 "    \"expires_in\": 3599,\n" +
                 "    \"scope\": \"tai@treasure-data.com\"\n" +
                 "}");
         String accessToken = marketoBaseRestClient.getAccessToken();
-        assertEquals("access_token", accessToken);
+        Assert.assertEquals("access_token", accessToken);
     }
 
     @Test
     public void testGetAccessTokenRequester()
     {
         ArgumentCaptor<Jetty92SingleRequester> jetty92SingleRequesterArgumentCaptor = ArgumentCaptor.forClass(Jetty92SingleRequester.class);
-        when(mockJetty92.requestWithRetry(any(StringJetty92ResponseEntityReader.class), jetty92SingleRequesterArgumentCaptor.capture())).thenReturn("{\"access_token\": \"access_token\"}");
+        Mockito.when(mockJetty92.requestWithRetry(Mockito.any(StringJetty92ResponseEntityReader.class), jetty92SingleRequesterArgumentCaptor.capture())).thenReturn("{\"access_token\": \"access_token\"}");
         String accessToken = marketoBaseRestClient.getAccessToken();
-        assertEquals("access_token", accessToken);
+        Assert.assertEquals("access_token", accessToken);
         Jetty92SingleRequester value = jetty92SingleRequesterArgumentCaptor.getValue();
-        HttpClient client = mock(HttpClient.class);
-        Response.Listener listener = mock(Response.Listener.class);
-        Request mockRequest = mock(Request.class);
-        when(client.newRequest(eq(IDENTITY_END_POINT + MarketoRESTEndpoint.ACCESS_TOKEN.getEndpoint()))).thenReturn(mockRequest);
-        Request request1 = mock(Request.class);
-        when(mockRequest.method(eq(HttpMethod.GET))).thenReturn(request1);
+        HttpClient client = Mockito.mock(HttpClient.class);
+        Response.Listener listener = Mockito.mock(Response.Listener.class);
+        Request mockRequest = Mockito.mock(Request.class);
+        Mockito.when(client.newRequest(Mockito.eq(IDENTITY_END_POINT + MarketoRESTEndpoint.ACCESS_TOKEN.getEndpoint()))).thenReturn(mockRequest);
+        Request request1 = Mockito.mock(Request.class);
+        Mockito.when(mockRequest.method(Mockito.eq(HttpMethod.GET))).thenReturn(request1);
         value.requestOnce(client, listener);
-        verify(request1, times(1)).param(eq("client_id"), eq("clientId"));
-        verify(request1, times(1)).param(eq("client_secret"), eq("clientSecret"));
-        verify(request1, times(1)).param(eq("grant_type"), eq("client_credentials"));
-        assertTrue(value.toRetry(createHttpResponseException(502)));
+        Mockito.verify(request1, Mockito.times(1)).param(Mockito.eq("client_id"), Mockito.eq("clientId"));
+        Mockito.verify(request1, Mockito.times(1)).param(Mockito.eq("client_secret"), Mockito.eq("clientSecret"));
+        Mockito.verify(request1, Mockito.times(1)).param(Mockito.eq("grant_type"), Mockito.eq("client_credentials"));
+        Assert.assertTrue(value.toRetry(createHttpResponseException(502)));
     }
     @Test
     public void testGetAccessTokenWithError()
     {
         ArgumentCaptor<Jetty92SingleRequester> jetty92SingleRequesterArgumentCaptor = ArgumentCaptor.forClass(Jetty92SingleRequester.class);
-        when(mockJetty92.requestWithRetry(any(StringJetty92ResponseEntityReader.class), jetty92SingleRequesterArgumentCaptor.capture())).thenReturn("{\n" +
+        Mockito.when(mockJetty92.requestWithRetry(Mockito.any(StringJetty92ResponseEntityReader.class), jetty92SingleRequesterArgumentCaptor.capture())).thenReturn("{\n" +
                 "    \"error\": \"invalid_client\",\n" +
                 "    \"error_description\": \"Bad client credentials\"\n" +
                 "}");
@@ -98,39 +97,39 @@ public class MarketoBaseRestClientTest
             marketoBaseRestClient.getAccessToken();
         }
         catch (DataException ex) {
-            assertEquals("Bad client credentials", ex.getMessage());
+            Assert.assertEquals("Bad client credentials", ex.getMessage());
             return;
         }
-        fail();
+        Assert.fail();
     }
 
     @Test
     public void testDoPost() throws Exception
     {
-        MarketoBaseRestClient spy = spy(marketoBaseRestClient);
+        MarketoBaseRestClient spy = Mockito.spy(marketoBaseRestClient);
         spy.doPost("target", Maps.<String, String>newHashMap(), new ImmutableListMultimap.Builder<String, String>().build(), "test_content", new StringJetty92ResponseEntityReader(10));
-        verify(spy, times(1)).doRequest(anyString(), eq(HttpMethod.POST), any(Map.class), any(Multimap.class), any(StringContentProvider.class), any(StringJetty92ResponseEntityReader.class));
+        Mockito.verify(spy, Mockito.times(1)).doRequest(Mockito.anyString(), Mockito.eq(HttpMethod.POST), Mockito.any(Map.class), Mockito.any(Multimap.class), Mockito.any(StringContentProvider.class), Mockito.any(StringJetty92ResponseEntityReader.class));
     }
 
     @Test
     public void testDoGet() throws Exception
     {
-        MarketoBaseRestClient spy = spy(marketoBaseRestClient);
+        MarketoBaseRestClient spy = Mockito.spy(marketoBaseRestClient);
         spy.doGet("target", Maps.<String, String>newHashMap(), new ImmutableListMultimap.Builder<String, String>().build(), new StringJetty92ResponseEntityReader(10));
-        verify(spy, times(1)).doRequest(anyString(), eq(HttpMethod.GET), any(Map.class), any(Multimap.class), isNull(ContentProvider.class), any(StringJetty92ResponseEntityReader.class));
+        Mockito.verify(spy, Mockito.times(1)).doRequest(Mockito.anyString(), Mockito.eq(HttpMethod.GET), Mockito.any(Map.class), Mockito.any(Multimap.class), Mockito.isNull(ContentProvider.class), Mockito.any(StringJetty92ResponseEntityReader.class));
     }
 
     @Test
     public void testDoRequestRequester() throws Exception
     {
-        MarketoBaseRestClient spy = spy(marketoBaseRestClient);
+        MarketoBaseRestClient spy = Mockito.spy(marketoBaseRestClient);
         StringContentProvider contentProvider = new StringContentProvider("Content", StandardCharsets.UTF_8);
         ArgumentCaptor<Jetty92SingleRequester> jetty92SingleRequesterArgumentCaptor = ArgumentCaptor.forClass(Jetty92SingleRequester.class);
 
         MarketoResponse<Object> expectedMarketoResponse = new MarketoResponse<>();
 
-        when(mockJetty92.requestWithRetry(any(MarketoResponseJetty92EntityReader.class), jetty92SingleRequesterArgumentCaptor.capture())).thenReturn(expectedMarketoResponse);
-        when(mockJetty92.requestWithRetry(any(StringJetty92ResponseEntityReader.class), any(Jetty92SingleRequester.class))).thenReturn("{\"access_token\": \"access_token\"}");
+        Mockito.when(mockJetty92.requestWithRetry(Mockito.any(MarketoResponseJetty92EntityReader.class), jetty92SingleRequesterArgumentCaptor.capture())).thenReturn(expectedMarketoResponse);
+        Mockito.when(mockJetty92.requestWithRetry(Mockito.any(StringJetty92ResponseEntityReader.class), Mockito.any(Jetty92SingleRequester.class))).thenReturn("{\"access_token\": \"access_token\"}");
 
         String target = "target";
         HashMap<String, String> headers = Maps.<String, String>newHashMap();
@@ -140,61 +139,61 @@ public class MarketoBaseRestClientTest
 
         MarketoResponse<Object> marketoResponse = spy.doRequest(target, HttpMethod.POST, headers, build, contentProvider, new MarketoResponseJetty92EntityReader<Object>(10));
 
-        HttpClient client = mock(HttpClient.class);
-        Response.Listener listener = mock(Response.Listener.class);
-        Request mockRequest = mock(Request.class);
-        when(client.newRequest(eq(target))).thenReturn(mockRequest);
+        HttpClient client = Mockito.mock(HttpClient.class);
+        Response.Listener listener = Mockito.mock(Response.Listener.class);
+        Request mockRequest = Mockito.mock(Request.class);
+        Mockito.when(client.newRequest(Mockito.eq(target))).thenReturn(mockRequest);
 
-        when(mockRequest.method(eq(HttpMethod.POST))).thenReturn(mockRequest);
+        Mockito.when(mockRequest.method(Mockito.eq(HttpMethod.POST))).thenReturn(mockRequest);
         Jetty92SingleRequester jetty92SingleRequester = jetty92SingleRequesterArgumentCaptor.getValue();
         jetty92SingleRequester.requestOnce(client, listener);
 
-        assertEquals(expectedMarketoResponse, marketoResponse);
+        Assert.assertEquals(expectedMarketoResponse, marketoResponse);
 
-        verify(mockRequest, times(1)).header(eq("testHeader1"), eq("testHeaderValue1"));
-        verify(mockRequest, times(1)).header(eq("Authorization"), eq("Bearer access_token"));
-        verify(mockRequest, times(1)).param(eq("param"), eq("param1"));
-        verify(mockRequest, times(1)).content(eq(contentProvider), eq("application/json"));
+        Mockito.verify(mockRequest, Mockito.times(1)).header(Mockito.eq("testHeader1"), Mockito.eq("testHeaderValue1"));
+        Mockito.verify(mockRequest, Mockito.times(1)).header(Mockito.eq("Authorization"), Mockito.eq("Bearer access_token"));
+        Mockito.verify(mockRequest, Mockito.times(1)).param(Mockito.eq("param"), Mockito.eq("param1"));
+        Mockito.verify(mockRequest, Mockito.times(1)).content(Mockito.eq(contentProvider), Mockito.eq("application/json"));
     }
 
     @Test
     public void testDoRequesterRetry() throws Exception
     {
-        MarketoBaseRestClient spy = spy(marketoBaseRestClient);
+        MarketoBaseRestClient spy = Mockito.spy(marketoBaseRestClient);
         ArgumentCaptor<Jetty92SingleRequester> jetty92SingleRequesterArgumentCaptor = ArgumentCaptor.forClass(Jetty92SingleRequester.class);
 
-        when(mockJetty92.requestWithRetry(any(MarketoResponseJetty92EntityReader.class), jetty92SingleRequesterArgumentCaptor.capture())).thenReturn(new MarketoResponse<>());
-        when(mockJetty92.requestWithRetry(any(StringJetty92ResponseEntityReader.class), any(Jetty92SingleRequester.class))).thenReturn("{\"access_token\": \"access_token\"}");
+        Mockito.when(mockJetty92.requestWithRetry(Mockito.any(MarketoResponseJetty92EntityReader.class), jetty92SingleRequesterArgumentCaptor.capture())).thenReturn(new MarketoResponse<>());
+        Mockito.when(mockJetty92.requestWithRetry(Mockito.any(StringJetty92ResponseEntityReader.class), Mockito.any(Jetty92SingleRequester.class))).thenReturn("{\"access_token\": \"access_token\"}");
 
         spy.doRequest("", HttpMethod.POST, null, null, null, new MarketoResponseJetty92EntityReader<Object>(10));
 
-        HttpClient client = mock(HttpClient.class);
-        Response.Listener listener = mock(Response.Listener.class);
-        Request mockRequest = mock(Request.class);
-        when(client.newRequest(anyString())).thenReturn(mockRequest);
+        HttpClient client = Mockito.mock(HttpClient.class);
+        Response.Listener listener = Mockito.mock(Response.Listener.class);
+        Request mockRequest = Mockito.mock(Request.class);
+        Mockito.when(client.newRequest(Mockito.anyString())).thenReturn(mockRequest);
 
-        when(mockRequest.method(eq(HttpMethod.POST))).thenReturn(mockRequest);
+        Mockito.when(mockRequest.method(Mockito.eq(HttpMethod.POST))).thenReturn(mockRequest);
 
         Jetty92SingleRequester jetty92SingleRequester = jetty92SingleRequesterArgumentCaptor.getValue();
         jetty92SingleRequester.requestOnce(client, listener);
-        assertTrue(jetty92SingleRequester.toRetry(createHttpResponseException(502)));
+        Assert.assertTrue(jetty92SingleRequester.toRetry(createHttpResponseException(502)));
 
-        assertFalse(jetty92SingleRequester.toRetry(createHttpResponseException(400)));
+        Assert.assertFalse(jetty92SingleRequester.toRetry(createHttpResponseException(400)));
 
-        assertFalse(jetty92SingleRequester.toRetry(createMarketoAPIException("ERR", "ERR")));
-        assertTrue(jetty92SingleRequester.toRetry(createMarketoAPIException("606", "")));
-        assertTrue(jetty92SingleRequester.toRetry(createMarketoAPIException("615", "")));
-        assertTrue(jetty92SingleRequester.toRetry(createMarketoAPIException("602", "")));
+        Assert.assertFalse(jetty92SingleRequester.toRetry(createMarketoAPIException("ERR", "ERR")));
+        Assert.assertTrue(jetty92SingleRequester.toRetry(createMarketoAPIException("606", "")));
+        Assert.assertTrue(jetty92SingleRequester.toRetry(createMarketoAPIException("615", "")));
+        Assert.assertTrue(jetty92SingleRequester.toRetry(createMarketoAPIException("602", "")));
 
-        verify(mockJetty92, times(2)).requestWithRetry(any(StringJetty92ResponseEntityReader.class), any(Jetty92SingleRequester.class));
+        Mockito.verify(mockJetty92, Mockito.times(2)).requestWithRetry(Mockito.any(StringJetty92ResponseEntityReader.class), Mockito.any(Jetty92SingleRequester.class));
     }
 
     private HttpResponseException createHttpResponseException(int statusCode)
     {
-        HttpResponseException exception = mock(HttpResponseException.class);
-        Response response = mock(Response.class);
-        when(exception.getResponse()).thenReturn(response);
-        when(response.getStatus()).thenReturn(statusCode);
+        HttpResponseException exception = Mockito.mock(HttpResponseException.class);
+        Response response = Mockito.mock(Response.class);
+        Mockito.when(exception.getResponse()).thenReturn(response);
+        Mockito.when(response.getStatus()).thenReturn(statusCode);
         return exception;
     }
 

data/src/test/java/org/embulk/input/marketo/rest/MarketoRestClientTest.java

@@ -10,6 +10,8 @@ import com.fasterxml.jackson.databind.node.TextNode;
 import com.google.common.collect.ImmutableListMultimap;
 import com.google.common.collect.Multimap;
 import com.google.common.io.ByteStreams;
+import org.eclipse.jetty.client.api.ContentProvider;
+import org.eclipse.jetty.client.util.FormContentProvider;
 import org.embulk.EmbulkTestRuntime;
 import org.embulk.config.ConfigSource;
 import org.embulk.input.marketo.MarketoUtils;
@@ -19,18 +21,23 @@ import org.embulk.input.marketo.model.MarketoResponse;
 import org.embulk.spi.DataException;
 import org.embulk.util.retryhelper.jetty92.Jetty92ResponseReader;
 import org.embulk.util.retryhelper.jetty92.Jetty92RetryHelper;
+import org.junit.Assert;
 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.io.InputStream;
+import java.nio.ByteBuffer;
 import java.text.SimpleDateFormat;
-import java.util.*;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
 
 /**
  * Created by khuutantaitai on 10/3/17.
@@ -65,9 +72,9 @@ public class MarketoRestClientTest
         configSource.set("client_id", TEST_CLIENT_ID);
         configSource.set("max_return", 2);
         MarketoRestClient.PluginTask task = configSource.loadConfig(MarketoRestClient.PluginTask.class);
-        mockRetryHelper = mock(Jetty92RetryHelper.class);
+        mockRetryHelper = Mockito.mock(Jetty92RetryHelper.class);
         MarketoRestClient realRestClient = new MarketoRestClient(task, mockRetryHelper);
-        marketoRestClient = spy(realRestClient);
+        marketoRestClient = Mockito.spy(realRestClient);
     }
 
     @Test
@@ -75,26 +82,14 @@ public class MarketoRestClientTest
     {
         String leadSchema = new String(ByteStreams.toByteArray(this.getClass().getResourceAsStream("/fixtures/lead_describe.json")));
         MarketoResponse<ObjectNode> marketoResponse = OBJECT_MAPPER.readValue(leadSchema, RESPONSE_TYPE);
-        doReturn(marketoResponse).when(marketoRestClient).doGet(eq(END_POINT + MarketoRESTEndpoint.DESCRIBE_LEAD.getEndpoint()), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.DESCRIBE_LEAD.getEndpoint()), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
         List<MarketoField> marketoFields = marketoRestClient.describeLead();
-        assertEquals(16, marketoFields.size());
+        Assert.assertEquals(16, marketoFields.size());
         JavaType marketoFieldType = OBJECT_MAPPER.getTypeFactory().constructParametrizedType(List.class, List.class, MarketoField.class);
         List<MarketoField> expectedFields = OBJECT_MAPPER.readValue(new String(ByteStreams.toByteArray(this.getClass().getResourceAsStream("/fixtures/lead_describe_expected.json"))), marketoFieldType);
-        assertArrayEquals(expectedFields.toArray(), marketoFields.toArray());
+        Assert.assertArrayEquals(expectedFields.toArray(), marketoFields.toArray());
     }
 
-//    @Test
-//    public void describeLead2() throws Exception {
-//        String leadSchema = new String(ByteStreams.toByteArray(this.getClass().getResourceAsStream("/fixtures/lead_describe_full.json")));
-//        MarketoResponse<ObjectNode> marketoResponse = OBJECT_MAPPER.readValue(leadSchema, RESPONSE_TYPE);
-//        doReturn(marketoResponse).when(marketoRestClient).doGet(eq(END_POINT + MarketoRESTEndpoint.DESCRIBE_LEAD.getEndpoint()), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoResponseJetty92EntityReader.class));
-//        List<MarketoField> marketoFields = marketoRestClient.describeLead();
-//        assertEquals(16, marketoFields.size());
-//        JavaType marketoFieldType = OBJECT_MAPPER.getTypeFactory().constructParametrizedType(List.class, List.class, MarketoField.class);
-//        List<MarketoField> expectedFields = OBJECT_MAPPER.readValue(new String(ByteStreams.toByteArray(this.getClass().getResourceAsStream("/fixtures/lead_describe_expected.json"))), marketoFieldType);
-//        assertArrayEquals(expectedFields.toArray(), marketoFields.toArray());
-//    }
-
     @Test
     public void createLeadBulkExtract() throws Exception
     {
@@ -106,21 +101,21 @@ public class MarketoRestClientTest
         bulkExtractResult.set("exportId", new TextNode("bulkExtractId"));
         marketoResponse.setResult(Arrays.asList(bulkExtractResult));
         ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
-        doReturn(marketoResponse).when(marketoRestClient).doPost(eq(END_POINT + MarketoRESTEndpoint.CREATE_LEAD_EXTRACT.getEndpoint()), isNull(Map.class), isNull(ImmutableListMultimap.class), argumentCaptor.capture(), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.CREATE_LEAD_EXTRACT.getEndpoint()), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), argumentCaptor.capture(), Mockito.any(MarketoResponseJetty92EntityReader.class));
         String filterField = "filterField";
         String bulkExtractId = marketoRestClient.createLeadBulkExtract(startDate, endDate, Arrays.asList("extract_field1", "extract_field2"), filterField);
-        assertEquals("bulkExtractId", bulkExtractId);
+        Assert.assertEquals("bulkExtractId", bulkExtractId);
         String postContent = argumentCaptor.getValue();
         ObjectNode marketoBulkExtractRequest = (ObjectNode) OBJECT_MAPPER.readTree(postContent);
         ObjectNode filter = (ObjectNode) marketoBulkExtractRequest.get("filter");
         ObjectNode dateRangeFilter = (ObjectNode) filter.get(filterField);
         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(MarketoUtils.MARKETO_DATE_SIMPLE_DATE_FORMAT);
-        assertEquals(simpleDateFormat.format(startDate), dateRangeFilter.get("startAt").textValue());
-        assertEquals(simpleDateFormat.format(endDate), dateRangeFilter.get("endAt").textValue());
-        assertEquals("CSV", marketoBulkExtractRequest.get("format").textValue());
+        Assert.assertEquals(simpleDateFormat.format(startDate), dateRangeFilter.get("startAt").textValue());
+        Assert.assertEquals(simpleDateFormat.format(endDate), dateRangeFilter.get("endAt").textValue());
+        Assert.assertEquals("CSV", marketoBulkExtractRequest.get("format").textValue());
         ArrayNode fields = (ArrayNode) marketoBulkExtractRequest.get("fields");
-        assertEquals("extract_field1", fields.get(0).textValue());
-        assertEquals("extract_field2", fields.get(1).textValue());
+        Assert.assertEquals("extract_field1", fields.get(0).textValue());
+        Assert.assertEquals("extract_field2", fields.get(1).textValue());
     }
 
     @Test
@@ -132,22 +127,22 @@ public class MarketoRestClientTest
         marketoError.setCode("ErrorCode1");
         marketoError.setMessage("Message");
         marketoResponse.setErrors(Arrays.asList(marketoError));
-        doReturn(marketoResponse).when(marketoRestClient).doPost(eq(END_POINT + MarketoRESTEndpoint.CREATE_LEAD_EXTRACT.getEndpoint()), isNull(Map.class), isNull(ImmutableListMultimap.class), anyString(), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.CREATE_LEAD_EXTRACT.getEndpoint()), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.anyString(), Mockito.any(MarketoResponseJetty92EntityReader.class));
         String filterField = "filterField";
         try {
             marketoRestClient.createLeadBulkExtract(new Date(), new Date(), Arrays.asList("extract_field1", "extract_field2"), filterField);
         }
         catch (DataException ex) {
-            assertEquals("ErrorCode1: Message", ex.getMessage());
+            Assert.assertEquals("ErrorCode1: Message", ex.getMessage());
             return;
         }
-        fail();
+        Assert.fail();
     }
 
     @Test()
     public void createLeadBulkExtractWithParseError() throws Exception
     {
-        doThrow(JsonProcessingException.class).when(marketoRestClient).doPost(eq(END_POINT + MarketoRESTEndpoint.CREATE_LEAD_EXTRACT.getEndpoint()), isNull(Map.class), isNull(ImmutableListMultimap.class), anyString(), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.doThrow(JsonProcessingException.class).when(marketoRestClient).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.CREATE_LEAD_EXTRACT.getEndpoint()), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.anyString(), Mockito.any(MarketoResponseJetty92EntityReader.class));
         String filterField = "filterField";
         try {
             marketoRestClient.createLeadBulkExtract(new Date(), new Date(), Arrays.asList("extract_field1", "extract_field2"), filterField);
@@ -155,7 +150,7 @@ public class MarketoRestClientTest
         catch (DataException ex) {
             return;
         }
-        fail();
+        Assert.fail();
     }
 
     @Test
@@ -169,13 +164,13 @@ public class MarketoRestClientTest
         bulkExtractResult.set("exportId", new TextNode("bulkExtractId"));
         marketoResponse.setResult(Arrays.asList(bulkExtractResult));
         ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
-        doReturn(marketoResponse).when(marketoRestClient).doPost(eq(END_POINT + MarketoRESTEndpoint.CREATE_ACTIVITY_EXTRACT.getEndpoint()), isNull(Map.class), isNull(ImmutableListMultimap.class), argumentCaptor.capture(), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.CREATE_ACTIVITY_EXTRACT.getEndpoint()), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), argumentCaptor.capture(), Mockito.any(MarketoResponseJetty92EntityReader.class));
         String bulkExtractId = marketoRestClient.createActivityExtract(startDate, endDate);
-        assertEquals("bulkExtractId", bulkExtractId);
+        Assert.assertEquals("bulkExtractId", bulkExtractId);
         String postContent = argumentCaptor.getValue();
         ObjectNode marketoBulkExtractRequest = (ObjectNode) OBJECT_MAPPER.readTree(postContent);
         ObjectNode filter = (ObjectNode) marketoBulkExtractRequest.get("filter");
-        assertTrue(filter.has("createdAt"));
+        Assert.assertTrue(filter.has("createdAt"));
     }
 
     @Test
@@ -186,9 +181,9 @@ public class MarketoRestClientTest
         pathParams.put("export_id", bulkExportId);
         MarketoResponse<ObjectNode> marketoResponse = new MarketoResponse<>();
         marketoResponse.setSuccess(true);
-        doReturn(marketoResponse).when(marketoRestClient).doPost(eq(END_POINT + MarketoRESTEndpoint.START_LEAD_EXPORT_JOB.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), isNull(String.class), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.START_LEAD_EXPORT_JOB.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.isNull(String.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
         marketoRestClient.startLeadBulkExtract(bulkExportId);
-        verify(marketoRestClient, times(1)).doPost(eq(END_POINT + MarketoRESTEndpoint.START_LEAD_EXPORT_JOB.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), isNull(String.class), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.verify(marketoRestClient, Mockito.times(1)).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.START_LEAD_EXPORT_JOB.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.isNull(String.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
     }
 
     @Test
@@ -203,15 +198,15 @@ public class MarketoRestClientTest
         marketoError.setCode("ErrorCode");
         marketoError.setMessage("Message");
         marketoResponse.setErrors(Arrays.asList(marketoError));
-        doReturn(marketoResponse).when(marketoRestClient).doPost(eq(END_POINT + MarketoRESTEndpoint.START_LEAD_EXPORT_JOB.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), isNull(String.class), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.START_LEAD_EXPORT_JOB.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.isNull(String.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
         try {
             marketoRestClient.startLeadBulkExtract(bulkExportId);
         }
         catch (DataException ex) {
-            verify(marketoRestClient, times(1)).doPost(eq(END_POINT + MarketoRESTEndpoint.START_LEAD_EXPORT_JOB.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), isNull(String.class), any(MarketoResponseJetty92EntityReader.class));
+            Mockito.verify(marketoRestClient, Mockito.times(1)).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.START_LEAD_EXPORT_JOB.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.isNull(String.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
             return;
         }
-        fail();
+        Assert.fail();
     }
 
     @Test
@@ -222,9 +217,9 @@ public class MarketoRestClientTest
         pathParams.put("export_id", bulkExportId);
         MarketoResponse<ObjectNode> marketoResponse = new MarketoResponse<>();
         marketoResponse.setSuccess(true);
-        doReturn(marketoResponse).when(marketoRestClient).doPost(eq(END_POINT + MarketoRESTEndpoint.START_ACTIVITY_EXPORT_JOB.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), isNull(String.class), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.START_ACTIVITY_EXPORT_JOB.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.isNull(String.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
         marketoRestClient.startActitvityBulkExtract(bulkExportId);
-        verify(marketoRestClient, times(1)).doPost(eq(END_POINT + MarketoRESTEndpoint.START_ACTIVITY_EXPORT_JOB.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), isNull(String.class), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.verify(marketoRestClient, Mockito.times(1)).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.START_ACTIVITY_EXPORT_JOB.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.isNull(String.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
     }
 
     @Test
@@ -233,14 +228,14 @@ public class MarketoRestClientTest
         String bulkExportId = "bulkExportId";
         Map<String, String> pathParams = new HashMap<>();
         pathParams.put("export_id", bulkExportId);
-        MarketoResponse<ObjectNode> marketoResponse = mock(MarketoResponse.class);
-        when(marketoResponse.isSuccess()).thenReturn(true);
-        ObjectNode result = mock(ObjectNode.class);
-        when(marketoResponse.getResult()).thenReturn(Arrays.asList(result));
-        when(result.get("status")).thenReturn(new TextNode("Queued")).thenReturn(new TextNode("Processing")).thenReturn(new TextNode("Completed"));
-        doReturn(marketoResponse).when(marketoRestClient).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoResponseJetty92EntityReader.class));
+        MarketoResponse<ObjectNode> marketoResponse = Mockito.mock(MarketoResponse.class);
+        Mockito.when(marketoResponse.isSuccess()).thenReturn(true);
+        ObjectNode result = Mockito.mock(ObjectNode.class);
+        Mockito.when(marketoResponse.getResult()).thenReturn(Arrays.asList(result));
+        Mockito.when(result.get("status")).thenReturn(new TextNode("Queued")).thenReturn(new TextNode("Processing")).thenReturn(new TextNode("Completed"));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
         marketoRestClient.waitLeadExportJobComplete(bulkExportId, 1, 4);
-        verify(marketoRestClient, times(3)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.verify(marketoRestClient, Mockito.times(3)).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
     }
 
     @Test
@@ -249,21 +244,21 @@ public class MarketoRestClientTest
         String bulkExportId = "bulkExportId";
         Map<String, String> pathParams = new HashMap<>();
         pathParams.put("export_id", bulkExportId);
-        MarketoResponse<ObjectNode> marketoResponse = mock(MarketoResponse.class);
-        when(marketoResponse.isSuccess()).thenReturn(true);
-        ObjectNode result = mock(ObjectNode.class);
-        when(marketoResponse.getResult()).thenReturn(Arrays.asList(result));
-        when(result.get("status")).thenReturn(new TextNode("Queued")).thenReturn(new TextNode("Processing"));
-        doReturn(marketoResponse).when(marketoRestClient).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoResponseJetty92EntityReader.class));
+        MarketoResponse<ObjectNode> marketoResponse = Mockito.mock(MarketoResponse.class);
+        Mockito.when(marketoResponse.isSuccess()).thenReturn(true);
+        ObjectNode result = Mockito.mock(ObjectNode.class);
+        Mockito.when(marketoResponse.getResult()).thenReturn(Arrays.asList(result));
+        Mockito.when(result.get("status")).thenReturn(new TextNode("Queued")).thenReturn(new TextNode("Processing"));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
         try {
             marketoRestClient.waitLeadExportJobComplete(bulkExportId, 1, 4);
         }
         catch (DataException e) {
-            assertTrue(e.getMessage().contains("Job timeout exception"));
-            verify(marketoRestClient, times(3)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoResponseJetty92EntityReader.class));
+            Assert.assertTrue(e.getMessage().contains("Job timeout exception"));
+            Mockito.verify(marketoRestClient, Mockito.times(3)).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
             return;
         }
-        fail();
+        Assert.fail();
     }
 
     @Test
@@ -272,23 +267,23 @@ public class MarketoRestClientTest
         String bulkExportId = "bulkExportId";
         Map<String, String> pathParams = new HashMap<>();
         pathParams.put("export_id", bulkExportId);
-        MarketoResponse<ObjectNode> marketoResponse = mock(MarketoResponse.class);
-        when(marketoResponse.isSuccess()).thenReturn(true);
-        ObjectNode result = mock(ObjectNode.class);
-        when(marketoResponse.getResult()).thenReturn(Arrays.asList(result));
-        when(result.get("status")).thenReturn(new TextNode("Queued")).thenReturn(new TextNode("Failed"));
-        when(result.get("errorMsg")).thenReturn(new TextNode("ErrorMessage"));
-        doReturn(marketoResponse).when(marketoRestClient).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoResponseJetty92EntityReader.class));
+        MarketoResponse<ObjectNode> marketoResponse = Mockito.mock(MarketoResponse.class);
+        Mockito.when(marketoResponse.isSuccess()).thenReturn(true);
+        ObjectNode result = Mockito.mock(ObjectNode.class);
+        Mockito.when(marketoResponse.getResult()).thenReturn(Arrays.asList(result));
+        Mockito.when(result.get("status")).thenReturn(new TextNode("Queued")).thenReturn(new TextNode("Failed"));
+        Mockito.when(result.get("errorMsg")).thenReturn(new TextNode("ErrorMessage"));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
         try {
             marketoRestClient.waitLeadExportJobComplete(bulkExportId, 1, 4);
         }
         catch (DataException e) {
-            assertTrue(e.getMessage().contains("Bulk extract job failed"));
-            assertTrue(e.getMessage().contains("ErrorMessage"));
-            verify(marketoRestClient, times(2)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoResponseJetty92EntityReader.class));
+            Assert.assertTrue(e.getMessage().contains("Bulk extract job failed"));
+            Assert.assertTrue(e.getMessage().contains("ErrorMessage"));
+            Mockito.verify(marketoRestClient, Mockito.times(2)).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_STATUS.getEndpoint(pathParams)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
             return;
         }
-        fail();
+        Assert.fail();
     }
 
     @Test
@@ -297,14 +292,14 @@ public class MarketoRestClientTest
         String exportId = "exportId";
         Map<String, String> pathParamMap = new HashMap<>();
         pathParamMap.put("export_id", exportId);
-        MarketoResponse<ObjectNode> marketoResponse = mock(MarketoResponse.class);
-        when(marketoResponse.isSuccess()).thenReturn(true);
-        ObjectNode mockObjectNode = mock(ObjectNode.class);
-        when(marketoResponse.getResult()).thenReturn(Arrays.asList(mockObjectNode));
-        when(mockObjectNode.get("status")).thenReturn(new TextNode("Completed"));
-        doReturn(marketoResponse).when(marketoRestClient).doGet(anyString(), isNull(Map.class), isNull(ImmutableListMultimap.class), any(Jetty92ResponseReader.class));
+        MarketoResponse<ObjectNode> marketoResponse = Mockito.mock(MarketoResponse.class);
+        Mockito.when(marketoResponse.isSuccess()).thenReturn(true);
+        ObjectNode mockObjectNode = Mockito.mock(ObjectNode.class);
+        Mockito.when(marketoResponse.getResult()).thenReturn(Arrays.asList(mockObjectNode));
+        Mockito.when(mockObjectNode.get("status")).thenReturn(new TextNode("Completed"));
+        Mockito.doReturn(marketoResponse).when(marketoRestClient).doGet(Mockito.anyString(), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(Jetty92ResponseReader.class));
         marketoRestClient.waitActitvityExportJobComplete(exportId, 1, 3);
-        verify(marketoRestClient, times(1)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_ACTIVITY_EXPORT_STATUS.getEndpoint(pathParamMap)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(Jetty92ResponseReader.class));
+        Mockito.verify(marketoRestClient, Mockito.times(1)).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_ACTIVITY_EXPORT_STATUS.getEndpoint(pathParamMap)), Mockito.isNull(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(Jetty92ResponseReader.class));
     }
 
     @Test
@@ -313,9 +308,9 @@ public class MarketoRestClientTest
         String exportId = "exportId";
         Map<String, String> pathParamMap = new HashMap<>();
         pathParamMap.put("export_id", exportId);
-        doReturn(mock(InputStream.class)).when(marketoRestClient).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_RESULT.getEndpoint(pathParamMap)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoInputStreamResponseEntityReader.class));
-        marketoRestClient.getLeadBulkExtractResult(exportId);
-        verify(marketoRestClient, times(1)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_RESULT.getEndpoint(pathParamMap)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoInputStreamResponseEntityReader.class));
+        Mockito.doReturn(Mockito.mock(InputStream.class)).when(marketoRestClient).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_RESULT.getEndpoint(pathParamMap)), Mockito.any(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoInputStreamResponseEntityReader.class));
+        marketoRestClient.getLeadBulkExtractResult(exportId, null);
+        Mockito.verify(marketoRestClient, Mockito.times(1)).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEAD_EXPORT_RESULT.getEndpoint(pathParamMap)), Mockito.any(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoInputStreamResponseEntityReader.class));
     }
 
     @Test
@@ -324,9 +319,9 @@ public class MarketoRestClientTest
         String exportId = "exportId";
         Map<String, String> pathParamMap = new HashMap<>();
         pathParamMap.put("export_id", exportId);
-        doReturn(mock(InputStream.class)).when(marketoRestClient).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_ACTIVITY_EXPORT_RESULT.getEndpoint(pathParamMap)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoInputStreamResponseEntityReader.class));
-        marketoRestClient.getActivitiesBulkExtractResult(exportId);
-        verify(marketoRestClient, times(1)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_ACTIVITY_EXPORT_RESULT.getEndpoint(pathParamMap)), isNull(Map.class), isNull(ImmutableListMultimap.class), any(MarketoInputStreamResponseEntityReader.class));
+        Mockito.doReturn(Mockito.mock(InputStream.class)).when(marketoRestClient).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_ACTIVITY_EXPORT_RESULT.getEndpoint(pathParamMap)), Mockito.any(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoInputStreamResponseEntityReader.class));
+        marketoRestClient.getActivitiesBulkExtractResult(exportId, null);
+        Mockito.verify(marketoRestClient, Mockito.times(1)).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_ACTIVITY_EXPORT_RESULT.getEndpoint(pathParamMap)), Mockito.any(Map.class), Mockito.isNull(ImmutableListMultimap.class), Mockito.any(MarketoInputStreamResponseEntityReader.class));
     }
 
     @Test
@@ -337,39 +332,42 @@ public class MarketoRestClientTest
         Iterator<ObjectNode> iterator = lists.iterator();
         ObjectNode list1 = iterator.next();
         ObjectNode list2 = iterator.next();
-        assertFalse(iterator.hasNext());
-        assertEquals("Test list 1", list1.get("name").asText());
-        assertEquals("Test list 2", list2.get("name").asText());
+        Assert.assertFalse(iterator.hasNext());
+        Assert.assertEquals("Test list 1", list1.get("name").asText());
+        Assert.assertEquals("Test list 2", list2.get("name").asText());
         ArgumentCaptor<Multimap> immutableListMultimapArgumentCaptor = ArgumentCaptor.forClass(Multimap.class);
-        verify(marketoRestClient, times(2)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LISTS.getEndpoint()), isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), any(MarketoResponseJetty92EntityReader.class));
+        ArgumentCaptor<FormContentProvider> formContentProviderArgumentCaptor = ArgumentCaptor.forClass(FormContentProvider.class);
+        Mockito.verify(marketoRestClient, Mockito.times(2)).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LISTS.getEndpoint()), Mockito.isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), Mockito.any(MarketoResponseJetty92EntityReader.class), formContentProviderArgumentCaptor.capture());
         List<Multimap> params = immutableListMultimapArgumentCaptor.getAllValues();
         Multimap params1 = params.get(0);
-        assertEquals("300", params1.get("batchSize").iterator().next());
-        Multimap params2 = params.get(1);
-        assertEquals("GWP55GLCVCZLPE6SS7OCG5IEXQ======", params2.get("nextPageToken").iterator().next());
+        Assert.assertEquals("GET", params1.get("_method").iterator().next());
+        Assert.assertEquals("nextPageToken=GWP55GLCVCZLPE6SS7OCG5IEXQ%3D%3D%3D%3D%3D%3D&batchSize=300", fromContentProviderToString(formContentProviderArgumentCaptor.getValue()));
     }
 
     @Test
     public void getPrograms() throws Exception
     {
-        mockMarketoPageResponse("/fixtures/program_response.json", END_POINT + MarketoRESTEndpoint.GET_PROGRAMS.getEndpoint());
+        ArrayNode listPages = (ArrayNode) OBJECT_MAPPER.readTree(new String(ByteStreams.toByteArray(this.getClass().getResourceAsStream("/fixtures/program_response.json")))).get("responses");
+        MarketoResponse<ObjectNode> page1 = OBJECT_MAPPER.readValue(listPages.get(0).toString(), RESPONSE_TYPE);
+        MarketoResponse<ObjectNode> page2 = OBJECT_MAPPER.readValue(listPages.get(1).toString(), RESPONSE_TYPE);
+        Mockito.doReturn(page1).doReturn(page2).when(marketoRestClient).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_PROGRAMS.getEndpoint()), Mockito.isNull(Map.class), Mockito.any(Multimap.class), Mockito.any(MarketoResponseJetty92EntityReader.class));
         RecordPagingIterable<ObjectNode> lists = marketoRestClient.getPrograms();
         Iterator<ObjectNode> iterator = lists.iterator();
         ObjectNode program1 = iterator.next();
         ObjectNode program2 = iterator.next();
         ObjectNode program3 = iterator.next();
-        assertFalse(iterator.hasNext());
-        assertEquals("MB_Sep_25_test_program", program1.get("name").asText());
-        assertEquals("TD Output Test Program", program2.get("name").asText());
-        assertEquals("Bill_progream", program3.get("name").asText());
+        Assert.assertFalse(iterator.hasNext());
+        Assert.assertEquals("MB_Sep_25_test_program", program1.get("name").asText());
+        Assert.assertEquals("TD Output Test Program", program2.get("name").asText());
+        Assert.assertEquals("Bill_progream", program3.get("name").asText());
         ArgumentCaptor<ImmutableListMultimap> immutableListMultimapArgumentCaptor = ArgumentCaptor.forClass(ImmutableListMultimap.class);
-        verify(marketoRestClient, times(2)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_PROGRAMS.getEndpoint()), isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.verify(marketoRestClient, Mockito.times(2)).doGet(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_PROGRAMS.getEndpoint()), Mockito.isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), Mockito.any(MarketoResponseJetty92EntityReader.class));
         List<ImmutableListMultimap> params = immutableListMultimapArgumentCaptor.getAllValues();
         ImmutableListMultimap params1 = params.get(0);
-        assertEquals("0", params1.get("offset").get(0));
-        assertEquals("2", params1.get("maxReturn").get(0));
+        Assert.assertEquals("0", params1.get("offset").get(0));
+        Assert.assertEquals("2", params1.get("maxReturn").get(0));
         ImmutableListMultimap params2 = params.get(1);
-        assertEquals("2", params2.get("offset").get(0));
+        Assert.assertEquals("2", params2.get("offset").get(0));
     }
 
     private void mockMarketoPageResponse(String fixtureName, String mockEndpoint) throws IOException
@@ -377,7 +375,7 @@ public class MarketoRestClientTest
         ArrayNode listPages = (ArrayNode) OBJECT_MAPPER.readTree(new String(ByteStreams.toByteArray(this.getClass().getResourceAsStream(fixtureName)))).get("responses");
         MarketoResponse<ObjectNode> page1 = OBJECT_MAPPER.readValue(listPages.get(0).toString(), RESPONSE_TYPE);
         MarketoResponse<ObjectNode> page2 = OBJECT_MAPPER.readValue(listPages.get(1).toString(), RESPONSE_TYPE);
-        doReturn(page1).doReturn(page2).when(marketoRestClient).doGet(eq(mockEndpoint), isNull(Map.class), any(Multimap.class), any(MarketoResponseJetty92EntityReader.class));
+        Mockito.doReturn(page1).doReturn(page2).when(marketoRestClient).doPost(Mockito.eq(mockEndpoint), Mockito.isNull(Map.class), Mockito.any(Multimap.class), Mockito.any(MarketoResponseJetty92EntityReader.class), Mockito.any(FormContentProvider.class));
     }
 
     @Test
@@ -387,21 +385,32 @@ public class MarketoRestClientTest
         Map<String, String> pathParamPath = new HashMap<>();
         pathParamPath.put("program_id", programId);
         mockMarketoPageResponse("/fixtures/lead_by_program_response.json", END_POINT + MarketoRESTEndpoint.GET_LEADS_BY_PROGRAM.getEndpoint(pathParamPath));
-        RecordPagingIterable<ObjectNode> lists = marketoRestClient.getLeadsByProgram(programId, Arrays.asList("firstName", "lastName"));
+        RecordPagingIterable<ObjectNode> lists = marketoRestClient.getLeadsByProgram(programId, "firstName,lastName");
         Iterator<ObjectNode> iterator = lists.iterator();
         ObjectNode lead1 = iterator.next();
         ObjectNode lead2 = iterator.next();
-        assertFalse(iterator.hasNext());
-        assertEquals("Tai 1", lead1.get("firstName").asText());
-        assertEquals("Tai", lead2.get("firstName").asText());
+        Assert.assertFalse(iterator.hasNext());
+        Assert.assertEquals("Tai 1", lead1.get("firstName").asText());
+        Assert.assertEquals("Tai", lead2.get("firstName").asText());
         ArgumentCaptor<ImmutableListMultimap> immutableListMultimapArgumentCaptor = ArgumentCaptor.forClass(ImmutableListMultimap.class);
-        verify(marketoRestClient, times(2)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEADS_BY_PROGRAM.getEndpoint(pathParamPath)), isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), any(MarketoResponseJetty92EntityReader.class));
+        ArgumentCaptor<FormContentProvider> formContentProviderArgumentCaptor = ArgumentCaptor.forClass(FormContentProvider.class);
+        Mockito.verify(marketoRestClient, Mockito.times(2)).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEADS_BY_PROGRAM.getEndpoint(pathParamPath)), Mockito.isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), Mockito.any(MarketoResponseJetty92EntityReader.class), formContentProviderArgumentCaptor.capture());
+        String formContent = fromContentProviderToString(formContentProviderArgumentCaptor.getValue());
         List<ImmutableListMultimap> params = immutableListMultimapArgumentCaptor.getAllValues();
         Multimap params1 = params.get(0);
-        assertEquals("300", params1.get("batchSize").iterator().next());
-        assertEquals("firstName,lastName", params1.get("fields").iterator().next());
-        Multimap params2 = params.get(1);
-        assertEquals("z4MgsIiC5C======", params2.get("nextPageToken").iterator().next());
+        Assert.assertEquals("GET", params1.get("_method").iterator().next());
+        Assert.assertEquals("nextPageToken=z4MgsIiC5C%3D%3D%3D%3D%3D%3D&batchSize=300&fields=firstName%2ClastName", formContent);
+    }
+
+    private String fromContentProviderToString(ContentProvider formContentProvider)
+    {
+        Iterator<ByteBuffer> byteBufferIterator = formContentProvider.iterator();
+        StringBuilder stringBuilder = new StringBuilder();
+        while (byteBufferIterator.hasNext()) {
+            ByteBuffer next = byteBufferIterator.next();
+            stringBuilder.append(new String(next.array()));
+        }
+        return stringBuilder.toString();
     }
 
     @Test
@@ -411,21 +420,21 @@ public class MarketoRestClientTest
         Map<String, String> pathParamPath = new HashMap<>();
         pathParamPath.put("list_id", listId);
         mockMarketoPageResponse("/fixtures/lead_by_list.json", END_POINT + MarketoRESTEndpoint.GET_LEADS_BY_LIST.getEndpoint(pathParamPath));
-        RecordPagingIterable<ObjectNode> lists = marketoRestClient.getLeadsByList(listId, Arrays.asList("firstName", "lastName"));
+        RecordPagingIterable<ObjectNode> lists = marketoRestClient.getLeadsByList(listId, "firstName,lastName");
         Iterator<ObjectNode> iterator = lists.iterator();
         ObjectNode lead1 = iterator.next();
         ObjectNode lead2 = iterator.next();
-        assertFalse(iterator.hasNext());
-        assertEquals("John10093", lead1.get("firstName").asText());
-        assertEquals("John10094", lead2.get("firstName").asText());
+        Assert.assertFalse(iterator.hasNext());
+        Assert.assertEquals("John10093", lead1.get("firstName").asText());
+        Assert.assertEquals("John10094", lead2.get("firstName").asText());
         ArgumentCaptor<ImmutableListMultimap> immutableListMultimapArgumentCaptor = ArgumentCaptor.forClass(ImmutableListMultimap.class);
-        verify(marketoRestClient, times(2)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_LEADS_BY_LIST.getEndpoint(pathParamPath)), isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), any(MarketoResponseJetty92EntityReader.class));
+        ArgumentCaptor<FormContentProvider> formContentProviderArgumentCaptor = ArgumentCaptor.forClass(FormContentProvider.class);
+        Mockito.verify(marketoRestClient, Mockito.times(2)).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_LEADS_BY_LIST.getEndpoint(pathParamPath)), Mockito.isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), Mockito.any(MarketoResponseJetty92EntityReader.class), formContentProviderArgumentCaptor.capture());
+        String formContent = fromContentProviderToString(formContentProviderArgumentCaptor.getValue());
         List<ImmutableListMultimap> params = immutableListMultimapArgumentCaptor.getAllValues();
         Multimap params1 = params.get(0);
-        assertEquals("300", params1.get("batchSize").iterator().next());
-        assertEquals("firstName,lastName", params1.get("fields").iterator().next());
-        Multimap params2 = params.get(1);
-        assertEquals("z4MgsIiC5C======", params2.get("nextPageToken").iterator().next());
+        Assert.assertEquals("GET", params1.get("_method").iterator().next());
+        Assert.assertEquals("nextPageToken=z4MgsIiC5C%3D%3D%3D%3D%3D%3D&batchSize=300&fields=firstName%2ClastName", formContent);
     }
 
     @Test
@@ -436,15 +445,17 @@ public class MarketoRestClientTest
         Iterator<ObjectNode> iterator = lists.iterator();
         ObjectNode campaign1 = iterator.next();
         ObjectNode campaign2 = iterator.next();
-        assertFalse(iterator.hasNext());
-        assertEquals("Opened Sales Email", campaign1.get("name").asText());
-        assertEquals("Clicks Link in Email", campaign2.get("name").asText());
+        Assert.assertFalse(iterator.hasNext());
+        Assert.assertEquals("Opened Sales Email", campaign1.get("name").asText());
+        Assert.assertEquals("Clicks Link in Email", campaign2.get("name").asText());
         ArgumentCaptor<ImmutableListMultimap> immutableListMultimapArgumentCaptor = ArgumentCaptor.forClass(ImmutableListMultimap.class);
-        verify(marketoRestClient, times(2)).doGet(eq(END_POINT + MarketoRESTEndpoint.GET_CAMPAIGN.getEndpoint()), isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), any(MarketoResponseJetty92EntityReader.class));
+        ArgumentCaptor<FormContentProvider> formContentProviderArgumentCaptor = ArgumentCaptor.forClass(FormContentProvider.class);
+        Mockito.verify(marketoRestClient, Mockito.times(2)).doPost(Mockito.eq(END_POINT + MarketoRESTEndpoint.GET_CAMPAIGN.getEndpoint()), Mockito.isNull(Map.class), immutableListMultimapArgumentCaptor.capture(), Mockito.any(MarketoResponseJetty92EntityReader.class), formContentProviderArgumentCaptor.capture());
+        String content = fromContentProviderToString(formContentProviderArgumentCaptor.getValue());
+
         List<ImmutableListMultimap> params = immutableListMultimapArgumentCaptor.getAllValues();
         Multimap params1 = params.get(0);
-        assertEquals("300", params1.get("batchSize").iterator().next());
-        Multimap params2 = params.get(1);
-        assertEquals("z4MgsIiC5C======", params2.get("nextPageToken").iterator().next());
+        Assert.assertEquals("GET", params1.get("_method").iterator().next());
+        Assert.assertEquals("nextPageToken=z4MgsIiC5C%3D%3D%3D%3D%3D%3D&batchSize=300", content);
     }
 }