DEV Community: Yusuf Aşık

Android/iOS Testing Perfected: 20 Appium Tricks You Need

Yusuf Aşık — Tue, 01 Apr 2025 20:45:18 +0000

Appium is one of the(maybe number one) most popular open-source automation tool for testing mobile applications across iOS and Android platforms. Strong libraries, wide community and documentation support and years of experience across all the QA Enginners and most importantly Selenium-like syntax makes it top choice for Native Mobile App testing. If we know that, we should know how to make it perfect too.

1. Use Appium Inspector

Appium Inspector helps in identifying element locators efficiently. It allows testers to inspect UI elements and retrieve attributes like resource-id, accessibility-id, text, and class.

Example:

Open Appium Inspector and connect to your running session.
Click on elements to fetch their properties.
Copy unique locators to use in your automation script, ensuring better test stability.

2. Find Exact App Names from Play Store

To correctly launch an app using Appium, you need the exact package name and main activity.

Example:

Install the "Package Name Viewer" on an android test device.
Use these details in your capabilities while setting up Appium.

3. Advanced ADB Command for Extracting Current Activity

Instead of manually searching the activity name from dumpsys window, use the following command to extract it precisely:

Example:

adb shell dumpsys window | grep -oP '(?<=mCurrentFocus=Window{)[^}]+'

This command extracts only the currently focused window, making it easier to grab the package and activity for use in Appium tests.

4. Explicit Waits

Avoid using Thread.sleep() as it introduces unnecessary delays. Instead, use explicit waits, which wait for an element until a specified condition is met.

Example:

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("login_button")));

This ensures that your test does not proceed until the element is visible.

5. Page Object Model (POM)

Using POM makes test scripts more structured and maintainable by separating UI elements and test logic.

Example:

public class LoginPage {
    @FindBy(id = "username")
    private WebElement username;

    @FindBy(id = "password")
    private WebElement password;

    @FindBy(id = "login_button")
    private WebElement loginButton;

    public void login(String user, String pass) {
        username.sendKeys(user);
        password.sendKeys(pass);
        loginButton.click();
    }
}

This makes test cases more readable and reusable.

6. Prefer Accessibility IDs and Resource IDs

Accessibility ID and Resource ID are the most reliable locators compared to XPaths, making tests more stable and faster.

Example:

driver.findElement(MobileBy.AccessibilityId("SubmitButton")).click();

This avoids issues caused by UI structure changes.

7. Relative XPaths over Absolute

Absolute XPaths are brittle as they depend on UI structure. Always prefer relative XPaths to improve test maintainability.

Example:

driver.findElement(By.xpath("//android.widget.Button[@text='Submit']")).click();

This makes tests resilient to minor UI changes.

8. Handle Flakiness with Retries

Tests may fail due to temporary issues like slow network or animations. Implement retry logic to reduce false failures.

Example:

@Test(retryAnalyzer = RetryAnalyzer.class)
public void testLogin() {
    // Test implementation
}

This improves test reliability.

9. Disable Animations via ADB

Animations can slow down tests and cause flakiness. Disable them using ADB commands.

Example:

adb shell settings put global window_animation_scale 0
adb shell settings put global transition_animation_scale 0
adb shell settings put global animator_duration_scale 0

This speeds up UI interactions during automation.

10. Parallel Test Execution

Run tests on multiple devices simultaneously to speed up execution.

Example:

<suite name="ParallelTests" parallel="tests" thread-count="2">
    <test name="AndroidTest1">
        <classes>
            <class name="tests.LoginTest" />
        </classes>
    </test>
</suite>

This optimizes test execution time.

11. Use UIAutomator2

UIAutomator2 is the recommended automation engine for Android as it provides better stability and speed.

Example (Java):

capabilities.setCapability("automationName", "UIAutomator2");

This ensures compatibility with modern Android versions.

12. Network Conditioning

Simulate different network conditions like slow or no internet to test app behavior.

Example:

adb shell am broadcast -a com.android.intent.action.SET_NETWORK_CONDITIONS --es condition slow

This helps validate app performance under various network conditions.

13. Grant Permissions via ADB

