@appium/mcp-documentation 1.0.2 → 1.0.4

package/src/resources/submodules/appium-xcuitest-driver/docs/guides/tvos.md

@@ -0,0 +1,246 @@
+---
+title: tvOS Automation
+---
+
+The XCUITest driver supports automation of the tvOS platform. The driver is compatible not only
+with simulators, but also with real wired and wireless devices.
+
+All tvOS sessions must set their `platformName` capability to `tvOS` (instead of `iOS`).
+
+## Simulator Setup
+
+Apart from installing the simulator itself, no additional configuration is needed - you can start a
+session right away. Make sure to provide the simulator's `deviceName` and `platformVersion`:
+
+```json
+{
+    "platformName": "tvOS",
+    "appium:automationName": "XCUITest",
+    "appium:deviceName": "<apple-tv-simulator-name>",
+    "appium:platformVersion": "<tvos-version>",
+    ...
+}
+```
+
+## Real Device Setup
+
+Similarly to real iOS/iPadOS devices, real tvOS devices also have several additional prerequisites.
+For wireless devices, configuration is highly dependent on your tvOS version.
+
+### Wireless tvOS 18 or Later
+
+Devices running tvOS 18 or later use Remote XPC services for pairing and communication. This
+functionality is provided by the optional [`appium-ios-remotexpc`](https://github.com/appium/appium-ios-remotexpc/)
+library. You can also skip this Remote XPC approach and use the solutions described in the tvOS 17
+section, though they are limited and less reliable compared to Remote XPC.
+
+1. Ensure you are using XCUITest driver `>= 10.30.0`, and have installed `appium-ios-remotexpc >= 0.13.0`
+
+2. Set up the common configuration described in the [Real Device Setup](../getting-started/device-setup.md#real-devices)
+   document, including the provisioning profile
+
+3. Pair your Apple TV device to the driver, similarly to how it was paired to Xcode in step 2:
+
+    1. Enable discovery mode in _Settings_ -> _Remotes and Devices_ -> _Remote App and Device_
+    2. Run the dedicated driver script for pairing (`sudo` required):
+
+        ```bash
+        sudo appium driver run xcuitest pair-appletv
+        ```
+
+        The above command will return a prompt for selecting a specific device. You can also skip
+        interactive selection by using the `--device` option. See [the Scripts reference page](../reference/scripts.md#pair-appletv)
+        for more information.
+
+    3. When prompted, enter the PIN that appears on the Apple TV
+        
+    If successful, the script will print an identifier for the paired Apple TV device. This
+    identifier _may_ be different from the device's standard UDID - in such cases it should replace
+    the standard UDID in all future actions.
+
+    For additional details on this procedure (discovery, cryptography, credential storage,
+    troubleshooting), refer to [the full pairing guide](https://github.com/appium/appium-ios-remotexpc/blob/main/docs/apple-tv-pairing-guide.md)
+    in the `appium-ios-remotexpc` project.
+
+4. Start a Remote XPC tunnel for your Apple TV, using another driver script (`sudo` required):
+
+    ```bash
+    sudo appium driver run xcuitest tunnel-creation -- --appletv-device-id <udid-from-pairing-script>
+    ```
+
+    It is also recommended to set the `--disconnect-retry-max-attempts` flag to `3` or more, as
+    disconnects are likely to occur. Refer to the [Remote XPC guide](./remotexpc-tunnels-real-devices.md)
+    and [Scripts reference page](../reference/scripts.md#tunnel-creation) for more details.
+
+5. Launch the Appium server (in a separate process from the Remote XPC tunnel), then start a
+   session as normal, making sure to use the UDID from step 3:
+
+    ```json
+    {
+        "platformName": "tvOS",
+        "appium:automationName": "XCUITest",
+        "appium:udid": "<udid-from-pairing-script>",
+        "appium:platformVersion": "<tvos-version>",
+        ...
+    }
+    ```
+
+### Wireless tvOS 17 or Later
+
+For devices running tvOS 17, the approach slightly differs depending on your Xcode version. It also
+works for devices running tvOS 18 or later, but is discouraged in favor of [the aforementioned Remote XPC approach](#wireless-tvos-18-or-later).
+
+1. Ensure you are using XCUITest driver `>= 10.10.0`
+
+2. Set up the common configuration described in the [Real Device Setup](../getting-started/device-setup.md#real-devices)
+   document, including the provisioning profile
+
+3. Launch the Appium server with the `APPIUM_XCUITEST_PREFER_DEVICECTL` flag:
+
+    ```sh
+    APPIUM_XCUITEST_PREFER_DEVICECTL=1 appium
+    ```
+
+4. If running Xcode `>= 26.1`:
+
+    1. Start a session with the additional `appium:wdaBaseUrl` capability, which must be set to the
+       IP address of the Apple TV:
+
+        ```json
+        {
+            "platformName": "tvOS",
+            "appium:automationName": "XCUITest",
+            "appium:udid": "<apple-tv-udid>",
+            "appium:platformVersion": "<tvos-version>",
+            "appium:wdaBaseUrl": "http://<apple-tv-ip-address>",
+            ...
+        }
+        ```
+
+        You can omit this capability if using [the Preinstalled WDA approach](./run-preinstalled-wda.md).
+
+5. If running Xcode `<= 26.0.1`:
+
+    1. Manually build and launch WebDriverAgentRunner (WDA) yourself. This can be done through the
+       Xcode GUI or otherwise. You can also refer to the steps in the [Run Preinstalled WDA](./run-preinstalled-wda.md#install-webdriveragent)
+       guide.
+    
+    2. Follow the [Attach to Running WDA](./attach-to-running-wda.md) guide and start a session
+       with the `appium:webDriverAgentUrl` capability.
+
+### Wireless tvOS 16 or Earlier
+
+Such devices have not been officially tested, but [user reports](https://github.com/appium/appium/issues/19343)
+have shown that they are discoverable and automatable with the same real device requirements as
+iOS/iPadOS. You can therefore follow the [Real Device Setup](../getting-started/device-setup.md#real-devices)
+document, then start a session as normal:
+
+```json
+{
+    "platformName": "tvOS",
+    "appium:automationName": "XCUITest",
+    "appium:udid": "<apple-tv-udid>",
+    "appium:platformVersion": "<tvos-version>",
+    ...
+}
+```
+
+### Wired
+
+Wired tvOS devices (Apple TV HD) use the same approach as iOS/iPadOS devices. Simply follow the
+[Real Device Setup](../getting-started/device-setup.md#real-devices) document, then start a session
+as normal:
+
+```json
+{
+    "platformName": "tvOS",
+    "appium:automationName": "XCUITest",
+    "appium:udid": "<apple-tv-udid>",
+    "appium:platformVersion": "<tvos-version",
+    ...
+}
+```
+
+## Session Actions
+
+Unlike iOS/iPadOS, interactions with tvOS use [remote controller](https://developer.apple.com/design/human-interface-guidelines/tvos/remote-and-controllers/remote/)
+based actions. The XCUITest driver implements these actions using the
+[`mobile: pressButton`](../reference/execute-methods.md#mobile-pressbutton) extension, with support
+for over 10 different buttons. The `menu` button functions as a back button in the iOS context.
+
+All actions are performed on the _focused_ element (which has the `focus` attribute set). The
+focused element is automatically changed after using `mobile: pressButton`.
+
+It is also possible to use the standard `findElement` and `click` methods. The XCUITest driver will
+automatically calculate the necessary sequence of `up/down/left/right` and `select` button presses,
+so you should not care about which keys should be pressed to reach an arbitrary element every time.
+
+You may want to consider using `wait` methods, since tvOS also has animation.
+
+Here are a few example action sequences in different client languages:
+
+=== "Java"
+
+    ```java
+    WebElement element = driver.findElementByAccessibilityId("element on the app");
+    element.getAttribute("focused");
+    element.click();
+    driver.queryAppState("test.package.name");
+    driver.executeScript("mobile: pressButton", ImmutableMap.of("name", "Home"));
+    driver.executeScript("mobile: pressButton", ImmutableMap.of("name", "Up"));
+    element = driver.switchTo().activeElement();
+    element.getAttribute("label");
+    ```
+
+=== "JS (WebdriverIO)"
+
+    ```javascript
+    const element = $('element on the app');
+    element.getAttribute('focused');
+    element.click();
+    driver.queryAppState("test.package.name");
+    driver.execute('mobile: pressButton', {name: 'Home'});
+    driver.execute('mobile: pressButton', {name: 'Up'});
+    const activeElement = driver.getActiveElement();
+    activeElement.getAttribute('label');
+    ```
+
+=== "Python"
+
+    ```Python
+    element = driver.find_element_by_accessibility_id('element on the app')
+    element.get_attribute('focused')
+    element.click()
+    driver.query_app_state('test.package.name')
+    driver.execute_script('mobile: pressButton', { 'name': 'Home' })
+    driver.execute_script('mobile: pressButton', { 'name': 'Up' })
+    element = driver.switch_to.active_element
+    element.get_attribute('label')
+    ```
+
+=== "Ruby"
+
+    ```ruby
+    element = @driver.find_element :accessibility_id, 'element on the app'
+    element.focused
+    element.click
+    @driver.app_state('test.package.name')
+    @driver.execute_script 'mobile: pressButton', { name: 'Home' }
+    @driver.execute_script 'mobile: pressButton', { name: 'Up' }
+    element = @driver.switch_to.active_element
+    element.label
+    ```
+
+## Known Limitations
+
+* Gesture commands do not work
+* Certain commands such as pasteboard do not work
+
+## Related Tickets
+
+* <https://github.com/appium/appium/pull/12401>
+* <https://github.com/appium/appium-xcuitest-driver/pull/911>
+* <https://github.com/appium/appium-xcuitest-driver/pull/931>
+* <https://github.com/appium/appium-xcuitest-driver/pull/939>
+* <https://github.com/appium/WebDriverAgent/pull/163>
+* <https://github.com/appium/appium-xcuitest-driver/pull/2194>

package/src/resources/submodules/appium-xcuitest-driver/docs/guides/wda-custom-server.md

@@ -0,0 +1,283 @@
+---
+title: Manage WDA by Yourself
+---
+
+The XCUITest driver uses [WebDriverAgent](https://github.com/appium/WebDriverAgent) (WDA) as the
+automation backend. This backend is based on Apple's XCTest framework and shares all the known
+problems that are present in XCTest. For some of them we have workarounds, but there are some that
+are hardly possible to workaround ([here is one example](https://github.com/facebookarchive/WebDriverAgent/issues/507)).
+The approach described in this article enables you to have full control over how WDA is built,
+managed, and run on the device. This way you may fine-tune your automated tests in a CI environment
+and make them more stable inlong-running perspective.
+
+!!! note
+
+    * The steps below are not necessary if default Appium capabilities are used. The server will do
+      everything for you, however, you will not have so much control over WDA.
+    * It is mandatory to have SSH or physical access to the machine to which the device under test
+      is connected.
+
+
+### WDA Setup
+
+In order to setup and launch WDA, please check the provided steps in the
+[Run Preinstalled WDA](./run-preinstalled-wda.md#using-xcode) documentation.
+
+### WDA Startup via Code
+
+WebDriverAgent application acts as a REST server, which proxies external API requests to native
+XCTest calls for your application under test. The server address will be `localhost` if you run your
+tests on a simulator, or the actual phone IP address in case of real device. Appium uses
+[`appium-ios-device`](https://github.com/appium/appium-ios-device) to route network requests to a
+real device from `localhost` via USB, which means one can use this tool to unify the WDA network
+addresses for a simulator and real device.
+
+You can use `appium-ios-device` to connect to a remote device by requiring the module from your
+JavaScript code. Alternatively, you can use [`iproxy`](https://github.com/libimobiledevice/libusbmuxd#iproxy),
+[`go-ios`](https://github.com/danielpaulus/go-ios) or [`tidevice`](https://github.com/alibaba/taobao-iphone-device)
+to handle the WDA process outside Appium, by installing and launching the WDA package. For instance,
+`iproxy` can be installed using `npm`: `npm install -g iproxy`.
+
+This helper class written in Java illustrates the main implementation details with `iproxy`:
+
+```java
+public class WDAServer {
+    private static final Logger log = ZLogger.getLog(WDAServer.class.getSimpleName());
+
+    private static final int MAX_REAL_DEVICE_RESTART_RETRIES = 1;
+    private static final Timedelta REAL_DEVICE_RUNNING_TIMEOUT = Timedelta.ofMinutes(4);
+    private static final Timedelta RESTART_TIMEOUT = Timedelta.ofMinutes(1);
+
+    // These settings are needed to properly sign WDA for real device tests
+    // See https://github.com/appium/appium-xcuitest-driver for more details
+    private static final File KEYCHAIN = new File(String.format("%s/%s",
+            System.getProperty("user.home"), "/Library/Keychains/MyKeychain.keychain"));
+    private static final String KEYCHAIN_PASSWORD = "******";
+
+    private static final File IPROXY_EXECUTABLE = new File("/usr/local/bin/iproxy");
+    private static final File XCODEBUILD_EXECUTABLE = new File("/usr/bin/xcodebuild");
+    private static final File WDA_PROJECT =
+            new File("~/.appium/node_modules/appium-xcuitest-driver/node_modules/appium-webdriveragent" +
+                    "/WebDriverAgent.xcodeproj");
+    private static final String WDA_SCHEME = "WebDriverAgentRunner";
+    private static final String WDA_CONFIGURATION = "Debug";
+    private static final File XCODEBUILD_LOG = new File("/usr/local/var/log/appium/build.log");
+    private static final File IPROXY_LOG = new File("/usr/local/var/log/appium/iproxy.log");
+
+    private static final int PORT = 8100;
+    public static final String SERVER_URL = String.format("http://127.0.0.1:%d", PORT);
+
+    private static final String[] IPROXY_CMDLINE = new String[]{
+            IPROXY_EXECUTABLE.getAbsolutePath(),
+            Integer.toString(PORT),
+            Integer.toString(PORT),
+            String.format("> %s 2>&1 &", IPROXY_LOG.getAbsolutePath())
+    };
+
+    private static WDAServer instance = null;
+    private final boolean isRealDevice;
+    private final String deviceId;
+    private final String platformVersion;
+    private int failedRestartRetriesCount = 0;
+
+    private WDAServer() {
+        try {
+            this.isRealDevice = !getIsSimulatorFromConfig(getClass());
+            final String udid;
+            if (isRealDevice) {
+                udid = IOSRealDeviceHelpers.getUDID();
+            } else {
+                udid = IOSSimulatorHelpers.getId();
+            }
+            this.deviceId = udid;
+            this.platformVersion = getPlatformVersionFromConfig(getClass());
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+        ensureToolsExistence();
+        ensureParentDirExistence();
+    }
+
+    public synchronized static WDAServer getInstance() {
+        if (instance == null) {
+            instance = new WDAServer();
+        }
+        return instance;
+    }
+
+    private boolean waitUntilIsRunning(Timedelta timeout) throws Exception {
+        final URL status = new URL(SERVER_URL + "/status");
+        try {
+            if (timeout.asSeconds() > 5) {
+                log.debug(String.format("Waiting max %s until WDA server starts responding...", timeout));
+            }
+            new UrlChecker().waitUntilAvailable(timeout.asMillis(), TimeUnit.MILLISECONDS, status);
+            return true;
+        } catch (UrlChecker.TimeoutException e) {
+            return false;
+        }
+    }
+
+    private static void ensureParentDirExistence() {
+        if (!XCODEBUILD_LOG.getParentFile().exists()) {
+            if (!XCODEBUILD_LOG.getParentFile().mkdirs()) {
+                throw new IllegalStateException(String.format(
+                        "The script has failed to create '%s' folder for Appium logs. " +
+                                "Please make sure your account has correct access permissions on the parent folder(s)",
+                        XCODEBUILD_LOG.getParentFile().getAbsolutePath()));
+            }
+        }
+    }
+
+    private void ensureToolsExistence() {
+        if (isRealDevice && !IPROXY_EXECUTABLE.exists()) {
+            throw new IllegalStateException(String.format("%s tool is expected to be installed (`npm install -g iproxy`)",
+                    IPROXY_EXECUTABLE.getAbsolutePath()));
+        }
+        if (!XCODEBUILD_EXECUTABLE.exists()) {
+            throw new IllegalStateException(String.format("xcodebuild tool is not detected on the current system at %s",
+                    XCODEBUILD_EXECUTABLE.getAbsolutePath()));
+        }
+        if (!WDA_PROJECT.exists()) {
+            throw new IllegalStateException(String.format("WDA project is expected to exist at %s",
+                    WDA_PROJECT.getAbsolutePath()));
+        }
+    }
+
+    private List<String> generateXcodebuildCmdline() {
+        final List<String> result = new ArrayList<>();
+        result.add(XCODEBUILD_EXECUTABLE.getAbsolutePath());
+        result.add("clean build-for-testing test-without-building");
+        result.add(String.format("-project %s", WDA_PROJECT.getAbsolutePath()));
+        result.add(String.format("-scheme %s", WDA_SCHEME));
+        result.add(String.format("-destination id=%s", deviceId));
+        result.add(String.format("-configuration %s", WDA_CONFIGURATION));
+        result.add(String.format("IPHONEOS_DEPLOYMENT_TARGET=%s", platformVersion));
+        result.add(String.format("> %s 2>&1 &", XCODEBUILD_LOG.getAbsolutePath()));
+        return result;
+    }
+
+    private static List<String> generateKeychainUnlockCmdlines() throws Exception {
+        final List<String> result = new ArrayList<>();
+        result.add(String.format("/usr/bin/security -v list-keychains -s %s", KEYCHAIN.getAbsolutePath()));
+        result.add(String.format("/usr/bin/security -v unlock-keychain -p %s %s",
+                KEYCHAIN_PASSWORD, KEYCHAIN.getAbsolutePath()));
+        result.add(String.format("/usr/bin/security set-keychain-settings -t 3600 %s", KEYCHAIN.getAbsolutePath()));
+        return result;
+    }
+
+    public synchronized void restart() throws Exception {
+        if (isRealDevice && failedRestartRetriesCount >= MAX_REAL_DEVICE_RESTART_RETRIES) {
+            throw new IllegalStateException(String.format(
+                    "WDA server cannot start on the connected device with udid %s after %s retries. " +
+                            "Reboot the device manually and try again", deviceId, MAX_REAL_DEVICE_RESTART_RETRIES));
+        }
+
+        final String hostname = InetAddress.getLocalHost().getHostName();
+        log.info(String.format("Trying to (re)start WDA server on %s:%s...", hostname, PORT));
+        UnixProcessHelpers.killProcessesGracefully(IPROXY_EXECUTABLE.getName(), XCODEBUILD_EXECUTABLE.getName());
+
+        final File scriptFile = File.createTempFile("script", ".sh");
+        try {
+            final List<String> scriptContent = new ArrayList<>();
+            scriptContent.add("#!/bin/bash");
+            if (isRealDevice && isRunningInJenkinsNetwork()) {
+                scriptContent.add(String.join("\n", generateKeychainUnlockCmdlines()));
+            }
+            if (isRealDevice) {
+                scriptContent.add(String.join(" ", IPROXY_CMDLINE));
+            }
+            final String wdaBuildCmdline = String.join(" ", generateXcodebuildCmdline());
+            log.debug(String.format("Building WDA with command line:\n%s\n", wdaBuildCmdline));
+            scriptContent.add(wdaBuildCmdline);
+            try (Writer output = new BufferedWriter(new FileWriter(scriptFile))) {
+                output.write(String.join("\n", scriptContent));
+            }
+            new ProcessBuilder("/bin/chmod", "u+x", scriptFile.getCanonicalPath())
+                    .redirectErrorStream(true).start().waitFor(5, TimeUnit.SECONDS);
+            final ProcessBuilder pb = new ProcessBuilder("/bin/bash", scriptFile.getCanonicalPath());
+            final Map<String, String> env = pb.environment();
+            // This is needed for Jenkins
+            env.put("BUILD_ID", "dontKillMe");
+            // This line is important. If USE_PORT environment variable is not set then WDA
+            // takes port number zero by default and won't accept any incoming requests
+            env.put("USE_PORT", Integer.toString(PORT));
+            log.info(String.format("Waiting max %s for WDA to be (re)started on %s:%s...", RESTART_TIMEOUT.toString(),
+                    hostname, PORT));
+            final Timedelta started = Timedelta.now();
+            pb.redirectErrorStream(true).start().waitFor(RESTART_TIMEOUT.asMillis(), TimeUnit.MILLISECONDS);
+            if (!waitUntilIsRunning(RESTART_TIMEOUT)) {
+                ++failedRestartRetriesCount;
+                throw new IllegalStateException(
+                        String.format("WDA server has failed to start after %s timeout on server '%s'.\n"
+                                        + "Please make sure that iDevice is properly connected and you can build "
+                                        + "WDA manually from XCode.\n"
+                                        + "Xcodebuild logs:\n\n%s\n\n\niproxy logs:\n\n%s\n\n\n",
+                                RESTART_TIMEOUT, hostname,
+                                getLog(XCODEBUILD_LOG).orElse("EMPTY"), getLog(IPROXY_LOG).orElse("EMPTY"))
+                );
+            }
+
+            log.info(String.format("WDA server has been successfully (re)started after %s " +
+                    "and now is listening on %s:%s", Timedelta.now().diff(started).toString(), hostname, PORT));
+        } finally {
+            scriptFile.delete();
+        }
+    }
+
+    public boolean isRunning() throws Exception {
+        if (!isProcessRunning(XCODEBUILD_EXECUTABLE.getName())
+                || (isRealDevice && !isProcessRunning(IPROXY_EXECUTABLE.getName()))) {
+            return false;
+        }
+        return waitUntilIsRunning(isRealDevice ? REAL_DEVICE_RUNNING_TIMEOUT : Timedelta.ofSeconds(3));
+    }
+
+    public Optional<String> getLog(File logFile) {
+        if (logFile.exists()) {
+            try {
+                return Optional.of(new String(Files.readAllBytes(logFile.toPath()), Charset.forName("UTF-8")));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return Optional.empty();
+    }
+}
+```
+
+The following piece of code should then be called before starting the XCUITest driver:
+
+```java
+if (!WDAServer.getInstance().isRunning()) {
+    WDAServer.getInstance().restart();
+}
+```
+
+It is important to set the `appium:webDriverAgentUrl` capability for the driver to let it know
+that WDA is ready for use:
+
+```java
+capabilities.setCapability("webDriverAgentUrl", WDAServer.SERVER_URL);
+```
+
+### Important Notes
+
+* The process does not have direct access to keychain if it is executed by a continuous integration
+  agent, so the keychain must be prepared before compiling WDA for real device, otherwise
+  codesigning will fail. Check the [CI Setup](./ci-setup.md) documentation for details.
+* The `xcodebuild` and `iproxy` processes are killed before restart to make sure compilation
+  succeeds, in case the processes are frozen
+* A dedicated `bash` script is used to detach the `iproxy`/`xcodebuild` processes, so they can
+  continue running in background even after the actual code execution is finished. This is extremely
+  important if multiple tests/suites are executed on the same machine/node in automation lab, which
+  requires minimum human interaction
+* The value of the `BUILD_ID` environment variable is changed to avoid the CI agent killing the
+  background process after the job is finished
+* The `isRunning` check is done by verifying the actual network endpoint
+* The output of daemonized processes is logged, so it is possible to track errors and unexpected
+  failures. The content of the log files is automatically added to the actual error message if the
+  server fails to (re)start.
+* Real device id can be parsed from `system_profiler SPUSBDataType` output
+* Simulator id can be parsed from `xcrun simctl list` output
+* The `UrlChecker` class is imported from the `org.openqa.selenium.net` package

package/src/resources/submodules/appium-xcuitest-driver/docs/index.md

@@ -0,0 +1,36 @@
+---
+hide:
+  - navigation
+  - toc
+
+title: Welcome
+---
+<style>
+  .md-typeset h1 {
+    display: none;
+  }
+</style>
+
+<div style="text-align: center">
+  <img src="assets/images/appium-plus-xctest.png" style="max-width: 500px;" />
+</div>
+
+Welcome to the Appium XCUITest Driver documentation! The XCUITest driver is a test automation
+framework for iOS, iPadOS and tvOS devices, enabling automated black-box testing of native, hybrid
+and WebKit web apps, on both emulators and real devices. 
+
+The XCUITest driver is part of the Appium test automation tool. For information on Appium itself,
+please visit [the Appium documentation](https://appium.io).
+
+## Explore the Documentation
+
+<div class="grid cards" markdown>
+
+-   Check out the [__Overview__](./overview.md) to learn how the driver works
+-   Go through the [__Getting Started__](./getting-started/index.md) steps to get set up and prepare your test device
+-   Browse the [__Reference__](./reference/scripts.md) documentation for everything exposed by the driver
+-   Read the different [__Guides__](./guides/parallel-tests.md) for a variety of instructions, tips and tricks
+-   See the [__Troubleshooting__](./troubleshooting/index.md) section for a list of potential issues
+-   For contributions to the driver, refer to the [__Contributing__](./contributing.md) page
+
+</div>