+
+
+
+Gray box end-to-end testing and automation framework for mobile apps. +
+
+
+
[](https://www.npmjs.com/package/detox) [](https://www.npmjs.com/package/detox) [](https://buildkite.com/wix-mobile-oss/detox) [](https://coveralls.io/github/wix/Detox?branch=master) [](LICENSE) [](https://wix.github.io/Detox/docs/contributing) [](https://discord.gg/CkD5QKheF5) [](https://twitter.com/detoxe2e)
+
+## What Does a Detox Test Look Like?
+
+This is a test for a login screen, it runs on a device/simulator like an actual user:
+
+```js
+describe('Login flow', () => {
+ beforeEach(async () => {
+ await device.reloadReactNative();
+ });
+
+ it('should login successfully', async () => {
+ await element(by.id('email')).typeText('john@example.com');
+ await element(by.id('password')).typeText('123456');
+
+ const loginButton = element(by.text('Login'));
+ await loginButton.tap();
+
+ await expect(loginButton).not.toExist();
+ await expect(element(by.label('Welcome'))).toBeVisible();
+ });
+});
+```
+
+[Get started with Detox now!](https://wix.github.io/Detox/docs/introduction/getting-started)
+
+## About
+
+High velocity native mobile development requires us to adopt continuous integration workflows, which means our reliance on manual QA has to drop significantly. Detox tests your mobile app while itās running in a real device/simulator, interacting with it just like a real user.
+
+The most difficult part of automated testing on mobile is the tip of the testing pyramid - E2E. The core problem with E2E tests is flakiness - tests are usually not deterministic. We believe the only way to tackle flakiness head on is by moving from black box testing to gray box testing. Thatās where Detox comes into play.
+
+- **Cross Platform:** Write end-to-end tests in JavaScript for React Native apps (Android & iOS).
+- **Debuggable:** Modern async-await API allows breakpoints in asynchronous tests to work as expected.
+- **Automatically Synchronized:** Stops flakiness at the core by monitoring asynchronous operations in your app.
+- **Made For CI:** Execute your E2E tests on CI platforms like Travis CI, Circle CI or Jenkins without grief.
+- **Runs on Devices:** Gain confidence to ship by testing your app on a device/simulator just like a real user (not yet supported on iOS).
+- **Test Runner Agnostic:** Detox provides a set of APIs to use with any test runner without it. It comes with [Jest](https://jestjs.io) integration out of the box.
+
+## Supported React Native Versions
+
+Detox was built from the ground up to support React Native projects.
+
+While Detox should work out of the box with almost any React Native version of the latest minor releases, official support is provided for React Native versions `0.73.x`, `0.74.x`, `0.75.x` and `0.76.x`, including React Native's ["New Architecture"](https://reactnative.dev/docs/the-new-architecture/landing-page).
+
+Newer versions may work with Detox but have not been thoroughly tested by the Detox team.
+
+Although we do not officially support older React Native versions, we do our best to keep Detox compatible with them.
+
+Also, in case of a problem with an unsupported version of React Native, please [submit an issue](https://github.com/wix/Detox/issues/new/choose) or write us in our [Discord server](https://discord.gg/CkD5QKheF5) and we will do our best to help out.
+
+### Known Issues with React Native
+
+- Visibility edge-case on Android: see this [RN issue](https://github.com/facebook/react-native/issues/23870).
+
+## Get Started with Detox
+
+Read the [Getting Started Guide](https://wix.github.io/Detox/docs/introduction/getting-started) to get Detox running on your app in less than 10 minutes.
+
+## Documents Site
+
+Explore further about using Detox from our new **[website](https://wix.github.io/Detox/)**.
+
+## Core Principles
+
+We believe that the only way to address the core difficulties with mobile end-to-end testing is by rethinking some of the principles of the entire approach. See what Detox [does differently](https://wix.github.io/Detox/docs/articles/design-principles).
+
+## Contributing to Detox
+
+Detox has been open-source from the first commit. If youāre interested in helping out with our roadmap, please see issues tagged with the [
](https://github.com/wix/Detox/labels/user%3A%20looking%20for%20contributors) label. If you have encountered a bug or would like to suggest a new feature, please open an issue.
+
+Dive into Detox core by reading the [Detox Contribution Guide](https://wix.github.io/Detox/docs/contributing).
+
+## License
+
+- Detox is licensed under the [MIT License](LICENSE)
+
+## Non-English Resources (Community)
+
+- [Getting Started (Brazilian Portuguese)](https://medium.com/quia-digital/iniciando-com-detox-framework-1-4-ce31ad7ae812)
diff --git a/detox-cli/cli.js b/detox-cli/cli.js
new file mode 100755
index 000000000..578872f1b
--- /dev/null
+++ b/detox-cli/cli.js
@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * @param {string} msg
+ */
+function log(msg) {
+ console.error(chalk.red(msg));
+}
+
+function main([_$0, _detox, ...cliArgs]) {
+ const [command] = cliArgs;
+
+ if (command === 'recorder' && process.platform === 'darwin') {
+ return spawnRecorder(cliArgs);
+ } else {
+ return spawnDetoxBinary(cliArgs);
+ }
+}
+
+function spawnDetoxBinary(cliArgs) {
+ const isWin32 = process.platform === 'win32';
+ const nodeBinariesPath = path.join(process.cwd(), 'node_modules/.bin');
+ const binaryPath = path.join(nodeBinariesPath, `detox${isWin32 ? '.cmd' : ''}`);
+
+ if (!fs.existsSync(binaryPath)) {
+ log(`Failed to find Detox executable at path: ${binaryPath}`);
+ log(`\nPossible solutions:`);
+ log(`1. Make sure your current working directory is correct.`);
+ log(`2. Run "npm install" to ensure your "node_modules" directory is up-to-date.`);
+ log(`3. Run "npm install detox --save-dev" for the fresh Detox installation in your project.\n`);
+
+ return 1;
+ }
+
+ const PATH = isWin32 ? findPathKey() : 'PATH';
+ const spawnOptions = {
+ stdio: 'inherit',
+ env: {
+ ...process.env,
+ [PATH]: [nodeBinariesPath, process.env.PATH].join(path.delimiter),
+ }
+ };
+
+ const result = isWin32
+ // { shell: true } option seems to break quoting on windows? Otherwise this would be much simpler.
+ ? cp.spawnSync('cmd', ['/c', binaryPath, ...cliArgs], spawnOptions)
+ : cp.spawnSync(binaryPath, cliArgs, spawnOptions);
+
+ return result.status;
+}
+
+function spawnRecorder([_recorder, ...recorderArgs]) {
+ const detoxRecorderPath = path.join(process.cwd(), 'node_modules/detox-recorder');
+ const detoxRecorderCLIPath = path.join(detoxRecorderPath, 'DetoxRecorderCLI');
+
+ if (!fs.existsSync(detoxRecorderCLIPath)) {
+ log(`Detox Recorder is not installed in this directory: ${detoxRecorderPath}`);
+ return 1;
+ }
+
+ const result = cp.spawnSync(detoxRecorderCLIPath, recorderArgs, { stdio: 'inherit' });
+ return result.status;
+}
+
+function findPathKey() {
+ return Object.keys(process.env).find(isCaseInsensitivePath);
+}
+
+function isCaseInsensitivePath(key) {
+ return key.toLowerCase() === 'path';
+}
+
+process.exit(main(process.argv));
diff --git a/detox-cli/package.json b/detox-cli/package.json
new file mode 100644
index 000000000..f3a0ab566
--- /dev/null
+++ b/detox-cli/package.json
@@ -0,0 +1,29 @@
+{
+ "name": "detox-cli",
+ "version": "20.26.0",
+ "description": "Optional wrapper for Detox CLI, meant to be installed globally",
+ "main": "cli.js",
+ "scripts": {
+ "test": ":"
+ },
+ "bin": {
+ "detox": "./cli.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/wix/detox.git"
+ },
+ "keywords": [
+ "detox",
+ "cli"
+ ],
+ "author": "Yaroslav Serhieiev + * Helper class for InvocationHandlers, which delegates equals, hashCode and toString + * calls to Object. + *
+ * + *+ * Copied from here + * Delegator + *
+ */ +public class Delegator implements InvocationHandler { + + private static Method hashCodeMethod; + private static Method equalsMethod; + private static Method toStringMethod; + static { + try { + hashCodeMethod = Object.class.getMethod("hashCode"); + equalsMethod = + Object.class.getMethod("equals", new Class[] { Object.class }); + toStringMethod = Object.class.getMethod("toString"); + } catch (NoSuchMethodException e) { + throw new NoSuchMethodError(e.getMessage()); + } + } + + private Class[] interfaces; + private Object[] delegates; + + public Delegator(Class[] interfaces, Object[] delegates) { + this.interfaces = (Class[]) interfaces.clone(); + this.delegates = (Object[]) delegates.clone(); + } + + public Object invoke(Object proxy, Method m, Object[] args) + throws Throwable + { + Class declaringClass = m.getDeclaringClass(); + + if (declaringClass == Object.class) { + if (m.equals(hashCodeMethod)) { + return proxyHashCode(proxy); + } else if (m.equals(equalsMethod)) { + return proxyEquals(proxy, args[0]); + } else if (m.equals(toStringMethod)) { + return proxyToString(proxy); + } else { + throw new InternalError( + "unexpected Object method dispatched: " + m); + } + } else { + for (int i = 0; i < interfaces.length; i++) { + if (declaringClass.isAssignableFrom(interfaces[i])) { + try { + return Reflect.on(delegates[i]).call(m.getName(), args).get(); + } catch (ReflectException e) { + throw e.getCause(); + } + } + } + + return invokeNotDelegated(proxy, m, args); + } + } + + // Simple workaround for a deeply rooted issue regarding Proxy classes + public Object invokeAsString(String methodName) throws ReflectException { + return Reflect.on(delegates[0]).call(methodName).get(); + } + + // Simple workaround for a deeply rooted issue regarding Proxy classes + public Object invokeAsString(String methodName, Object[] args) throws ReflectException { + return Reflect.on(delegates[0]).call(methodName, args).get(); + } + + protected Object invokeNotDelegated(Object proxy, Method m, + Object[] args) + throws Throwable + { + throw new InternalError("unexpected method dispatched: " + m); + } + + protected Integer proxyHashCode(Object proxy) { + return System.identityHashCode(proxy); + } + + protected Boolean proxyEquals(Object proxy, Object other) { + return (proxy == other ? Boolean.TRUE : Boolean.FALSE); + } + + protected String proxyToString(Object proxy) { + return proxy.getClass().getName() + '@' + + Integer.toHexString(proxy.hashCode()); + } +} diff --git a/detox/android/detox/src/full/java/com/wix/detox/Detox.java b/detox/android/detox/src/full/java/com/wix/detox/Detox.java new file mode 100644 index 000000000..0e81f218a --- /dev/null +++ b/detox/android/detox/src/full/java/com/wix/detox/Detox.java @@ -0,0 +1,149 @@ +package com.wix.detox; + +import android.content.Context; + +import androidx.annotation.NonNull; +import androidx.test.platform.app.InstrumentationRegistry; +import androidx.test.rule.ActivityTestRule; + +import com.wix.detox.config.DetoxConfig; +import com.wix.detox.espresso.hierarchy.ViewHierarchyGenerator; + +/** + *Static class.
+ * + *To start Detox tests, call runTests() from a JUnit test. + * This test must use AndroidJUnitRunner or a subclass of it, as Detox uses Espresso internally. + * All non-standard async code must be wrapped in an Espresso + * IdlingResource.
+ * + * Example usage + *{@code
+ *@literal @runWith(AndroidJUnit4.class)
+ *@literal @LargeTest
+ * public class DetoxTest {
+ * @literal @Rule
+ * //The Activity that controls React Native.
+ * public ActivityTestRule mActivityRule = new ActivityTestRule(MainActivity.class);
+ *
+ * @literal @Before
+ * public void setUpCustomEspressoIdlingResources() {
+ * // set up your own custom Espresso resources here
+ * }
+ *
+ * @literal @Test
+ * public void runDetoxTests() {
+ * Detox.runTests();
+ * }
+ * }}
+ *
+ * Two required parameters are detoxServer and detoxSessionId. These
+ * must be provided either by Gradle.
+ *
+ *
+ *
{@code
+ * android {
+ * defaultConfig {
+ * testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+ * testInstrumentationRunnerArguments = [
+ * 'detoxServer': 'ws://10.0.2.2:8001',
+ * 'detoxSessionId': '1'
+ * ]
+ * }
+ * }}
+ *
+ *
+ * Or through command line, e.g {@code adb shell am instrument -w -e detoxServer ws://localhost:8001 -e detoxSessionId + * 1 com.example/android.support.test.runner.AndroidJUnitRunner}+ * + *
These are automatically set using, + *
{@code detox test}+ * + *
If not set, then Detox tests are no ops. So it's safe to mix it with other tests.
+ */ +public final class Detox { + private static ActivityLaunchHelper sActivityLaunchHelper; + + private Detox() { + } + + /** + *+ * Call this method from a JUnit test to invoke detox tests. + *
+ * + *+ * In case you have a non-standard React Native application, consider using + * {@link #runTests(ActivityTestRule, Context)}}. + *
+ * + * @param activityTestRule the activityTestRule + */ + public static void runTests(ActivityTestRule activityTestRule) { + runTests(activityTestRule, getAppContext()); + } + + /** + * Same as the default {@link #runTests(ActivityTestRule)} method, but allows for the explicit specification of + * various configurations. Note: review {@link DetoxConfig} for defaults. + * + * @param detoxConfig The configurations to apply. + */ + public static void runTests(ActivityTestRule activityTestRule, DetoxConfig detoxConfig) { + runTests(activityTestRule, getAppContext(), detoxConfig); + } + + /** + *+ * Use this method only if you have a React Native application and it + * doesn't implement ReactApplication; Otherwise use {@link Detox#runTests(ActivityTestRule)}. + *
+ * + *+ * The only requirement is that the passed in object must have + * a method with the signature + *
{@code ReactNativeHost getReactNativeHost();}+ * + * + * @param activityTestRule the activityTestRule + * @param context an object that has a {@code getReactNativeHost()} method + */ + public static void runTests(ActivityTestRule activityTestRule, @NonNull final Context context) { + runTests(activityTestRule, context, new DetoxConfig()); + } + + /** + * Same as {@link #runTests(ActivityTestRule, Context)}, but allows for the explicit specification of + * various configurations. Note: review {@link DetoxConfig} for defaults. + * + * @param detoxConfig The configurations to apply. + */ + public static void runTests(ActivityTestRule activityTestRule, @NonNull final Context context, DetoxConfig detoxConfig) { + DetoxConfig.CONFIG = detoxConfig; + DetoxConfig.CONFIG.apply(); + + sActivityLaunchHelper = new ActivityLaunchHelper(activityTestRule); + DetoxMain.run(context, sActivityLaunchHelper); + } + + public static void launchMainActivity() { + sActivityLaunchHelper.launchMainActivity(); + } + + public static void startActivityFromUrl(String url) { + sActivityLaunchHelper.startActivityFromUrl(url); + } + + public static void startActivityFromNotification(String dataFilePath) { + sActivityLaunchHelper.startActivityFromNotification(dataFilePath); + } + + private static Context getAppContext() { + return InstrumentationRegistry.getInstrumentation().getTargetContext().getApplicationContext(); + } + + public static String generateViewHierarchyXml(boolean shouldInjectTestIds) { + return ViewHierarchyGenerator.generateXml(shouldInjectTestIds); + } +} diff --git a/detox/android/detox/src/full/java/com/wix/detox/DetoxANRHandler.kt b/detox/android/detox/src/full/java/com/wix/detox/DetoxANRHandler.kt new file mode 100644 index 000000000..6108e8bce --- /dev/null +++ b/detox/android/detox/src/full/java/com/wix/detox/DetoxANRHandler.kt @@ -0,0 +1,25 @@ +package com.wix.detox + +import android.util.Log +import com.github.anrwatchdog.ANRWatchDog +import com.wix.detox.adapters.server.OutboundServerAdapter + +class DetoxANRHandler(private val outboundServerAdapter: OutboundServerAdapter) { + fun attach() { + ANRWatchDog().setReportMainThreadOnly().setANRListener { + val info = mapOf("threadDump" to Log.getStackTraceString(it)) + outboundServerAdapter.sendMessage(ACTION_NAME, info, MESSAGE_ID) + }.start() + + ANRWatchDog().setANRListener { + Log.e(LOG_TAG, "App nonresnponsive detection!", it) + }.start() + } + + companion object { + private val LOG_TAG: String = DetoxANRHandler::class.java.simpleName + + private const val ACTION_NAME = "AppNonresponsiveDetected" + private const val MESSAGE_ID = -10001L + } +} diff --git a/detox/android/detox/src/full/java/com/wix/detox/DetoxCrashHandler.kt b/detox/android/detox/src/full/java/com/wix/detox/DetoxCrashHandler.kt new file mode 100644 index 000000000..62efbea30 --- /dev/null +++ b/detox/android/detox/src/full/java/com/wix/detox/DetoxCrashHandler.kt @@ -0,0 +1,22 @@ +package com.wix.detox + +import android.util.Log +import com.wix.detox.adapters.server.OutboundServerAdapter + +class DetoxCrashHandler(private val outboundServerAdapter: OutboundServerAdapter) { + fun attach() { + Thread.setDefaultUncaughtExceptionHandler { thread, exception -> + Log.e(LOG_TAG, "Crash detected!!! thread=${thread.name} (${thread.id})", exception) + + val crashInfo = mapOf("errorDetails" to "@Thread ${thread.name}(${thread.id}):\n${Log.getStackTraceString(exception)}\nCheck device logs for full details!") + outboundServerAdapter.sendMessage(ACTION_NAME, crashInfo, MESSAGE_ID) + } + } + + companion object { + private val LOG_TAG: String = DetoxCrashHandler::class.java.simpleName + + private const val ACTION_NAME = "AppWillTerminateWithError" + private const val MESSAGE_ID = -10000L + } +} diff --git a/detox/android/detox/src/full/java/com/wix/detox/DetoxJUnitRunner.java b/detox/android/detox/src/full/java/com/wix/detox/DetoxJUnitRunner.java new file mode 100644 index 000000000..4f0977421 --- /dev/null +++ b/detox/android/detox/src/full/java/com/wix/detox/DetoxJUnitRunner.java @@ -0,0 +1,73 @@ +package com.wix.detox; + +import android.app.Application; +import android.os.Bundle; +import android.util.Log; + +import androidx.test.runner.AndroidJUnitRunner; +import androidx.test.runner.lifecycle.ApplicationLifecycleCallback; +import androidx.test.runner.lifecycle.ApplicationLifecycleMonitor; +import androidx.test.runner.lifecycle.ApplicationLifecycleMonitorRegistry; +import androidx.test.runner.lifecycle.ApplicationStage; + +import com.wix.detox.instruments.DetoxInstrumentsManager; + + +public class DetoxJUnitRunner extends AndroidJUnitRunner { + private static final String TAG = "DetoxJUnitRunner"; + private DetoxInstrumentsManager instrumentsManager; + private ApplicationLifecycleCallback lifecycleCallback; + + @Override + public void onCreate(final Bundle arguments) { + super.onCreate(arguments); + + final ApplicationLifecycleMonitor monitor = ApplicationLifecycleMonitorRegistry.getInstance(); + lifecycleCallback = new ApplicationLifecycleCallback() { + @Override + public void onApplicationLifecycleChanged(Application app, ApplicationStage stage) { + if (stage == ApplicationStage.PRE_ON_CREATE) { + onBeforeAppOnCreate(app, arguments); + } else if (stage == ApplicationStage.CREATED) { + onAfterAppOnCreate(); + } + } + }; + monitor.addLifecycleCallback(lifecycleCallback); + } + + @Override + public void onDestroy() { + instrumentsManager.stopRecording(); + instrumentsManager = null; + lifecycleCallback = null; + + super.onDestroy(); + } + + private void onBeforeAppOnCreate(Application app, Bundle arguments) { + final String recordingPath = arguments.getString("detoxInstrumRecPath"); + if (recordingPath != null) { + if (DetoxInstrumentsManager.supports()) { + long samplingInterval = 250; + try { + final String interval = arguments.getString("detoxInstrumSamplingInterval"); + if (interval != null) { + samplingInterval = Long.parseLong(interval); + } + } catch (NumberFormatException ignore) { + Log.w(TAG, "Invalid value for param \"detoxInstrumSamplingInterval\", default was used"); + } + + instrumentsManager = new DetoxInstrumentsManager(app); + instrumentsManager.startRecordingAtLocalPath(recordingPath, samplingInterval); + } + } + } + + private void onAfterAppOnCreate() { + if (instrumentsManager != null) { + instrumentsManager.tryInstallJsi(); + } + } +} diff --git a/detox/android/detox/src/full/java/com/wix/detox/DetoxMain.kt b/detox/android/detox/src/full/java/com/wix/detox/DetoxMain.kt new file mode 100644 index 000000000..811fab107 --- /dev/null +++ b/detox/android/detox/src/full/java/com/wix/detox/DetoxMain.kt @@ -0,0 +1,130 @@ +package com.wix.detox + +import android.content.Context +import android.util.Log +import com.wix.detox.adapters.server.* +import com.wix.detox.common.DetoxLog +import com.wix.detox.espresso.UiControllerSpy +import com.wix.detox.instruments.DetoxInstrumentsManager +import com.wix.detox.reactnative.ReactNativeExtension +import com.wix.invoke.MethodInvocation +import java.util.concurrent.CountDownLatch + +private const val TERMINATION_ACTION = "_terminate" + +object DetoxMain { + private val handshakeLock = CountDownLatch(1) + + @JvmStatic + fun run(rnHostHolder: Context, activityLaunchHelper: ActivityLaunchHelper) { + val detoxServerInfo = DetoxServerInfo() + val testEngineFacade = TestEngineFacade() + val actionsDispatcher = DetoxActionsDispatcher() + val serverAdapter = DetoxServerAdapter(actionsDispatcher, detoxServerInfo, TERMINATION_ACTION) + + initCrashHandler(serverAdapter) + initANRListener(serverAdapter) + initEspresso() + initReactNative() + + setupActionHandlers(actionsDispatcher, serverAdapter, testEngineFacade, rnHostHolder) + serverAdapter.connect() + + launchActivityOnCue(rnHostHolder, activityLaunchHelper) + actionsDispatcher.join() + } + + /** + * Launch the tested activity "on cue", namely, right after a connection is established and the handshake + * completes successfully. + * + * This has to be synchronized so that an `isReady` isn't handled *before* the activity is launched (albeit not fully + * initialized - all native modules and everything) and a react context is available. + * + * As a better alternative, it would make sense to execute this as a simple action from within the actions + * dispatcher (i.e. handler of `loginSuccess`), in which case, no inter-thread locking would be required + * thanks to the usage of Handlers. However, in this type of a solution, errors / crashes would be reported + * not by instrumentation itself, but based on the `AppWillTerminateWithError` message; In it's own, it is a good + * thing, but for a reason we're not sure of yet, it is ignored by the test runner at this point in the flow. + */ + private fun launchActivityOnCue(rnHostHolder: Context, activityLaunchHelper: ActivityLaunchHelper) { + synchronized(this) { + awaitHandshake() + launchActivity(rnHostHolder, activityLaunchHelper) + } + } + + private fun awaitHandshake() { + handshakeLock.await() + } + + private fun onLoginSuccess() { + handshakeLock.countDown() + } + + private fun doTeardown(serverAdapter: DetoxServerAdapter, actionsDispatcher: DetoxActionsDispatcher, testEngineFacade: TestEngineFacade) { + testEngineFacade.resetReactNative() + + serverAdapter.teardown() + actionsDispatcher.teardown() + } + + private fun setupActionHandlers(actionsDispatcher: DetoxActionsDispatcher, serverAdapter: DetoxServerAdapter, testEngineFacade: TestEngineFacade, rnHostHolder: Context) { + class SynchronizedActionHandler(private val actionHandler: DetoxActionHandler): DetoxActionHandler { + override fun handle(params: String, messageId: Long) { + synchronized(this@DetoxMain) { + actionHandler.handle(params, messageId) + } + } + } + + // Primary actions + with(actionsDispatcher) { + val readyHandler = SynchronizedActionHandler( ReadyActionHandler(serverAdapter, testEngineFacade) ) + val rnReloadHandler = SynchronizedActionHandler( ReactNativeReloadActionHandler(rnHostHolder, serverAdapter, testEngineFacade) ) + + associateActionHandler("loginSuccess", ::onLoginSuccess) + associateActionHandler("isReady", readyHandler) + associateActionHandler("reactNativeReload", rnReloadHandler) + associateActionHandler("invoke", InvokeActionHandler(MethodInvocation(), serverAdapter)) + associateActionHandler("cleanup", CleanupActionHandler(serverAdapter, testEngineFacade) { + dispatchAction(TERMINATION_ACTION, "", 0) + }) + associateActionHandler(TERMINATION_ACTION) { -> doTeardown(serverAdapter, actionsDispatcher, testEngineFacade) } + + if (DetoxInstrumentsManager.supports()) { + val instrumentsManager = DetoxInstrumentsManager(rnHostHolder) + associateActionHandler("setRecordingState", InstrumentsRecordingStateActionHandler(instrumentsManager, serverAdapter)) + associateActionHandler("event", InstrumentsEventsActionsHandler(instrumentsManager, serverAdapter)) + } + } + + // Secondary actions + with(actionsDispatcher) { + val queryStatusHandler = SynchronizedActionHandler( QueryStatusActionHandler(serverAdapter, testEngineFacade) ) + associateSecondaryActionHandler("currentStatus", queryStatusHandler) + } + } + + private fun initCrashHandler(outboundServerAdapter: OutboundServerAdapter) { + DetoxCrashHandler(outboundServerAdapter).attach() + } + + private fun initANRListener(outboundServerAdapter: OutboundServerAdapter) { + DetoxANRHandler(outboundServerAdapter).attach() + } + + private fun initEspresso() { + UiControllerSpy.attachThroughProxy() + } + + private fun initReactNative() { + ReactNativeExtension.initIfNeeded() + } + + private fun launchActivity(rnHostHolder: Context, activityLaunchHelper: ActivityLaunchHelper) { + Log.i(DetoxLog.LOG_TAG, "Launching the tested activity!") + activityLaunchHelper.launchActivityUnderTest() + ReactNativeExtension.waitForRNBootstrap(rnHostHolder) + } +} diff --git a/detox/android/detox/src/full/java/com/wix/detox/LaunchArgs.java b/detox/android/detox/src/full/java/com/wix/detox/LaunchArgs.java new file mode 100644 index 000000000..0e1352615 --- /dev/null +++ b/detox/android/detox/src/full/java/com/wix/detox/LaunchArgs.java @@ -0,0 +1,82 @@ +package com.wix.detox; + +import android.os.Bundle; +import android.util.Base64; + +import java.util.Arrays; +import java.util.List; + +import androidx.test.platform.app.InstrumentationRegistry; + +public class LaunchArgs { + private static final String DETOX_SERVER_URL_ARG = "detoxServer"; + private static final String DETOX_SESSION_ID_ARG_KEY = "detoxSessionId"; + private static final String DETOX_NOTIFICATION_PATH_ARG = "detoxUserNotificationDataURL"; + private static final String DETOX_BLACKLIST_URLS_ARG = "detoxURLBlacklistRegex"; + private static final String DETOX_URL_OVERRIDE_ARG = "detoxURLOverride"; + private static final String DETOX_ENABLE_SYNCHRONIZATION = "detoxEnableSynchronization"; + private static final List
+ * React Native uses Choreographer callbacks. Those are invisible to Espresso. + * One of them is UIModule, UIViewOperationQueue. + *
+ * After everything idled out, we should still wait for UIModule to initiate it's changes + * on the UI by waiting out its Choreographer frame. + *
+ * TODO:
+ * Find a way to wrap up the UIModule in an Espresso IdlingResource, similar to JS Timers.
+ */
+ private static void waitForChoreographer() {
+ final int waitFrameCount = 2;
+ final CountDownLatch latch = new CountDownLatch(1);
+ Handler handler = new Handler(InstrumentationRegistry.getInstrumentation().getTargetContext().getMainLooper());
+ handler.post(
+ new Runnable() {
+ @Override
+ public void run() {
+ Choreographer.getInstance().postFrameCallback(
+ new Choreographer.FrameCallback() {
+
+ private int frameCount = 0;
+
+ @Override
+ public void doFrame(long frameTimeNanos) {
+ frameCount++;
+ if (frameCount == waitFrameCount) {
+ latch.countDown();
+ } else {
+ Choreographer.getInstance().postFrameCallback(this);
+ }
+ }
+ });
+ }
+ });
+ try {
+ if (!latch.await(500, TimeUnit.MILLISECONDS)) {
+ throw new RuntimeException("Timed out waiting for Choreographer");
+ }
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @SuppressLint({"DiscouragedApi", "InternalInsetResource"})
+ public static int getStatusBarHeightDps(View view) {
+ Context context = view.getContext();
+ int resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
+ return (int) (context.getResources().getDimensionPixelSize(resourceId) / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT));
+ }
+}
diff --git a/detox/android/detox/src/full/java/com/wix/detox/espresso/action/AdjustSliderToPositionAction.kt b/detox/android/detox/src/full/java/com/wix/detox/espresso/action/AdjustSliderToPositionAction.kt
new file mode 100644
index 000000000..08e609a67
--- /dev/null
+++ b/detox/android/detox/src/full/java/com/wix/detox/espresso/action/AdjustSliderToPositionAction.kt
@@ -0,0 +1,22 @@
+package com.wix.detox.espresso.action
+
+import android.view.View
+import androidx.appcompat.widget.AppCompatSeekBar
+import androidx.test.espresso.UiController
+import androidx.test.espresso.ViewAction
+import androidx.test.espresso.matcher.ViewMatchers.isAssignableFrom
+import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import com.wix.detox.espresso.common.ReactSliderHelper
+import org.hamcrest.Matcher
+import org.hamcrest.Matchers
+
+class AdjustSliderToPositionAction(private val targetPositionPct: Float) : ViewAction {
+ override fun getDescription() = "adjustSliderToPosition"
+ override fun getConstraints(): Matcher