Some apps require runtime permissions. Instead of manually accepting popups, grant permissions via ADB.

Example:

adb shell pm grant com.example android.permission.CAMERA

This ensures smooth test execution without interruptions.

14. Screenshots on Failure

Capture screenshots on test failures to debug issues effectively.

Example:

File scrFile = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
FileUtils.copyFile(scrFile, new File("failure_screenshot.png"));

This helps in analyzing failures visually.

15. Test Data Cleanup

Ensure a fresh app state before every test by resetting app data.

Example:

driver.resetApp();

This prevents stale data from affecting test results.

16. Cloud Testing Services

Use services like BrowserStack, Sauce Labs, or Firebase Test Lab to run tests on real devices in the cloud. It will also help you if you are unable to use Mac machine to test IOS.

Example:

capabilities.setCapability("browserstack.user", "your_username");
capabilities.setCapability("browserstack.key", "your_access_key");

Cloud testing provides access to multiple device configurations and reduces infrastructure costs.

Bonus: iOS Tips

Use `xcuitest` Automation Engine

For iOS automation, always use the XCUITest automation engine as it is the most stable and widely supported.

Example:

capabilities.setCapability("automationName", "XCUITest");

This ensures better compatibility with iOS devices.

Handle iOS Permissions Automatically

iOS apps require permissions for features like camera and location. You can pre-approve these using Appium capabilities.

Example:

capabilities.setCapability("autoAcceptAlerts", true);

This prevents permission popups from interrupting your tests.

Use Predicate Strings for Locators

Instead of XPaths, use Predicate Strings for better performance and stability.

Example:

driver.findElement(MobileBy.iOSNsPredicateString("label == 'Submit'"));

Predicate Strings execute faster and are more robust than XPath.

Use iosClassChain for Faster Element Finding

For better performance in iOS automation, prefer iosClassChain instead of XPath. It’s more efficient and faster for locating elements.

Example:

driver.findElement(MobileBy.iOSClassChain("**/XCUIElementTypeButton[`label == 'Submit'`]")).click();

This improves execution speed compared to XPath and is more reliable.

Predicate String vs iOSClassChain

Use Predicate String when you need more readable and flexible conditions (e.g., filtering by label, value, or name).
Use iosClassChain when dealing with deeply nested elements or hierarchical structures (e.g., finding a button inside a specific cell).

TL&DR: Predicate String for simple queries, iosClassChain for complex UI trees.

If performance is a concern, iosClassChain is generally faster than Predicate Strings, especially for deeply nested elements.

Following these best practices will significantly improve the stability, reliability, and efficiency of your Appium-based mobile test automation.

Let me know if you have other tips as well!

Security Testing for SDETs: Automate Vulnerability Scans with OWASP ZAP

Yusuf Aşık — Mon, 24 Mar 2025 15:42:55 +0000

As Software Development Engineers in Test (SDETs), we’re no strangers to automation. We build frameworks to validate functionality, performance, and usability. But in today’s threat landscape, security testing can no longer be an afterthought – and that’s where OWASP ZAP (Zed Attack Proxy) shines. Let’s explore why integrating ZAP into your automated tests matters and how it transforms your role in securing applications.

Why Security Testing Matters for SDETs

Shift-Left Security

Security vulnerabilities caught late in the SDLC cost 6x more to fix than those identified early. By integrating security testing into automation, SDETs enable proactive risk mitigation.
Beyond Functional Testing

Modern SDETs are guardians of quality and security. A feature might work perfectly but leak sensitive data or expose SQL injection points.
Compliance & Reputation

GDPR, PCI-DSS, and other regulations demand security rigor. Automated security tests provide auditable proof of due diligence.

OWASP ZAP: The SDET’s Security Swiss Army Knife

ZAP isn’t just another scanner – it’s a developer-centric toolkit designed for automation:

Passive Scanning: Analyze traffic during functional tests
Active Scanning: Simulate attacks (XSS, SQLi, etc.)
API-first Design: Perfect for CI/CD pipelines
Customizable: Addons for OAuth, GraphQL, and more

Integrating ZAP into Your Framework: Key Benefits

