detox 20.27.7-smoke.0 → 20.31.0

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

@@ -0,0 +1,145 @@
+package com.wix.detox.reactnative.idlingresources
+
+import android.os.Looper
+import android.util.Log
+import androidx.test.espresso.Espresso
+import androidx.test.espresso.IdlingRegistry
+import androidx.test.espresso.base.IdlingResourceRegistry
+import com.facebook.react.bridge.ReactContext
+import com.wix.detox.LaunchArgs
+import com.wix.detox.reactnative.idlingresources.factory.DetoxIdlingResourceFactory
+import com.wix.detox.reactnative.idlingresources.factory.IdlingResourcesName
+import com.wix.detox.reactnative.idlingresources.factory.LooperName
+import com.wix.detox.reactnative.idlingresources.looper.MQThreadsReflector
+import com.wix.detox.reactnative.idlingresources.network.NetworkIdlingResource
+import kotlinx.coroutines.runBlocking
+import org.joor.Reflect
+
+
+private const val LOG_TAG = "DetoxRNIdleRes"
+
+class ReactNativeIdlingResources(
+    private val reactContext: ReactContext,
+    private var launchArgs: LaunchArgs,
+    private val idlingResourcesFactory: DetoxIdlingResourceFactory = DetoxIdlingResourceFactory(reactContext)
+) {
+
+    private val idlingResources = mutableMapOf<IdlingResourcesName, DetoxIdlingResource>()
+    private val loopers = mutableMapOf<LooperName, Looper>()
+
+    fun registerAll() {
+        runBlocking {
+            Log.i(LOG_TAG, "Setting up Espresso Idling Resources for React Native")
+            unregisterAll()
+
+            setupUrlBlacklist()
+            setupMQThreadsInterrogators()
+            syncIdlingResources()
+            setupIdlingResources()
+            syncIdlingResources()
+        }
+    }
+
+    fun unregisterAll() {
+        unregisterMQThreadsInterrogators()
+        unregisterIdlingResources()
+    }
+
+    fun pauseNetworkSynchronization() = pauseIdlingResource(IdlingResourcesName.Network)
+    fun resumeNetworkSynchronization() {
+        resumeIdlingResource(IdlingResourcesName.Network)
+    }
+
+    fun pauseRNTimersIdlingResource() = pauseIdlingResource(IdlingResourcesName.Timers)
+    fun resumeRNTimersIdlingResource() = resumeIdlingResource(IdlingResourcesName.Timers)
+    fun pauseUIIdlingResource() = pauseIdlingResource(IdlingResourcesName.UIModule)
+    fun resumeUIIdlingResource() = resumeIdlingResource(IdlingResourcesName.UIModule)
+
+    fun setBlacklistUrls(urlList: String) {
+        setIdlingResourceBlacklist(urlList)
+    }
+
+    private fun setIdlingResourceBlacklist(urlList: String) {
+        val urlArray = toFormattedUrlArray(urlList)
+        NetworkIdlingResource.setURLBlacklist(urlArray)
+    }
+
+    private fun setupMQThreadsInterrogators() {
+        setupMQThreadsInterrogator(LooperName.JS)
+        setupMQThreadsInterrogator(LooperName.NativeModules)
+    }
+
+    private fun setupUrlBlacklist() {
+        if (launchArgs.hasURLBlacklist()) {
+            val blacklistUrls = launchArgs.urlBlacklist
+            setIdlingResourceBlacklist(blacklistUrls)
+        }
+    }
+
+    private fun setupMQThreadsInterrogator(looperName: LooperName) {
+        val mqThreadsReflector = MQThreadsReflector(reactContext)
+        val looper = when (looperName) {
+            LooperName.JS -> mqThreadsReflector.getJSMQueue()?.getLooper()
+            LooperName.NativeModules -> mqThreadsReflector.getNativeModulesQueue()?.getLooper()
+        }
+
+        looper?.let {
+            IdlingRegistry.getInstance().registerLooperAsIdlingResource(it)
+            loopers[looperName] = it
+        }
+    }
+
+    private suspend fun setupIdlingResources() {
+        idlingResources.putAll(idlingResourcesFactory.create())
+        idlingResources.forEach { (_, idlingResource) ->
+            IdlingRegistry.getInstance().register(idlingResource)
+        }
+    }
+
+    private fun syncIdlingResources() {
+        IdlingRegistry.getInstance().apply {
+            val irr: IdlingResourceRegistry =
+                Reflect.on(Espresso::class.java).field("baseRegistry").get()
+            irr.sync(this.resources, this.loopers)
+        }
+    }
+
+    private fun unregisterMQThreadsInterrogators() {
+        loopers.values.forEach {
+            IdlingRegistry.getInstance().unregisterLooperAsIdlingResource(it)
+        }
+        loopers.clear()
+    }
+
+    private fun unregisterIdlingResources() {
+        IdlingResourcesName.entries.forEach {
+            removeIdlingResource(it)
+        }
+    }
+
+    private fun pauseIdlingResource(idlingResourcesName: IdlingResourcesName) {
+        val idlingResource = idlingResources[idlingResourcesName]
+        idlingResource?.pause()
+    }
+
+    private fun resumeIdlingResource(idlingResourcesName: IdlingResourcesName) {
+        val idlingResource = idlingResources[idlingResourcesName]
+        idlingResource?.resume()
+    }
+
+    private fun removeIdlingResource(idlingResourcesName: IdlingResourcesName) {
+        val idlingResource = idlingResources[idlingResourcesName]
+        idlingResource?.let {
+            IdlingRegistry.getInstance().unregister(it)
+            idlingResource.onUnregistered()
+            idlingResources.remove(idlingResourcesName)
+        }
+    }
+
+    private fun toFormattedUrlArray(urlList: String): List<String> {
+        var formattedUrls = urlList
+        formattedUrls = formattedUrls.replace(Regex("""[()"]"""), "")
+        formattedUrls = formattedUrls.trim()
+        return formattedUrls.split(',')
+    }
+}

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/animations/AnimatedModuleIdlingResource.kt

