detox 20.28.0 → 20.31.0

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

@@ -0,0 +1,248 @@
+package com.wix.detox.reactnative.idlingresources
+
+import androidx.test.espresso.IdlingResource
+import com.facebook.react.bridge.NativeModule
+import com.wix.detox.UTHelpers.yieldToOtherThreads
+import com.wix.detox.reactnative.idlingresources.storage.AsyncStorageIdlingResource
+import com.wix.detox.reactnative.idlingresources.storage.SerialExecutorReflected
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.robolectric.RobolectricTestRunner
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+
+private class AsyncStorageModuleStub : NativeModule {
+    val executor: Executor = mock(name = "native-module's executor")
+    override fun getName() = "stub"
+    override fun initialize() {}
+    override fun canOverrideExistingModule() = false
+    override fun onCatalystInstanceDestroy() {}
+    override fun invalidate() {}
+}
+
+@RunWith(RobolectricTestRunner::class)
+class AsyncStorageIdlingResourceTest {
+    private lateinit var sexecutor: Executor
+    private lateinit var sexecutorReflected: SerialExecutorReflected
+    private lateinit var sexecutorReflectedGenFn: (executor: Executor) -> SerialExecutorReflected
+    private lateinit var module: AsyncStorageModuleStub
+    private lateinit var uut: AsyncStorageIdlingResource
+
+    @Before
+    fun setup() {
+        sexecutor = mock()
+        module = AsyncStorageModuleStub()
+        sexecutorReflected = mock() {
+            on { executor() }.thenReturn(sexecutor)
+        }
+        sexecutorReflectedGenFn = mock() {
+            on { invoke(eq(module.executor)) }.thenReturn(sexecutorReflected)
+        }
+
+
+        uut = AsyncStorageIdlingResource(module, sexecutorReflectedGenFn)
+    }
+
+    fun givenNoActiveTasks() = whenever(sexecutorReflected.hasActiveTask()).thenReturn(false)
+    fun givenAnActiveTask() = whenever(sexecutorReflected.hasActiveTask()).thenReturn(true)
+    fun givenNoPendingTasks() = whenever(sexecutorReflected.hasPendingTasks()).thenReturn(false)
+    fun givenPendingTasks() = whenever(sexecutorReflected.hasPendingTasks()).thenReturn(true)
+    fun givenIdleSExecutor() {
+        givenNoActiveTasks()
+        givenNoPendingTasks()
+    }
+
+    fun givenBusySExecutor() {
+        givenAnActiveTask()
+        givenNoPendingTasks()
+    }
+
+    fun verifyNoTasksEnqueued() = verify(sexecutorReflected, never()).executeTask(any())
+    fun verifyTaskEnqueuedOnce() = verify(sexecutorReflected, times(1)).executeTask(any())
+    fun verifyTaskEnqueuedTwice() = verify(sexecutorReflected, times(2)).executeTask(any())
+
+    @Test
+    fun `should have a name`() {
+        assertThat(uut.name).isEqualTo("com.wix.detox.reactnative.idlingresources.storage.AsyncStorageIdlingResource")
+    }
+
+    @Test
+    fun `should have a debug-name`() {
+        assertThat(uut.getDebugName()).isEqualTo("io")
+    }
+
+    @Test
+    fun `should be idle`() {
+        givenIdleSExecutor()
+        assertThat(uut.isIdleNow).isTrue()
+    }
+
+    @Test
+    fun `should be busy if executor is executing`() {
+        givenAnActiveTask()
+        givenNoPendingTasks()
+        assertThat(uut.isIdleNow).isFalse()
+    }
+
+    @Test
+    fun `should be busy if executor has pending tasks`() {
+        givenNoActiveTasks()
+        givenPendingTasks()
+        assertThat(uut.isIdleNow).isFalse()
+    }
+
+    @Test
+    fun `should be synchronized over actual executor`() {
+        val localExecutor = Executors.newSingleThreadExecutor()
+        var isIdle: Boolean? = null
+        synchronized(sexecutor) {
+            localExecutor.submit {
+                isIdle = uut.isIdleNow
+            }
+            yieldToOtherThreads(localExecutor)
+            assertThat(isIdle).isNull()
+        }
+        yieldToOtherThreads(localExecutor)
+    }
+
+    @Test
+    fun `should enqueue an idle-check task if resource is busy`() {
+        givenBusySExecutor()
+        uut.isIdleNow
+        verifyTaskEnqueuedOnce()
+    }
+
+    @Test
+    fun `should not enqueue an idle-check task if resource if idle`() {
+        givenIdleSExecutor()
+        uut.isIdleNow
+        verifyNoTasksEnqueued()
+    }
+
+    @Test
+    fun `should not enqueue more than one idle-check task`() {
+        givenBusySExecutor()
+
+        repeat(2) {
+            uut.isIdleNow
+        }
+        verifyTaskEnqueuedOnce()
+    }
+
+    private val callback: IdlingResource.ResourceCallback = mock()
+
+
+    fun verifyTransitionToIdleCalled() = verify(callback).onTransitionToIdle()
+    fun verifyTransitionToIdleNotCalled() = verify(callback, never()).onTransitionToIdle()
+
+    @Test
+    fun `should enqueue an idle-check task`() {
+        uut.registerIdleTransitionCallback(callback)
+        verifyTaskEnqueuedOnce()
+    }
+
+    @Test
+    fun `callback registration - should be synchronized over actual executor`() {
+        val localExecutor = Executors.newSingleThreadExecutor()
+
+        synchronized(sexecutor) {
+            localExecutor.submit {
+                uut.registerIdleTransitionCallback(callback)
+            }
+            yieldToOtherThreads(localExecutor)
+            verifyNoTasksEnqueued()
+        }
+        yieldToOtherThreads(localExecutor)
+    }
+
+
+    fun executeIdleCheckTask() {
+        argumentCaptor<Runnable>().also {
+            verify(sexecutorReflected).executeTask(it.capture())
+        }.firstValue.run()
+    }
+
+    @Test
+    fun `should transition to idle`() {
+        givenIdleSExecutor()
+
+        uut.registerIdleTransitionCallback(callback)
+        executeIdleCheckTask()
+
+        verifyTransitionToIdleCalled()
+    }
+
+    @Test
+    fun `should not transition to idle if busy`() {
+        givenAnActiveTask()
+        givenPendingTasks()
+
+        uut.registerIdleTransitionCallback(callback)
+        executeIdleCheckTask()
+
+        verifyTransitionToIdleNotCalled()
+    }
+
+    @Test
+    fun `should not inspect sexecutor for activity, because it runs on the executor itself`() {
+        givenAnActiveTask()
+        givenPendingTasks()
+
+        uut.registerIdleTransitionCallback(callback)
+        executeIdleCheckTask()
+
+        verify(sexecutorReflected, never()).hasActiveTask()
+    }
+
+    @Test
+    fun `should reenqueue if still busy`() {
+        givenAnActiveTask()
+        givenPendingTasks()
+
+        uut.registerIdleTransitionCallback(callback)
+        executeIdleCheckTask()
+
+        verifyTaskEnqueuedTwice()
+    }
+
+    @Test
+    fun `should be synchronized`() {
+        val localExecutor = Executors.newSingleThreadExecutor()
+
+        givenIdleSExecutor()
+        uut.registerIdleTransitionCallback(callback)
+
+        synchronized(sexecutor) {
+            localExecutor.submit {
+                executeIdleCheckTask()
+            }
+            yieldToOtherThreads(localExecutor)
+            verifyTransitionToIdleNotCalled()
+        }
+        yieldToOtherThreads(localExecutor)
+    }
+
+
+    @Test
+    fun `should allow for an enqueuing of more tasks after idle-transition`() {
+        uut.registerIdleTransitionCallback(callback)
+
+        givenIdleSExecutor()
+        executeIdleCheckTask()
+
+        givenBusySExecutor()
+        uut.isIdleNow
+
+        verifyTaskEnqueuedTwice()
+    }
+}

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

