Testing Levels: Unit, Integration, System, and UAT

# Example: Unit test for authentication service
import pytest
from auth_service import AuthService, InvalidCredentialsError

class TestAuthService:
    def setup_method(self):
        """Set up test fixtures before each test"""
        self.auth = AuthService(database="test_db")
 (as discussed in [Entry and Exit Criteria in Software Testing: When to Start and Stop Testing](/blog/entry-exit-criteria))        self.valid_user = {
            "email": "test@example.com",
            "password": "SecurePass123!"
        }

    def test_successful_authentication(self):
        """Test that valid credentials return auth token"""
        token = self.auth.authenticate(
            self.valid_user["email"],
            self.valid_user["password"]
        )

        assert token is not None
        assert len(token) == 64  # JWT token length
        assert self.auth.is_token_valid(token) is True

    def test_invalid_password_raises_error(self):
        """Test that invalid password raises appropriate error"""
        with pytest.raises(InvalidCredentialsError) as exc_info:
            self.auth.authenticate(
                self.valid_user["email"],
                "WrongPassword"
            )

        assert "Invalid credentials" in str(exc_info.value)

    def test_nonexistent_user_raises_error(self):
        """Test that non-existent user raises error"""
        with pytest.raises(InvalidCredentialsError):
            self.auth.authenticate(
                "nonexistent@example.com",
                "anypassword"
            )

    def test_account_lockout_after_failed_attempts(self):
        """Test that account locks after 5 failed login attempts"""
        # Attempt 5 failed logins
        for _ in range(5):
            with pytest.raises(InvalidCredentialsError):
                self.auth.authenticate(
                    self.valid_user["email"],
                    "WrongPassword"
                )

        # 6th attempt should raise AccountLockedError
        from auth_service import AccountLockedError
        with pytest.raises(AccountLockedError):
            self.auth.authenticate(
                self.valid_user["email"],
                self.valid_user["password"]  # Even with correct password
            )

    def test_token_expiration(self):
        """Test that tokens expire after configured time"""
        import time

        token = self.auth.authenticate(
            self.valid_user["email"],
            self.valid_user["password"]
        )

        # Mock time passage (in real code, use time mocking library)
        self.auth._set_time_offset(3600)  # +1 hour

        assert self.auth.is_token_valid(token) is False

// Example: Testing integration between authentication and user service
const request = require('supertest');
const app = require('../app');

describe('Authentication and User Service Integration', () => {
  let authToken;
  let userId;

  beforeAll(async () => {
    // Set up test database
 (as discussed in [Grey Box Testing: Best of Both Worlds](/blog/grey-box-testing))    await setupTestDatabase();
  });

  afterAll(async () => {
    // Clean up test database
    await cleanupTestDatabase();
  });

  test('User registration creates user and returns auth token', async () => {
    const newUser = {
      email: 'integration@test.com',
      password: 'SecurePass123!',
      name: 'Integration Test User'
    };

    const response = await request(app)
      .post('/api/auth/register')
      .send(newUser)
      .expect(201);

    // Verify response structure
    expect(response.body).toHaveProperty('token');
    expect(response.body).toHaveProperty('user');
    expect(response.body.user.email).toBe(newUser.email);

    // Store for subsequent tests
    authToken = response.body.token;
    userId = response.body.user.id;
  });

  test('Authenticated user can access profile endpoint', async () => {
    const response = await request(app)
      .get(`/api/users/${userId}/profile`)
      .set('Authorization', `Bearer ${authToken}`)
      .expect(200);

    expect(response.body.email).toBe('integration@test.com');
    expect(response.body.name).toBe('Integration Test User');
  });

  test('Unauthenticated request to profile returns 401', async () => {
    await request(app)
      .get(`/api/users/${userId}/profile`)
      .expect(401);
  });

  test('Invalid token returns 403', async () => {
    await request(app)
      .get(`/api/users/${userId}/profile`)
      .set('Authorization', 'Bearer invalid_token_here')
      .expect(403);
  });

  test('User can update profile with valid auth token', async () => {
    const updates = {
      name: 'Updated Name',
      bio: 'Integration testing is awesome'
    };

    const response = await request(app)
      .patch(`/api/users/${userId}/profile`)
      .set('Authorization', `Bearer ${authToken}`)
      .send(updates)
      .expect(200);

    expect(response.body.name).toBe('Updated Name');
    expect(response.body.bio).toBe('Integration testing is awesome');
  });

  test('Logout invalidates auth token', async () => {
    // Logout
    await request(app)
      .post('/api/auth/logout')
      .set('Authorization', `Bearer ${authToken}`)
      .expect(200);

    // Try to access profile with invalidated token
    await request(app)
      .get(`/api/users/${userId}/profile`)
      .set('Authorization', `Bearer ${authToken}`)
      .expect(401);
  });
});

# Functional System Test: E-commerce Purchase Flow

Feature: Complete purchase workflow
  As a customer
  I want to purchase products
  So that I can receive them at my address

Background:
  Given the e-commerce system is running
  And test products exist in inventory
  And test user account "systemtest@example.com" exists

