Test Automation Problem Solving Questions

# pseudocode
def generate_stable_selector(dom_root, target_node):
    build_node_records(dom_root)              # fill AttrIndex, HashCache
    candidates = []
    # 1. Try single-attribute unique selectors
    for attr in preferred_attrs_order:
        val = target_node.attrs.get(attr)
        if val:
            if AttrIndex[(attr,val)].size == 1:
                candidates.append(make_selector(target_node.tag, attr, val, reason="unique_attr"))
                return best(candidates)
            else:
                candidates.append(make_selector(..., score=low))
    # 2. Try text-based
    if normalized_text(target_node):
        sel = selector_by_text(target_node)
        candidates.append(sel)
    # 3. Try hierarchical hashing path
    path = build_hash_path(target_node)   # uses parent hashes and preferred attrs
    candidates.append(path_to_selector(path))
    # 4. Fallback: class-chain or nth-child with penalties
    candidates.extend(fallback_selectors(target_node))
    return best(candidates, scoring_function)

def scoring_function(candidate):
    score = base
    score += unique_attr_bonus if candidate.uses_unique_attr()
    score += text_match_bonus if candidate.uses_normalized_text()
    score -= positional_penalty if candidate.uses_nth_child()
    score += hierarchy_match_bonus if candidate.matches_hash()
    score -= dynamic_pattern_penalty if detects_dynamic_values()
    return score

import time
import functools
import threading

def retry(max_retries=3, delay=1.0):
    """
    Thread-safe retry decorator for synchronous functions.
    Retries up to max_retries times (total attempts = max_retries)
    with fixed delay (seconds) between attempts.
    """
    if max_retries < 1:
        raise ValueError("max_retries must be >= 1")

    def decorator(fn):
        lock = threading.Lock()  # used only for optional serialized logging; not for retry state

        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            last_exc = None
            for attempt in range(1, max_retries + 1):
                try:
                    return fn(*args, **kwargs)
                except Exception as e:
                    last_exc = e
                    # optional: small critical section for any shared logging/metrics
                    with lock:
                        # keep logging/metrics thread-safe if needed
                        pass
                    if attempt == max_retries:
                        # re-raise the original exception so tests/CI see real failure
                        raise
                    time.sleep(delay)
            # defensive: if loop exits unexpectedly
            raise last_exc
        return wrapper
    return decorator