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/AdjustSliderToPositionActionTest.kt

@@ -1,59 +0,0 @@
-package com.wix.detox.espresso.action
-
-import android.view.View
-import com.facebook.react.views.slider.ReactSlider
-import com.facebook.react.views.slider.ReactSliderManager
-import org.assertj.core.api.Assertions.assertThat
-import org.hamcrest.Matcher
-import org.junit.Before
-import org.junit.Test
-import org.mockito.kotlin.*
-
-@Suppress("IllegalIdentifier")
-class AdjustSliderToPositionActionTest {
-    val mockReactSliderManager: ReactSliderManager = mock()
-    var uut: AdjustSliderToPositionAction = spy(AdjustSliderToPositionAction(0.25, mockReactSliderManager))
-    private lateinit var mockReactSlider: ReactSlider
-
-    @Before
-    fun setup() {
-        mockReactSlider = mock {
-            on {progress}.thenReturn(250)
-        }
-    }
-
-    @Test
-    fun `should have correct description`() {
-        assertThat(uut.description).isEqualTo("adjustSliderToPosition")
-    }
-
-    @Test
-    fun `should have correct constraints`() {
-        val mockReactSlider: ReactSlider = mock()
-        val mockView: View = mock()
-        val mockIsDisplayed: Matcher<View?> = mock {
-            on {matches(any())}.thenReturn(true)
-        }
-        doReturn(mockIsDisplayed).whenever(uut).getIsDisplayed()
-
-        assertThat(uut.constraints).isNotNull
-        assertThat(uut.constraints!!.matches(null)).isFalse()
-        assertThat(uut.constraints!!.matches(1)).isFalse()
-        assertThat(uut.constraints!!.matches(mockReactSlider)).isTrue()
-        assertThat(uut.constraints!!.matches(mockView)).isFalse()
-    }
-
-    @Test
-    fun `should change progress of slider`() {
-        val mockReactSliderManager: ReactSliderManager = mock {
-            on{updateProperties(any(), any())}.thenAnswer{
-                doReturn(750).whenever(mockReactSlider).progress
-            }
-        }
-        uut = spy(AdjustSliderToPositionAction(0.75, mockReactSliderManager))
-        uut.perform(null, mockReactSlider)
-
-        verify(mockReactSliderManager, times(1)).updateProperties(any(), any())
-        assertThat(mockReactSlider.progress).isEqualTo(750)
-    }
-}

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

