HardTechnical

24 practiced

Write a Python function that generates deterministic, unique synthetic test data for users and orders given a seed and a test identifier. The function should ensure idempotent output across runs, avoid collisions, and produce realistic-looking emails/usernames for integration tests. Provide code and explain collision avoidance and cleanup considerations.

Sample Answer

**Approach — brief**Use a seeded cryptographic PRNG (hash-based) derived from seed + test_id to generate deterministic, unique user and order fields. Namespace values (prefixes) to avoid collisions with real data. Provide cleanup keys to locate and remove test data.

python

import hashlib
import hmac
import random
import string
from datetime import datetime, timedelta

# Deterministic RNG from seed + test_id
def _rng(seed: str, test_id: str):
    key = (seed + "|" + test_id).encode()
    # Use HMAC-SHA256 as deterministic entropy source
    counter = 0
    while True:
        msg = f"{counter}".encode()
        digest = hmac.new(key, msg, hashlib.sha256).digest()
        # turn digest into an int seed for random.Random
        yield random.Random(int.from_bytes(digest, "big"))
        counter += 1

def deterministic_user_and_orders(seed: str, test_id: str, user_idx: int = 0, orders: int = 3):
    """
    Returns deterministic user dict and list of order dicts.
    - seed: global secret (e.g., CI pipeline secret)
    - test_id: short identifier per test (e.g., 'signup_flow_42')
    - user_idx: index to create multiple users per test
    - orders: number of orders to generate
    """
    gen = _rng(seed, test_id)
    # one RNG for user, one for orders
    user_rnd = next(gen)
    order_rnd = next(gen)

    # namespace to avoid collisions with production: prefix test_{test_id}
    ns = f"test_{test_id}"
    # deterministic username/email
    base = f"{ns}_u{user_idx}"
    # append deterministic suffix to increase uniqueness
    suffix = ''.join(user_rnd.choices(string.ascii_lowercase + string.digits, k=6))
    username = f"{base}_{suffix}"
    email = f"{username}@example.test"  # use .test TLD to avoid real domains

    user = {
        "username": username,
        "email": email,
        "full_name": f"Test User {user_idx}",
        "created_at": datetime.utcfromtimestamp(user_rnd.randint(1_600_000_000, 1_700_000_000)).isoformat() + "Z",
        "test_tag": ns  # helpful for cleanup/filtering
    }

    orders_list = []
    for i in range(orders):
        rnd = order_rnd
        # consume RNG deterministically per order
        oid_suffix = ''.join(rnd.choices(string.hexdigits.lower(), k=8))
        order_id = f"{ns}_order_{user_idx}_{oid_suffix}"
        amount_cents = rnd.randint(100, 50_000)
        created = datetime.utcfromtimestamp(rnd.randint(1_600_000_000, 1_700_000_000)).isoformat() + "Z"
        orders_list.append({
            "order_id": order_id,
            "user_username": username,
            "amount_cents": amount_cents,
            "currency": "USD",
            "created_at": created,
            "test_tag": ns
        })

    return user, orders_list

Explanation — collision avoidance and idempotency- Determinism: HMAC-SHA256 seeded by (seed + test_id) produces reproducible RNGs so repeated calls yield identical results.- Namespacing: Every generated entity includes a test_tag and uses the "test_{test_id}" prefix and .test email domain to avoid colliding with production data or real domains.- Suffix entropy: Deterministic suffixes (from RNG) reduce accidental collisions between multiple users/orders for same test_id.- Idempotency: Given same seed, test_id, and user_idx, the function returns identical objects — safe for repeated setup runs.

Cleanup considerations- Persist test_tag/test_id on created DB records. Delete by filtering on test_tag after tests.- Use short TTLs for test data in long-running environments (e.g., mark records with expiration timestamp and background job purges them).- Access control: Run cleanup with least-privilege credentials and confirm before destructive operations in shared environments.- Safety: In CI, run cleanup in a dry-run mode first and log affected IDs. Use dedicated test schemas or databases when possible for fast tear-down.

Complexity- CPU/time: O(n) in number of orders generated; memory: O(n) for returned list.

EasyTechnical

28 practiced

Describe data-driven testing and parameterization techniques in pytest, TestNG, and JUnit. Include examples of loading test data from CSV, JSON, or a database, explain where seeding and teardown should occur, and best practices to keep tests readable and maintainable when using large datasets.

Sample Answer

**Overview (what I do and why)** I use data-driven testing to run the same test logic against many inputs to improve coverage and reduce duplication. I favor parameterization so tests are deterministic, readable, and maintainable.

**pytest (Python)**- Approach: use @pytest.mark.parametrize or @pytest.fixture to load CSV/JSON/DB rows.- Example CSV -> parametrize:

python

import csv, pytest

def load_csv(path):
    with open(path) as f:
        return [tuple(row.values()) for row in csv.DictReader(f)]

