Smoke Test Checklist Documentation: Building Effective Build Verification Tests

critical_paths:
  e_commerce_platform:
    user_authentication:
      priority: P0
      flows:
        - "User login with valid credentials"
        - "Session persistence verification"
        - "Logout functionality"
      acceptance_criteria: "All auth flows complete without errors"

    product_catalog:
      priority: P0
      flows:
        - "Homepage loads with products"
        - "Product search returns results"
        - "Product detail page displays"
      acceptance_criteria: "Catalog accessible and searchable"

    checkout_process:
      priority: P0
      flows:
        - "Add item to cart"
        - "View cart with correct items"
        - "Proceed to checkout"
        - "Complete payment (test mode)"
      acceptance_criteria: "End-to-end purchase flow completes"

    order_management:
      priority: P1
      flows:
        - "View order confirmation"
        - "Access order history"
      acceptance_criteria: "Order tracking functional"

  banking_application:
    authentication:
      priority: P0
      flows:
        - "Login with username/password"
        - "Two-factor authentication"
        - "Security question validation"
      acceptance_criteria: "Secure access established"

    account_operations:
      priority: P0
      flows:
        - "View account balance"
        - "Display recent transactions"
        - "Access account details"
      acceptance_criteria: "Account data accessible"

    transactions:
      priority: P0
      flows:
        - "Internal transfer between accounts"
        - "Bill payment initiation"
        - "Transaction confirmation"
      acceptance_criteria: "Money movement functional"

## Three-Layer Smoke Test Strategy

### Layer 1: Infrastructure Smoke (5 minutes)
**Purpose**: Verify basic deployment and connectivity

- [ ] Application URL accessible (HTTP 200)
- [ ] Health check endpoint responds
- [ ] Database connection established
- [ ] Cache service responding
- [ ] Message queue accessible
- [ ] CDN serving static assets
- [ ] API gateway routing correctly

### Layer 2: Component Smoke (10 minutes)
**Purpose**: Verify key components initialize

- [ ] Login page loads
- [ ] Homepage renders with data
- [ ] API endpoints return expected responses
- [ ] Frontend JavaScript loads without errors
- [ ] CSS styling applies correctly
- [ ] Background jobs processing
- [ ] Email service sending test messages

### Layer 3: Integration Smoke (15 minutes)
**Purpose**: Verify critical end-to-end flows

- [ ] User can login
- [ ] User can perform primary action (purchase, transfer, post)
- [ ] Data persists correctly
- [ ] Email notifications sent
- [ ] Third-party integrations responding
- [ ] Logging and monitoring active

# smoke_test_suite.py
import pytest
from selenium import webdriver
from api_client import APIClient
import logging

class SmokeTestSuite:
    """
    Comprehensive smoke test suite for build verification
    """

    @pytest.fixture(scope="class")
    def setup(self):
        """Setup test environment"""
        self.driver = webdriver.Chrome()
        self.api = APIClient(base_url="https://api.example.com")
        self.logger = logging.getLogger(__name__)
        yield
        self.driver.quit()

    @pytest.mark.smoke
    @pytest.mark.priority_p0
    def test_infrastructure_health(self):
        """Layer 1: Verify infrastructure"""
        # Health check
        response = self.api.get("/health")
        assert response.status_code == 200
        assert response.json()["status"] == "healthy"

        # Database connectivity
        db_check = self.api.get("/health/database")
        assert db_check.json()["database"] == "connected"

        self.logger.info("✓ Infrastructure smoke passed")

    @pytest.mark.smoke
    @pytest.mark.priority_p0
    def test_authentication_flow(self):
        """Layer 2: Verify authentication"""
        self.driver.get("https://app.example.com/login")

        # Login elements present
        assert self.driver.find_element("id", "username")
        assert self.driver.find_element("id", "password")
        assert self.driver.find_element("id", "login-button")

        # Perform login
        self.driver.find_element("id", "username").send_keys("smoke_test_user")
        self.driver.find_element("id", "password").send_keys("test_password")
        self.driver.find_element("id", "login-button").click()

        # Verify successful login
        assert "dashboard" in self.driver.current_url
        assert self.driver.find_element("class", "user-greeting")

        self.logger.info("✓ Authentication smoke passed")

    @pytest.mark.smoke
    @pytest.mark.priority_p0
    def test_critical_business_flow(self):
        """Layer 3: Verify end-to-end critical flow"""
        # Assumes already logged in from previous test

        # Navigate to product
        self.driver.get("https://app.example.com/products")
        product = self.driver.find_element("class", "product-card")
        product.click()

        # Add to cart
        add_to_cart_btn = self.driver.find_element("id", "add-to-cart")
        add_to_cart_btn.click()

        # Verify cart
        cart_count = self.driver.find_element("id", "cart-count").text
        assert int(cart_count) > 0

        # Proceed to checkout
        self.driver.get("https://app.example.com/checkout")
        assert "checkout" in self.driver.current_url

        # Verify checkout page elements
        assert self.driver.find_element("id", "shipping-form")
        assert self.driver.find_element("id", "payment-form")

        self.logger.info("✓ Critical business flow smoke passed")

    @pytest.mark.smoke
    @pytest.mark.priority_p0
    def test_api_critical_endpoints(self):
        """Verify critical API endpoints"""
        # Test product listing
        products = self.api.get("/api/products")
        assert products.status_code == 200
        assert len(products.json()["data"]) > 0

        # Test user profile
        profile = self.api.get("/api/user/profile",
                              headers={"Authorization": "Bearer test_token"})
        assert profile.status_code == 200
        assert "email" in profile.json()

        # Test order creation (dry run)
        order_payload = {
            "items": [{"product_id": 1, "quantity": 1}],
            "dry_run": True
        }
        order = self.api.post("/api/orders", json=order_payload)
        assert order.status_code == 200

        self.logger.info("✓ API smoke passed")

