# TensorFlow — classify defect severity from text
# (a very common QA ML use case)

import tensorflow as tf
from tensorflow.keras import layers

# Simple text classification model
model = tf.keras.Sequential([
    layers.TextVectorization(
        max_tokens=10000, output_sequence_length=100
    ),
    layers.Embedding(10000, 32),
    layers.GlobalAveragePooling1D(),
    layers.Dense(64, activation="relu"),
    layers.Dropout(0.3),
    layers.Dense(3, activation="softmax"),  # Low / Medium / High
])

model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

# In a real QA pipeline:
# - Train on historical bug tickets
# - Predict severity for new bugs at submission time
# - Compare predictions to tester-assigned severity
# - Retrain quarterly with fresh data

# Visual regression with TensorFlow
# Compare two screenshots — is the difference meaningful?

import tensorflow as tf
import numpy as np

def load_image(path, size=(224, 224)):
    img = tf.io.read_file(path)
    img = tf.image.decode_png(img, channels=3)
    img = tf.image.resize(img, size)
    return tf.cast(img, tf.float32) / 255.0

baseline = load_image("baseline.png")
current  = load_image("current.png")

# Simple per-pixel difference — a starting point
diff = tf.abs(baseline - current)
mean_diff = tf.reduce_mean(diff).numpy()
pct_changed = tf.reduce_mean(
    tf.cast(diff > 0.05, tf.float32)
).numpy()

print(f"Mean diff: {mean_diff:.4f}")
print(f"% pixels changed: {pct_changed:.2%}")

# In production teams use pretrained models (SSIM, CLIP-based)
# to distinguish real regressions from benign anti-aliasing.
# Pixel diff alone produces too much noise.

# Flaky test prediction — using test history as features
# (pseudo-code outline; runs on nightly CI history)

import pandas as pd
import tensorflow as tf

# Feature table — one row per test per run
# Columns: test_id, retries, prev_fail_rate, runtime,
#          changed_files_count, days_since_edit, ...

df = pd.read_parquet("test_history.parquet")

X = df.drop(columns=["test_id", "flaked_next_3_runs"])
y = df["flaked_next_3_runs"]

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation="relu", input_shape=(X.shape[1],)),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(32, activation="relu"),
    tf.keras.layers.Dense(1, activation="sigmoid"),
])

model.compile(
    optimizer="adam",
    loss="binary_crossentropy",
    metrics=[tf.keras.metrics.AUC(name="auc")],
)

# Then in CI:
# - Score each test before running
# - Quarantine high-risk tests for a stabilisation review
# - Reduce false alarms in the regression suite

Old QA workflow (Selenium era):
1. Read requirements
2. Write manual test cases in Excel
3. Write Selenium scripts for critical paths
4. Run full regression nightly
5. Triage every failure by hand
6. Log bugs with manual severity
7. Rerun, retry flaky tests, repeat

Pain points:
- Slow feedback (nightly cycle)
- High flake noise (30-40% of failures)
- Manual triage burns hours
- No prediction, no prioritisation
- Testers stuck writing scripts

New QA workflow (AI-assisted era):
1. Read requirements + past defect data
2. Human writes high-value test cases
3. AI generates boilerplate for standard flows
4. Predictive selection: run only affected tests
5. Model classifies failures (bug vs flake vs env)
6. Model predicts defect severity + dup candidates
7. Human reviews AI suggestions; ships or blocks

Benefits:
- Feedback in minutes, not hours
- Less flake noise to triage
- Faster, better-prioritised bugs
- Higher-risk areas get more attention
- Testers shift to design + risk + judgment

# Playwright + Pytest — a modern E2E test
# tests/test_checkout.py

import re
import pytest
from playwright.sync_api import Page, expect

@pytest.fixture
def app_url():
    return "https://saucedemo.com"

def test_checkout_flow(page: Page, app_url: str):
    page.goto(app_url)

    page.get_by_placeholder("Username").fill("standard_user")
    page.get_by_placeholder("Password").fill("secret_sauce")
    page.get_by_role("button", name="Login").click()

    expect(page).to_have_url(re.compile("/inventory"))

    page.get_by_role("button", name="Add to cart").first.click()
    page.locator(".shopping_cart_link").click()

    expect(page.locator(".cart_item")).to_have_count(1)

    page.get_by_role("button", name="Checkout").click()
    expect(page).to_have_url(re.compile("/checkout-step-one"))

# Modern Playwright gives you:
# - Auto-waits (no explicit sleep)
# - Traces (playwright show-trace)
# - Cross-browser in one API

# GitHub Actions — run tests on every pull request
# .github/workflows/qa.yml

name: QA

on:
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - name: Install deps
        run: |
          pip install -r requirements.txt
          playwright install --with-deps

      - name: Run tests
        run: pytest --tracing on

      - name: Upload trace on failure
        if: failure()
        uses: actions/upload-artifact@v4
        with:
          name: playwright-traces
          path: test-results/

# Traces help you debug failures without reproducing
# them locally — the biggest QA productivity win in years.