1 files changed, 63 insertions, 60 deletions

diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/offline/OfflineManagerTest.kt b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/offline/OfflineManagerTest.kt
index 144d67feee..8e5f3f7c5f 100644
--- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/offline/OfflineManagerTest.kt
+++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/offline/OfflineManagerTest.kt
@@ -1,59 +1,43 @@
 package com.mapbox.mapboxsdk.testapp.offline
 
 import android.content.Context
-import android.support.test.espresso.Espresso
-import android.support.test.espresso.IdlingRegistry
-import android.support.test.espresso.UiController
-import android.support.test.espresso.idling.CountingIdlingResource
+import android.support.test.rule.ActivityTestRule
 import android.support.test.runner.AndroidJUnit4
-import com.mapbox.mapboxsdk.maps.MapboxMap
 import com.mapbox.mapboxsdk.offline.OfflineManager
 import com.mapbox.mapboxsdk.offline.OfflineRegion
 import com.mapbox.mapboxsdk.storage.FileSource
-import com.mapbox.mapboxsdk.testapp.action.MapboxMapAction.invoke
-import com.mapbox.mapboxsdk.testapp.activity.EspressoTest
+import com.mapbox.mapboxsdk.testapp.activity.FeatureOverviewActivity
 import com.mapbox.mapboxsdk.testapp.utils.FileUtils
+import org.junit.FixMethodOrder
+import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
 import java.io.IOException
+import java.util.concurrent.CountDownLatch
 
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
 @RunWith(AndroidJUnit4::class)
-class OfflineManagerTest : EspressoTest() {
+class OfflineManagerTest {
 
   companion object {
     private const val TEST_DB_FILE_NAME = "offline_test.db"
+    private lateinit var mergedRegion: OfflineRegion
   }
 
-  private val context: Context by lazy { rule.activity }
-
-  private lateinit var offlineIdlingResource: CountingIdlingResource
-
-  override fun beforeTest() {
-    super.beforeTest()
-    offlineIdlingResource = CountingIdlingResource("idling_resource")
-    IdlingRegistry.getInstance().register(offlineIdlingResource)
-  }
+  @Rule
+  @JvmField
+  var rule = ActivityTestRule(FeatureOverviewActivity::class.java)
 
-  @Test
-  fun offlineMergeListDeleteTest() {
-    validateTestSetup()
+  private val context: Context by lazy { rule.activity }
 
-    invoke(mapboxMap) { _: UiController, _: MapboxMap ->
-      offlineIdlingResource.increment()
+  @Test(timeout = 30_000)
+  fun a_copyFileFromAssets() {
+    val latch = CountDownLatch(1)
+    rule.runOnUiThread {
       FileUtils.CopyFileFromAssetsTask(rule.activity, object : FileUtils.OnFileCopiedFromAssetsListener {
         override fun onFileCopiedFromAssets() {
-          OfflineManager.getInstance(context).mergeOfflineRegions(
-            FileSource.getResourcesCachePath(rule.activity) + "/" + TEST_DB_FILE_NAME,
-            object : OfflineManager.MergeOfflineRegionsCallback {
-              override fun onMerge(offlineRegions: Array<out OfflineRegion>?) {
-                assert(offlineRegions?.size == 1)
-                offlineIdlingResource.decrement()
-              }
-
-              override fun onError(error: String?) {
-                throw RuntimeException("Unable to merge external offline database. $error")
-              }
-            })
+          latch.countDown()
         }
 
         override fun onError() {
@@ -61,43 +45,62 @@ class OfflineManagerTest : EspressoTest() {
         }
       }).execute(TEST_DB_FILE_NAME, FileSource.getResourcesCachePath(rule.activity))
     }
+    latch.await()
+  }
+
+  @Test(timeout = 30_000)
+  fun b_mergeRegion() {
+    val latch = CountDownLatch(1)
+    rule.runOnUiThread {
+      OfflineManager.getInstance(context).mergeOfflineRegions(
+        FileSource.getResourcesCachePath(rule.activity) + "/" + TEST_DB_FILE_NAME,
+        object : OfflineManager.MergeOfflineRegionsCallback {
+          override fun onMerge(offlineRegions: Array<out OfflineRegion>?) {
+            assert(offlineRegions?.size == 1)
+            latch.countDown()
+          }
+
+          override fun onError(error: String?) {
+            throw RuntimeException("Unable to merge external offline database. $error")
+          }
+        })
+    }
+    latch.await()
+  }
 
-    invoke(mapboxMap) { _: UiController, _: MapboxMap ->
-      offlineIdlingResource.increment()
+  @Test(timeout = 30_000)
+  fun c_listRegion() {
+    val latch = CountDownLatch(1)
+    rule.runOnUiThread {
       OfflineManager.getInstance(context).listOfflineRegions(object : OfflineManager.ListOfflineRegionsCallback {
         override fun onList(offlineRegions: Array<out OfflineRegion>?) {
           assert(offlineRegions?.size == 1)
-          if (offlineRegions != null) {
-            for (region in offlineRegions) {
-              offlineIdlingResource.increment()
-              region.delete(object : OfflineRegion.OfflineRegionDeleteCallback {
-                override fun onDelete() {
-                  offlineIdlingResource.decrement()
-                }
-
-                override fun onError(error: String?) {
-                  throw RuntimeException("Unable to delete region with ID: ${region.id}. $error")
-                }
-              })
-            }
-          } else {
-            throw RuntimeException("Unable to find merged region.")
-          }
-          offlineIdlingResource.decrement()
+          mergedRegion = offlineRegions!![0]
+          latch.countDown()
         }
 
         override fun onError(error: String?) {
-          throw RuntimeException("Unable to obtain offline regions list. $error")
+          throw RuntimeException("Unable to merge external offline database. $error")
         }
       })
     }
-
-    // waiting for offline idling resource
-    Espresso.onIdle()
+    latch.await()
   }
 
-  override fun afterTest() {
-    super.afterTest()
-    IdlingRegistry.getInstance().unregister(offlineIdlingResource)
+  @Test(timeout = 30_000)
+  fun d_deleteRegion() {
+    val latch = CountDownLatch(1)
+    rule.runOnUiThread {
+      mergedRegion.delete(object : OfflineRegion.OfflineRegionDeleteCallback {
+        override fun onDelete() {
+          latch.countDown()
+        }
+
+        override fun onError(error: String?) {
+          throw RuntimeException("Unable to delete region")
+        }
+      })
+    }
+    latch.await()
   }
 }
\ No newline at end of file