✅ Seamless Automation

Trigger scans programmatically via ZAP’s REST API during Selenium test suites.

✅ Context-Aware Testing

Use authenticated sessions from your functional tests to scan post-login workflows.

✅ CI/CD Friendly

Fail builds automatically when ZAP detects high-risk vulnerabilities.

✅ Allure-Ready Reports

Combine ZAP’s HTML/JSON reports with Allure’s trend analysis for security metrics.

How to Integrate ZAP with Selenium + TestNG

Architecture Overview

ZAP Proxy Setup: Route Selenium traffic through ZAP
Passive Scan During Tests: Let ZAP analyze HTTP/S traffic
Active Scan Post-Test: Trigger attacks after critical workflows
Report Generation: Export results to Allure

Note: Headless mode requires additional steps and for normal test ZAP GUI should be opened before test starts.

Example Code Snippets (Dependencies)

<!-- Selenium -->
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>4.30.0</version>
        </dependency>

<!-- https://mvnrepository.com/artifact/io.cucumber/cucumber-java -->
        <dependency>
            <groupId>io.cucumber</groupId>
            <artifactId>cucumber-java</artifactId>
            <version>7.21.1</version>
        </dependency>

<!-- https://mvnrepository.com/artifact/org.zaproxy/zap-clientapi -->
        <dependency>
            <groupId>org.zaproxy</groupId>
            <artifactId>zap-clientapi</artifactId>
            <version>1.16.0</version>
        </dependency>

<!-- https://mvnrepository.com/artifact/org.testng/testng -->
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>7.10.2</version>
            <scope>test</scope>
        </dependency>

<!-- Allure -->
        <dependency>
            <groupId>io.qameta.allure</groupId>
            <artifactId>allure-cucumber7-jvm</artifactId>
            <scope>test</scope>
        </dependency>

<!-- https://mvnrepository.com/artifact/io.qameta.allure/allure-testng -->
        <dependency>
            <groupId>io.qameta.allure</groupId>
            <artifactId>allure-testng</artifactId>
            <version>2.29.1</version>
        </dependency>

Feature File


Feature: ZAP Security Check

  @sec
  Scenario: I need to run security check
    When i started security test

Step Definition

package com.velespit.step_definitions;

import com.velespit.utilities.BrowserUtils;
import com.velespit.utilities.ConfigurationReader;
import io.qameta.allure.Allure;
import io.qameta.allure.Description;
import io.qameta.allure.testng.Tag;
import org.testng.annotations.Test;
import org.zaproxy.clientapi.core.*;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.zaproxy.clientapi.core.ClientApi;

import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;

public class ZapSecurityTest {

    private static final Logger logger = LoggerFactory.getLogger(ZapSecurityTest.class);
    private static final String ZAP_PROXY_HOST = "localhost";
    private static final int ZAP_PROXY_PORT = 8080;
    private static final String ZAP_API_KEY = ConfigurationReader.getProperty("zap_api_key"); // Replace with your ZAP API key

    private static ClientApi zapClient;

    public ZapSecurityTest() {
        zapClient = new ClientApi(ZAP_PROXY_HOST, ZAP_PROXY_PORT, ZAP_API_KEY);
    }

    public static void startZAPHeadless() {
        try {
            ProcessBuilder processBuilder = new ProcessBuilder(
                    "cmd.exe", "/c", ConfigurationReader.getProperty("zap_path"), "-daemon", "-port", "8080", "-host", "localhost"
            );

            processBuilder.directory(new File(ConfigurationReader.getProperty("zap_path")));
            processBuilder.redirectErrorStream(true);

            Process zapProcess = processBuilder.start();
            logger.info("ZAP started in headless mode.");

            // Wait until ZAP is fully initialized before continuing
            waitForZapStartup();

        } catch (Exception e) {
            logger.error("Failed to start ZAP in headless mode.", e);
        }
    }

    private static void waitForZapStartup() throws InterruptedException {
        logger.info("Waiting for ZAP to initialize...");

        int retries = 10;
        while (retries > 0) {
            if (isZapRunning()) {
                logger.info("ZAP is ready!");
                return;
            }
            BrowserUtils.sleep(5); // Wait 5 seconds
            retries--;
        }
        throw new RuntimeException("ZAP did not start within the expected time!");
    }

