@josuelmm/cordova-background-geolocation 2.3.5

package/android/common/src/test/java/com/marianhello/backgroundgeolocation/HashMapLocationTemplateTest.java

@@ -0,0 +1,216 @@
+package com.marianhello.backgroundgeolocation;
+
+import com.marianhello.bgloc.Config;
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.HashMapLocationTemplate;
+import com.marianhello.bgloc.data.LocationTemplate;
+import com.marianhello.bgloc.data.LocationTemplateFactory;
+
+import junit.framework.Assert;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.junit.Test;
+
+import java.util.HashMap;
+
+/**
+ * Created by finch on 9.12.2017.
+ */
+
+public class HashMapLocationTemplateTest {
+    @Test
+    public void testObjectTemplateToString() {
+        HashMap props = new HashMap();
+        props.put("foo", "bar");
+        props.put("pretzels", 123);
+        HashMapLocationTemplate tpl = new HashMapLocationTemplate(props);
+
+        Assert.assertEquals("{\"foo\":\"bar\",\"pretzels\":123}" , tpl.toString());
+    }
+
+    @Test
+    public void testLocationToJSONObject() throws JSONException {
+        BackgroundLocation location = new BackgroundLocation();
+        location.setLocationId(11L);
+        location.setProvider("test");
+        location.setElapsedRealtimeNanos(2000000000L * 60 * 2);
+        location.setAltitude(100);
+        location.setLatitude(49);
+        location.setLongitude(5);
+        location.setLocationProvider(1);
+        location.setAccuracy(105);
+        location.setSpeed(50);
+        location.setBearing(1);
+
+        HashMap map = new HashMap<String, String>();
+        map.put("Id", "@id");
+        map.put("Provider", "@provider");
+        map.put("Time", "@time");
+        map.put("Altitude", "@altitude");
+        map.put("Latitude", "@latitude");
+        map.put("Longitude", "@longitude");
+        map.put("Foo", "bar");
+        map.put("LocationProvider", "@locationProvider");
+        map.put("Accuracy", "@accuracy");
+        map.put("Speed", "@speed");
+        map.put("Bearing", "@bearing");
+        map.put("Pretzels", 123);
+
+        LocationTemplate tpl = new HashMapLocationTemplate(map);
+        JSONObject expected = (JSONObject) tpl.locationToJson(location);
+
+        Assert.assertEquals(expected.get("Id"), location.getLocationId());
+        Assert.assertEquals(expected.get("Provider"), location.getProvider());
+        Assert.assertEquals(expected.get("Time"), location.getTime());
+        Assert.assertEquals(expected.get("Altitude"), location.getAltitude());
+        Assert.assertEquals(expected.get("Latitude"), location.getLatitude());
+        Assert.assertEquals(expected.get("Longitude"), location.getLongitude());
+        Assert.assertEquals(expected.get("Foo"), "bar");
+        Assert.assertEquals(expected.get("LocationProvider"), location.getLocationProvider());
+        Assert.assertEquals(expected.get("Accuracy"), location.getAccuracy());
+        Assert.assertEquals(expected.get("Speed"), location.getSpeed());
+        Assert.assertEquals(expected.get("Bearing"), location.getBearing());
+        Assert.assertEquals(expected.get("Pretzels"), 123);
+    }
+
+    @Test
+    public void testLocationToJSONObjectFactory() throws JSONException {
+        BackgroundLocation location = new BackgroundLocation();
+        location.setLocationId(11L);
+        location.setProvider("test");
+        location.setElapsedRealtimeNanos(2000000000L * 60 * 2);
+        location.setAltitude(100);
+        location.setLatitude(49);
+        location.setLongitude(5);
+        location.setLocationProvider(1);
+        location.setAccuracy(105);
+        location.setSpeed(50);
+        location.setBearing(1);
+
+        HashMap map = new HashMap();
+        map.put("Id", "@id");
+        map.put("Provider", "@provider");
+        map.put("Time", "@time");
+        map.put("Altitude", "@altitude");
+        map.put("Latitude", "@latitude");
+        map.put("Longitude", "@longitude");
+        map.put("Foo", "bar");
+        map.put("LocationProvider", "@locationProvider");
+        map.put("Accuracy", "@accuracy");
+        map.put("Speed", "@speed");
+        map.put("Bearing", "@bearing");
+        map.put("Pretzels", 123);
+
+        JSONObject json = new JSONObject(map);
+        LocationTemplate tpl = LocationTemplateFactory.fromJSON(json);
+
+        JSONObject expected = (JSONObject) tpl.locationToJson(location);
+
+        Assert.assertEquals(expected.get("Id"), location.getLocationId());
+        Assert.assertEquals(expected.get("Provider"), location.getProvider());
+        Assert.assertEquals(expected.get("Time"), location.getTime());
+        Assert.assertEquals(expected.get("Altitude"), location.getAltitude());
+        Assert.assertEquals(expected.get("Latitude"), location.getLatitude());
+        Assert.assertEquals(expected.get("Longitude"), location.getLongitude());
+        Assert.assertEquals(expected.get("Foo"), "bar");
+        Assert.assertEquals(expected.get("LocationProvider"), location.getLocationProvider());
+        Assert.assertEquals(expected.get("Accuracy"), location.getAccuracy());
+        Assert.assertEquals(expected.get("Speed"), location.getSpeed());
+        Assert.assertEquals(expected.get("Bearing"), location.getBearing());
+    }
+
+    @Test
+    public void testNullToString() {
+        HashMapLocationTemplate tpl = new HashMapLocationTemplate((HashMap)null);
+        Assert.assertEquals("null", tpl.toString());
+    }
+
+    @Test
+    public void testNestedObjectTemplate() throws JSONException {
+        BackgroundLocation location = new BackgroundLocation();
+        location.setLocationId(11L);
+        location.setProvider("test");
+        location.setElapsedRealtimeNanos(2000000000L * 60 * 2);
+        location.setAltitude(100);
+        location.setLatitude(49);
+        location.setLongitude(5);
+        location.setLocationProvider(1);
+        location.setAccuracy(105);
+        location.setSpeed(50);
+        location.setBearing(1);
+
+        JSONObject template = new JSONObject(
+            "{\"data\":{\"Id\":\"@id\"," +
+                    "\"Provider\":\"@provider\"," +
+                    "\"Time\":\"@time\"," +
+                    "\"Altitude\":\"@altitude\"," +
+                    "\"Latitude\":\"@latitude\"," +
+                    "\"Longitude\":\"@longitude\"," +
+                    "\"Foo\":\"bar\"," +
+                    "\"LocationProvider\":\"@locationProvider\"," +
+                    "\"Accuracy\":\"@accuracy\"," +
+                    "\"Speed\":\"@speed\"," +
+                    "\"Bearing\":\"@bearing\"}" +
+                    "}"
+        );
+        LocationTemplate tpl = LocationTemplateFactory.fromJSON(template);
+
+        JSONObject json = ((JSONObject) tpl.locationToJson(location));
+        JSONObject expected = json.getJSONObject("data");
+
+        Assert.assertEquals(expected.get("Id"), location.getLocationId());
+        Assert.assertEquals(expected.get("Provider"), location.getProvider());
+        Assert.assertEquals(expected.get("Time"), location.getTime());
+        Assert.assertEquals(expected.get("Altitude"), location.getAltitude());
+        Assert.assertEquals(expected.get("Latitude"), location.getLatitude());
+        Assert.assertEquals(expected.get("Longitude"), location.getLongitude());
+        Assert.assertEquals(expected.get("Foo"), "bar");
+        Assert.assertEquals(expected.get("LocationProvider"), location.getLocationProvider());
+        Assert.assertEquals(expected.get("Accuracy"), location.getAccuracy());
+        Assert.assertEquals(expected.get("Speed"), location.getSpeed());
+        Assert.assertEquals(expected.get("Bearing"), location.getBearing());
+    }
+
+
+    @Test
+    public void testNestedArrayTemplate() throws JSONException {
+        BackgroundLocation location = new BackgroundLocation();
+        location.setLocationId(11L);
+        location.setProvider("test");
+        location.setElapsedRealtimeNanos(2000000000L * 60 * 2);
+        location.setAltitude(100);
+        location.setLatitude(49);
+        location.setLongitude(5);
+        location.setLocationProvider(1);
+        location.setAccuracy(105);
+        location.setSpeed(50);
+        location.setBearing(1);
+
+        JSONObject template = new JSONObject(
+                "{\"data\":[\"@id\",\"@provider\",\"@time\",\"@altitude\",\"@latitude\"," +
+                "\"@longitude\",\"foo\",\"@locationProvider\",\"@accuracy\",\"@speed\"," +
+                "\"@bearing\",123]}"
+        );
+        LocationTemplate tpl = LocationTemplateFactory.fromJSON(template);
+
+        JSONObject json = ((JSONObject) tpl.locationToJson(location));
+        JSONArray expected = json.getJSONArray("data");
+
+        Assert.assertEquals(expected.get(0), location.getLocationId());
+        Assert.assertEquals(expected.get(1), location.getProvider());
+        Assert.assertEquals(expected.get(2), location.getTime());
+        Assert.assertEquals(expected.get(3), location.getAltitude());
+        Assert.assertEquals(expected.get(4), location.getLatitude());
+        Assert.assertEquals(expected.get(5), location.getLongitude());
+        Assert.assertEquals(expected.get(6), "foo");
+        Assert.assertEquals(expected.get(7), location.getLocationProvider());
+        Assert.assertEquals(expected.get(8), location.getAccuracy());
+        Assert.assertEquals(expected.get(9), location.getSpeed());
+        Assert.assertEquals(expected.get(10), location.getBearing());
+        Assert.assertEquals(expected.get(11), 123);
+
+    }
+
+}

