Test Automation Script Development Questions

Focuses on the hands on skills required to write, maintain, and troubleshoot automated test scripts across application types. Includes web user interface automation, API testing, mobile and desktop automation, interacting with UI elements, form submission, element selection and localization strategies, synchronization and waiting strategies, reliable assertion design, test data management, modular and readable test code structure, tagging and organizing tests, and common frameworks and libraries such as Selenium WebDriver, RestAssured, and pytest. Also covers best practices for maintainability, parameterization, test fixtures, mocking and stubbing external dependencies, and diagnosing flaky tests.

EasyTechnical

61 practiced

What makes an assertion 'reliable' in UI test automation? Give two examples of fragile assertions and two examples of robust assertions for verifying a successful form submission on a web page. Explain why the robust ones are better for maintainability.

MediumTechnical

66 practiced

Write a pytest-based Selenium test in Python that verifies an AJAX-loaded table contains a row with a specific value (e.g., 'Order #12345'). The test should use an explicit wait until the table has more than zero rows, then search table rows for the target value. Structure the test using a simple page object class for the table component.

Sample Answer

**Approach (brief)**

Use a small Page Object for the AJAX-loaded table that exposes a method to wait until rows appear and to find a row containing target text. The pytest test will open the page, call the page object wait, then assert that 'Order #12345' is present.

**Page object + test (pytest + Selenium)**

python

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import pytest

class OrdersTable:
    def __init__(self, driver):
        self.driver = driver
        self.table_locator = (By.CSS_SELECTOR, "table#orders tbody")

    def wait_for_rows(self, timeout=10):
        # Wait until tbody has at least one tr (AJAX-loaded)
        WebDriverWait(self.driver, timeout).until(
            lambda d: len(d.find_elements(By.CSS_SELECTOR, "table#orders tbody tr")) > 0
        )

    def has_row_with_text(self, text):
        rows = self.driver.find_elements(By.CSS_SELECTOR, "table#orders tbody tr")
        for r in rows:
            if text in r.text:
                return True
        return False

@pytest.fixture
def driver():
    from selenium import webdriver
    d = webdriver.Chrome()
    yield d
    d.quit()

def test_ajax_table_contains_order(driver):
    driver.get("https://example.com/orders")  # replace with real URL
    table = OrdersTable(driver)
    table.wait_for_rows(timeout=15)
    assert table.has_row_with_text("Order #12345"), "Expected order row not found"

**Why this is good**- Explicit wait avoids flaky sleeps and synchronizes on row count.- Page object encapsulates table operations for reuse and readability.- The test asserts a clear condition and provides a helpful failure message.

EasyTechnical

50 practiced

Define a 'flaky test' in the context of automated testing. List at least five common causes of flakiness (both test and environment related) and describe a short triage checklist you would use to quickly determine the root cause when a flaky test fails intermittently.

HardTechnical

63 practiced

A critical end-to-end test fails nondeterministically during page load because a third-party analytics script sometimes blocks user-event listeners from firing. You cannot change production code. Describe how you would investigate, reproduce, and mitigate this issue so the test suite is reliable without modifying production code. Include short-term and long-term options.

Sample Answer

**Situation & goal**A nondeterministic E2E failure during page load occurs because a third‑party analytics script sometimes blocks user-event listeners. I need to investigate, reliably reproduce, and mitigate so the CI test suite is stable without changing production code.

**Investigate**- Reproduce locally with CI browser config (same Chrome version, flags).- Capture logs: browser console, network waterfall, long‑task API, and performance.trace.- Instrument page load to record when listeners are registered vs when analytics script executes (console.time, MutationObserver).- Correlate failure with timing: is the script delaying parser, causing long tasks, or overriding addEventListener?

**Reproduce**- Use deterministic throttling: CPU throttle and network conditions to force the timing window.- Run headful and headless to compare.- Use Playwright/Puppeteer to intercept the third‑party script and simulate slow/blocked responses.

Example short Playwright snippet to stub or block the analytics script:

javascript

