detox 20.28.0 → 20.31.0

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())
-        }
-    }
-})