# Execution configuration
if __name__ == "__main__":
    pytest.main([
        __file__,
        "-m", "smoke",
        "--tb=short",
        "--maxfail=1",  # Stop on first failure
        "-v"
    ])

go_no_go_criteria:
  immediate_rejection:
    - "Application fails to deploy"
    - "Health check endpoint returns 5xx errors"
    - "Database connection fails"
    - "Authentication completely broken"
    - "Critical API endpoints return 500 errors"
    - "Frontend fails to load (white screen)"
    - "Any P0 smoke test fails"

  conditional_acceptance:
    - condition: "1-2 P1 smoke tests fail"
      action: "Accept with bug tickets, proceed with caution"
    - condition: "Performance degradation <20%"
      action: "Accept, monitor closely"
    - condition: "Minor UI rendering issues"
      action: "Accept, log defects"

  full_acceptance:
    - "All P0 smoke tests pass"
    - "No critical errors in logs"
    - "Response times within baseline ±10%"
    - "No security vulnerabilities introduced"
    - "All services healthy"

# Smoke Test Results Report

## Build Information
- **Build ID**: #2045
- **Build Date**: 2025-10-10 14:30 UTC
- **Environment**: Staging
- **Test Execution Time**: 18 minutes
- **Executed By**: Jenkins CI/CD Pipeline

## Test Summary
| Category | Total | Passed | Failed | Skipped |
|----------|-------|--------|--------|---------|
| Infrastructure | 7 | 7 | 0 | 0 |
| Component | 12 | 12 | 0 | 0 |
| Integration | 8 | 7 | 1 | 0 |
| **TOTAL** | **27** | **26** | **1** | **0** |

## Go/No-Go Decision: ⚠️ CONDITIONAL GO

### Failed Tests
1. ❌ **Integration: Order Notification Email**
   - Expected: Email sent within 30 seconds
   - Actual: Email service timeout after 60 seconds
   - Impact: Medium (notifications delayed but order completes)
   - Ticket: BUG-4521

### Warnings
- Performance: Checkout page load time 3.2s (baseline: 2.1s, threshold: 3.0s)
- Log Errors: 3 non-critical errors in application logs

### Recommendation
**ACCEPT BUILD** with following conditions:
- Create P1 bug ticket for email service timeout
- Monitor email service performance in production
- Schedule performance optimization for checkout page
- Proceed with functional testing

### Next Steps
- [ ] Create bug tickets for identified issues
- [ ] Notify QA team of build acceptance
- [ ] Begin full regression suite
- [ ] Monitor production deployment closely

# Manual Smoke Test Checklist
**Build**: ________  **Date**: ________  **Tester**: ________

## Pre-Test Setup (2 min)
- [ ] Clear browser cache
- [ ] Verify test data available
- [ ] Confirm testing on correct environment URL
- [ ] Note build version displayed in app

## Authentication & Access (3 min)
- [ ] Navigate to login page
- [ ] Login with valid credentials
- [ ] Verify dashboard/home loads
- [ ] Check user name displays correctly
- [ ] Test logout functionality
- [ ] **Result**: PASS / FAIL / BLOCKED

## Core Functionality (10 min)
### Primary Feature 1: [Product Search]
- [ ] Enter search term
- [ ] Results display within 3 seconds
- [ ] Click product from results
- [ ] Product detail page loads
- [ ] **Result**: PASS / FAIL / BLOCKED

### Primary Feature 2: [Shopping Cart]
- [ ] Add item to cart
- [ ] Cart count updates
- [ ] View cart page
- [ ] Verify item details correct
- [ ] **Result**: PASS / FAIL / BLOCKED

### Primary Feature 3: [Checkout]
- [ ] Proceed to checkout
- [ ] Enter shipping information
- [ ] Enter payment (test card)
- [ ] Complete order
- [ ] Confirmation page displays
- [ ] **Result**: PASS / FAIL / BLOCKED

## API Verification (5 min)
- [ ] Open browser DevTools
- [ ] Verify API calls return 200/201
- [ ] Check for console errors
- [ ] Verify no 500 errors in Network tab
- [ ] **Result**: PASS / FAIL / BLOCKED

## Data Integrity (3 min)
- [ ] Create new record
- [ ] Refresh page
- [ ] Verify data persisted
- [ ] Edit record
- [ ] Verify update saved
- [ ] **Result**: PASS / FAIL / BLOCKED