@@ -0,0 +1,61 @@
+package com.wix.detox.reactnative.idlingresources.animations
+
+import android.util.Log
+import android.view.Choreographer
+import androidx.test.espresso.IdlingResource.ResourceCallback
+import com.facebook.react.animated.NativeAnimatedModule
+import com.facebook.react.bridge.ReactContext
+import com.wix.detox.reactnative.idlingresources.DetoxIdlingResource
+
+private const val LOG_TAG = "Detox"
+
+
+/**
+ * Created by simonracz on 25/08/2017.
+ */
+/**
+ *
+ * Espresso IdlingResource for React Native's Animated Module.
+ *
+ *
+ * Hooks up to React Native internals to monitor the state of the animations.
+ *
+ */
+class AnimatedModuleIdlingResource(private val reactContext: ReactContext) : DetoxIdlingResource(),
+    Choreographer.FrameCallback {
+
+    override fun getName() = AnimatedModuleIdlingResource::class.java.name
+
+    override fun getDebugName(): String {
+        return "AnimatedModule"
+    }
+
+    override fun getBusyHint(): Map<String, Any> {
+        return mapOf("reason" to "Animations running on screen")
+    }
+
+    override fun checkIdle(): Boolean {
+        val animatedModule = reactContext.getNativeModule(NativeAnimatedModule::class.java)
+        val hasAnimations = animatedModule?.nodesManager?.hasActiveAnimations() ?: false
+
+        if (hasAnimations) {
+            Log.i(LOG_TAG, "AnimatedModule is busy.")
+            Choreographer.getInstance().postFrameCallback(this)
+            return false
+        }
+
+        notifyIdle()
+        return true
+    }
+
+    override fun registerIdleTransitionCallback(callback: ResourceCallback?) {
+        super.registerIdleTransitionCallback(callback)
+        Choreographer.getInstance().postFrameCallback(this)
+    }
+
+    override fun doFrame(frameTimeNanos: Long) {
+        isIdleNow
+    }
+}
+
+

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/bridge/BridgeIdlingResource.kt