@@ -1,115 +0,0 @@
-package com.wix.detox.reactnative.idlingresources.timers
-
-import com.facebook.react.bridge.NativeModule
-import com.wix.detox.UTHelpers
-import org.assertj.core.api.Assertions
-import org.spekframework.spek2.Spek
-import org.spekframework.spek2.style.specification.describe
-import java.util.*
-import java.util.concurrent.Executors
-
-private const val BUSY_INTERVAL_MS = 1500
-private const val MEANINGFUL_TIMER_INTERVAL = BUSY_INTERVAL_MS
-
-data class TimerStub(
-        private var mCallbackID: Int,
-        private var mTargetTime: Long,
-        private var mInterval: Int,
-        private var mRepeat: Boolean)
-
-class TimersNativeModuleStub : NativeModule {
-    val mTimers: PriorityQueue<Any> = PriorityQueue(2) { _, _ -> 0}
-    val mTimerGuard = "Lock-Mock"
-
-    override fun onCatalystInstanceDestroy() {}
-    override fun invalidate() {}
-
-    override fun getName(): String = "TimersNativeModuleStub"
-    override fun canOverrideExistingModule() = false
-    override fun initialize() {}
-}
-
-private fun now() = System.nanoTime() / 1000000L
-private fun aTimer(targetTime: Long, interval: Int, isRepeating: Boolean): TimerStub {
-    return TimerStub(-1, targetTime, interval, isRepeating)
-}
-private fun aTimer(interval: Int, isRepeating: Boolean) = aTimer(now() + interval + 10, interval, isRepeating)
-private fun aOneShotTimer(interval: Int) = aTimer(interval, false)
-private fun aRepeatingTimer(interval: Int) = aTimer(interval, true)
-private fun anOverdueTimer() = aTimer(now() - 100, 123, false)
-
-object DefaultIdleInterrogationStrategySpec: Spek({
-  describe("Default timers idle-interrogation strategy") {
-
-      lateinit var timersNativeModule: TimersNativeModuleStub
-
-      beforeEachTest {
-          timersNativeModule = TimersNativeModuleStub()
-      }
-
-      fun givenTimer(timer: Any) {
-          timersNativeModule.mTimers.add(timer)
-      }
-
-      fun uut() = DefaultIdleInterrogationStrategy(timersNativeModule)
-
-      it("should be idle if there are no timers in queue") {
-          Assertions.assertThat(uut().isIdleNow()).isTrue()
-      }
-
-      it("should be busy if there's a meaningful pending timer") {
-          givenTimer(aOneShotTimer(MEANINGFUL_TIMER_INTERVAL))
-          Assertions.assertThat(uut().isIdleNow()).isFalse()
-      }
-
-      it("should be idle if pending timer is too far away (ie not meaningful)") {
-          givenTimer(aOneShotTimer(BUSY_INTERVAL_MS + 1))
-          Assertions.assertThat(uut().isIdleNow()).isTrue()
-      }
-
-      it("should be idle if the only timer is a repeating one") {
-          givenTimer(aRepeatingTimer(MEANINGFUL_TIMER_INTERVAL))
-          Assertions.assertThat(uut().isIdleNow()).isTrue()
-      }
-
-      it("should be busy if a meaningful pending timer lies beyond a repeating one") {
-          givenTimer(aRepeatingTimer(BUSY_INTERVAL_MS / 10))
-          givenTimer(aOneShotTimer(BUSY_INTERVAL_MS))
-          Assertions.assertThat(uut().isIdleNow()).isFalse()
-      }
-
-      /**
-       * Note: Reversed logic due to this issue: https://github.com/wix/Detox/issues/1171 !!!
-       *
-       * Apparently at times (rare) this caused Espresso to think we're idle too soon, rendering
-       * it never to query any idling resource again even after the timer effectively expires...
-       */
-      it("should be *busy* even if all timers are overdue") {
-          givenTimer(anOverdueTimer())
-          givenTimer(anOverdueTimer())
-          Assertions.assertThat(uut().isIdleNow()).isFalse()
-      }
-
-      it("should be busy if has a meaningful pending timer set beyond an overdue timer") {
-          givenTimer(anOverdueTimer())
-          givenTimer(aOneShotTimer(MEANINGFUL_TIMER_INTERVAL))
-          Assertions.assertThat(uut().isIdleNow()).isFalse()
-      }
-
-      it("should yield to other threads using the timers module") {
-          val executor = Executors.newSingleThreadExecutor()
-          var isIdle: Boolean? = null
-
-          synchronized(timersNativeModule.mTimerGuard) {
-              executor.submit {
-                  isIdle = uut().isIdleNow()
-              }
-              UTHelpers.yieldToOtherThreads(executor)
-              Assertions.assertThat(isIdle).isNull()
-          }
-          UTHelpers.yieldToOtherThreads(executor)
-          Assertions.assertThat(isIdle).isNotNull()
-          executor.shutdownNow()
-      }
-  }
-})

package/local-cli/build.test.js

