() {
+ @Override
+ public Unit invoke() {
+ flushEvents();
+ return Unit.INSTANCE;
+ }
+ }, flushInterval * 1000L,
ParselyCoroutineScopeKt.getSdkScope());
inMemoryBuffer = new InMemoryBuffer(ParselyCoroutineScopeKt.getSdkScope(), localStorageRepository, () -> {
if (!flushTimerIsActive()) {
@@ -85,14 +87,13 @@ protected ParselyTracker(String siteId, int flushInterval, Context c) {
}
return Unit.INSTANCE;
});
+ flushQueue = new FlushQueue(flushManager, localStorageRepository, new ParselyAPIConnection(ROOT_URL + "mobileproxy"), ParselyCoroutineScopeKt.getSdkScope());
// get the adkey straight away on instantiation
timer = new Timer();
isDebug = false;
- if (localStorageRepository.getStoredQueue().size() > 0) {
- startFlushTimer();
- }
+ flushManager.start();
ProcessLifecycleOwner.get().getLifecycle().addObserver(
(LifecycleEventObserver) (lifecycleOwner, event) -> {
@@ -428,34 +429,6 @@ public void flushEventQueue() {
// no-op
}
- /**
- * Send the batched event request to Parsely.
- *
- * Creates a POST request containing the JSON encoding of the event queue.
- * Sends this request to Parse.ly servers.
- *
- * @param events The list of event dictionaries to serialize
- */
- private void sendBatchRequest(ArrayList> events) {
- if (events == null || events.size() == 0) {
- return;
- }
- PLog("Sending request with %d events", events.size());
-
- // Put in a Map for the proxy server
- Map batchMap = new HashMap<>();
- batchMap.put("events", events);
-
- if (isDebug) {
- PLog("Debug mode on. Not sending to Parse.ly");
- purgeEventsQueue();
- } else {
- new ParselyAPIConnection(this).execute(ROOT_URL + "mobileproxy", JsonEncode(batchMap));
- PLog("Requested %s", ROOT_URL);
- }
- PLog("POST Data %s", JsonEncode(batchMap));
- }
-
/**
* Returns whether the network is accessible and Parsely is reachable.
*
@@ -468,29 +441,6 @@ private boolean isReachable() {
return netInfo != null && netInfo.isConnectedOrConnecting();
}
- void purgeEventsQueue() {
- localStorageRepository.purgeStoredQueue();
- }
-
- /**
- * Encode an event Map as JSON.
- *
- * @param map The Map object to encode as JSON.
- * @return The JSON-encoded value of `map`.
- */
- private String JsonEncode(Map map) {
- ObjectMapper mapper = new ObjectMapper();
- String ret = null;
- try {
- StringWriter strWriter = new StringWriter();
- mapper.writeValue(strWriter, map);
- ret = strWriter.toString();
- } catch (IOException e) {
- e.printStackTrace();
- }
- return ret;
- }
-
/**
* Start the timer to flush events to Parsely.
*
@@ -511,60 +461,16 @@ public boolean flushTimerIsActive() {
return flushManager.isRunning();
}
- /**
- * Stop the event queue flush timer.
- */
- public void stopFlushTimer() {
- flushManager.stop();
- }
-
@NonNull
private String generatePixelId() {
return UUID.randomUUID().toString();
}
- /**
- * Get the number of events waiting to be flushed to Parsely.
- *
- * @return The number of events waiting to be flushed to Parsely.
- */
- public int queueSize() {
- return localStorageRepository.getStoredQueue().size();
- }
-
- /**
- * Get the number of events stored in persistent storage.
- *
- * @return The number of events stored in persistent storage.
- */
- public int storedEventsCount() {
- ArrayList> ar = localStorageRepository.getStoredQueue();
- return ar.size();
- }
-
- private class FlushQueue extends AsyncTask {
- @Override
- protected synchronized Void doInBackground(Void... params) {
- ArrayList> storedQueue = localStorageRepository.getStoredQueue();
- PLog("%d events in stored queue", storedEventsCount());
- // in case both queues have been flushed and app quits, don't crash
- if (storedQueue.isEmpty()) {
- stopFlushTimer();
- return null;
- }
- if (!isReachable()) {
- PLog("Network unreachable. Not flushing.");
- return null;
- }
-
- PLog("Flushing queue");
- sendBatchRequest(storedQueue);
- return null;
- }
- }
-
void flushEvents() {
- new FlushQueue().execute();
+ if (!isReachable()) {
+ PLog("Network unreachable. Not flushing.");
+ return;
+ }
+ flushQueue.invoke(isDebug);
}
-
}
diff --git a/parsely/src/test/java/com/parsely/parselyandroid/FlushManagerTest.kt b/parsely/src/test/java/com/parsely/parselyandroid/FlushManagerTest.kt
index cf2ef157..02842a2c 100644
--- a/parsely/src/test/java/com/parsely/parselyandroid/FlushManagerTest.kt
+++ b/parsely/src/test/java/com/parsely/parselyandroid/FlushManagerTest.kt
@@ -1,6 +1,5 @@
package com.parsely.parselyandroid
-import androidx.test.core.app.ApplicationProvider
import kotlin.time.Duration.Companion.seconds
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.advanceTimeBy
@@ -8,42 +7,42 @@ import kotlinx.coroutines.test.runCurrent
import kotlinx.coroutines.test.runTest
import org.assertj.core.api.Assertions.assertThat
import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
@OptIn(ExperimentalCoroutinesApi::class)
-@RunWith(RobolectricTestRunner::class)
class FlushManagerTest {
- private lateinit var sut: FlushManager
- private val tracker = FakeTracker()
-
@Test
fun `when timer starts and interval time passes, then flush queue`() = runTest {
- sut = FlushManager(tracker, DEFAULT_INTERVAL_MILLIS, backgroundScope)
+ var flushEventsCounter = 0
+ val sut =
+ ParselyFlushManager({ flushEventsCounter++ }, DEFAULT_INTERVAL_MILLIS, backgroundScope)
sut.start()
advanceTimeBy(DEFAULT_INTERVAL_MILLIS)
runCurrent()
- assertThat(tracker.flushEventsCounter).isEqualTo(1)
+ assertThat(flushEventsCounter).isEqualTo(1)
}
@Test
fun `when timer starts and three interval time passes, then flush queue 3 times`() = runTest {
- sut = FlushManager(tracker, DEFAULT_INTERVAL_MILLIS, backgroundScope)
+ var flushEventsCounter = 0
+ val sut =
+ ParselyFlushManager({ flushEventsCounter++ }, DEFAULT_INTERVAL_MILLIS, backgroundScope)
sut.start()
advanceTimeBy(3 * DEFAULT_INTERVAL_MILLIS)
runCurrent()
- assertThat(tracker.flushEventsCounter).isEqualTo(3)
+ assertThat(flushEventsCounter).isEqualTo(3)
}
@Test
fun `when timer starts and is stopped after 2 intervals passes, then flush queue 2 times`() =
runTest {
- sut = FlushManager(tracker, DEFAULT_INTERVAL_MILLIS, backgroundScope)
+ var flushEventsCounter = 0
+ val sut =
+ ParselyFlushManager({ flushEventsCounter++ }, DEFAULT_INTERVAL_MILLIS, backgroundScope)
sut.start()
advanceTimeBy(2 * DEFAULT_INTERVAL_MILLIS)
@@ -52,13 +51,15 @@ class FlushManagerTest {
advanceTimeBy(DEFAULT_INTERVAL_MILLIS)
runCurrent()
- assertThat(tracker.flushEventsCounter).isEqualTo(2)
+ assertThat(flushEventsCounter).isEqualTo(2)
}
@Test
fun `when timer starts, is stopped before end of interval and then time of interval passes, then do not flush queue`() =
runTest {
- sut = FlushManager(tracker, DEFAULT_INTERVAL_MILLIS, backgroundScope)
+ var flushEventsCounter = 0
+ val sut =
+ ParselyFlushManager({ flushEventsCounter++ }, DEFAULT_INTERVAL_MILLIS, backgroundScope)
sut.start()
advanceTimeBy(DEFAULT_INTERVAL_MILLIS / 2)
@@ -67,13 +68,15 @@ class FlushManagerTest {
advanceTimeBy(DEFAULT_INTERVAL_MILLIS / 2)
runCurrent()
- assertThat(tracker.flushEventsCounter).isEqualTo(0)
+ assertThat(flushEventsCounter).isEqualTo(0)
}
@Test
fun `when timer starts, and another timer starts after some time, then flush queue according to the first start`() =
runTest {
- sut = FlushManager(tracker, DEFAULT_INTERVAL_MILLIS, backgroundScope)
+ var flushEventsCounter = 0
+ val sut =
+ ParselyFlushManager({ flushEventsCounter++ }, DEFAULT_INTERVAL_MILLIS, backgroundScope)
sut.start()
advanceTimeBy(DEFAULT_INTERVAL_MILLIS / 2)
@@ -82,25 +85,15 @@ class FlushManagerTest {
advanceTimeBy(DEFAULT_INTERVAL_MILLIS / 2)
runCurrent()
- assertThat(tracker.flushEventsCounter).isEqualTo(1)
+ assertThat(flushEventsCounter).isEqualTo(1)
advanceTimeBy(DEFAULT_INTERVAL_MILLIS / 2)
runCurrent()
- assertThat(tracker.flushEventsCounter).isEqualTo(1)
+ assertThat(flushEventsCounter).isEqualTo(1)
}
private companion object {
val DEFAULT_INTERVAL_MILLIS: Long = 30.seconds.inWholeMilliseconds
}
-
- class FakeTracker : ParselyTracker(
- "", 0, ApplicationProvider.getApplicationContext()
- ) {
- var flushEventsCounter = 0
-
- override fun flushEvents() {
- flushEventsCounter++
- }
- }
}
diff --git a/parsely/src/test/java/com/parsely/parselyandroid/FlushQueueTest.kt b/parsely/src/test/java/com/parsely/parselyandroid/FlushQueueTest.kt
new file mode 100644
index 00000000..e49605b6
--- /dev/null
+++ b/parsely/src/test/java/com/parsely/parselyandroid/FlushQueueTest.kt
@@ -0,0 +1,219 @@
+package com.parsely.parselyandroid
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(RobolectricTestRunner::class)
+class FlushQueueTest {
+
+ @Test
+ fun `given empty local storage, when sending events, then do nothing`() =
+ runTest {
+ // given
+ val sut = FlushQueue(
+ FakeFlushManager(),
+ FakeRepository(),
+ FakeRestClient(),
+ this
+ )
+
+ // when
+ sut.invoke(false)
+ runCurrent()
+
+ // then
+ assertThat(FakeRepository().getStoredQueue()).isEmpty()
+ }
+
+ @Test
+ fun `given non-empty local storage, when flushing queue with not skipping sending events, then events are sent and removed from local storage`() =
+ runTest {
+ // given
+ val repository = FakeRepository().apply {
+ insertEvents(listOf(mapOf("test" to 123)))
+ }
+ val parselyAPIConnection = FakeRestClient().apply {
+ nextResult = Result.success(Unit)
+ }
+ val sut = FlushQueue(
+ FakeFlushManager(),
+ repository,
+ parselyAPIConnection,
+ this
+ )
+
+ // when
+ sut.invoke(false)
+ runCurrent()
+
+ // then
+ assertThat(repository.getStoredQueue()).isEmpty()
+ }
+
+ @Test
+ fun `given non-empty local storage, when flushing queue with skipping sending events, then events are not sent and removed from local storage`() =
+ runTest {
+ // given
+ val repository = FakeRepository().apply {
+ insertEvents(listOf(mapOf("test" to 123)))
+ }
+ val sut = FlushQueue(
+ FakeFlushManager(),
+ repository,
+ FakeRestClient(),
+ this
+ )
+
+ // when
+ sut.invoke(true)
+ runCurrent()
+
+ // then
+ assertThat(repository.getStoredQueue()).isEmpty()
+ }
+
+ @Test
+ fun `given non-empty local storage, when flushing queue with not skipping sending events fails, then events are not removed from local storage`() =
+ runTest {
+ // given
+ val repository = FakeRepository().apply {
+ insertEvents(listOf(mapOf("test" to 123)))
+ }
+ val parselyAPIConnection = FakeRestClient().apply {
+ nextResult = Result.failure(Exception())
+ }
+ val sut = FlushQueue(
+ FakeFlushManager(),
+ repository,
+ parselyAPIConnection,
+ this
+ )
+
+ // when
+ sut.invoke(false)
+ runCurrent()
+
+ // then
+ assertThat(repository.getStoredQueue()).isNotEmpty
+ }
+
+ @Test
+ fun `given non-empty local storage, when flushing queue with not skipping sending events fails, then flush manager is not stopped`() =
+ runTest {
+ // given
+ val flushManager = FakeFlushManager()
+ val repository = FakeRepository().apply {
+ insertEvents(listOf(mapOf("test" to 123)))
+ }
+ val parselyAPIConnection = FakeRestClient().apply {
+ nextResult = Result.failure(Exception())
+ }
+ val sut = FlushQueue(
+ flushManager,
+ repository,
+ parselyAPIConnection,
+ this
+ )
+
+ // when
+ sut.invoke(false)
+ runCurrent()
+
+ // then
+ assertThat(flushManager.stopped).isFalse
+ }
+
+ @Test
+ fun `given non-empty local storage, when storage is not empty after successful flushing queue with not skipping sending events, then flush manager is not stopped`() =
+ runTest {
+ // given
+ val flushManager = FakeFlushManager()
+ val repository = object : FakeRepository() {
+ override suspend fun getStoredQueue(): ArrayList?> {
+ return ArrayList(listOf(mapOf("test" to 123)))
+ }
+ }
+ val parselyAPIConnection = FakeRestClient().apply {
+ nextResult = Result.success(Unit)
+ }
+ val sut = FlushQueue(
+ flushManager,
+ repository,
+ parselyAPIConnection,
+ this
+ )
+
+ // when
+ sut.invoke(false)
+ runCurrent()
+
+ // then
+ assertThat(flushManager.stopped).isFalse
+ }
+
+ @Test
+ fun `given empty local storage, when invoked, then flush manager is stopped`() = runTest {
+ // given
+ val flushManager = FakeFlushManager()
+ val sut = FlushQueue(
+ flushManager,
+ FakeRepository(),
+ FakeRestClient(),
+ this
+ )
+
+ // when
+ sut.invoke(false)
+ runCurrent()
+
+ // then
+ assertThat(flushManager.stopped).isTrue()
+ }
+
+ private class FakeFlushManager : FlushManager {
+ var stopped = false
+ override fun start() {
+ TODO("Not implemented")
+ }
+
+ override fun stop() {
+ stopped = true
+ }
+
+ override val isRunning
+ get() = TODO("Not implemented")
+ override val intervalMillis
+ get() = TODO("Not implemented")
+ }
+
+ private open class FakeRepository : QueueRepository {
+ private var storage = emptyList?>()
+
+ override suspend fun insertEvents(toInsert: List?>) {
+ storage = storage + toInsert
+ }
+
+ override suspend fun remove(toRemove: List?>) {
+ storage = storage - toRemove.toSet()
+ }
+
+ override suspend fun getStoredQueue(): ArrayList?> {
+ return ArrayList(storage)
+ }
+ }
+
+ private class FakeRestClient : RestClient {
+
+ var nextResult: Result? = null
+
+ override suspend fun send(payload: String): Result {
+ return nextResult!!
+ }
+ }
+}
diff --git a/parsely/src/test/java/com/parsely/parselyandroid/InMemoryBufferTest.kt b/parsely/src/test/java/com/parsely/parselyandroid/InMemoryBufferTest.kt
index 66bc9614..e4f354ff 100644
--- a/parsely/src/test/java/com/parsely/parselyandroid/InMemoryBufferTest.kt
+++ b/parsely/src/test/java/com/parsely/parselyandroid/InMemoryBufferTest.kt
@@ -1,6 +1,5 @@
package com.parsely.parselyandroid
-import androidx.test.core.app.ApplicationProvider
import kotlin.time.Duration.Companion.seconds
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.cancel
@@ -78,8 +77,7 @@ internal class InMemoryBufferTest {
assertThat(repository.getStoredQueue()).containsOnlyOnceElementsOf(events)
}
- class FakeLocalStorageRepository :
- LocalStorageRepository(ApplicationProvider.getApplicationContext()) {
+ class FakeLocalStorageRepository : QueueRepository {
private val events = mutableListOf?>()
@@ -87,7 +85,11 @@ internal class InMemoryBufferTest {
events.addAll(toInsert)
}
- override fun getStoredQueue(): ArrayList?> {
+ override suspend fun remove(toRemove: List?>) {
+ TODO("Not implemented")
+ }
+
+ override suspend fun getStoredQueue(): ArrayList?> {
return ArrayList(events)
}
}
diff --git a/parsely/src/test/java/com/parsely/parselyandroid/LocalStorageRepositoryTest.kt b/parsely/src/test/java/com/parsely/parselyandroid/LocalStorageRepositoryTest.kt
index f92b0d59..47a60057 100644
--- a/parsely/src/test/java/com/parsely/parselyandroid/LocalStorageRepositoryTest.kt
+++ b/parsely/src/test/java/com/parsely/parselyandroid/LocalStorageRepositoryTest.kt
@@ -24,19 +24,6 @@ class LocalStorageRepositoryTest {
sut = LocalStorageRepository(context)
}
- @Test
- fun `when expelling stored event, then assert that it has no effect`() = runTest {
- // given
- sut.insertEvents(((1..100).map { mapOf("index" to it) }))
- runCurrent()
-
- // when
- sut.expelStoredEvent()
-
- // then
- assertThat(sut.getStoredQueue()).hasSize(100)
- }
-
@Test
fun `given the list of events, when persisting the list, then querying the list returns the same result`() = runTest {
// given
@@ -51,7 +38,7 @@ class LocalStorageRepositoryTest {
}
@Test
- fun `given no locally stored list, when requesting stored queue, then return an empty list`() {
+ fun `given no locally stored list, when requesting stored queue, then return an empty list`() = runTest {
assertThat(sut.getStoredQueue()).isEmpty()
}
@@ -92,7 +79,7 @@ class LocalStorageRepositoryTest {
}
@Test
- fun `given stored file with serialized events, when querying the queue, then list has expected events`() {
+ fun `given stored file with serialized events, when querying the queue, then list has expected events`() = runTest {
// given
val file = File(context.filesDir.path + "/parsely-events.ser")
File(ClassLoader.getSystemResource("valid-java-parsely-events.ser")?.path!!).copyTo(file)
diff --git a/parsely/src/test/java/com/parsely/parselyandroid/ParselyAPIConnectionTest.kt b/parsely/src/test/java/com/parsely/parselyandroid/ParselyAPIConnectionTest.kt
index 815abc93..497e5d5c 100644
--- a/parsely/src/test/java/com/parsely/parselyandroid/ParselyAPIConnectionTest.kt
+++ b/parsely/src/test/java/com/parsely/parselyandroid/ParselyAPIConnectionTest.kt
@@ -1,29 +1,29 @@
package com.parsely.parselyandroid
-import androidx.test.core.app.ApplicationProvider
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
+import okio.IOException
import org.assertj.core.api.Assertions.assertThat
import org.junit.After
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.LooperMode
-import org.robolectric.shadows.ShadowLooper.shadowMainLooper
+@OptIn(ExperimentalCoroutinesApi::class)
@RunWith(RobolectricTestRunner::class)
-@LooperMode(LooperMode.Mode.PAUSED)
class ParselyAPIConnectionTest {
private lateinit var sut: ParselyAPIConnection
private val mockServer = MockWebServer()
private val url = mockServer.url("").toString()
- private val tracker = FakeTracker()
@Before
fun setUp() {
- sut = ParselyAPIConnection(tracker)
+ sut = ParselyAPIConnection(url)
}
@After
@@ -32,88 +32,43 @@ class ParselyAPIConnectionTest {
}
@Test
- fun `given successful response, when making connection without any events, then make GET request`() {
- // given
- mockServer.enqueue(MockResponse().setResponseCode(200))
-
- // when
- sut.execute(url).get()
- shadowMainLooper().idle();
-
- // then
- val request = mockServer.takeRequest()
- assertThat(request).satisfies({
- assertThat(it.method).isEqualTo("GET")
- assertThat(it.failure).isNull()
- })
- }
-
- @Test
- fun `given successful response, when making connection with events, then make POST request with JSON Content-Type header`() {
- // given
- mockServer.enqueue(MockResponse().setResponseCode(200))
-
- // when
- sut.execute(url, pixelPayload).get()
- shadowMainLooper().idle();
-
- // then
- assertThat(mockServer.takeRequest()).satisfies({
- assertThat(it.method).isEqualTo("POST")
- assertThat(it.headers["Content-Type"]).isEqualTo("application/json")
- assertThat(it.body.readUtf8()).isEqualTo(pixelPayload)
- })
- }
-
- @Test
- fun `given successful response, when request is made, then purge events queue and stop flush timer`() {
- // given
- mockServer.enqueue(MockResponse().setResponseCode(200))
- tracker.events.add(mapOf("idsite" to "example.com"))
-
- // when
- sut.execute(url).get()
- shadowMainLooper().idle();
-
- // then
- assertThat(tracker.events).isEmpty()
- assertThat(tracker.flushTimerStopped).isTrue
- }
+ fun `given successful response, when making connection with events, then make POST request with JSON Content-Type header`() =
+ runTest {
+ // given
+ mockServer.enqueue(MockResponse().setResponseCode(200))
+
+ // when
+ val result = sut.send(pixelPayload)
+ runCurrent()
+
+ // then
+ assertThat(mockServer.takeRequest()).satisfies({
+ assertThat(it.method).isEqualTo("POST")
+ assertThat(it.headers["Content-Type"]).isEqualTo("application/json")
+ assertThat(it.body.readUtf8()).isEqualTo(pixelPayload)
+ })
+ assertThat(result.isSuccess).isTrue
+ }
@Test
- fun `given unsuccessful response, when request is made, then do not purge events queue and do not stop flush timer`() {
- // given
- mockServer.enqueue(MockResponse().setResponseCode(400))
- val sampleEvents = mapOf("idsite" to "example.com")
- tracker.events.add(sampleEvents)
-
- // when
- sut.execute(url).get()
- shadowMainLooper().idle();
-
- // then
- assertThat(tracker.events).containsExactly(sampleEvents)
- assertThat(tracker.flushTimerStopped).isFalse
- }
+ fun `given unsuccessful response, when request is made, then return failure with exception`() =
+ runTest {
+ // given
+ mockServer.enqueue(MockResponse().setResponseCode(400))
+
+ // when
+ val result = sut.send(pixelPayload)
+ runCurrent()
+
+ // then
+ assertThat(result.isFailure).isTrue
+ assertThat(result.exceptionOrNull()).isInstanceOf(IOException::class.java)
+ }
companion object {
val pixelPayload: String =
- this::class.java.getResource("pixel_payload.json")?.readText().orEmpty()
- }
-
- private class FakeTracker : ParselyTracker(
- "siteId", 10, ApplicationProvider.getApplicationContext()
- ) {
-
- var flushTimerStopped = false
- val events = mutableListOf>()
-
- override fun purgeEventsQueue() {
- events.clear()
- }
-
- override fun stopFlushTimer() {
- flushTimerStopped = true
- }
+ ClassLoader.getSystemResource("pixel_payload.json").readText().apply {
+ assert(isNotBlank())
+ }
}
}