@pytest.mark.parametrize("user,email", load_csv("users.csv"))
def test_create_user(user, email):
    assert create_user(user, email).status_code == 201

- DB/JSON: use a fixture with scope="session" to seed data; teardown in finalizer.

**TestNG (Java)**- Use @DataProvider to supply Object[][] from CSV/JSON/DB.

java

@DataProvider(name="users")
public Object[][] users() { return readCsv("users.csv"); }

@Test(dataProvider="users")
public void testCreateUser(String user, String email) { ... }

- Seed in @BeforeSuite, teardown in @AfterSuite for global DB state; use @BeforeMethod/@AfterMethod for per-test cleanup.

**JUnit 5 (Java)**- Use @ParameterizedTest with @CsvFileSource or custom ArgumentsProvider for JSON/DB.

java

@ParameterizedTest
@CsvFileSource(resources="/users.csv", numLinesToSkip=1)
void testCreateUser(String user, String email) { ... }

- DB setup via @BeforeAll (seed) and @AfterAll (teardown) or Testcontainers for isolated DB per test class.

**Seeding & Teardown**- Seed once at suite/session scope when data expensive; seed per-test when isolation required.- Always clean up in matching scope (finalizer, @After* / fixture teardown) to avoid flaky tests.

**Best Practices**- Keep dataset small and focused; use representative samples rather than entire DB dumps.- Separate data from assertions: use clear column names or DTOs.- Use descriptive test IDs, and skip or mark long-running data-driven tests.- Version test data alongside tests; prefer programmatic factories for complex objects.- Log which data row failed for quick debugging.

EasyTechnical

45 practiced

Define the different test levels used in automated testing (unit testing, integration testing, system testing, end-to-end testing). For each level: describe its purpose, typical tools/frameworks used, examples of what to automate at that level for a web + API + mobile product, and the main trade-offs (speed, isolation, maintenance) when choosing coverage at that level.

EasyTechnical

26 practiced

Given a new user signup flow, describe the decision process and criteria you would use to determine which tests to automate (unit, integration, UI). Include factors such as business criticality, frequency of change, execution time, flakiness risk, and ROI. Provide a prioritized automation plan for the signup flow.

EasyTechnical

21 practiced

Explain fixture and hook concepts in pytest, TestNG, and JUnit. For each framework provide code or pseudo-code examples showing a setup/teardown that runs before each test, before a test class, and before an entire test suite. Explain how you would safely share a WebDriver or database connection across tests.

Sample Answer

**Overview**I’ll explain fixtures/hooks in pytest, TestNG, and JUnit, show setup/teardown at three levels (per-test, per-class, per-suite), and describe safe sharing of WebDriver/DB connections.

**pytest**- Concept: fixtures provide setup/teardown; scope controls lifetime (function, class, session).- Examples:

python

# conftest.py
import pytest
from selenium import webdriver

@pytest.fixture(scope="function")
def driver():
    d = webdriver.Chrome()
    yield d
    d.quit()

@pytest.fixture(scope="class")
def class_driver(request):
    d = webdriver.Chrome()
    request.cls.driver = d
    yield
    d.quit()

@pytest.fixture(scope="session")
def db_conn():
    conn = open_db_connection()
    yield conn
    conn.close()

**TestNG (Java)**- Concept: @BeforeMethod, @BeforeClass, @BeforeSuite with corresponding @After...- Examples:

java

public class Tests {
  WebDriver driver;
  @BeforeMethod
  public void beforeEach() { driver = new ChromeDriver(); }
  @AfterMethod public void afterEach() { driver.quit(); }

  @BeforeClass
  public void beforeClass() { /* init once for class */ }

  @BeforeSuite
  public void beforeSuite() { /* global setup */ }
}

**JUnit 5**- Concept: @BeforeEach, @BeforeAll, @AfterEach, @AfterAll (static for @BeforeAll by default)- Examples:

java

class Tests {
  static WebDriver driver;
  @BeforeEach void setupEach() { driver = new ChromeDriver(); }
  @AfterEach void tearEach() { driver.quit(); }

  @BeforeAll static void setupAll() { /* suite-level or use external runner */ }
  @AfterAll static void tearAll() { /* cleanup */ }
}

**Safe sharing of WebDriver / DB**- Prefer narrow scope: function or class unless tests are read-only and isolated.- Use fixtures/singletons with teardown to avoid leaks.- For WebDriver: - Run tests in parallel only with isolated driver instances (thread-local or factory per test). - For session-level driver, ensure tests are non-conflicting and reset state between tests.- For DB: - Use connection pools; wrap each test in a transaction and rollback after test to restore state. - Use test schemas or isolated test databases for parallelism.

I’d choose per-test fixtures for reliability; use session/class scope only when startup cost dominates and tests are carefully isolated.

Test Automation Frameworks and Tools Questions

Sample Answer

Sample Answer

Sample Answer

Sample Answer

Sample Answer

Unlock Full Question Bank