// Playwright: block or return a fast stub for the analytics URL
await page.route('https://analytics.example.com/script.js', route => {
  // short-term: respond with a no-op script to avoid blocking
  route.fulfill({
    status: 200,
    contentType: 'application/javascript',
    body: 'window.__analytics_noop = true;'
  });
});

**Short‑term mitigations (no prod code changes)**- Intercept network requests in test setup to block or stub the analytics script (as above).- Add robust test-side synchronization: wait for specific elements or for event listeners to be active (poll for a known post‑init flag) rather than blind timeouts.- Retry flaky test steps with bounded attempts and logging to surface timing details.- Run affected tests in isolated suites with increased timeout/CPU profile to reduce flakiness.

**Long‑term mitigations**- Advocate with devs to load analytics asynchronously/non‑blocking or use dynamic import/idle callback (create a ticket with reproducible artifacts).- Add contract tests and integration tests that simulate slow third‑party responses.- Add observability: synthetic monitoring that measures third‑party impact and alerts on regressions.- Vendor management: request optimized delivery (subresource integrity, smaller payloads) or switch to an alternative.

**Outcome & metrics**- Short term: stabilize CI by stubbing analytics; reduce flakes by >=90%.- Long term: eliminate root cause via asynchronous loading and continuous monitoring; track flaky test rate and mean time between flakes.

HardTechnical

53 practiced

Implement (or describe in clear Python pseudocode) a custom Selenium locator helper that accepts multiple selector strategies (e.g., id, css, xpath, data-test-id) and attempts them in order until one finds an element. The helper should log which selector succeeded and raise a descriptive error if none succeed. Discuss any performance considerations and caching options.

Sample Answer

**Approach (brief)** I’d build a helper that accepts an ordered list of selector tuples (strategy, value), tries each with a short configurable timeout, logs the successful selector, caches the resolved locator (optional), and raises a descriptive error if none match.

**Python pseudocode**

python

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class MultiLocator:
    def __init__(self, driver, timeout=2, poll=0.2, cache=True, logger=None):
        self.driver = driver
        self.timeout = timeout
        self.poll = poll
        self.cache = {} if cache else None
        self.logger = logger or (lambda msg: print(msg))

    def _by(self, strategy):
        mapping = {'id': By.ID, 'css': By.CSS_SELECTOR, 'xpath': By.XPATH, 'data-test-id': By.CSS_SELECTOR}
        return mapping[strategy]

    def find(self, selectors, parent=None):
        key = tuple(selectors)
        if self.cache is not None and key in self.cache:
            self.logger(f"cache hit: {self.cache[key][0]} -> {self.cache[key][1]}")
            return self.cache[key][1]

        root = parent or self.driver
        last_exceptions = []
        for strat, val in selectors:
            # support data-test-id -> [data-test-id="value"]
            if strat == 'data-test-id':
                val = f'[data-test-id="{val}"]'
            by = self._by(strat)
            try:
                elem = WebDriverWait(root, self.timeout, self.poll).until(EC.presence_of_element_located((by, val)))
                self.logger(f"found with {strat}: {val}")
                if self.cache is not None:
                    self.cache[key] = ( (strat, val), elem )
                return elem
            except Exception as e:
                last_exceptions.append((strat, val, str(e)))
        raise LookupError(f"No selector matched. Tried: {last_exceptions}")

**Key concepts & reasoning**- Try selectors in order; short per-strategy timeout avoids long waits.- Map human-friendly strategies (data-test-id) to CSS.- Cache successful selector -> element to speed repeated lookups; validate stale element handling in tests.

**Performance & caching considerations**- Short timeouts reduce overall latency but risk false negatives for slow pages; tune per app.- Cache entries can speed repeat finds but must handle StaleElementReferenceException (evict or re-find).- Parallel tests: avoid global shared cache; keep per-driver or thread-local cache.- Alternative: first try fast DOM queries (css/id) before xpath.

**Edge cases**- Multiple matches: return first or expose find_all.- Shadow DOM / iframes need special handling (switch frames or shadow roots).

Unlock Full Question Bank

Get access to hundreds of Test Automation Script Development interview questions and detailed answers.

Join thousands of developers preparing for their dream job.