@@ -0,0 +1,72 @@
+package com.wix.detox.reactnative.idlingresources.bridge
+
+import android.util.Log
+import com.facebook.react.bridge.NotThreadSafeBridgeIdleDebugListener
+import com.facebook.react.bridge.ReactContext
+import com.wix.detox.reactnative.idlingresources.DetoxIdlingResource
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * Created by simonracz on 01/06/2017.
+ */
+/**
+ *
+ *
+ * IdlingResource for Espresso, which monitors the traffic of
+ * React Native's JS bridge.
+ *
+ */
+class BridgeIdlingResource(private val reactContext: ReactContext) : DetoxIdlingResource(),
+    NotThreadSafeBridgeIdleDebugListener {
+    private val idleNow = AtomicBoolean(true)
+
+    init {
+        reactContext.catalystInstance.addBridgeIdleDebugListener(this)
+    }
+
+    fun onDetach() {
+        reactContext.catalystInstance.removeBridgeIdleDebugListener(this)
+    }
+
+    override fun getName(): String {
+        return BridgeIdlingResource::class.java.name
+    }
+
+    override fun getDebugName(): String {
+        return "bridge"
+    }
+
+    override fun getBusyHint(): Map<String, Any>? {
+        return null
+    }
+
+    override fun checkIdle(): Boolean {
+        val ret = idleNow.get()
+        if (!ret) {
+            Log.i(LOG_TAG, "JS Bridge is busy")
+        }
+        return ret
+    }
+
+    override fun onTransitionToBridgeIdle() {
+        idleNow.set(true)
+        notifyIdle()
+    }
+
+    override fun onTransitionToBridgeBusy() {
+        idleNow.set(false)
+        // Log.i(LOG_TAG, "JS Bridge transitions to busy.");
+    }
+
+    override fun onBridgeDestroyed() {
+    }
+
+    override fun onUnregistered() {
+        super.onUnregistered()
+        onDetach()
+    }
+
+    companion object {
+        private const val LOG_TAG = "Detox"
+    }
+}

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/factory/DetoxIdlingResourceFactory.kt

@@ -0,0 +1,32 @@
+package com.wix.detox.reactnative.idlingresources.factory
+
+import com.facebook.react.bridge.ReactContext
+import com.wix.detox.reactnative.idlingresources.DetoxIdlingResource
+import com.wix.detox.reactnative.idlingresources.animations.AnimatedModuleIdlingResource
+import com.wix.detox.reactnative.idlingresources.bridge.BridgeIdlingResource
+import com.wix.detox.reactnative.idlingresources.network.NetworkIdlingResource
+import com.wix.detox.reactnative.idlingresources.storage.AsyncStorageIdlingResource
+import com.wix.detox.reactnative.idlingresources.timers.TimersIdlingResource
+import com.wix.detox.reactnative.idlingresources.uimodule.UIModuleIdlingResource
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class DetoxIdlingResourceFactory(private val reactContext: ReactContext) {
+    suspend fun create(): Map<IdlingResourcesName, DetoxIdlingResource> = withContext(Dispatchers.Main) {
+        val result = mutableMapOf(
+            IdlingResourcesName.Timers to TimersIdlingResource(reactContext),
+            IdlingResourcesName.RNBridge to BridgeIdlingResource(reactContext),
+            IdlingResourcesName.UIModule to UIModuleIdlingResource(reactContext),
+            IdlingResourcesName.Animations to AnimatedModuleIdlingResource(reactContext),
+            IdlingResourcesName.Network to NetworkIdlingResource(reactContext)
+        )
+
+        val asyncStorageIdlingResource = AsyncStorageIdlingResource.createIfNeeded(reactContext)
+        if (asyncStorageIdlingResource != null) {
+            result[IdlingResourcesName.AsyncStorage] = asyncStorageIdlingResource
+        }
+
+        return@withContext result
+    }
+}
+

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/factory/IdlingResourcesName.kt

