detox 20.27.7-smoke.0 → 20.31.0

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

@@ -1,23 +0,0 @@
-
-package com.wix.detox.reactnative.idlingresources.timers
-
-import com.facebook.react.bridge.ReactContext
-import com.facebook.react.modules.core.TimingModule
-
-private const val BUSY_WINDOW_THRESHOLD = 1500L
-
-/**
- * Delegates the interrogation to the native module itself, added
- * [here](https://github.com/facebook/react-native/pull/27539) in the context
- * of RN v0.62 (followed by a previous refactor and rename of the class).
- */
-class DelegatedIdleInterrogationStrategy(private val timingModule: TimingModule): IdleInterrogationStrategy {
-    override fun isIdleNow(): Boolean = !timingModule.hasActiveTimersInRange(BUSY_WINDOW_THRESHOLD)
-
-    companion object {
-        fun create(reactContext: ReactContext): DelegatedIdleInterrogationStrategy {
-            val timingModule = reactContext.getNativeModule(TimingModule::class.java)!!
-            return DelegatedIdleInterrogationStrategy(timingModule)
-        }
-    }
-}

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

@@ -1,16 +0,0 @@
-package com.wix.detox.reactnative.idlingresources.timers
-
-import com.facebook.react.bridge.ReactContext
-import com.wix.detox.common.UIThread
-import java.util.concurrent.Callable
-
-interface IdleInterrogationStrategy {
-    fun isIdleNow(): Boolean
-}
-
-fun getInterrogationStrategy(reactContext: ReactContext): IdleInterrogationStrategy? =
-    // Getting a native-module (inside) also initializes it if needed. That has to run on a
-    // looper thread, and the easiest to make sure that happens is to use the main thread.
-    UIThread.runSync(Callable {
-        return@Callable DelegatedIdleInterrogationStrategy.create(reactContext)
-    })

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

@@ -1,71 +0,0 @@
-package com.wix.detox.reactnative.idlingresources.uimodule
-
-import android.util.Log
-import android.view.View
-import com.facebook.react.uimanager.IllegalViewOperationException
-import com.wix.detox.common.DetoxLog.Companion.LOG_TAG
-import com.wix.detox.reactnative.ReactNativeInfo
-import java.lang.ref.WeakReference
-
-private const val NUM_TIMES_BEFORE_NOTIFY_IDLE = 10
-private const val SET_NATIVE_VALUE = "setNativeValue"
-private const val CLASS_REACT_SWITCH = "com.facebook.react.views.switchview.ReactSwitch"
-
-class RN66Workaround {
-    private var timesStuckQueueDetected = 0
-    private var stuckOperation: WeakReference<Any?>? = null
-
-    // This is a workaround for https://github.com/facebook/react-native/issues/32594
-    // uses duck typing heuristics to determine that this is probably the stuck Switch operation and if so, ignores it
-    fun isScarceUISwitchCommandStuckInQueue(uiManagerModuleReflected: UIManagerModuleReflected): Boolean {
-        var isStuckSwitchOperation = false
-
-        if (isRelevantRNVersion() && uiManagerModuleReflected.getUIOpsCount() >= 1) {
-            val nextUIOperation = uiManagerModuleReflected.getNextUIOpReflected()
-            val view = getUIOpView(uiManagerModuleReflected, nextUIOperation)
-            val isReactSwitch = isReactSwitch(view)
-            val hasOneRetryIncremented = nextUIOperation?.numRetries == 1
-            val isSetNativeValueCommand = (nextUIOperation?.viewCommand ?: "") == SET_NATIVE_VALUE
-
-            if (isReactSwitch && hasOneRetryIncremented && isSetNativeValueCommand) {
-                if (stuckOperation?.get() == nextUIOperation?.instance) {
-                    timesStuckQueueDetected++
-                } else {
-                    stuckOperation = WeakReference(nextUIOperation?.instance)
-                    timesStuckQueueDetected = 0
-                }
-            }
-
-            if (timesStuckQueueDetected >= NUM_TIMES_BEFORE_NOTIFY_IDLE) {
-                isStuckSwitchOperation = true
-            }
-        } else {
-            timesStuckQueueDetected = 0
-        }
-        return isStuckSwitchOperation
-    }
-
-    private fun isRelevantRNVersion(): Boolean {
-        val rnVersion = ReactNativeInfo.rnVersion()
-        return rnVersion.minor == 66 || (rnVersion.minor == 67 && rnVersion.patch < 4)
-    }
-
-    private fun getUIOpView(uiManagerModuleReflected: UIManagerModuleReflected, uiOperation: DispatchCommandOperationReflected?): View? {
-        val nativeViewHierarchyManager = uiManagerModuleReflected.nativeViewHierarchyManager() ?: return null
-        val tag = uiOperation?.tag ?: return null
-        return try {
-            nativeViewHierarchyManager.getViewClass(tag)
-        } catch(e: IllegalViewOperationException) {
-            Log.e(LOG_TAG, "failed to get view from tag ", e.cause)
-            null
-        }
-    }
-
-    private fun isReactSwitch(view: View?) = try {
-        val ReactSwitchClass: Class<*> = Class.forName(CLASS_REACT_SWITCH)
-        if (view != null) ReactSwitchClass.isAssignableFrom(view.javaClass) else false
-    } catch (e: ClassNotFoundException) {
-        Log.e(LOG_TAG, "failed to get $CLASS_REACT_SWITCH class ", e.cause)
-        false
-    }
-}

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