    private static boolean isZapRunning() {
        try {
            ProcessBuilder checkProcess = new ProcessBuilder("curl", "-s", "http://localhost:8080/");
            Process process = checkProcess.start();
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));

            String response;
            while ((response = reader.readLine()) != null) {
                if (response.contains("ZAP")) {
                    return true;
                }
            }
        } catch (Exception e) {
            return false;
        }
        return false;
    }

    public void startZapSecurityTest(String targetUrl) {
        try {
            // Start a new session
            zapClient.core.newSession("ZAP Security Test", "true");

            // Spider the target URL to discover links
            logger.info("Starting ZAP Spider for: {}", targetUrl);
            ApiResponse spiderResponse = zapClient.spider.scan(targetUrl, null, null, null, null);
            String scanId = ((ApiResponseElement) spiderResponse).getValue();
            waitForSpiderToComplete(scanId);

            // Active scan for vulnerabilities
            logger.info("Starting ZAP Active Scan for: {}", targetUrl);
            ApiResponse activeScanResponse = zapClient.ascan.scan(targetUrl, "true", "false", null, null, null);
            String activeScanId = ((ApiResponseElement) activeScanResponse).getValue();
            waitForActiveScanToComplete(activeScanId);

            // Generate and report security findings
            reportSecurityFindings(targetUrl);

        } catch (ClientApiException | InterruptedException e) {
            logger.error("An error occurred during ZAP security testing: ", e);
            Allure.addAttachment("Error", "text/plain", "An error occurred: " + e.getMessage());
        }
    }

    private void waitForSpiderToComplete(String scanId) throws ClientApiException, InterruptedException {
        while (true) {
            BrowserUtils.sleep(2); // Poll every 2 seconds
            ApiResponse spiderStatus = zapClient.spider.status(scanId);
            int progress = Integer.parseInt(((ApiResponseElement) spiderStatus).getValue());
            logger.info("ZAP Spider progress: {}%", progress);
            if (progress >= 100) {
                break;
            }
        }
        logger.info("ZAP Spider completed.");
    }

    private void waitForActiveScanToComplete(String scanId) throws ClientApiException, InterruptedException {
        while (true) {
            BrowserUtils.sleep(2); // Poll every 2 seconds
            ApiResponse activeScanStatus = zapClient.ascan.status(scanId);
            int progress = Integer.parseInt(((ApiResponseElement) activeScanStatus).getValue());
            logger.info("ZAP Active Scan progress: {}%", progress);
            if (progress >= 100) {
                break;
            }
        }
        logger.info("ZAP Active Scan completed.");
    }

    private void reportSecurityFindings(String targetUrl) throws ClientApiException {
        // Get alerts (vulnerabilities) using the new API method
        ApiResponse alertsResponse = zapClient.alert.alerts(targetUrl, null, null, null);
        List<Map<String, String>> alerts = parseAlerts((ApiResponseList) alertsResponse);
        if (alerts.isEmpty()) {
            Allure.addAttachment("ZAP Security Result", "text/plain", "No security issues found for: " + targetUrl);
        } else {
            Allure.addAttachment("ZAP Security Result", "text/plain", "Security Issues Found for: " + targetUrl);
            for (Map<String, String> alert : alerts) {
                String alertDetails = formatAlertDetails(alert);

                if (alertDetails != null) {
                    Allure.addAttachment("Alert: " + alert.get("alert"), "text/plain", alertDetails);
                }
            }
        }
    }

    private List<Map<String, String>> parseAlerts(ApiResponseList alertsResponse) {
        List<Map<String, String>> alerts = new ArrayList<>();

        for (ApiResponse response : alertsResponse.getItems()) {
            if (response instanceof ApiResponseSet alertSet) {
                if (alertSet.getValuesMap() != null && !alertSet.getValuesMap().isEmpty()) {
                    Map<String, String> alertDetails = new HashMap<>();

                    for (Map.Entry<String, ApiResponse> entry : alertSet.getValuesMap().entrySet()) {
                        if (entry.getValue() != null) {
                            alertDetails.put(entry.getKey(), entry.getValue().toString());
                        } else {
                            alertDetails.put(entry.getKey(), "null"); // null kontrolü
                        }
                    }
                    alerts.add(alertDetails);
                }
            }
        }
        return alerts;
    }


    private String formatAlertDetails(Map<String, String> alert) {
        if (alert == null || alert.isEmpty()) {
            return null; // Return null if map is empty or null
        }

        String risk = alert.get("risk");
        if (risk == null || risk.equals("Low") || risk.equals("Informational")) {
            return null; // Return null if low or informational risk
        }

        // Check if necessary alert keys are available
        if (!alert.containsKey("alert") || !alert.containsKey("confidence") ||
                !alert.containsKey("description") || !alert.containsKey("solution") ||
                !alert.containsKey("reference") || !alert.containsKey("url")) {
            return "Missing required alert details."; // Return error message if missing information
        }

        return "Alert: " + alert.get("alert") + "\n" +
                "Risk: " + risk + "\n" +
                "Confidence: " + alert.get("confidence") + "\n" +
                "Description: " + alert.get("description") + "\n" +
                "Solution: " + alert.get("solution") + "\n" +
                "Reference: " + alert.get("reference") + "\n" +
                "URL: " + alert.get("url") + "\n" +
                "--------------------";
    }

    public static void shutDownZAP() {
        // Shutdown ZAP after testing
        try {
            zapClient.core.shutdown();
            logger.info("ZAP has been shut down.");
        } catch (ClientApiException e) {
            logger.error("Failed to shutdown ZAP.", e);
        }
    }

    @Tag("Security")
    @Description("Security Test with ZAP API using TestNG")
    @Test
    public void secTest() {

        startZAPHeadless();

        startZapSecurityTest("https://yusufasik.com");

        shutDownZAP();

    }