@@ -1,6 +1,7 @@
 package com.wix.detox.reactnative.idlingresources
 
 import com.wix.detox.UTHelpers.yieldToOtherThreads
+import com.wix.detox.reactnative.idlingresources.network.NetworkIdlingResource
 import org.assertj.core.api.Assertions.assertThat
 
 import okhttp3.Dispatcher
@@ -18,7 +19,10 @@ class NetworkIdlingResourcesTest {
     @Before
     fun setup() {
         dispatcher = Dispatcher()
-        uut = NetworkIdlingResource(dispatcher)
+        uut =
+            NetworkIdlingResource(
+                dispatcher
+            )
     }
 
     // Note: Ideally, we should test that the list of busy resources is protected,

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

@@ -1,5 +1,6 @@
 package com.wix.detox.reactnative.idlingresources
 
+import com.wix.detox.reactnative.idlingresources.storage.SerialExecutorReflected
 import org.assertj.core.api.Assertions.assertThat
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify

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

@@ -0,0 +1,212 @@
+package com.wix.detox.reactnative.idlingresources.timers
+
+import android.view.Choreographer
+import androidx.test.espresso.IdlingResource
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.TimingModule
+import org.assertj.core.api.Assertions
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.*
+import org.robolectric.RobolectricTestRunner
+import org.spekframework.spek2.Spek
+import org.spekframework.spek2.style.specification.describe
+
+private fun anIdlingResourceCallback() = mock<IdlingResource.ResourceCallback>()
+
+@RunWith(RobolectricTestRunner::class)
+class TimersIdlingResourceTest {
+    private val choreographer: Choreographer = mock()
+    private val context: ReactContext = mock()
+    private val timersModule: TimingModule = mock()
+    private lateinit var timersIdlingResource: TimersIdlingResource
+
+    @Before
+    fun setup() {
+        whenever(context.getNativeModule(eq(TimingModule::class.java))).thenReturn(timersModule)
+        timersIdlingResource = TimersIdlingResource(context) { choreographer }
+    }
+
+
+    private fun givenIdleStrategy() {
+        whenever(timersModule.hasActiveTimersInRange(any())).thenReturn(false)
+    }
+
+    private fun givenBusyStrategy() {
+        whenever(timersModule.hasActiveTimersInRange(any())).thenReturn(true)
+    }
+
+    private fun getChoreographerCallback(): Choreographer.FrameCallback {
+        argumentCaptor<Choreographer.FrameCallback>().apply {
+            verify(choreographer).postFrameCallback(capture())
+            return firstValue
+        }
+    }
+
+    private fun invokeChoreographerCallback() {
+        getChoreographerCallback().doFrame(0L)
+    }
+
+    @Test
+    fun `should return a debug-name`() {
+        Assertions.assertThat(timersIdlingResource.getDebugName()).isEqualTo("timers")
+    }
+
+    @Test
+    fun `should be idle if strategy says so`() {
+        givenIdleStrategy()
+        Assertions.assertThat(timersIdlingResource.isIdleNow).isTrue()
+    }
+
+    @Test
+    fun `should be busy if strategy says so`() {
+        givenBusyStrategy()
+        Assertions.assertThat(timersIdlingResource.isIdleNow).isFalse()
+    }
+
+    @Test
+    fun `should transition to idle if found idle by strategy`() {
+        givenIdleStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        with(timersIdlingResource) {
+            registerIdleTransitionCallback(callback)
+            isIdleNow
+        }
+
+        verify(callback).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should NOT transition to idle if found busy by strategy`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        with(timersIdlingResource) {
+            registerIdleTransitionCallback(callback)
+            isIdleNow
+        }
+
+        verify(callback, never()).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should be idle if paused`() {
+        givenBusyStrategy()
+
+        val uut = timersIdlingResource.apply {
+            pause()
+        }
+
+        Assertions.assertThat(uut.isIdleNow).isTrue()
+    }
+
+    @Test
+    fun `should be busy if paused and resumed`() {
+        givenBusyStrategy()
+
+        val uut = timersIdlingResource.apply {
+            pause()
+            resume()
+        }
+
+        Assertions.assertThat(uut.isIdleNow).isFalse()
+    }
+
+    @Test
+    fun `should notify of transition to idle upon pausing`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        with(timersIdlingResource) {
+            registerIdleTransitionCallback(callback)
+            pause()
+        }
+
+        verify(callback).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should enqueue an is-idle check using choreographer when a callback gets registered`() {
+        with(timersIdlingResource) {
+            registerIdleTransitionCallback(mock())
+        }
+
+        verify(choreographer).postFrameCallback(any())
+    }
+
+    @Test
+    fun `should transition to idle when preregistered choreographer is dispatched`() {
+        givenIdleStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        timersIdlingResource.registerIdleTransitionCallback(callback)
+        invokeChoreographerCallback()
+
+        verify(callback).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should NOT transition to idle if not idle when preregistered choreographer is dispatched`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        timersIdlingResource.registerIdleTransitionCallback(callback)
+        invokeChoreographerCallback()
+
+        verify(callback, never()).onTransitionToIdle()
+    }
+
+    @Test
+    fun `should re-register choreographer if found idle while preregistered choreographer is dispatched`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        val uut = timersIdlingResource
+        uut.registerIdleTransitionCallback(callback)
+        invokeChoreographerCallback()
+
+        verify(choreographer, times(2)).postFrameCallback(any())
+    }
+
+    @Test
+    fun `should adhere to pausing also when invoked via choreographer callback`() {
+        givenBusyStrategy()
+
+        val callback = anIdlingResourceCallback()
+
+        timersIdlingResource.apply {
+            pause()
+            registerIdleTransitionCallback(callback)
+        }
+        val runtimeChoreographerCallback = getChoreographerCallback()
+
+        reset(callback, choreographer)
+        runtimeChoreographerCallback.doFrame(0L)
+
+        verify(callback, never()).onTransitionToIdle()
+        verify(choreographer, never()).postFrameCallback(any())
+    }
+
+    @Test
+    fun `should enqueue an additional idle check (using choreographer) if found busy`() {
+        givenBusyStrategy()
+        timersIdlingResource.isIdleNow
+        verify(choreographer).postFrameCallback(any())
+    }
+
+    @Test
+    fun `should NOT enqueue an additional idle check (using choreographer) if found idle`() {
+        givenIdleStrategy()
+        timersIdlingResource.isIdleNow
+        verify(choreographer, never()).postFrameCallback(any())
+    }
+}
+

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

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