package/android/common/src/test/java/com/marianhello/backgroundgeolocation/HttpPostServiceTest.java

@@ -0,0 +1,223 @@
+package com.marianhello.backgroundgeolocation;
+
+import android.os.Build;
+
+import com.marianhello.bgloc.HttpPostService;
+import com.marianhello.bgloc.HttpPostService.UploadingProgressListener;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.UnknownHostException;
+import java.util.HashMap;
+import java.util.Random;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(RobolectricTestRunner.class)
+public class HttpPostServiceTest {
+    @Mock
+    HttpURLConnection mockHttpURLConnection;
+
+    private static final int DEFAULT_SDK_INT = Build.VERSION.SDK_INT;
+
+    @Rule
+    public final ExpectedException exception = ExpectedException.none();
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @After
+    public void cleanUp() {
+        try {
+            TestHelper.setFinalStatic(Build.VERSION.class.getField("SDK_INT"), DEFAULT_SDK_INT);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void testPostJSONThrowsMalformedURLException() throws IOException {
+        exception.expect(MalformedURLException.class);
+        HttpPostService.postJSON(null, (JSONObject) null, null);
+    }
+
+    @Test
+    public void testPostJSONThrowsUnknownHostException() throws IOException {
+        exception.expect(UnknownHostException.class);
+        HttpPostService.postJSON("http://unknown/json", (JSONObject) null, null);
+    }
+
+    @Test
+    public void testPostJSONResult() throws IOException {
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+        when(mockHttpURLConnection.getResponseCode()).thenReturn(200);
+
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        assertThat(service.postJSON((JSONObject) new JSONObject(), null), is(200));
+        verify(mockHttpURLConnection).setRequestMethod("POST");
+    }
+
+
+    @Test
+    public void testPostJSONShouldPostHeaders() throws IOException {
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+
+        HashMap headers = new HashMap();
+        headers.put("foo", "bar");
+
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        service.postJSON((JSONObject) null, headers);
+        verify(mockHttpURLConnection).setRequestMethod("POST");
+        verify(mockHttpURLConnection).setRequestProperty("Content-Type", "application/json");
+        verify(mockHttpURLConnection).setRequestProperty("foo", "bar");
+    }
+
+    @Test
+    public void testPostJSONObject() throws IOException {
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        service.postJSON(new JSONObject(), null);
+        verify(mockHttpURLConnection).setRequestMethod("POST");
+        assertThat(outputStream.toString(), is("{}"));
+    }
+
+    @Test
+    public void testPostJSONArray() throws IOException {
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        service.postJSON(new JSONArray(), null);
+        verify(mockHttpURLConnection).setRequestMethod("POST");
+        assertThat(outputStream.toString(), is("[]"));
+    }
+
+    @Test
+    public void testPostJSONObjectNull() throws IOException {
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        service.postJSON((JSONObject) null, null);
+        verify(mockHttpURLConnection).setRequestMethod("POST");
+        assertThat(outputStream.toString(), is("null"));
+    }
+
+    @Test
+    public void testPostJSONArrayNull() throws IOException {
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        service.postJSON((JSONArray) null, null);
+        verify(mockHttpURLConnection).setRequestMethod("POST");
+        assertThat(outputStream.toString(), is("null"));
+    }
+
+    @Test
+    public void testPostString() throws IOException {
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        service.postJSONString("test", null);
+        verify(mockHttpURLConnection).setRequestMethod("POST");
+        verify(mockHttpURLConnection).setRequestProperty("Content-Type", "application/json");
+        assertThat(outputStream.toString(), is("test"));
+    }
+
+    @Test
+    public void testPostStream() throws Exception {
+        TestHelper.setFinalStatic(Build.VERSION.class.getField("SDK_INT"), Build.VERSION_CODES.KITKAT);
+
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+        when(mockHttpURLConnection.getResponseCode()).thenReturn(200);
+
+        String body = "test";
+        InputStream inputStream = new ByteArrayInputStream(body.getBytes());
+        HashMap headers = new HashMap();
+        headers.put("foo", "bar");
+
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        assertThat(service.postJSONFile(inputStream, headers, null), is(200));
+        verify(mockHttpURLConnection).setRequestMethod("POST");
+        verify(mockHttpURLConnection).setRequestProperty("foo", "bar");
+        verify(mockHttpURLConnection).setFixedLengthStreamingMode((long) body.length());
+        //verify(mockHttpURLConnection).setChunkedStreamingMode(0);
+        assertThat(outputStream.toString(), is("test"));
+    }
+
+    @Test
+    public void testJSONPostFile() throws Exception {
+        TestHelper.setFinalStatic(Build.VERSION.class.getField("SDK_INT"), Build.VERSION_CODES.KITKAT);
+
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+        when(mockHttpURLConnection.getResponseCode()).thenReturn(200);
+
+        File file = new File("./README.md");
+
+        HashMap headers = new HashMap();
+        headers.put("foo", "bar");
+
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        assertThat(service.postJSONFile(file, headers, null), is(200));
+        verify(mockHttpURLConnection).setRequestMethod("POST");
+        verify(mockHttpURLConnection).setRequestProperty("Content-Type", "application/json");
+        verify(mockHttpURLConnection).setRequestProperty("foo", "bar");
+        verify(mockHttpURLConnection).setFixedLengthStreamingMode((long) file.length());
+        //verify(mockHttpURLConnection).setChunkedStreamingMode(0);
+    }
+
+    @Test
+    public void testJSONPostFileProgressListener() throws IOException {
+        HttpPostService service = new HttpPostService(mockHttpURLConnection);
+        UploadingProgressListener mockListener = mock(UploadingProgressListener.class);
+
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        when(mockHttpURLConnection.getOutputStream()).thenReturn(outputStream);
+
+        int bodySize = HttpPostService.BUFFER_SIZE * 5;
+        byte[] body = new byte[bodySize];
+        new Random().nextBytes(body);
+        InputStream inputStream = new ByteArrayInputStream(body);
+
+        service.postJSONFile(inputStream, null, mockListener);
+        InOrder inOrder = inOrder(mockListener);
+        inOrder.verify(mockListener).onProgress(20);
+        inOrder.verify(mockListener).onProgress(40);
+        inOrder.verify(mockListener).onProgress(60);
+        inOrder.verify(mockListener).onProgress(80);
+        inOrder.verify(mockListener).onProgress(100);
+    }
+}

package/android/common/src/test/java/com/marianhello/backgroundgeolocation/LocationTemplateFactoryTest.java

@@ -0,0 +1,50 @@
+package com.marianhello.backgroundgeolocation;
+
+import com.marianhello.bgloc.data.LocationTemplate;
+import com.marianhello.bgloc.data.LocationTemplateFactory;
+
+import junit.framework.Assert;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+import org.junit.Test;
+
+/**
+ * Created by finch on 9.12.2017.
+ */
+
+public class LocationTemplateFactoryTest {
+    @Test
+    public void testTemplateFromJsonArray() {
+        String jsonString = "[\"foo\",\"bar\",123]";
+
+        try {
+            LocationTemplate tpl = LocationTemplateFactory.fromJSONString(jsonString);
+            JSONArray expected = new JSONArray();
+            expected.put("foo");
+            expected.put("bar");
+            expected.put(123);
+            Assert.assertEquals(expected.toString(), tpl.toString());
+        } catch (JSONException e) {
+            org.junit.Assert.fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void testTemplateFromJsonObject() {
+        String jsonString = "{\"foo\":\"bar\",\"pretzels\":123}";
+
+        try {
+            LocationTemplate tpl = LocationTemplateFactory.fromJSONString(jsonString);
+            JSONObject expected = new JSONObject();
+            expected.put("foo", "bar");
+            expected.put("pretzels", 123);
+            Assert.assertEquals(expected.toString(), tpl.toString());
+        } catch (JSONException e) {
+            org.junit.Assert.fail(e.getMessage());
+        }
+    }
+
+}

package/android/common/src/test/java/com/marianhello/backgroundgeolocation/PostLocationTaskTest.java

@@ -0,0 +1,180 @@
+package com.marianhello.backgroundgeolocation;
+
+import com.marianhello.bgloc.Config;
+import com.marianhello.bgloc.ConnectivityListener;
+import com.marianhello.bgloc.PostLocationTask;
+import com.marianhello.bgloc.PostLocationTask.PostLocationTaskListener;
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.LocationDAO;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+import java.net.URLStreamHandlerFactory;
+import java.util.concurrent.RejectedExecutionException;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test inspired by
+ * https://github.com/google/agera/blob/master/extensions/net/src/test/java/com/google/android/agera/net/HttpFunctionsTest.java
+ */
+@RunWith(RobolectricTestRunner.class)
+public class PostLocationTaskTest {
+    private static final String TEST_PROTOCOL = "httptest";
+    private static final String SLOW_PROTOCOL = "httpslow";
+
+    private static HttpURLConnection mockHttpURLConnection;
+
+    private ConnectivityListener connectivityListener = new ConnectivityListener() {
+        @Override
+        public boolean hasConnectivity() {
+            return true;
+        }
+    };
+
+    @Rule
+    public final ExpectedException exception = ExpectedException.none();
+
+    @BeforeClass
+    public static void onlyOnce() throws Throwable {
+        mockHttpURLConnection = mock(HttpURLConnection.class);
+        URL.setURLStreamHandlerFactory(new URLStreamHandlerFactory() {
+            @Override
+            public URLStreamHandler createURLStreamHandler(final String s) {
+                if (TEST_PROTOCOL.equals(s)) {
+                    return new URLStreamHandler() {
+                        @Override
+                        protected URLConnection openConnection(final URL url) throws IOException {
+                            return mockHttpURLConnection;
+                        }
+                    };
+                }
+                if (SLOW_PROTOCOL.equals(s)) {
+                    return new URLStreamHandler() {
+                        @Override
+                        protected URLConnection openConnection(final URL url) throws IOException {
+                            try {
+                                Thread.sleep(100);
+                            } catch (InterruptedException e) { /* noop */ }
+                            return mockHttpURLConnection;
+                        }
+                    };
+                }
+
+                return null;
+            }
+        });
+    }
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @After
+    public void tearDown() {
+        reset(mockHttpURLConnection);
+    }
+
+    @Test
+    public void persistTask() throws ProtocolException, InterruptedException {
+        LocationDAO mockDAO = mock(LocationDAO.class);
+
+        PostLocationTaskListener mockListener = mock(PostLocationTaskListener.class);
+        PostLocationTask task = new PostLocationTask(mockDAO,mockListener, connectivityListener);
+
+        Config config = Config.getDefault();
+        config.setUrl(TEST_PROTOCOL + "://localhost:3000/locations");
+        config.setSyncUrl(TEST_PROTOCOL + "://localhost:3000/sync");
+        task.setConfig(config);
+
+        for (int i = 0; i < 10; i++) {
+            task.add(new BackgroundLocation());
+        }
+
+        Thread.sleep(3000);
+        verify(mockHttpURLConnection, times(10)).setRequestMethod("POST");
+    }
+
+    @Test
+    public void persistTaskShouldRejectAfterShutdown() {
+        LocationDAO mockDAO = mock(LocationDAO.class);
+
+        PostLocationTaskListener mockListener = mock(PostLocationTaskListener.class);
+        PostLocationTask task = new PostLocationTask(mockDAO,mockListener, connectivityListener);
+
+        Config config = Config.getDefault();
+        config.setUrl(TEST_PROTOCOL + "://localhost:3000/locations");
+        config.setSyncUrl(TEST_PROTOCOL + "://localhost:3000/sync");
+        task.setConfig(config);
+
+        for (int i = 0; i < 10; i++) {
+            task.add(new BackgroundLocation());
+        }
+
+        task.shutdown();
+        task.add(new BackgroundLocation());
+    }
+
+    @Test
+    public void persistTaskOnShutdown() throws ProtocolException, InterruptedException {
+        LocationDAO mockDAO = mock(LocationDAO.class);
+
+        PostLocationTaskListener mockListener = mock(PostLocationTaskListener.class);
+        PostLocationTask task = new PostLocationTask(mockDAO,mockListener, connectivityListener);
+
+        Config config = Config.getDefault();
+        config.setUrl(SLOW_PROTOCOL + "://localhost:3000/locations");
+        config.setSyncUrl(SLOW_PROTOCOL + "://localhost:3000/sync");
+        task.setConfig(config);
+
+        for (int i = 0; i < 10; i++) {
+            task.add(new BackgroundLocation());
+        }
+
+        task.shutdown(600);
+
+        Thread.sleep(3000);
+        verify(mockHttpURLConnection, times(10)).setRequestMethod("POST");
+    }
+
+    @Test
+    public void persistTaskSetUnsyncedOnShutdown() throws InterruptedException {
+        LocationDAO mockDAO = mock(LocationDAO.class);
+
+        PostLocationTaskListener mockListener = mock(PostLocationTaskListener.class);
+        PostLocationTask task = new PostLocationTask(mockDAO,mockListener, connectivityListener);
+
+        Config config = Config.getDefault();
+        config.setUrl(SLOW_PROTOCOL + "://localhost:3000/locations");
+        config.setSyncUrl(SLOW_PROTOCOL + "://localhost:3000/sync");
+        task.setConfig(config);
+
+        for (int i = 0; i < 10; i++) {
+            task.add(new BackgroundLocation());
+        }
+
+        task.shutdown(1);
+
+        Thread.sleep(3000);
+        verify(mockDAO).deleteUnpostedLocations();
+    }
+}

package/android/common/src/test/java/com/marianhello/backgroundgeolocation/TestHelper.java

@@ -0,0 +1,16 @@
+package com.marianhello.backgroundgeolocation;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+public class TestHelper {
+    static void setFinalStatic(Field field, Object newValue) throws Exception {
+        field.setAccessible(true);
+
+        Field modifiersField = Field.class.getDeclaredField("modifiers");
+        modifiersField.setAccessible(true);
+        modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+
+        field.set(null, newValue);
+    }
+}