Testing Best Practices

This page is under construction. More content coming soon!

Core Testing Principles

Test Early, Test Often

Catch bugs when they’re cheapest to fix—during development

Automate Wisely

Automate stable, repetitive tests. Keep exploratory testing manual.

Test the Right Things

Focus on critical functionality and user journeys, not every edge case

Make Tests Maintainable

Clear, simple tests are easier to maintain than clever, complex ones

Writing Effective Test Cases

Clarity
Scope
Independence
Data

Write Clear, Unambiguous Tests

Good test case characteristics:

Specific: No room for interpretation
Repeatable: Anyone can execute and get same result
Self-contained: Includes all necessary information
Actionable: Clear steps to follow

**Title**: Verify user can login with valid credentials

**Preconditions**:
- User account exists: test@example.com / Password123!
- User is not currently logged in

**Steps**:
1. Navigate to https://app.example.com/login
   → Login page displays with email and password fields

2. Enter email: test@example.com
   → Email field accepts input

3. Enter password: Password123!
   → Password is masked with dots

4. Click "Login" button
   → User is redirected to dashboard at /dashboard
   → Welcome message displays: "Welcome, Test User"

One Test, One Purpose

Do: Test one thing per test case

✅ Test: Verify user can login with valid credentials
✅ Test: Verify error message for invalid password
✅ Test: Verify error message for non-existent user

Don’t: Test multiple things in one test

❌ Test: Verify entire user journey from signup to purchase

Why: When the test fails, you immediately know what broke. Large tests are hard to debug and maintain.

If your test title includes “and”, it’s probably doing too much.

Make Tests Independent

Each test should:

Set up its own test data
Not depend on other tests running first
Clean up after itself (or use fresh test data)
Be runnable in any order

Example:

❌ Bad: Test depends on previous test
Test 1: Create user account
Test 2: Login with account from Test 1 ← Fails if Test 1 is skipped

✅ Good: Each test is independent
Test 1: Verify user registration
  - Creates test user
  - Verifies creation
  - Cleans up

Test 2: Verify login with valid credentials
  - Uses pre-existing test account
  - Doesn't depend on Test 1

Use Good Test Data

Test data best practices:

Realistic but not real: Use fake data that looks real
- ✅ john.smith@example.com
- ❌ Real customer email addresses
Descriptive: Data should indicate its purpose
- ✅ test_user_valid@example.com
- ✅ expired_credit_card_4111111111111111

Documented: Include test data in test case

**Test Data**:
- Username: test@example.com
- Password: ValidPassword123!
- Expected result: Successful login

Isolated: Don’t share mutable test data between tests
Fresh: Use data that won’t be affected by other tests

Test Organization

Use Meaningful Names

Test cases: Start with action verb

✅ “Verify user can checkout with credit card”
❌ “Checkout test #42”

Folders: Group by feature or user journey

✅ /Authentication/Login/
❌ /Tests/Stuff/More Stuff/

Tags: Be consistent

✅ smoke, regression, critical
❌ smoke, Smoke, SMOKE, smoke-test

Prioritize Tests

Use priority levels:

P0/Critical: Blocks releases if failing
P1/High: Important functionality
P2/Medium: Standard features
P3/Low: Nice to have
P4/Trivial: Optional

Run tests by priority:

priority = p0  # Run first
priority IN (p0, p1)  # Smoke suite
priority IN (p0, p1, p2)  # Full regression

Track Coverage

Ensure coverage of:

All critical user journeys
All P0/P1 requirements
Common error scenarios
Edge cases for critical features

Use OQL to find gaps:

# High priority features without tests
requirements ~ "US-" AND priority IN (p0, p1) AND test_count = 0

# Features not tested recently
status = active AND last_run < -30d AND priority IN (p0, p1)

Automation Strategy

What to Automate
Automation Pyramid
Maintenance

Automate These Tests

Good candidates for automation:

✅ Smoke tests (run after every deployment)
✅ Regression tests (run before release)
✅ API tests (fast, stable, repeatable)
✅ Data-driven tests (same steps, different data)
✅ Tests run frequently (>5 times per week)
✅ Stable tests (pass rate >95%)

Keep these manual:

❌ Exploratory testing
❌ Usability testing
❌ Visual design testing
❌ Tests that change frequently
❌ Tests run rarely
❌ Tests with complex verification

Test Automation Pyramid

Follow the testing pyramid for balanced automation:

       /\
      /UI\         10% - Slow, brittle, expensive
     /----\
    / API \        30% - Faster, more stable
   /------\
  /  Unit  \      60% - Fast, cheap, reliable
 /----------\

Guidelines:

Unit tests: Most of your tests (60%)
API/Integration tests: Moderate amount (30%)
UI tests: Smallest amount (10%)

Why: Lower layers are faster, more reliable, and cheaper to maintain.

Test Execution

When to Run Tests

Smoke tests: After every deployment

Quick verification (15-30 min)
Critical paths only
Blocks further testing if fails

Regression tests: Before releases

Comprehensive validation (2-4 hours)
All important features
Blocks release if P0/P1 fail

Exploratory tests: Ongoing

Ad-hoc testing
New features
Edge cases
Unusual scenarios

Automated tests: Continuously

On every commit (unit tests)
Nightly (full regression)
Pre-merge (affected tests)

