detox 20.1.0-next-is-hittable-check.0 → 20.1.0

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/uimodule/UIManagerModuleReflected.kt

@@ -9,12 +9,12 @@ import org.joor.Reflect
 private const val CLASS_UI_MANAGER_MODULE = "com.facebook.react.uimanager.UIManagerModule"
 private const val METHOD_GET_NATIVE_MODULE = "getNativeModule"
 private const val METHOD_GET_UI_IMPLEMENTATION = "getUIImplementation"
+private const val METHOD_IS_EMPTY = "isEmpty"
 private const val FIELD_UI_OPERATION_QUEUE = "mOperationsQueue"
 private const val FIELD_DISPATCH_RUNNABLES = "mDispatchUIRunnables"
 private const val FIELD_DISPATCH_RUNNABLES_LOCK = "mDispatchRunnablesLock"
 private const val FIELD_NON_BATCHED_OPS = "mNonBatchedOperations"
 private const val FIELD_NON_BATCHED_OPS_LOCK = "mNonBatchedOperationsLock"
-private const val METHOD_IS_EMPTY = "isEmpty"
 
 class UIManagerModuleReflected(private val reactContext: ReactContext) {
 

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/uimodule/UIModuleIdlingResource.kt

@@ -6,7 +6,6 @@ import androidx.test.espresso.IdlingResource.ResourceCallback
 import com.facebook.react.bridge.ReactContext
 import com.wix.detox.reactnative.helpers.RNHelpers
 import com.wix.detox.reactnative.idlingresources.DetoxBaseIdlingResource
-import com.wix.detox.reactnative.idlingresources.IdlingResourceDescription
 import org.joor.ReflectException
 
 /**
@@ -21,11 +20,10 @@ class UIModuleIdlingResource(private val reactContext: ReactContext)
     private var callback: ResourceCallback? = null
 
     override fun getName(): String = UIModuleIdlingResource::class.java.name
-    override fun getDescription() =
-            IdlingResourceDescription.Builder()
-                .name("ui")
-                .addDescription("reason", "UI rendering activity")
-                .build()
+    override fun getDebugName(): String = " ui"
+    override fun getBusyHint(): Map<String, Any> {
+        return mapOf("reason" to "UI rendering activity")
+    }
 
     override fun checkIdle(): Boolean {
         try {

package/android/detox/src/testFull/java/com/wix/detox/adapters/server/QueryStatusActionHandlerSpec.kt

@@ -1,9 +1,8 @@
 package com.wix.detox.adapters.server
 
-import androidx.test.espresso.IdlingResource
 import com.wix.detox.TestEngineFacade
-import com.wix.detox.reactnative.idlingresources.DescriptiveIdlingResource
-import com.wix.detox.reactnative.idlingresources.IdlingResourceDescription
+import com.wix.detox.inquiry.DetoxBusyResource
+import com.wix.detox.inquiry.DetoxBusyResourceDescription
 import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
@@ -31,103 +30,45 @@ object QueryStatusActionHandlerSpec : Spek({
             }
         }
 
-        fun queryStatusHandler() = QueryStatusActionHandler(outboundServerAdapter, testEngineFacade)
+        fun uut() = QueryStatusActionHandler(outboundServerAdapter, testEngineFacade)
 
-        it("should return idle app status") {
-            queryStatusHandler().handle(params, messageId)
-            val expectedData =  mapOf("status" to mapOf("app_status" to "idle"))
-            verify(outboundServerAdapter).sendMessage(eq("currentStatusResult"), eq(expectedData), eq(messageId))
-        }
-
-        fun createMockedDescriptiveResource(description: IdlingResourceDescription):
-                DescriptiveIdlingResource {
-            val resource: DescriptiveIdlingResource = mock()
-            whenever(resource.getDescription()).thenReturn(description)
-            return resource
-        }
-
-        it("should return busy app status with descriptive resource") {
-            val fakeDescription = IdlingResourceDescription.Builder()
-                .name("foo")
-                .addDescription("bar", "baz")
-                .addDescription("qux", "quux")
-                .build()
-
-            val busyResources: List<IdlingResource> = listOf(
-                createMockedDescriptiveResource(fakeDescription)
-            )
-            whenever(testEngineFacade.getBusyIdlingResources()).thenReturn(busyResources)
+        describe("given an idle app") {
+            it("should send an idle status indication") {
+                val expectedData =  mapOf("status" to mapOf("app_status" to "idle"))
 
-            queryStatusHandler().handle(params, messageId)
-
-            val expectedBusyResourceDescription = listOf(
-                mapOf("name" to "foo", "description" to mapOf("bar" to "baz", "qux" to "quux"))
-            )
-            val expectedData =  mapOf("status" to mapOf("app_status" to "busy", "busy_resources" to expectedBusyResourceDescription))
-            verify(outboundServerAdapter).sendMessage(eq("currentStatusResult"), eq(expectedData), eq(messageId))
-        }
-
-        abstract class LooperIdlingResource: IdlingResource {}
-
-        fun createMockedLooperIdlingResource(resourceName: String): LooperIdlingResource {
-            val resource: LooperIdlingResource = mock()
-            whenever(resource.name).thenReturn(resourceName)
-            return resource
+                uut().handle(params, messageId)
+                verify(outboundServerAdapter).sendMessage(eq("currentStatusResult"), eq(expectedData), eq(messageId))
+            }
         }
 
-        it("should return busy app status with looper resources") {
-            val busyResources: List<IdlingResource> = listOf(
-                createMockedLooperIdlingResource("mqt_js"),
-                createMockedLooperIdlingResource("mqt_native"),
-                createMockedLooperIdlingResource("unmapped")
-            )
-            whenever(testEngineFacade.getBusyIdlingResources()).thenReturn(busyResources)
-
-            queryStatusHandler().handle(params, messageId)
+        describe("given a busy app") {
+            fun aBusyResourceDescription(description: Map<String, Any>): DetoxBusyResourceDescription =
+                mock {
+                    on { json() }.thenReturn(description)
+                }
+
+            fun aBusyResource(identifier: String): DetoxBusyResource {
+                val mockedDescription = aBusyResourceDescription(mapOf("mock" to identifier))
+                return mock {
+                    on { getDescription() }.thenReturn(mockedDescription)
+                }
+            }
 
-            val expectedBusyResourceDescription = listOf(
-                mapOf(
-                    "name" to "looper",
-                    "description" to mapOf(
-                        "thread" to "\"mqt_js\" (JS Thread)",
-                        "execution_type" to "JavaScript code"
-                    )
-                ),
-                mapOf(
-                    "name" to "looper",
-                    "description" to mapOf(
-                        "thread" to "\"mqt_native\" (Native Modules Thread)",
-                        "execution_type" to "native module calls"
+            it("should send a descriptive busy-status indication") {
+                val busyResource = aBusyResource("some-resource")
+                val busyResource2 = aBusyResource("yet-another-resource")
+                val expectedData =  mapOf<String, Any>("status" to mapOf(
+                    "app_status" to "busy",
+                    "busy_resources" to listOf(
+                        mapOf("mock" to "some-resource"),
+                        mapOf("mock" to "yet-another-resource"),
                     )
-                ),
-                mapOf(
-                    "name" to "looper",
-                    "description" to mapOf("thread" to "\"unmapped\"")
-                )
-            )
-            val expectedData =  mapOf("status" to mapOf("app_status" to "busy", "busy_resources" to expectedBusyResourceDescription))
-            verify(outboundServerAdapter).sendMessage(eq("currentStatusResult"), eq(expectedData), eq(messageId))
-        }
+                ))
+                whenever(testEngineFacade.getAllBusyResources()).thenReturn(listOf(busyResource, busyResource2))
 
-        fun createMockedIdlingResource(name: String): IdlingResource {
-            val resource: IdlingResource = mock()
-            whenever(resource.name).thenReturn(name)
-            return resource
-        }
-
-        it("should return busy app status with unknown resource") {
-            val busyResources: List<IdlingResource> = listOf(
-                createMockedIdlingResource( "quux")
-            )
-            whenever(testEngineFacade.getBusyIdlingResources()).thenReturn(busyResources)
-
-            queryStatusHandler().handle(params, messageId)
-
-            val expectedBusyResourceDescription = listOf(
-                mapOf("name" to "unknown", "description" to mapOf("identifier" to "quux"))
-            )
-            val expectedData =  mapOf("status" to mapOf("app_status" to "busy", "busy_resources" to expectedBusyResourceDescription))
-            verify(outboundServerAdapter).sendMessage(eq("currentStatusResult"), eq(expectedData), eq(messageId))
+                uut().handle(params, messageId)
+                verify(outboundServerAdapter).sendMessage(eq("currentStatusResult"), eq(expectedData), eq(messageId))
+            }
         }
-    }
+   }
 })

package/android/detox/src/testFull/java/com/wix/detox/espresso/registry/{IRStatusInquirerTest.kt → BusyResourcesInquirerTest.kt}

@@ -4,6 +4,8 @@ import android.os.Looper
 import androidx.test.espresso.IdlingResource
 import androidx.test.espresso.base.IdlingResourceRegistry
 import com.wix.detox.UTHelpers
+import com.wix.detox.espresso.common.UiControllerImplReflected
+import com.wix.detox.inquiry.DetoxBusyResource
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Before
 import org.junit.Test
@@ -21,10 +23,11 @@ import java.util.concurrent.Executors
 // Fixes: Hangs in UIThread.postFirstSync inside IRStatusInquirer.getAllBusyResources when upgrading robolectric 4.3.x -> 4.4
 // See http://robolectric.org/blog/2019/06/04/paused-looper/ (coming from https://github.com/robolectric/robolectric/releases/tag/robolectric-4.4)
 @LooperMode(LooperMode.Mode.LEGACY)
-class IRStatusInquirerTest {
+class BusyResourcesInquirerTest {
 
     lateinit var registry: IdlingResourceRegistry
-    lateinit var uut: IRStatusInquirer
+    lateinit var uiController: UiControllerImplReflected
+    lateinit var uut: BusyResourcesInquirer
 
     private fun anIdleResource() = mock<IdlingResource> {
         on { isIdleNow } doReturn true
@@ -38,10 +41,22 @@ class IRStatusInquirerTest {
         whenever(registry.resources).doReturn(resources.asList())
     }
 
+    private fun givenRunningAsyncTasks() {
+        whenever(uiController.isAsyncIdleNow()).doReturn(false)
+    }
+
+    private fun givenRunningCompatAsyncTasks() {
+        whenever(uiController.isCompatIdleNow()).doReturn(false)
+    }
+
     @Before
     fun setup() {
         registry = mock()
-        uut = IRStatusInquirer(registry)
+        uiController = mock() {
+            on { isAsyncIdleNow() } doReturn true
+            on { isCompatIdleNow() } doReturn true
+        }
+        uut = BusyResourcesInquirer(registry, uiController)
     }
 
     @Test
@@ -51,13 +66,33 @@ class IRStatusInquirerTest {
     }
 
     @Test
-    fun `should return busy resources if there are some`() {
+    fun `should return busy resources if there are some IR ones`() {
         val resourceIdle = anIdleResource()
         val resourceBusy = aBusyResource()
         givenIdlingResources(resourceIdle, resourceBusy)
 
         val result = uut.getAllBusyResources()
-        assertThat(result).isEqualTo(arrayListOf(resourceBusy))
+        assertThat(result.size).isEqualTo(1)
+        assertThat(result[0] is DetoxBusyResource.BusyIdlingResource)
+        assertThat((result[0] as DetoxBusyResource.BusyIdlingResource).resource).isEqualTo(resourceBusy)
+    }
+
+    @Test
+    fun `should return the async-task busy resource if some async-tasks are running`() {
+        givenRunningAsyncTasks()
+
+        val result = uut.getAllBusyResources()
+        assertThat(result.size).isEqualTo(1)
+        assertThat(result[0] is DetoxBusyResource.BusyAsyncTasks)
+    }
+
+    @Test
+    fun `should return the async-task busy resource if some legacy async-tasks are running`() {
+        givenRunningCompatAsyncTasks()
+
+        val result = uut.getAllBusyResources()
+        assertThat(result.size).isEqualTo(1)
+        assertThat(result[0] is DetoxBusyResource.BusyAsyncTasks)
     }
 
     @Test
@@ -79,13 +114,17 @@ class IRStatusInquirerTest {
         }
         givenIdlingResources(resource)
 
-        var result: List<IdlingResource>? = null
+        var result: List<DetoxBusyResource>? = null
         executor.execute {
             result = uut.getAllBusyResources()
         }
         Thread.sleep(100L) // Give time for the unit to actually post on the main thread (as it's suppose to...)
         Robolectric.flushForegroundThreadScheduler()
         UTHelpers.yieldToOtherThreads(executor)
-        assertThat(result).isEqualTo(arrayListOf(resource)) // Assert (2)
+
+        assertThat(result).isNotNull
+        assertThat(result!!.size).isEqualTo(1)
+        assertThat(result!![0] is DetoxBusyResource.BusyIdlingResource)
+        assertThat((result!![0] as DetoxBusyResource.BusyIdlingResource).resource).isEqualTo(resource)
     }
 }

package/android/detox/src/testFull/java/com/wix/detox/{reactnative/idlingresources/IdlingResourceDescriptionSpec.kt → inquiry/DetoxBusyResourceDescriptionSpec.kt}

@@ -1,16 +1,16 @@
-package com.wix.detox.reactnative.idlingresources
+package com.wix.detox.inquiry
 
 import org.assertj.core.api.Assertions
 import org.spekframework.spek2.Spek
 import org.spekframework.spek2.style.specification.describe
 
-class IdlingResourceDescriptionSpec: Spek({
+class DetoxBusyResourceDescriptionSpec: Spek({
     describe("Idling Resource Description Builder") {
-        lateinit var description: IdlingResourceDescription
+        lateinit var description: DetoxBusyResourceDescription
         lateinit var expectedJSON: Map<String, Any>
 
         it("should build with given description") {
-            description = IdlingResourceDescription.Builder()
+            description = DetoxBusyResourceDescription.Builder()
                 .name("foo")
                 .addDescription("bar", "baz")
                 .addDescription("qux", "quux")
@@ -24,14 +24,14 @@ class IdlingResourceDescriptionSpec: Spek({
         }
 
         it("should build without description") {
-            description = IdlingResourceDescription.Builder().name("foo").build()
+            description = DetoxBusyResourceDescription.Builder().name("foo").build()
 
             expectedJSON = mapOf("name" to "foo")
             Assertions.assertThat(description.json()).isEqualTo(expectedJSON)
         }
 
         it("should build without name") {
-            description = IdlingResourceDescription.Builder()
+            description = DetoxBusyResourceDescription.Builder()
                 .addDescription("bar", "baz")
                 .addDescription("qux", "quux")
                 .build()

package/android/detox/src/testFull/java/com/wix/detox/inquiry/DetoxBusyResourceSpec.kt

@@ -0,0 +1,134 @@
+package com.wix.detox.inquiry
+
+import androidx.test.espresso.IdlingResource
+import com.wix.detox.espresso.idlingresources.DescriptiveIdlingResource
+import org.assertj.core.api.Assertions.assertThat
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.spekframework.spek2.Spek
+import org.spekframework.spek2.style.specification.describe
+
+class DetoxBusyResourceSpec: Spek({
+    describe("Detox busy resource") {
+        data class TestCase<in T: IdlingResource>(
+            val caseTitle: String,
+            val idlingResource: IdlingResource,
+            val expectedDescription: DetoxBusyResourceDescription
+        )
+
+        describe("given a descriptive idling resource") {
+            val mockedDebugName = "mock:debug-name"
+
+            fun aDescriptiveIdlingResource(busyHint: Map<String, Any>?): DescriptiveIdlingResource =
+                mock() {
+                    on { getDebugName() }.doReturn(mockedDebugName)
+                    on { getBusyHint() }.doReturn(busyHint)
+                }
+
+            listOf(
+                TestCase<IdlingResource>(
+                    caseTitle = "should return a description based on debug-name and busy-hint",
+                    idlingResource = aDescriptiveIdlingResource(mapOf("mocked" to "hint", "mocked2" to "hint2")),
+                    expectedDescription = DetoxBusyResourceDescription.Builder()
+                        .name(mockedDebugName)
+                        .addDescription("mocked", "hint")
+                        .addDescription("mocked2", "hint2")
+                        .build()
+                ),
+                TestCase(
+                    caseTitle = "should return a description even without a busy-hint",
+                    idlingResource = aDescriptiveIdlingResource(busyHint = null),
+                    expectedDescription = DetoxBusyResourceDescription.Builder()
+                        .name(mockedDebugName)
+                        .build()
+                ),
+            ).forEach { (caseTitle, idlingResource, expectedDescription)  ->
+                it(caseTitle) {
+                    val uut = DetoxBusyResource.BusyIdlingResource(idlingResource)
+
+                    assertThat(uut.resource).isEqualTo(idlingResource)
+                    assertThat(uut.getDescription()).isEqualTo(expectedDescription)
+                }
+            }
+        }
+
+        describe("given a looper idling resource") {
+
+            abstract class LooperIdlingResource: IdlingResource {}
+
+            fun aLooperIdlingResourceMock(resourceName: String): LooperIdlingResource =
+                mock() {
+                    on { name }.doReturn(resourceName)
+                }
+
+            listOf(
+                TestCase<LooperIdlingResource>(
+                    caseTitle = "should return a tailored description for the js-thread looper",
+                    idlingResource = aLooperIdlingResourceMock("mqt_js"),
+                    expectedDescription = DetoxBusyResourceDescription.Builder()
+                        .name("looper")
+                        .addDescription("thread", "\"mqt_js\" (JS Thread)")
+                        .addDescription("execution_type", "JavaScript code")
+                        .build(),
+                ),
+                TestCase<LooperIdlingResource>(
+                    caseTitle = "should return a tailored description for native-modules thread",
+                    idlingResource = aLooperIdlingResourceMock("mqt_native"),
+                    expectedDescription = DetoxBusyResourceDescription.Builder()
+                        .name("looper")
+                        .addDescription("thread", "\"mqt_native\" (Native Modules Thread)")
+                        .addDescription("execution_type", "native module calls")
+                        .build()
+                ),
+                TestCase<LooperIdlingResource>(
+                    caseTitle = "should return a default description for unspecified looper-threads",
+                    idlingResource = aLooperIdlingResourceMock("unmapped"),
+                    expectedDescription = DetoxBusyResourceDescription.Builder()
+                        .name("looper")
+                        .addDescription("thread", "\"unmapped\"")
+                        .build(),
+                ),
+            ).forEach { (caseTitle, idlingResource, expectedDescription) ->
+                it(caseTitle) {
+                    val uut = DetoxBusyResource.BusyIdlingResource(idlingResource)
+
+                    assertThat(uut.resource).isEqualTo(idlingResource)
+                    assertThat(uut.getDescription()).isEqualTo(expectedDescription)
+                }
+            }
+        }
+
+        describe("given a generic idling resource") {
+            val mockedResourceName = "mock:resource-name"
+
+            listOf(
+                TestCase<IdlingResource>(
+                    caseTitle = "should return a generic description for a generic idling resource",
+                    idlingResource = mock { on { name}.doReturn(mockedResourceName) },
+                    expectedDescription = DetoxBusyResourceDescription.Builder()
+                        .name("unknown")
+                        .addDescription("identifier", mockedResourceName)
+                        .build()
+                )
+            ).forEach { (caseTitle, idlingResource, expectedDescription) ->
+                it (caseTitle) {
+                    val uut = DetoxBusyResource.BusyIdlingResource(idlingResource)
+
+                    assertThat(uut.resource).isEqualTo(idlingResource)
+                    assertThat(uut.getDescription()).isEqualTo(expectedDescription)
+                }
+            }
+        }
+
+        describe("busy async-task(s) description") {
+            it("should return a general description") {
+                val expectedDescription = DetoxBusyResourceDescription.Builder()
+                    .name("bg")
+                    .addDescription("reason", "native async-tasks")
+                    .build()
+
+                assertThat(DetoxBusyResource.BusyAsyncTasks.getDescription()).isEqualTo(expectedDescription)
+            }
+        }
+    }
+})

package/android/detox/src/testFull/java/com/wix/detox/reactnative/idlingresources/AsyncStorageIdlingResourceSpec.kt

@@ -61,6 +61,10 @@ class AsyncStorageIdlingResourceSpec: Spek({
             assertThat(uut.name).isEqualTo("com.wix.detox.reactnative.idlingresources.AsyncStorageIdlingResource")
         }
 
+        it("should have a debug-name") {
+            assertThat(uut.getDebugName()).isEqualTo("io")
+        }
+
         describe("idle-checking") {
             it("should be idle") {
                 givenIdleSExecutor()
@@ -71,11 +75,6 @@ class AsyncStorageIdlingResourceSpec: Spek({
                 givenAnActiveTask()
                 givenNoPendingTasks()
                 assertThat(uut.isIdleNow).isFalse()
-
-                val expectedDescription = IdlingResourceDescription.Builder()
-                    .name("io")
-                    .build()
-                assertThat(uut.getDescription()).isEqualTo(expectedDescription)
             }
 
             it("should be busy if executor has pending tasks") {

package/android/detox/src/testFull/java/com/wix/detox/reactnative/idlingresources/NetworkIdlingResourcesTest.kt

@@ -24,20 +24,20 @@ class NetworkIdlingResourcesTest {
     // Note: Ideally, we should test that the list of busy resources is protected,
     // rather than testing thread-safety as a whole.
     @Test
-    fun `should return the description in a thread-safe way`() {
+    fun `should return the descriptive data a thread-safe way`() {
         val localExecutor = Executors.newSingleThreadExecutor()
-        var description: IdlingResourceDescription? = null
+        var busyHint: Map<String, Any>? = null
 
         synchronized(uut) {
             localExecutor.submit {
-                description = uut.getDescription()
+                busyHint = uut.getBusyHint()
             }
 
             yieldToOtherThreads(localExecutor)
-            assertThat(description).isNull()
+            assertThat(busyHint).isNull()
         }
         yieldToOtherThreads(localExecutor)
-        assertThat(description).isNotNull()
+        assertThat(busyHint).isNotNull
     }
 
     // Note: Ideally, we should test that the list of busy resources is protected,

package/android/detox/src/testFull/java/com/wix/detox/reactnative/idlingresources/timers/TimersIdlingResourceSpec.kt

@@ -2,7 +2,6 @@ package com.wix.detox.reactnative.idlingresources.timers
 
 import android.view.Choreographer
 import androidx.test.espresso.IdlingResource
-import com.wix.detox.reactnative.idlingresources.IdlingResourceDescription
 import org.assertj.core.api.Assertions
 import org.mockito.kotlin.*
 import org.spekframework.spek2.Spek
@@ -41,6 +40,10 @@ object TimersIdlingResourceSpec : Spek({
             getChoreographerCallback().doFrame(0L)
         }
 
+        it("should return a debug-name") {
+            Assertions.assertThat(uut().getDebugName()).isEqualTo("timers")
+        }
+
         it("should be idle if strategy says so") {
             givenIdleStrategy()
             Assertions.assertThat(uut().isIdleNow).isTrue()
@@ -49,11 +52,6 @@ object TimersIdlingResourceSpec : Spek({
         it("should be busy if strategy says so") {
             givenBusyStrategy()
             Assertions.assertThat(uut().isIdleNow).isFalse()
-
-            val expectedDescription = IdlingResourceDescription.Builder()
-                .name("timers")
-                .build()
-            Assertions.assertThat(uut().getDescription()).isEqualTo(expectedDescription)
         }
 
         it("should transition to idle if found idle by strategy") {