@@ -1,104 +0,0 @@
-const tempfile = require('tempfile');
-
-describe('build', () => {
-  let execSync, detox, callCli;
-
-  beforeEach(() => {
-    // @ts-ignore
-    callCli = global.callCli;
-    jest.mock('child_process');
-    execSync = require('child_process').execSync;
-
-    jest.mock('../src/utils/logger');
-    jest.mock('../internals', () => {
-      const DetoxConfigErrorComposer = require('../src/errors/DetoxConfigErrorComposer');
-
-      const config = {
-        appsConfig: {},
-        artifactsConfig: {},
-        behaviorConfig: {},
-        errorComposer: new DetoxConfigErrorComposer(),
-        deviceConfig: {},
-        sessionConfig: {}
-      };
-
-      return ({
-        config,
-        resolveConfig: jest.fn().mockResolvedValue(config),
-        log: require('../src/utils/logger')
-      });
-    });
-
-    detox = require('../internals');
-  });
-
-  it('passes argv to resolveConfig', async () => {
-    await callCli('./build', 'build -C /etc/.detoxrc.js -c myconf').catch(() => {});
-
-    expect(detox.resolveConfig).toHaveBeenCalledWith({
-      argv: expect.objectContaining({
-        'C': '/etc/.detoxrc.js',
-        'c': 'myconf',
-      }),
-    });
-  });
-
-  it('runs the build script from the composed device config', async () => {
-    detox.config.appsConfig.default = { build: 'yet another command' };
-
-    await callCli('./build', 'build');
-    expect(execSync).toHaveBeenCalledWith('yet another command', expect.anything());
-  });
-
-  it('skips building the app if the binary exists and --if-missing flag is set', async () => {
-    detox.config.appsConfig.default = { build: 'yet another command', binaryPath: __filename };
-
-    await callCli('./build', 'build -i');
-    expect(execSync).not.toHaveBeenCalled();
-
-    await callCli('./build', 'build --if-missing');
-    expect(execSync).not.toHaveBeenCalled();
-
-    expect(detox.log.info).toHaveBeenCalledWith('Skipping build for "default" app...');
-  });
-
-  it('fails with an error if a build script has not been found', async () => {
-    detox.config.appsConfig.default = {};
-    await expect(callCli('./build', 'build')).rejects.toThrowError(/Failed to build/);
-  });
-
-  it('should ignore missing build command with -s, --silent flag', async () => {
-    detox.config.appsConfig.default = {};
-    await expect(callCli('./build', 'build -s')).resolves.not.toThrowError();
-    expect(detox.log.warn).not.toHaveBeenCalled();
-  });
-
-  it('should print a warning upon user build script failure', async () => {
-    detox.config.appsConfig.default = { build: 'a command' };
-    execSync.mockImplementation(() => { throw new Error('Build failure'); });
-    await expect(callCli('./build', 'build')).rejects.toThrowError(/Build failure/);
-    expect(detox.log.warn).toHaveBeenCalledWith(expect.stringContaining('You are responsible'));
-  });
-
-  it('should print a warning if app is not found at binary path', async () => {
-    detox.config.appsConfig.default = { binaryPath: tempfile() };
-    await expect(callCli('./build', 'build -s')).resolves.not.toThrowError();
-    expect(detox.log.warn).toHaveBeenCalledWith(expect.stringContaining('could not find your app at the given binary path'));
-  });
-
-  it('should print extra message with the app name before building (in a multi-app configuration)', async () => {
-    detox.config.appsConfig.app1 = { binaryPath: tempfile(), build: ':' };
-    detox.config.appsConfig.app2 = { binaryPath: tempfile(), build: ':' };
-
-    await expect(callCli('./build', 'build -s')).resolves.not.toThrowError();
-    expect(detox.log.info).toHaveBeenCalledWith(expect.stringContaining('app1'));
-    expect(detox.log.info).toHaveBeenCalledWith(expect.stringContaining('app2'));
-  });
-
-  it('should not print that extra message when the app is single', async () => {
-    detox.config.appsConfig.default = { binaryPath: tempfile(), build: ':' };
-
-    await expect(callCli('./build', 'build -s')).resolves.not.toThrowError();
-    expect(detox.log.info).not.toHaveBeenCalledWith(expect.stringContaining('default'));
-  });
-});

package/local-cli/run-server.test.js

@@ -1,23 +0,0 @@
-// @ts-nocheck
-jest.mock('../src/utils/logger');
-
-describe('run-server', () => {
-  it('starts the server', async () => {
-    jest.mock('../src/server/DetoxServer');
-    const DetoxServer = require('../src/server/DetoxServer');
-    await callCli('./run-server', 'run-server');
-
-    expect(DetoxServer).toHaveBeenCalledWith(expect.objectContaining({ port: 8099 }));
-  });
-
-  it('throws if the port number is out of range', async () => {
-    jest.spyOn(process, 'exit'); // otherwise tests are aborted
-    jest.mock('../src/server/DetoxServer');
-    const DetoxServer = require('../src/server/DetoxServer');
-
-    await expect(callCli('./run-server', 'run-server -p PORT')).rejects.toThrowErrorMatchingSnapshot();
-    await expect(callCli('./run-server', 'run-server -p 0')).rejects.toThrowErrorMatchingSnapshot();
-    await expect(callCli('./run-server', 'run-server -p 100000')).rejects.toThrowErrorMatchingSnapshot();
-    expect(DetoxServer).not.toHaveBeenCalled();
-  });
-});