## Cross-Browser Quick Check (Optional, 5 min)
- [ ] Repeat critical flow in Chrome
- [ ] Repeat critical flow in Firefox
- [ ] Repeat critical flow in Safari/Edge
- [ ] **Result**: PASS / FAIL / BLOCKED

## Final Assessment
**Total Time**: _______ minutes
**Overall Result**: PASS / FAIL
**Critical Failures**: _______
**Go/No-Go Decision**: _______
**Notes**: _______________________________________

{
  "info": {
    "name": "Smoke Test - API Suite",
    "description": "Critical API endpoints verification"
  },
  "item": [
    {
      "name": "Health Check",
      "request": {
        "method": "GET",
        "url": "{{base_url}}/health"
      },
      "tests": [
        "pm.test('Status is 200', function() { pm.response.to.have.status(200); });",
        "pm.test('Response time < 500ms', function() { pm.expect(pm.response.responseTime).to.be.below(500); });",
        "pm.test('Status is healthy', function() { pm.expect(pm.response.json().status).to.eql('healthy'); });"
      ]
    },
    {
      "name": "User Login",
      "request": {
        "method": "POST",
        "url": "{{base_url}}/api/auth/login",
        "body": {
          "username": "smoke_test_user",
          "password": "test_pass_123"
        }
      },
      "tests": [
        "pm.test('Login successful', function() { pm.response.to.have.status(200); });",
        "pm.test('Token received', function() { pm.expect(pm.response.json().token).to.exist; });",
        "pm.environment.set('auth_token', pm.response.json().token);"
      ]
    },
    {
      "name": "Get Products",
      "request": {
        "method": "GET",
        "url": "{{base_url}}/api/products",
        "header": "Authorization: Bearer {{auth_token}}"
      },
      "tests": [
        "pm.test('Products retrieved', function() { pm.response.to.have.status(200); });",
        "pm.test('At least one product', function() { pm.expect(pm.response.json().data.length).to.be.above(0); });"
      ]
    },
    {
      "name": "Create Order (Test)",
      "request": {
        "method": "POST",
        "url": "{{base_url}}/api/orders",
        "header": "Authorization: Bearer {{auth_token}}",
        "body": {
          "items": [{"product_id": 1, "quantity": 1}],
          "test_mode": true
        }
      },
      "tests": [
        "pm.test('Order created', function() { pm.response.to.have.status(201); });",
        "pm.test('Order ID returned', function() { pm.expect(pm.response.json().order_id).to.exist; });"
      ]
    }
  ]
}

smoke_test_maintenance:
  update_triggers:
    - "New critical feature deployed"
    - "Critical bug fix implemented"
    - "Architecture change affecting core flows"
    - "Dependency upgrade (major version)"

  review_schedule:
    frequency: "Bi-weekly"
    participants:
      - "QA Lead"
      - "Development Lead"
      - "DevOps Engineer"
    agenda:
      - "Review failed smoke tests"
      - "Update for new features"
      - "Remove obsolete tests"
      - "Optimize execution time"

  quality_metrics:
    execution_time_target: "< 20 minutes"
    false_positive_rate: "< 5%"
    test_stability: "> 95% consistent results"
    coverage_of_critical_paths: "100%"

pipeline {
    agent any

    stages {
        stage('Deploy to Staging') {
            steps {
                sh 'deploy.sh staging'
            }
        }

        stage('Smoke Tests') {
            parallel {
                stage('Infrastructure Smoke') {
                    steps {
                        sh 'curl -f http://staging.example.com/health || exit 1'
                        sh 'python smoke_tests/infrastructure.py'
                    }
                }
                stage('API Smoke') {
                    steps {
                        sh 'newman run smoke_tests/api_collection.json --environment staging'
                    }
                }
                stage('UI Smoke') {
                    steps {
                        sh 'pytest smoke_tests/ui_smoke.py -m smoke'
                    }
                }
            }
        }

        stage('Go/No-Go Decision') {
            steps {
                script {
                    def smokeResults = readJSON file: 'smoke_results.json'
                    if (smokeResults.failed > 0 && smokeResults.critical_failures > 0) {
                        currentBuild.result = 'FAILURE'
                        error("Smoke tests failed - Build rejected")
                    } else if (smokeResults.failed > 0) {
                        echo "Warning: Non-critical smoke failures detected"
                        input message: "Proceed despite warnings?", ok: "Proceed"
                    }
                }
            }
        }

        stage('Full Test Suite') {
            when {
                expression { currentBuild.result != 'FAILURE' }
            }
            steps {
                sh 'pytest tests/ -m "not slow"'
            }
        }
    }

    post {
        always {
            publishHTML([
                reportDir: 'smoke_test_reports',
                reportFiles: 'index.html',
                reportName: 'Smoke Test Report'
            ])
        }
        failure {
            emailext (
                subject: "Smoke Tests Failed - Build #${BUILD_NUMBER}",
                body: "Smoke tests have failed. Build rejected.",
                to: "qa-team@example.com"
            )
        }
    }
}