package/android/rninfo.gradle

@@ -1,11 +1,24 @@
 import groovy.json.JsonSlurper
 
-def getRNVersion = { workingDir ->
-    println("RNInfo: workingDir=$workingDir")
+def getRNPackageJsonDir() {
+    def currentDir = rootDir
+    while (currentDir != null) {
+        def nodeModulesDir = new File(currentDir, "node_modules/react-native")
+        def file = new File(nodeModulesDir, 'package.json')
+        if (file.exists()) {
+            return file.path
+        }
+        currentDir = currentDir.parentFile
+    }
+    throw new GradleException("Unable to find module: $moduleName")
+}
+
+def getRNVersion = { rnPackageJsonPath ->
+    println("RNInfo: package.json=$rnPackageJsonPath")
     def jsonSlurper = new JsonSlurper()
-    def packageFile = "$workingDir/../node_modules/react-native/package.json"
-    println("RNInfo: reading $packageFile")
-    Map<String, Object> packageJSON  = jsonSlurper.parse(new File(packageFile))
+    def packageFile =
+    println("RNInfo: reading $rnPackageJsonPath")
+    Map<String, Object> packageJSON  = jsonSlurper.parse(new File(rnPackageJsonPath))
     String rnVersion = packageJSON.get('version')
     return rnVersion
 }
@@ -15,24 +28,18 @@ def getMajorVersionInternal = { semanticVersion ->
     return rnVersionMajor
 }
 
-ext.getRnMajorVersion = { workingDir ->
-    String rnVersion = getRNVersion(workingDir)
-    Integer rnVersionMajor = getMajorVersionInternal(rnVersion)
-    return rnVersionMajor
-}
-
-def rnVersion = getRNVersion(rootDir)
+def rnVersion = getRNVersion(getRNPackageJsonDir())
 def rnMajorVer = getMajorVersionInternal(rnVersion)
-if (hasProperty('project')) {
-    println "[$project] RNInfo: detected React Native version: $rnVersion (major=$rnMajorVer)"
+println "RNInfo: detected React Native version: $rnVersion (major=$rnMajorVer)"
 
-    project.ext.rnInfo = [
-        version       : rnVersion,
-        majorVersion  : rnMajorVer,
-        isRN69OrHigher: rnMajorVer >= 69,
-        isRN70OrHigher: rnMajorVer >= 70,
-        isRN71OrHigher: rnMajorVer >= 71,
-        isRN72OrHigher: rnMajorVer >= 72,
-        isRN73OrHigher: rnMajorVer >= 73,
-    ]
-}
+ext.rnInfo = [
+    version       : rnVersion,
+    majorVersion  : rnMajorVer,
+    isRN69OrHigher: rnMajorVer >= 69,
+    isRN70OrHigher: rnMajorVer >= 70,
+    isRN71OrHigher: rnMajorVer >= 71,
+    isRN72OrHigher: rnMajorVer >= 72,
+    isRN73OrHigher: rnMajorVer >= 73,
+    isRN74OrHigher: rnMajorVer >= 74,
+    isRN75OrHigher: rnMajorVer >= 75,
+]

package/android/settings.gradle

@@ -1,14 +1,19 @@
+// RN75+_BLOCK_START
+pluginManagement { includeBuild("../node_modules/@react-native/gradle-plugin") }
+plugins { id("com.facebook.react.settings") }
+extensions.configure(com.facebook.react.ReactSettingsExtension){ ex -> ex.autolinkLibrariesFromCommand() }
+// RN75+_BLOCK_END
+
+
 apply from: '../android/rninfo.gradle'
 include ':detox'
 
 println("RNInfo: rootDir=$rootDir")
+println "[settings] RNInfo: detected React Native version: (major=${ext.rnInfo.version})"
 
-def rnMajorVer = getRnMajorVersion(rootDir)
-println "[settings] RNInfo: detected React Native version: (major=$rnMajorVer)"
 
-if (rnMajorVer < 72) {
-    includeBuild('../node_modules/react-native-gradle-plugin')
-} else {
+if (ext.rnInfo.isRN72OrHigher) {
     includeBuild('../node_modules/@react-native/gradle-plugin')
+} else {
+    includeBuild('../node_modules/react-native-gradle-plugin')
 }
-

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "20.28.0",
+  "version": "20.31.0",
   "bin": {
     "detox": "local-cli/cli.js"
   },
@@ -34,10 +34,13 @@
     "postinstall": "node scripts/postinstall.js"
   },
   "devDependencies": {
-    "@react-native/babel-preset": "0.73.19",
-    "@react-native/eslint-config": "^0.73.2",
-    "@react-native/metro-config": "^0.73.3",
-    "@react-native/typescript-config": "0.73.1",
+    "@react-native-community/cli": "15.0.1",
+    "@react-native-community/cli-platform-android": "15.0.1",
+    "@react-native-community/cli-platform-ios": "15.0.1",
+    "@react-native/babel-preset": "0.76.3",
+    "@react-native/eslint-config": "0.76.3",
+    "@react-native/metro-config": "0.76.3",
+    "@react-native/typescript-config": "0.76.3",
     "@tsconfig/react-native": "^3.0.0",
     "@types/bunyan": "^1.8.8",
     "@types/child-process-promise": "^2.2.1",
@@ -59,7 +62,7 @@
     "jest-allure2-reporter": "^2.0.0-beta.18",
     "metro-react-native-babel-preset": "0.76.8",
     "prettier": "^3.1.1",
-    "react-native": "0.73.2",
+    "react-native": "0.76.3",
     "react-native-codegen": "^0.0.8",
     "typescript": "^5.3.3",
     "wtfnode": "^0.9.1"
@@ -71,7 +74,7 @@
     "caf": "^15.0.1",
     "chalk": "^4.0.0",
     "child-process-promise": "^2.2.0",
-    "detox-copilot": "^0.0.24",
+    "detox-copilot": "^0.0.27",
     "execa": "^5.1.1",
     "find-up": "^5.0.0",
     "fs-extra": "^11.0.0",
@@ -116,5 +119,5 @@
   "browserslist": [
     "node 14"
   ],
-  "gitHead": "c97e583d7e33ad9472d5b3e68dda724f1300c83c"
+  "gitHead": "89a3f0efbac69cd37db886a53f712d51db8f857d"
 }

package/scripts/postinstall.js

@@ -1,6 +1,6 @@
 const { platform, env } = process;
 
-const { setGradleVersionByRNVersion } = require('./updateGradle');
+const { patchGradleByRNVersion } = require('./updateGradle');
 
 const isDarwin = platform === 'darwin';
 const shouldInstallDetox = !env.DETOX_DISABLE_POSTINSTALL;
@@ -12,4 +12,4 @@ if (isDarwin && shouldInstallDetox) {
   execFileSync(`${__dirname}/build_local_xcuitest.ios.sh`, { stdio: 'inherit' });
 }
 
-setGradleVersionByRNVersion();
+patchGradleByRNVersion();