@@ -0,0 +1,10 @@
+package com.wix.detox.reactnative.idlingresources.factory
+
+enum class IdlingResourcesName {
+    Timers,
+    AsyncStorage,
+    RNBridge,
+    UIModule,
+    Animations,
+    Network
+}

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/factory/LooperName.kt

@@ -0,0 +1,6 @@
+package com.wix.detox.reactnative.idlingresources.factory
+
+enum class LooperName {
+    JS,
+    NativeModules
+}

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/looper/MQThreadsReflector.kt

@@ -0,0 +1,47 @@
+package com.wix.detox.reactnative.idlingresources.looper
+
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.ReactContext
+import org.joor.Reflect
+import org.joor.ReflectException
+
+
+private const val LOG_TAG = "DetoxRNIdleRes"
+private const val METHOD_GET_LOOPER = "getLooper"
+private const val FIELD_NATIVE_MODULES_MSG_QUEUE = "mNativeModulesMessageQueueThread"
+private const val FIELD_JS_MSG_QUEUE = "mJSMessageQueueThread"
+
+internal class MQThreadsReflector(private val reactContext: ReactContext) {
+
+    fun getJSMQueue(): MQThreadReflected? {
+        return getQueue(FIELD_JS_MSG_QUEUE)
+    }
+
+    fun getNativeModulesQueue(): MQThreadReflected? {
+        return getQueue(FIELD_NATIVE_MODULES_MSG_QUEUE)
+    }
+
+    private fun getQueue(queueName: String): MQThreadReflected? {
+        try {
+            val queue = Reflect.on(reactContext).field(queueName).get() as Any?
+            return MQThreadReflected(queue, queueName)
+        } catch (e: ReflectException) {
+            Log.e(LOG_TAG, "Could not find queue: $queueName", e)
+        }
+        return null
+    }
+}
+
+internal class MQThreadReflected(private val queue: Any?, private val queueName: String) {
+    fun getLooper(): Looper? {
+        try {
+            if (queue != null) {
+                return Reflect.on(queue).call(METHOD_GET_LOOPER).get()
+            }
+        } catch (e: ReflectException) {
+            Log.e(LOG_TAG, "Could not find looper for queue: $queueName", e)
+        }
+        return null
+    }
+}

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/network/NetworkIdlingResource.kt