@@ -1,227 +0,0 @@
-package com.wix.detox.reactnative.idlingresources
-
-import androidx.test.espresso.IdlingResource
-import com.facebook.react.bridge.NativeModule
-import com.wix.detox.UTHelpers.yieldToOtherThreads
-import org.assertj.core.api.Assertions.assertThat
-import org.mockito.kotlin.*
-import org.spekframework.spek2.Spek
-import org.spekframework.spek2.style.specification.describe
-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() {}
-}
-
-class AsyncStorageIdlingResourceSpec: Spek({
-    describe("React Native Async-Storage idling-resource") {
-        lateinit var sexecutor: Executor
-        lateinit var sexecutorReflected: SerialExecutorReflected
-        lateinit var sexecutorReflectedGenFn: (executor: Executor) -> SerialExecutorReflected
-        lateinit var module: AsyncStorageModuleStub
-        lateinit var uut: AsyncStorageIdlingResource
-
-        beforeEachTest {
-            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())
-
-        it("should have a name") {
-            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()
-                assertThat(uut.isIdleNow).isTrue()
-            }
-
-            it("should be busy if executor is executing") {
-                givenAnActiveTask()
-                givenNoPendingTasks()
-                assertThat(uut.isIdleNow).isFalse()
-            }
-
-            it("should be busy if executor has pending tasks") {
-                givenNoActiveTasks()
-                givenPendingTasks()
-                assertThat(uut.isIdleNow).isFalse()
-            }
-
-            it("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)
-            }
-
-            it("should enqueue an idle-check task if resource is busy") {
-                givenBusySExecutor()
-                uut.isIdleNow
-                verifyTaskEnqueuedOnce()
-            }
-
-            it("should not enqueue an idle-check task if resource if idle") {
-                givenIdleSExecutor()
-                uut.isIdleNow
-                verifyNoTasksEnqueued()
-            }
-
-            it("should not enqueue more than one idle-check task") {
-                givenBusySExecutor()
-
-                repeat(2) {
-                    uut.isIdleNow
-                }
-                verifyTaskEnqueuedOnce()
-            }
-        }
-
-        describe("callback registration") {
-            lateinit var callback: IdlingResource.ResourceCallback
-
-            beforeEachTest {
-                callback = mock()
-            }
-
-            fun verifyTransitionToIdleCalled() = verify(callback).onTransitionToIdle()
-            fun verifyTransitionToIdleNotCalled() = verify(callback, never()).onTransitionToIdle()
-
-            it("should enqueue an idle-check task") {
-                uut.registerIdleTransitionCallback(callback)
-                verifyTaskEnqueuedOnce()
-            }
-
-            it("should be synchronized over actual executor") {
-                val localExecutor = Executors.newSingleThreadExecutor()
-
-                synchronized(sexecutor) {
-                    localExecutor.submit {
-                        uut.registerIdleTransitionCallback(callback)
-                    }
-                    yieldToOtherThreads(localExecutor)
-                    verifyNoTasksEnqueued()
-                }
-                yieldToOtherThreads(localExecutor)
-            }
-
-            describe("the idle-check task") {
-                fun executeIdleCheckTask() {
-                    argumentCaptor<Runnable>().also {
-                        verify(sexecutorReflected).executeTask(it.capture())
-                    }.firstValue.run()
-                }
-
-                it("should transition to idle") {
-                    givenIdleSExecutor()
-
-                    uut.registerIdleTransitionCallback(callback)
-                    executeIdleCheckTask()
-
-                    verifyTransitionToIdleCalled()
-                }
-
-                it("should not transition to idle if busy") {
-                    givenAnActiveTask()
-                    givenPendingTasks()
-
-                    uut.registerIdleTransitionCallback(callback)
-                    executeIdleCheckTask()
-
-                    verifyTransitionToIdleNotCalled()
-                }
-
-                it("should not inspect sexecutor for activity, because it runs on the executor itself") {
-                    givenAnActiveTask()
-                    givenPendingTasks()
-
-                    uut.registerIdleTransitionCallback(callback)
-                    executeIdleCheckTask()
-
-                    verify(sexecutorReflected, never()).hasActiveTask()
-                }
-
-                it("should reenqueue if still busy") {
-                    givenAnActiveTask()
-                    givenPendingTasks()
-
-                    uut.registerIdleTransitionCallback(callback)
-                    executeIdleCheckTask()
-
-                    verifyTaskEnqueuedTwice()
-                }
-
-                it("should be synchronized") {
-                    val localExecutor = Executors.newSingleThreadExecutor()
-
-                    givenIdleSExecutor()
-                    uut.registerIdleTransitionCallback(callback)
-
-                    synchronized(sexecutor) {
-                        localExecutor.submit {
-                            executeIdleCheckTask()
-                        }
-                        yieldToOtherThreads(localExecutor)
-                        verifyTransitionToIdleNotCalled()
-                    }
-                    yieldToOtherThreads(localExecutor)
-                }
-
-                describe("vs. immediate idle-check") {
-                    it("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/timers/DelegatedIdleInterrogationStrategySpec.kt

@@ -1,47 +0,0 @@
-package com.wix.detox.reactnative.idlingresources.timers
-
-import com.facebook.react.bridge.NativeModule
-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
-
-object DelegatedIdleInterrogationStrategySpec : Spek({
-    describe("Timers idle-interrogation strategy") {
-
-        lateinit var timingModule: TimingModule
-
-        beforeEachTest {
-            timingModule = mock()
-        }
-
-        fun givenActiveTimersInQueue() {
-            whenever(timingModule.hasActiveTimersInRange(any())).thenReturn(true)
-        }
-
-        fun givenNoActiveTimersInQueue() {
-            whenever(timingModule.hasActiveTimersInRange(any())).thenReturn(false)
-        }
-
-        fun uut() = DelegatedIdleInterrogationStrategy(timingModule)
-
-        it("should be idle if timing module has no active timers") {
-            givenNoActiveTimersInQueue()
-            assertThat(uut().isIdleNow()).isTrue()
-        }
-
-        it("should be busy if timing module has active timers") {
-            givenActiveTimersInQueue()
-            assertThat(uut().isIdleNow()).isFalse()
-        }
-
-        it("should specify the busy-interval as the active-timers lookahead range") {
-            givenActiveTimersInQueue()
-            uut().isIdleNow()
-            verify(timingModule).hasActiveTimersInRange(eq(BUSY_INTERVAL_MS))
-        }
-    }
-})

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

@@ -1,189 +0,0 @@
-package com.wix.detox.reactnative.idlingresources.timers
-
-import android.view.Choreographer
-import androidx.test.espresso.IdlingResource
-import org.assertj.core.api.Assertions
-import org.mockito.kotlin.*
-import org.spekframework.spek2.Spek
-import org.spekframework.spek2.style.specification.describe
-
-private fun anIdlingResourceCallback() = mock<IdlingResource.ResourceCallback>()
-
-object TimersIdlingResourceSpec : Spek({
-    describe("React Native timers idling-resource") {
-        lateinit var choreographer: Choreographer
-        lateinit var idleInterrogationStrategy: IdleInterrogationStrategy
-
-        beforeEachTest {
-            idleInterrogationStrategy = mock()
-            choreographer = mock()
-        }
-
-        fun uut() = TimersIdlingResource(idleInterrogationStrategy) { choreographer }
-
-        fun givenIdleStrategy() {
-            whenever(idleInterrogationStrategy.isIdleNow()).thenReturn(true)
-        }
-
-        fun givenBusyStrategy() {
-            whenever(idleInterrogationStrategy.isIdleNow()).thenReturn(false)
-        }
-
-        fun getChoreographerCallback(): Choreographer.FrameCallback {
-            argumentCaptor<Choreographer.FrameCallback>().apply {
-                verify(choreographer).postFrameCallback(capture())
-                return firstValue
-            }
-        }
-
-        fun invokeChoreographerCallback() {
-            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()
-        }
-
-        it("should be busy if strategy says so") {
-            givenBusyStrategy()
-            Assertions.assertThat(uut().isIdleNow).isFalse()
-        }
-
-        it("should transition to idle if found idle by strategy") {
-            givenIdleStrategy()
-
-            val callback = anIdlingResourceCallback()
-
-            with(uut()) {
-                registerIdleTransitionCallback(callback)
-                isIdleNow
-            }
-
-            verify(callback).onTransitionToIdle()
-        }
-
-        it("should NOT transition to idle if found busy by strategy") {
-            givenBusyStrategy()
-
-            val callback = anIdlingResourceCallback()
-
-            with(uut()) {
-                registerIdleTransitionCallback(callback)
-                isIdleNow
-            }
-
-            verify(callback, never()).onTransitionToIdle()
-        }
-
-        it("should be idle if paused") {
-            givenBusyStrategy()
-
-            val uut = uut().apply {
-                pause()
-            }
-
-            Assertions.assertThat(uut.isIdleNow).isTrue()
-        }
-
-        it("should be busy if paused and resumed") {
-            givenBusyStrategy()
-
-            val uut = uut().apply {
-                pause()
-                resume()
-            }
-
-            Assertions.assertThat(uut.isIdleNow).isFalse()
-        }
-
-        it("should notify of transition to idle upon pausing") {
-            givenBusyStrategy()
-
-            val callback = anIdlingResourceCallback()
-
-            with(uut()) {
-                registerIdleTransitionCallback(callback)
-                pause()
-            }
-
-            verify(callback).onTransitionToIdle()
-        }
-
-        it("should enqueue an is-idle check using choreographer when a callback gets registered") {
-            with(uut()) {
-                registerIdleTransitionCallback(mock())
-            }
-
-            verify(choreographer).postFrameCallback(any())
-        }
-
-        it("should transition to idle when preregistered choreographer is dispatched") {
-            givenIdleStrategy()
-
-            val callback = anIdlingResourceCallback()
-
-            uut().registerIdleTransitionCallback(callback)
-            invokeChoreographerCallback()
-
-            verify(callback).onTransitionToIdle()
-        }
-
-        it("should NOT transition to idle if not idle when preregistered choreographer is dispatched") {
-            givenBusyStrategy()
-
-            val callback = anIdlingResourceCallback()
-
-            uut().registerIdleTransitionCallback(callback)
-            invokeChoreographerCallback()
-
-            verify(callback, never()).onTransitionToIdle()
-        }
-
-        it("should re-register choreographer if found idle while preregistered choreographer is dispatched") {
-            givenBusyStrategy()
-
-            val callback = anIdlingResourceCallback()
-
-            val uut = uut()
-            uut.registerIdleTransitionCallback(callback)
-            invokeChoreographerCallback()
-
-            verify(choreographer, times(2)).postFrameCallback(any())
-        }
-
-        it("should adhere to pausing also when invoked via choreographer callback") {
-            givenBusyStrategy()
-
-            val callback = anIdlingResourceCallback()
-
-            uut().apply {
-                pause()
-                registerIdleTransitionCallback(callback)
-            }
-            val runtimeChoreographerCallback = getChoreographerCallback()
-
-            reset(callback, choreographer)
-            runtimeChoreographerCallback.doFrame(0L)
-
-            verify(callback, never()).onTransitionToIdle()
-            verify(choreographer, never()).postFrameCallback(any())
-        }
-
-        it("should enqueue an additional idle check (using choreographer) if found busy") {
-            givenBusyStrategy()
-            uut().isIdleNow
-            verify(choreographer).postFrameCallback(any())
-        }
-
-        it("should NOT enqueue an additional idle check (using choreographer) if found idle") {
-            givenIdleStrategy()
-            uut().isIdleNow
-            verify(choreographer, never()).postFrameCallback(any())
-        }
-    }
-})