detox 21.0.0-breaking.new-global-lifecycle.0 → 21.0.1-rc.0

package/android/detox/src/testFull/java/com/wix/detox/espresso/action/GetAttributesActionTest.kt

@@ -4,7 +4,9 @@ import android.view.View
 import android.widget.CheckBox
 import android.widget.ProgressBar
 import android.widget.TextView
+import com.facebook.react.views.slider.ReactSlider
 import com.google.android.material.slider.Slider
+import com.wix.detox.reactnative.ui.getAccessibilityLabel
 import org.assertj.core.api.Assertions.assertThat
 import org.json.JSONObject
 import org.junit.Before
@@ -31,7 +33,7 @@ class GetAttributesActionTest {
     private fun givenNoViewTag() = givenViewTag(null)
     private fun givenVisibility(value: Int) { whenever(view.visibility).doReturn(value) }
     private fun givenVisibilityRectAvailability(value: Boolean) { whenever(view.getLocalVisibleRect(any())).doReturn(value) }
-    private fun givenContentDescription(value: String) { whenever(view.contentDescription).doReturn(value) }
+    private fun givenAccessibilityLabel(value: String) { whenever(view.getAccessibilityLabel()).doReturn(value) }
 
     private fun perform(v: View = view): JSONObject {
         uut.perform(null, v)
@@ -109,16 +111,16 @@ class GetAttributesActionTest {
     }
 
     @Test
-    fun `should return label according to content-description`() {
-        val contentDescription = "content-description-mock"
-        givenContentDescription(contentDescription)
+    fun `should return label according to accessibilityLabel extension`() {
+        val accessibilityLabel = "label-mock"
+        givenAccessibilityLabel(accessibilityLabel)
 
         val resultJson = perform()
-        assertThat(resultJson.opt("label")).isEqualTo(contentDescription)
+        assertThat(resultJson.opt("label")).isEqualTo(accessibilityLabel)
     }
 
     @Test
-    fun `should not return label if content description no set`() {
+    fun `should not return label if accessibility label is not available`() {
         val resultJson = perform()
         assertThat(resultJson.opt("label")).isNull()
     }
@@ -179,7 +181,7 @@ class GetAttributesActionTest {
     }
 
     @Test
-    fun `should return ProgressBar (or SeekBar) "progress" via value attribute`() {
+    fun `should return raw ProgressBar or SeekBar 'progress' via value attribute`() {
         val progressBar: ProgressBar = mock {
             on { progress } doReturn 42
         }
@@ -189,7 +191,18 @@ class GetAttributesActionTest {
     }
 
     @Test
-    fun `should return Slider state through value attribute`() {
+    fun `should return RN-Slider via value attribute`() {
+        val progressBar: ReactSlider = mock {
+            on { max } doReturn 100
+            on { progress } doReturn 50
+        }
+
+        val resultJson = perform(progressBar)
+        assertThat(resultJson.opt("value")).isEqualTo(0.5)
+    }
+
+    @Test
+    fun `should return material-Slider state through value attribute`() {
         val slider: Slider = mock {
             on { value } doReturn 0.42f
         }
@@ -225,7 +238,7 @@ class GetAttributesActionTest {
     }
 
     @Test
-    fun `should return text hint via "placeholder" attribute, if applicable`() {
+    fun `should return text hint via 'placeholder' attribute, if applicable`() {
         val textViewWithHint: TextView = mock {
             on { hint } doReturn "hint-text-mock"
         }

package/android/detox/src/testFull/java/com/wix/detox/espresso/common/SliderHelperTest.kt

@@ -0,0 +1,39 @@
+package com.wix.detox.espresso.common
+
+import com.facebook.react.views.slider.ReactSlider
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Note: This only tests against the react *legacy* (non-community) slider in order
+ * to avoid having to install the community slider under node_modules just for this.
+ */
+@RunWith(RobolectricTestRunner::class)
+class SliderHelperTest {
+    lateinit var slider: ReactSlider
+    lateinit var uut: SliderHelper
+
+    @Before
+    fun setup() {
+        slider = mock()
+        uut = SliderHelper.create(slider)
+    }
+
+    private fun givenNativeProgressTraits(current: Int, max: Int) {
+        whenever(slider.progress).doReturn(current)
+        whenever(slider.max).doReturn(max)
+    }
+
+    @Test
+    fun `should properly calculate current progress, in percentage`() {
+        givenNativeProgressTraits(current = 20, max = 100)
+
+        assertThat(uut.getCurrentProgressPct()).isEqualTo(0.2)
+    }
+}

package/android/detox/src/testFull/java/com/wix/detox/espresso/matcher/ViewAtIndexMatcherSpec.kt

@@ -3,7 +3,6 @@ package com.wix.detox.espresso.matcher
 import android.view.View
 import org.hamcrest.Description
 import org.hamcrest.Matcher
-import org.hamcrest.Matchers
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
@@ -28,7 +27,7 @@ object ViewAtIndexMatcherSpec: Spek({
                 uut.describeTo(description)
                 verify(description).appendText("View at index #0, of those matching MATCHER(innerMatcher description)")
             }
-            
+
             it("should append a valid description for index≥0") {
                 val uut = ViewAtIndexMatcher(7, innerMatcher)
                 uut.describeTo(description)

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

@@ -0,0 +1,61 @@
+package com.wix.detox.reactnative.idlingresources
+
+import com.wix.detox.UTHelpers.yieldToOtherThreads
+import org.assertj.core.api.Assertions.assertThat
+
+import okhttp3.Dispatcher
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import java.util.concurrent.Executors
+
+@RunWith(RobolectricTestRunner::class)
+class NetworkIdlingResourcesTest {
+    lateinit var dispatcher: Dispatcher
+    lateinit var uut: NetworkIdlingResource
+
+    @Before
+    fun setup() {
+        dispatcher = Dispatcher()
+        uut = NetworkIdlingResource(dispatcher)
+    }
+
+    // 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 descriptive data a thread-safe way`() {
+        val localExecutor = Executors.newSingleThreadExecutor()
+        var busyHint: Map<String, Any>? = null
+
+        synchronized(uut) {
+            localExecutor.submit {
+                busyHint = uut.getBusyHint()
+            }
+
+            yieldToOtherThreads(localExecutor)
+            assertThat(busyHint).isNull()
+        }
+        yieldToOtherThreads(localExecutor)
+        assertThat(busyHint).isNotNull
+    }
+
+    // Note: Ideally, we should test that the list of busy resources is protected,
+    // rather than testing thread-safety as a whole.
+    @Test
+    fun `should check for idle in a thread-safe way`() {
+        val localExecutor = Executors.newSingleThreadExecutor()
+        var idle = false
+
+        synchronized(uut) {
+            localExecutor.submit {
+                idle = uut.isIdleNow
+            }
+
+            yieldToOtherThreads(localExecutor)
+            assertThat(idle).isFalse
+        }
+        yieldToOtherThreads(localExecutor)
+        assertThat(idle).isTrue
+    }
+}

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

@@ -5,22 +5,14 @@ import org.assertj.core.api.Assertions.assertThat
 import org.mockito.kotlin.*
 import org.spekframework.spek2.Spek
 import org.spekframework.spek2.style.specification.describe
+import com.facebook.react.modules.core.TimingModule
 
 private const val BUSY_INTERVAL_MS = 1500L
 
-abstract class TimingModuleStub: NativeModule {
-    abstract fun hasActiveTimersInRange(rangeMs: Long): Boolean
-
-    override fun onCatalystInstanceDestroy() {}
-    override fun getName(): String = "TimersNativeModuleStub"
-    override fun canOverrideExistingModule() = false
-    override fun initialize() {}
-}
-
 object DelegatedIdleInterrogationStrategySpec : Spek({
-    describe("RN62+ timers idle-interrogation strategy") {
+    describe("Timers idle-interrogation strategy") {
 
-        lateinit var timingModule: TimingModuleStub
+        lateinit var timingModule: TimingModule
 
         beforeEachTest {
             timingModule = mock()

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") {

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,5 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.9-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-all.zip
+