Challenges & Best Practices

⚠️ Common Pitfalls

False Positives: Always triage results
Performance: Schedule aggressive scans off-peak
Session Handling: Reuse authenticated contexts

🔑 Pro Tips

Start with passive scans to avoid test flakiness
Use ZAP’s @Tags to filter irrelevant vulnerabilities (Or my if statement if you dont want to deal with it)
Update ZAP weekly – new vulnerabilities emerge constantly

Conclusion: Security is Your Responsibility Now

SDETs are uniquely positioned to democratize security testing. By embedding ZAP into your automation framework, you:

Catch vulnerabilities before they reach production
Build security into the team’s daily workflow
Elevate your role from test author to quality architect

Ready to try it? Drop your ZAP questions below or share how you’ve integrated security testing! 👇

The Ultimate Guide to Web Accessibility Testing: From Screen Readers to LighthouseCI

Yusuf Aşık — Sun, 23 Mar 2025 12:39:49 +0000

Accessibility Testing

Accessibility testing is one of the most underrated yet critical aspects of web development. As someone who’s both a dark-mode addict and a self-proclaimed "bug magnet," I’ve come to realize that accessibility isn’t just about supporting disabled users—it’s about creating a seamless, inclusive experience for everyone.

What is Accessibility Testing?

Accessibility testing ensures that web applications are usable by everyone, including individuals with visual, auditory, motor, and cognitive impairments. This process follows the Web Content Accessibility Guidelines (WCAG) to ensure web content is:

Perceivable — Content must be presented in a way that users can experience (e.g., alternative text for images, captions for videos).
Operable — Users should be able to navigate and interact seamlessly (e.g., keyboard accessibility, no time-based restrictions).
Understandable — Content must be clear and predictable (e.g., user-friendly error messages, readable text).
Robust — Web content should be compatible with assistive technologies like screen readers and voice navigation.

Understanding WCAG

The Web Content Accessibility Guidelines (WCAG), developed by the W3C (Yes! like Selenium), are international standards designed to make the web more inclusive.

WCAG Compliance Levels:

A (Basic) — Covers fundamental accessibility features (e.g., alternative text for images).
AA (Recommended) — Addresses major barriers (e.g., proper color contrast, keyboard focus).
AAA (Advanced) — Ensures the highest level of accessibility (e.g., sign language interpretation).

Manual Accessibility Testing Tools

While automated tools detect many issues, manual testing is crucial to ensure a truly accessible user experience.

Screen Readers:

NVDA (NonVisual Desktop Access) — Free, open-source screen reader for Windows.
JAWS (Job Access With Speech) — Paid, widely used in corporate environments.
VoiceOver (Mac & iOS) — Built-in screen reader for Apple devices.

Browser Extensions:

WAVE (Web Accessibility Evaluation Tool) — Highlights accessibility errors visually.
Axe DevTools — Detects WCAG violations and suggests code fixes.
Accessibility Insights (Microsoft) — Assists in testing keyboard navigation, ARIA roles, and screen reader compatibility.

Accessibility FastPass Report

Keyboard Navigation Testing:

Test your website using Tab, Shift+Tab, Enter, Space, Esc, and Arrow keys.
Ensure focus indicators are clearly visible using :focus in CSS.
Prevent keyboard traps (users should be able to exit modals using the Esc key).

Automated Accessibility Testing Tools

Speed up your accessibility testing by integrating automated tools into your workflow!

Google Lighthouse (Built into Chrome DevTools)

Checks accessibility, performance, and SEO in one go.
Run via Chrome DevTools → Lighthouse Tab.

Pa11y (CLI Tool for Automated Testing)

Executes accessibility tests via the command line.
Manual testing is possible with just a couple of commands.
Easily integrates into CI/CD pipelines.

Example Pa11y Run with Custom Options from CLI:

#bash
pa11y https://example.com \
  --runner axe \
  --reporter html > report.html \
  --standard WCAG2AA \
  --timeout 30000 \
  --hide-elements '#ad-banner, .popup'

axe-core + Selenium/WebDriver

Automates accessibility tests within Selenium-based test suites.
Ensures elements have correct labels, alt text, and keyboard focus.

Dependencies:

<dependencies>
    <!-- Selenium WebDriver -->
    <dependency>
        <groupId>org.seleniumhq.selenium</groupId>
        <artifactId>selenium-java</artifactId>
        <version>4.29.0</version>
    </dependency>

    <!-- Axe-Core Selenium -->
    <dependency>
        <groupId>com.deque.html.axe-core</groupId>
        <artifactId>selenium</artifactId>
        <version>4.10.1</version>
    </dependency>
</dependencies>

Selenium Example:

import static com.velespit.utilities.Driver.*;
import com.deque.html.axecore.results.Results;
import com.deque.html.axecore.results.Rule;
import com.deque.html.axecore.selenium.AxeBuilder;
import org.junit.Test;
import org.openqa.selenium.JavascriptExecutor;
import java.net.URL;
import java.util.List;

