Expert-level quality assurance, testing strategies, automation, and QA processes
Expert guidance for quality assurance, testing strategies, test automation, and QA best practices.
import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from typing import Dict, List
class BasePage:
"""Base page object"""
def __init__(self, driver):
self.driver = driver
self.wait = WebDriverWait(driver, 10)
def find_element(self, locator):
return self.wait.until(EC.presence_of_element_located(locator))
def click(self, locator):
element = self.find_element(locator)
element.click()
def type_text(self, locator, text):
element = self.find_element(locator)
element.clear()
element.send_keys(text)
def get_text(self, locator):
element = self.find_element(locator)
return element.text
class LoginPage(BasePage):
"""Login page object"""
USERNAME_INPUT = (By.ID, "username")
PASSWORD_INPUT = (By.ID, "password")
LOGIN_BUTTON = (By.ID, "login-button")
ERROR_MESSAGE = (By.CLASS_NAME, "error-message")
def login(self, username: str, password: str):
self.type_text(self.USERNAME_INPUT, username)
self.type_text(self.PASSWORD_INPUT, password)
self.click(self.LOGIN_BUTTON)
def get_error_message(self):
return self.get_text(self.ERROR_MESSAGE)
class TestRunner:
"""Test execution framework"""
def __init__(self, browser: str = "chrome"):
self.browser = browser
self.driver = None
self.results = []
def setup(self):
if self.browser == "chrome":
options = webdriver.ChromeOptions()
options.add_argument("--headless")
self.driver = webdriver.Chrome(options=options)
elif self.browser == "firefox":
self.driver = webdriver.Firefox()
self.driver.implicitly_wait(10)
def teardown(self):
if self.driver:
self.driver.quit()
def run_test(self, test_func, test_name: str):
try:
test_func()
self.results.append({"test": test_name, "status": "PASS"})
except Exception as e:
self.results.append({
"test": test_name,
"status": "FAIL",
"error": str(e)
})
def generate_report(self) -> Dict:
total = len(self.results)
passed = sum(1 for r in self.results if r["status"] == "PASS")
failed = total - passed
return {
"total": total,
"passed": passed,
"failed": failed,
"pass_rate": (passed / total * 100) if total > 0 else 0,
"results": self.results
}
# Pytest fixtures
@pytest.fixture
def driver():
options = webdriver.ChromeOptions()
options.add_argument("--headless")
driver = webdriver.Chrome(options=options)
yield driver
driver.quit()
@pytest.fixture
def login_page(driver):
driver.get("https://example.com/login")
return LoginPage(driver)
# Test cases
def test_successful_login(login_page):
login_page.login("testuser", "password123")
assert "Dashboard" in login_page.driver.title
def test_invalid_credentials(login_page):
login_page.login("invalid", "wrong")
error = login_page.get_error_message()
assert "Invalid credentials" in error
import requests
from typing import Dict, Any
class APITestClient:
"""API testing client"""
def __init__(self, base_url: str):
self.base_url = base_url
self.session = requests.Session()
self.test_results = []
def test_get_endpoint(self, endpoint: str, expected_status: int = 200,
expected_keys: List[str] = None) -> Dict:
"""Test GET endpoint"""
url = f"{self.base_url}{endpoint}"
response = self.session.get(url)
result = {
"endpoint": endpoint,
"method": "GET",
"status_code": response.status_code,
"passed": response.status_code == expected_status
}
if expected_keys and response.status_code == 200:
data = response.json()
missing_keys = [k for k in expected_keys if k not in data]
result["missing_keys"] = missing_keys
result["passed"] = result["passed"] and len(missing_keys) == 0
self.test_results.append(result)
return result
def test_post_endpoint(self, endpoint: str, payload: Dict,
expected_status: int = 201) -> Dict:
"""Test POST endpoint"""
url = f"{self.base_url}{endpoint}"
response = self.session.post(url, json=payload)
result = {
"endpoint": endpoint,
"method": "POST",
"status_code": response.status_code,
"passed": response.status_code == expected_status,
"response_time_ms": response.elapsed.total_seconds() * 1000
}
self.test_results.append(result)
return result
def test_authentication(self, login_endpoint: str,
credentials: Dict) -> bool:
"""Test API authentication"""
response = self.session.post(
f"{self.base_url}{login_endpoint}",
json=credentials
)
if response.status_code == 200:
token = response.json().get("token")
if token:
self.session.headers.update({"Authorization": f"Bearer {token}"})
return True
return False
def test_rate_limiting(self, endpoint: str, requests_count: int = 100):
"""Test rate limiting"""
url = f"{self.base_url}{endpoint}"
rate_limited = False
for i in range(requests_count):
response = self.session.get(url)
if response.status_code == 429:
rate_limited = True
break
return {
"rate_limited": rate_limited,
"requests_before_limit": i if rate_limited else requests_count
}
import random
from faker import Faker
from typing import Dict, List
class TestDataGenerator:
"""Generate test data"""
def __init__(self):
self.faker = Faker()
def generate_user(self) -> Dict:
"""Generate user test data"""
return {
"username": self.faker.user_name(),
"email": self.faker.email(),
"first_name": self.faker.first_name(),
"last_name": self.faker.last_name(),
"phone": self.faker.phone_number(),
"address": {
"street": self.faker.street_address(),
"city": self.faker.city(),
"state": self.faker.state(),
"zip": self.faker.zipcode()
}
}
def generate_users(self, count: int) -> List[Dict]:
"""Generate multiple users"""
return [self.generate_user() for _ in range(count)]
def generate_order(self, user_id: str) -> Dict:
"""Generate order test data"""
return {
"order_id": self.faker.uuid4(),
"user_id": user_id,
"items": [
{
"product_id": self.faker.uuid4(),
"quantity": random.randint(1, 5),
"price": round(random.uniform(10, 500), 2)
}
for _ in range(random.randint(1, 5))
],
"total": 0, # Calculate based on items
"status": random.choice(["pending", "processing", "shipped", "delivered"])
}
def generate_invalid_data(self, field: str) -> Any:
"""Generate invalid test data for boundary testing"""
invalid_patterns = {
"email": ["not-an-email", "missing@domain", "@nodomain.com"],
"phone": ["123", "abc-def-ghij", "+++"],
"zip": ["ABC", "123", "12345678"],
"date": ["99/99/9999", "2023-13-45", "invalid"]
}
return random.choice(invalid_patterns.get(field, ["invalid"]))
from dataclasses import dataclass
from datetime import datetime
from enum import Enum
class Severity(Enum):
CRITICAL = "critical"
HIGH = "high"
MEDIUM = "medium"
LOW = "low"
class Priority(Enum):
P0 = "p0"
P1 = "p1"
P2 = "p2"
P3 = "p3"
@dataclass
class Defect:
defect_id: str
title: str
description: str
severity: Severity
priority: Priority
status: str
reported_by: str
assigned_to: str
created_at: datetime
environment: str
steps_to_reproduce: List[str]
expected_result: str
actual_result: str
class DefectTracker:
"""Track and manage defects"""
def __init__(self):
self.defects: Dict[str, Defect] = {}
def create_defect(self, defect: Defect) -> str:
"""Create new defect"""
self.defects[defect.defect_id] = defect
return defect.defect_id
def update_status(self, defect_id: str, new_status: str):
"""Update defect status"""
if defect_id in self.defects:
self.defects[defect_id].status = new_status
def get_critical_defects(self) -> List[Defect]:
"""Get all critical defects"""
return [d for d in self.defects.values()
if d.severity == Severity.CRITICAL and d.status != "closed"]
def generate_metrics(self) -> Dict:
"""Generate defect metrics"""
total = len(self.defects)
by_severity = {}
by_status = {}
for defect in self.defects.values():
severity = defect.severity.value
status = defect.status
by_severity[severity] = by_severity.get(severity, 0) + 1
by_status[status] = by_status.get(status, 0) + 1
return {
"total_defects": total,
"by_severity": by_severity,
"by_status": by_status,
"critical_open": len(self.get_critical_defects())
}
❌ Testing only happy paths ❌ No test automation strategy ❌ Vague bug reports ❌ Testing without requirements ❌ Ignoring flaky tests ❌ No regression testing ❌ Testing in production only