Test Environments

Environment strategy:

Development: Developer local testing
QA/Test: QA team testing
Staging: Pre-production validation
Production: Smoke tests only

Best practices:

Keep staging identical to production
Use production-like data (anonymized)
Isolate test data from production
Refresh test environments regularly
Document environment differences

Handling Failures

When a test fails:

Reproduce: Can you reproduce the failure?
- Yes → Investigate
- No → Might be flaky, investigate further
Classify: What type of failure?
- Real bug → Create defect
- Test issue → Fix the test
- Environmental → Check environment
- Known issue → Link to existing bug
Document: Add details:
- Screenshots
- Logs
- Steps to reproduce
- Environment details
Act: Take appropriate action:
- Block release if P0/P1
- Assess risk if P2/P3
- Fix test if test issue

Team Collaboration

Shared Responsibility

Everyone owns quality: devs write unit tests, QA writes integration tests, product defines acceptance criteria

Clear Communication

Use test results to communicate: pass rate, coverage, trends, risks

Review Tests

Review test cases like code: check for clarity, completeness, maintainability

Share Knowledge

Document testing strategies, share test patterns, train new team members

Common Anti-Patterns

Avoid these testing mistakes:

Testing Everything

Problem: Trying to test every possible scenarioWhy it’s bad: Wastes time, most tests add little valueSolution: Focus on:

Critical user journeys
High-risk areas
Recently changed code
Areas with frequent bugs

Test Automation for Everything

Problem: Automating all tests blindlyWhy it’s bad: Some tests cost more to automate than run manuallySolution: Automate selectively based on:

Frequency of execution
Stability of feature
Cost of automation vs manual
ROI of automation

Ignoring Flaky Tests

Problem: “Oh, that test is flaky, just re-run it”Why it’s bad: Erodes trust in test suite, masks real issuesSolution:

Fix flaky tests immediately
If can’t fix, remove from suite
Never accept “sometimes it fails”

No Test Maintenance

Problem: Writing tests but never updating themWhy it’s bad: Tests become outdated, irrelevant, or brokenSolution:

Review tests quarterly
Update for product changes
Remove obsolete tests
Fix broken tests immediately

Testing Too Late

Problem: Only testing at the end of developmentWhy it’s bad: Bugs are expensive to fix late in cycleSolution:

Test during development
Write tests first (TDD)
Review requirements before coding
Continuous testing in CI/CD

Metrics That Matter

Track these metrics to improve testing:

Pass Rate

Target: >95% for regression suite

Coverage

% of features with tests

Defect Detection Rate

Bugs found in test vs production

Cycle Time

Time from code to tested

Automation Rate

% of tests automated

Flaky Test Rate

Target: <2%

Test Management

Learn about OneTest’s features

Smoke Testing

Critical path testing workflow

Regression Testing

Comprehensive testing workflow

Team Collaboration

Work together on testing

Recommended Books

Lessons Learned in Software Testing

By Cem Kaner, James Bach, and Bret PettichordClassic book with 293 lessons about software testing

Agile Testing

By Lisa Crispin and Janet GregoryTesting in agile environments

Explore It!

By Elisabeth HendricksonExploratory testing techniques

The Art of Software Testing

By Glenford J. MyersFundamentals of software testing (classic)

Get Started

Using OneTest

Settings

Resources

Testing Best Practices

Core Testing Principles

Test Early, Test Often

Automate Wisely

Test the Right Things

Make Tests Maintainable

Writing Effective Test Cases

Write Clear, Unambiguous Tests

One Test, One Purpose

Make Tests Independent

Use Good Test Data

Test Organization

Automation Strategy

Automate These Tests

Test Automation Pyramid

Keep Automation Healthy

Test Execution

Team Collaboration

Shared Responsibility

Clear Communication

Review Tests

Share Knowledge

Common Anti-Patterns

Metrics That Matter

Pass Rate

Coverage

Defect Detection Rate

Cycle Time

Automation Rate

Flaky Test Rate

Further Reading

Test Management

Smoke Testing

Regression Testing

Team Collaboration

Recommended Books

Get Started

Using OneTest

Settings

Resources

​Core Testing Principles

Test Early, Test Often

Automate Wisely

Test the Right Things

Make Tests Maintainable

​Writing Effective Test Cases

​Write Clear, Unambiguous Tests

​One Test, One Purpose

​Make Tests Independent

​Use Good Test Data

​Test Organization

​Automation Strategy

​Automate These Tests

​Test Automation Pyramid

​Keep Automation Healthy

​Test Execution

​Team Collaboration

Shared Responsibility

Clear Communication

Review Tests

Share Knowledge

​Common Anti-Patterns

​Metrics That Matter

Pass Rate

Coverage

Defect Detection Rate

Cycle Time

Automation Rate

Flaky Test Rate

​Further Reading

Test Management

Smoke Testing

Regression Testing

Team Collaboration

​Recommended Books

Core Testing Principles

Writing Effective Test Cases

Write Clear, Unambiguous Tests

One Test, One Purpose

Make Tests Independent

Use Good Test Data

Test Organization

Automation Strategy

Automate These Tests

Test Automation Pyramid

Keep Automation Healthy

Test Execution

Team Collaboration

Common Anti-Patterns

Metrics That Matter

Further Reading

Recommended Books