@@ -0,0 +1,105 @@
+package com.wix.detox.reactnative.idlingresources.network
+
+import android.util.Log
+import android.view.Choreographer
+import androidx.test.espresso.IdlingResource.ResourceCallback
+import com.facebook.react.bridge.ReactContext
+import com.wix.detox.reactnative.idlingresources.DetoxIdlingResource
+import okhttp3.Dispatcher
+import java.util.regex.Pattern
+import java.util.regex.PatternSyntaxException
+
+/**
+ * Created by simonracz on 09/10/2017.
+ *
+ * Idling Resource which monitors React Native's OkHttpClient.
+ *
+ *
+ * Must call stop() on it, before removing it from Espresso.
+ */
+class NetworkIdlingResource(private val dispatcher: Dispatcher) : DetoxIdlingResource(),
+    Choreographer.FrameCallback {
+    private val busyResources: MutableSet<String> = HashSet()
+
+    constructor(reactContext: ReactContext) : this(NetworkingModuleReflected(reactContext).getHttpClient()!!.dispatcher)
+
+    override fun getName(): String {
+        return NetworkIdlingResource::class.java.name
+    }
+
+    override fun getDebugName(): String {
+        return "network"
+    }
+
+    @Synchronized
+    override fun getBusyHint(): Map<String, Any> = mapOf("urls" to ArrayList(busyResources))
+
+    override fun registerIdleTransitionCallback(callback: ResourceCallback?) {
+        super.registerIdleTransitionCallback(callback)
+        Choreographer.getInstance().postFrameCallback(this)
+    }
+
+    override fun doFrame(frameTimeNanos: Long) {
+        isIdleNow
+    }
+
+    @Synchronized
+    override fun checkIdle(): Boolean {
+        busyResources.clear()
+
+        val calls = dispatcher.runningCalls()
+        for (call in calls) {
+            val url = call.request().url.toString()
+
+            if (!isUrlBlacklisted(url)) {
+                busyResources.add(url)
+            }
+        }
+
+        if (busyResources.isNotEmpty()) {
+            Log.i(LOG_TAG, "Network is busy, with " + busyResources.size + " in-flight calls")
+            Choreographer.getInstance().postFrameCallback(this)
+            return false
+        }
+
+        notifyIdle()
+        return true
+    }
+
+    private fun isUrlBlacklisted(url: String): Boolean {
+        for (pattern in blacklist) {
+            if (pattern.matcher(url).matches()) {
+                return true
+            }
+        }
+        return false
+    }
+
+    companion object {
+        private const val LOG_TAG = "Detox"
+
+        private val blacklist = ArrayList<Pattern>()
+
+        /**
+         * Must be called on the UI thread.
+         *
+         * @param urls list of regexes of blacklisted urls
+         */
+        @JvmStatic
+        fun setURLBlacklist(urls: List<String>?) {
+            blacklist.clear()
+            if (urls == null) return
+
+            for (url in urls) {
+                try {
+                    blacklist.add(Pattern.compile(url))
+                } catch (e: PatternSyntaxException) {
+                    Log.e(
+                        LOG_TAG,
+                        "Couldn't parse regular expression for Black list url: $url", e
+                    )
+                }
+            }
+        }
+    }
+}

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/{NetworkingModuleReflected.kt → network/NetworkingModuleReflected.kt}

@@ -1,4 +1,4 @@
-package com.wix.detox.reactnative.idlingresources
+package com.wix.detox.reactnative.idlingresources.network
 
 import android.util.Log
 import com.facebook.react.bridge.ReactContext

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/{AsyncStorageIdlingResource.kt → storage/AsyncStorageIdlingResource.kt}

@@ -1,16 +1,18 @@
-package com.wix.detox.reactnative.idlingresources
+package com.wix.detox.reactnative.idlingresources.storage
 
 import android.util.Log
 import androidx.test.espresso.IdlingResource
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactContext
-import com.wix.detox.espresso.idlingresources.DescriptiveIdlingResource
 import com.wix.detox.reactnative.helpers.RNHelpers
+import com.wix.detox.reactnative.idlingresources.DetoxIdlingResource
 import org.joor.Reflect
 import java.util.concurrent.Executor
 
 private typealias SExecutorReflectedGenFnType = (executor: Executor) -> SerialExecutorReflected