Scenario: Successful product purchase with credit card
  Given I am logged in as "systemtest@example.com"
  When I search for "wireless headphones"
  And I select "Sony WH-1000XM4" from results
  And I click "Add to Cart"
  And I proceed to checkout
  And I enter shipping address:
    | Field      | Value              |
    | Street     | 123 Test St        |
    | City       | San Francisco      |
    | State      | CA                 |
    | Zip        | 94105              |
  And I select "Credit Card" as payment method
  And I enter valid credit card details
  And I confirm the order
  Then I should see "Order Confirmed" message
  And I should receive order confirmation email within 2 minutes
  And order status should be "Processing" in my account
  And inventory should be decremented by 1 for "Sony WH-1000XM4"
  And payment should be processed for $349.99

Scenario: Out of stock handling
  Given product "Limited Edition Watch" has 0 inventory
  When I attempt to add it to cart
  Then I should see "Out of Stock" notification
  And "Add to Cart" button should be disabled
  And I should see "Notify me when available" option

Scenario: Invalid payment information
  Given I have items in my cart
  When I proceed to checkout
  And I enter invalid credit card number "1234 5678 9012 3456"
  And I confirm the order
  Then I should see "Invalid payment information" error
  And order should not be created
  And inventory should not be decremented

# Example: Load testing for system performance validation
from locust import HttpUser, task, between

class EcommerceUser(HttpUser):
    wait_time = between(1, 3)  # Wait 1-3 seconds between requests

    def on_start(self):
        """Login when user starts"""
        response = self.client.post("/api/auth/login", json={
            "email": "loadtest@example.com",
            "password": "TestPass123!"
        })
        self.token = response.json()["token"]

    @task(3)
    def browse_products(self):
        """Browse products (high frequency)"""
        self.client.get("/api/products", headers={
            "Authorization": f"Bearer {self.token}"
        })

    @task(2)
    def view_product_detail(self):
        """View specific product (medium frequency)"""
        self.client.get("/api/products/12345", headers={
            "Authorization": f"Bearer {self.token}"
        })

    @task(1)
    def add_to_cart(self):
        """Add product to cart (lower frequency)"""
        self.client.post("/api/cart/items", json={
            "productId": "12345",
            "quantity": 1
        }, headers={
            "Authorization": f"Bearer {self.token}"
        })

    @task(1)
    def view_cart(self):
        """View shopping cart"""
        self.client.get("/api/cart", headers={
            "Authorization": f"Bearer {self.token}"
        })

# Run with: locust -f system_load_test.py --users 1000 --spawn-rate 50
# Tests system with 1000 concurrent users, ramping up 50 users per second

## UAT Test Case: Monthly Financial Report Generation

**Test ID:** UAT-FIN-001
**Feature:** Financial Reporting
**Priority:** High
**Tester:** Jane Smith (Finance Manager)
**Date:** 2025-10-02

### Business Requirement
Finance managers need to generate comprehensive monthly financial reports
that summarize revenue, expenses, and profit margins by department.

### Pre-conditions
- User has Finance Manager role
- Financial data exists for September 2025
- User is logged into the system

### Test Steps

1. Navigate to Reports → Financial → Monthly Summary
   - **Expected:** Monthly Summary page loads within 3 seconds
   - **Actual:** _______________
   - **Pass/Fail:** ___________

2. Select "September 2025" from month dropdown
   - **Expected:** Month selected, form updates
   - **Actual:** _______________
   - **Pass/Fail:** ___________

3. Select "All Departments" or specific department
   - **Expected:** Department selection available
   - **Actual:** _______________
   - **Pass/Fail:** ___________

4. Click "Generate Report" button
   - **Expected:** Report generates within 10 seconds, progress indicator shows
   - **Actual:** _______________
   - **Pass/Fail:** ___________

5. Review report contents for accuracy
   - **Expected:** Report includes:
     - Total revenue by department
     - Total expenses by category
     - Profit margin calculations
     - Month-over-month comparison
     - Visual charts (revenue trend, expense breakdown)
   - **Actual:** _______________
   - **Pass/Fail:** ___________

6. Verify report numbers match source data
   - **Expected:** Manually verify 3 sample transactions appear correctly
   - **Actual:** _______________
   - **Pass/Fail:** ___________

7. Export report as PDF
   - **Expected:** PDF downloads, maintains formatting, includes all data
   - **Actual:** _______________
   - **Pass/Fail:** ___________

8. Export report as Excel
   - **Expected:** Excel downloads, data is editable, formulas included
   - **Actual:** _______________
   - **Pass/Fail:** ___________

### Business Acceptance Criteria
- [  ] Report accurately reflects financial data
- [  ] Report generates within acceptable time (< 10 seconds)
- [  ] Report format meets business standards
- [  ] Export functionality works for PDF and Excel
- [  ] Report is understandable without technical knowledge

### Comments/Issues
_____________________________________________________________________
_____________________________________________________________________

### Overall Result: PASS / FAIL / CONDITIONAL PASS

**Signed:** _____________________ **Date:** __________