@Test
public void accessTest() {
    try {
        getDriver().get("https://yusufasik.com");
        URL axeScriptUrl = AccessibilityTest.class.getResource("/axe.min.js");
        JavascriptExecutor js = (JavascriptExecutor) getDriver();
        js.executeScript("var script = document.createElement('script');" +
                "script.src = arguments[0];" +
                "document.head.appendChild(script);", axeScriptUrl.toString());

        AxeBuilder axeBuilder = new AxeBuilder();
        Results results = axeBuilder.analyze(getDriver());
        List<Rule> violations = results.getViolations();

        if (violations.isEmpty()) {
            System.out.println("No accessibility issues found.");
        } else {
            System.out.println("Accessibility Issues Found:");
            for (Rule violation : violations) {
                    System.out.println("Violation: " + violation.getId());
                    System.out.println("Description: " + violation.getDescription());
                    System.out.println("Help: " + violation.getHelp());
                    System.out.println("Help URL: " + violation.getHelpUrl());
                    System.out.println("Impact: " + violation.getImpact());
                    System.out.println("Tags: " + violation.getTags());
                    System.out.println("Nodes: " + violation.getNodes().size());
                    System.out.println("--------------------");
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        closeDriver();
    }
}

Integrating Accessibility Testing into CI/CD Pipelines

Want to ensure accessibility compliance continuously? Automate it in your CI/CD workflow:

Lighthouse CI (Jenkins)

`machine-setup.sh`

#!/bin/bash

set -euxo pipefail

# Add Chrome's apt-key
echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee -a /etc/apt/sources.list.d/google.list
wget -q -O - https://dl.google.com/linux/linux_signing_key.pub | sudo apt-key add -

# Add Node's apt-key
curl -sL https://deb.nodesource.com/setup_20.x | sudo -E bash -

# Install NodeJS and Google Chrome
sudo apt update
sudo apt install -y nodejs google-chrome-stable

`job.sh`

#!/bin/bash

set -euxo pipefail

npm install
npm run build

export CHROME_PATH=$(which google-chrome-stable)
export LHCI_BUILD_CONTEXT__EXTERNAL_BUILD_URL="$BUILD_URL"

npm install -g @lhci/cli@0.14.x
lhci autorun

Make sure to check full guide in my repo:

GitHub Repository

Pa11y CI

Integrates accessibility checks into CI/CD pipelines.

Axe CLI + Jest

Adds automated accessibility tests to unit testing.

When Should Accessibility Testing Be Performed?

During Development — Use linters and static analysis tools to catch accessibility issues early.
UI Testing (System & Integration Testing) — Use tools like axe, WAVE, Lighthouse.
Before UAT (Performance & Functional Testing) — Ensure accessibility features do not impact performance.
During UAT (Final Validation Before Release) — Validate real-world usability and WCAG compliance.

Key Takeaways

Accessibility is a journey, not a checkbox.
Manual tools (axe, NVDA) catch UX gaps; automation (Lighthouse, pa11y) scales compliance.
Test early and often — integrate tools into your workflow with CI/CD pipelines for long-term compliance.

DEV Community: Yusuf Aşık

Android/iOS Testing Perfected: 20 Appium Tricks You Need

1. Use Appium Inspector

2. Find Exact App Names from Play Store

3. Advanced ADB Command for Extracting Current Activity

4. Explicit Waits

5. Page Object Model (POM)

6. Prefer Accessibility IDs and Resource IDs

7. Relative XPaths over Absolute

8. Handle Flakiness with Retries

9. Disable Animations via ADB

10. Parallel Test Execution

11. Use UIAutomator2

12. Network Conditioning

13. Grant Permissions via ADB

14. Screenshots on Failure

15. Test Data Cleanup

16. Cloud Testing Services

Bonus: iOS Tips

Use xcuitest Automation Engine

Handle iOS Permissions Automatically

Use Predicate Strings for Locators

Use iosClassChain for Faster Element Finding

Predicate String vs iOSClassChain

Security Testing for SDETs: Automate Vulnerability Scans with OWASP ZAP

Why Security Testing Matters for SDETs

OWASP ZAP: The SDET’s Security Swiss Army Knife

Integrating ZAP into Your Framework: Key Benefits

How to Integrate ZAP with Selenium + TestNG

Architecture Overview

Example Code Snippets (Dependencies)

Feature File

Step Definition

Challenges & Best Practices

Conclusion: Security is Your Responsibility Now

The Ultimate Guide to Web Accessibility Testing: From Screen Readers to LighthouseCI

Accessibility Testing

What is Accessibility Testing?

Understanding WCAG

WCAG Compliance Levels:

Manual Accessibility Testing Tools

Screen Readers:

Browser Extensions:

Keyboard Navigation Testing:

Automated Accessibility Testing Tools

Google Lighthouse (Built into Chrome DevTools)

Pa11y (CLI Tool for Automated Testing)

Example Pa11y Run with Custom Options from CLI:

axe-core + Selenium/WebDriver

Dependencies:

Selenium Example:

Integrating Accessibility Testing into CI/CD Pipelines

Lighthouse CI (Jenkins)

machine-setup.sh

job.sh

Pa11y CI

Axe CLI + Jest

When Should Accessibility Testing Be Performed?

Key Takeaways

Further Reading:

Use `xcuitest` Automation Engine

`machine-setup.sh`

`job.sh`