-private val defaultSExecutorReflectedGenFn: SExecutorReflectedGenFnType = { executor: Executor -> SerialExecutorReflected(executor) }
+
+private val defaultSExecutorReflectedGenFn: SExecutorReflectedGenFnType =
+    { executor: Executor -> SerialExecutorReflected(executor) }
 
 private class ModuleReflected(module: NativeModule, sexecutorReflectedGen: SExecutorReflectedGenFnType) {
     private val executorReflected: SerialExecutorReflected
@@ -25,17 +27,16 @@ private class ModuleReflected(module: NativeModule, sexecutorReflectedGen: SExec
         get() = executorReflected
 }
 
-open class AsyncStorageIdlingResource
-    @JvmOverloads constructor(
-        module: NativeModule,
-        sexecutorReflectedGenFn: SExecutorReflectedGenFnType = defaultSExecutorReflectedGenFn)
-    : DescriptiveIdlingResource {
+class AsyncStorageIdlingResource
+@JvmOverloads constructor(
+    module: NativeModule,
+    sexecutorReflectedGenFn: SExecutorReflectedGenFnType = defaultSExecutorReflectedGenFn
+) : DetoxIdlingResource() {
 
-    open val logTag: String
+    val logTag: String
         get() = LOG_TAG
 
     private val moduleReflected = ModuleReflected(module, sexecutorReflectedGenFn)
-    private var callback: IdlingResource.ResourceCallback? = null
     private var idleCheckTask: Runnable? = null
     private val idleCheckTaskImpl = Runnable {
         with(moduleReflected.sexecutor) {
@@ -44,7 +45,7 @@ open class AsyncStorageIdlingResource
                     executeTask(idleCheckTask!!)
                 } else {
                     clearIdleCheckTask()
-                    callback?.onTransitionToIdle()
+                    notifyIdle()
                 }
             }
         }
@@ -54,22 +55,24 @@ open class AsyncStorageIdlingResource
     override fun getDebugName() = "io"
     override fun getBusyHint(): Map<String, Any>? = null
 
-    override fun isIdleNow(): Boolean =
-        checkIdle().also { idle ->
-            if (!idle) {
-                Log.d(logTag, "Async-storage is busy!")
-                enqueueIdleCheckTask()
+
+    private fun checkIdleInternal(): Boolean =
+        with(moduleReflected.sexecutor) {
+            synchronized(executor()) {
+                !hasActiveTask() && !hasPendingTasks()
             }
         }
+
     override fun registerIdleTransitionCallback(callback: IdlingResource.ResourceCallback?) {
-        this.callback = callback
+        super.registerIdleTransitionCallback(callback)
         enqueueIdleCheckTask()
     }
 
-    private fun checkIdle(): Boolean =
-        with(moduleReflected.sexecutor) {
-            synchronized(executor()) {
-                !hasActiveTask() && !hasPendingTasks()
+    override fun checkIdle(): Boolean =
+        checkIdleInternal().also { idle ->
+            if (!idle) {
+                Log.d(logTag, "Async-storage is busy!")
+                enqueueIdleCheckTask()
             }
         }
 
@@ -94,26 +97,21 @@ open class AsyncStorageIdlingResource
     companion object {
         private const val LOG_TAG = "AsyncStorageIR"
 
-        fun createIfNeeded(reactContext: ReactContext, legacy: Boolean): AsyncStorageIdlingResource? {
-            Log.d(LOG_TAG, "Checking whether a custom IR for Async-Storage is required... (legacy=$legacy)")
+        fun createIfNeeded(reactContext: ReactContext): AsyncStorageIdlingResource? {
+            Log.d(LOG_TAG, "Checking whether a custom IR for Async-Storage is required...")
 
-            return RNHelpers.getNativeModule(reactContext, className(legacy))?.let { module ->
-                Log.d(LOG_TAG, "IR for Async-Storage is required! (legacy=$legacy)")
-                createInstance(module, legacy)
+            return RNHelpers.getNativeModule(reactContext, className())?.let { module ->
+                Log.d(LOG_TAG, "IR for Async-Storage is required!")
+                createInstance(module)
             }
         }
 
-        private fun className(legacy: Boolean): String {
-            val packageName = if (legacy) "com.facebook.react.modules.storage" else "com.reactnativecommunity.asyncstorage"
+        private fun className(): String {
+            val packageName = "com.reactnativecommunity.asyncstorage"
             return "$packageName.AsyncStorageModule"
         }
 
-        private fun createInstance(module: NativeModule, legacy: Boolean) =
-            if (legacy) AsyncStorageIdlingResourceLegacy(module) else AsyncStorageIdlingResource(module)
+        private fun createInstance(module: NativeModule) =
+            AsyncStorageIdlingResource(module)
     }
 }
-
-class AsyncStorageIdlingResourceLegacy(module: NativeModule): AsyncStorageIdlingResource(module) {
-    override val logTag: String
-        get() = super.logTag + "Legacy"
-}

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/{SerialExecutorReflected.kt → storage/SerialExecutorReflected.kt}

@@ -1,4 +1,4 @@
-package com.wix.detox.reactnative.idlingresources
+package com.wix.detox.reactnative.idlingresources.storage
 
 import org.joor.Reflect
 import java.util.concurrent.Executor