Choosing Your Learning Path

🗺️ NAVIGATION | Find the right resources for your goals

This page helps you navigate the documentation based on what you want to accomplish.

Quick Navigation by Goal

"I'm just getting started"

Duration: 1-2 hours | Difficulty: Beginner

Start here and follow in order:

1. Introduction (10 min) - Understand Chicago TDD philosophy
2. Quick Start Tutorial (25 min) - Write your first test
3. Fixtures Deep Dive (15 min) - Master test isolation
4. Core Testing Patterns (20 min) - Learn the essentials
5. Error Path Testing (15 min) - Find where bugs hide

Next step: Pick one real-world tutorial based on what you want to build.

"I want to build a CLI application"

Duration: 1-2 hours | Difficulty: Intermediate

Follow this path:

1. Quick Start (25 min) - Review basics
2. CLI Application Tutorial (45 min) - Build complete CLI
3. CLI Testing (20 min) - Test CLI output with golden files
4. Best Practices (30 min) - Production patterns

Key files to reference:

• TestFixture API - For test isolation
• Error Path Testing - Test error cases

"I want to build a REST API / Web Service"

Duration: 1.5-2.5 hours | Difficulty: Intermediate

Follow this path:

1. Quick Start (25 min) - Review basics
2. REST Web Service Tutorial (50 min) - Build complete API
3. Integration Testing with Docker (30 min) - Test with real database
4. Observability & Quality (20 min) - Add monitoring

Key files to reference:

• Data Builders - For building test data
• Error Path Testing - Test error responses

"I need to test complex logic"

Duration: 2-3 hours | Difficulty: Intermediate-Advanced

Follow this path:

1. Error Path Testing (15 min) - Comprehensive error testing
2. Property-Based Testing (30 min) - Generate test cases
3. Mutation Testing (20 min) - Validate test quality
4. Concurrency Testing (20 min) - Test thread safety

Key files to reference:

• Core Testing Patterns - For building blocks
• Best Practices - Quality assurance patterns

"I want to ensure high-quality tests"

Duration: 1-2 hours | Difficulty: Intermediate

Follow this path:

1. Error Path Testing (15 min) - Test error cases thoroughly
2. Mutation Testing (20 min) - Validate test quality
3. Coverage & Performance (20 min) - Measure metrics
4. Best Practices (30 min) - Industry patterns

Tools:

• Run cargo make coverage - Generate coverage reports
• Run cargo make test-mutation - Validate test quality
• Use TestFixture snapshots - Track state changes

"I'm migrating from another testing framework"

Duration: 1.5-2 hours | Difficulty: Beginner-Intermediate

Follow this path:

1. Introduction (10 min) - Understand differences
2. Quick Start (25 min) - Learn Chicago TDD style
3. Core Testing Patterns (20 min) - Relearn with new approach
4. Best Practices & Migration (30 min) - Strategies for migration

Key concepts to learn:

• Real dependencies vs mocks
• Type-level correctness
• AAA pattern enforcement
• Poka-yoke design

"I need a specific feature"

Find your feature in this table:

Learning Path Summary

Beginner (0-1 day)

Quick Start (25 min)
  ↓
Fixtures Deep Dive (15 min)
  ↓
Core Patterns (20 min)
  ↓
Pick a real-world tutorial (45-50 min)

Intermediate (1-3 days)

Complete Beginner path
  ↓
Advanced Techniques (property, mutation, snapshot)
  ↓
Real-world applications (CLI, Web Service, Docker)
  ↓
Best Practices

Advanced (3+ days)

Complete Intermediate path
  ↓
Observability & OTEL
  ↓
Performance & Coverage
  ↓
Mutation testing & quality validation
  ↓
Write your own applications

Decision Matrix

Choose based on your situation:

If you're ...

Common Starting Points

"Show me code examples"

→ Jump to Real-World Applications

"I need to solve a problem right now"

→ Search Best Practices or use feature table above

"I want to understand the philosophy"

→ Read Introduction and "Go the Extra Mile"

"I'm evaluating this for my team"

→ Read Introduction and skim Best Practices

"I want to learn everything"

→ Follow the progressive learning paths in "Learning Path Summary" above

Next Steps After Learning

After completing Quick Start & Fixtures

→ Choose one real-world tutorial to build something real

After completing a real-world tutorial

→ Explore Advanced Techniques that match your needs

After exploring multiple areas

→ Best Practices - See industry patterns

After mastering the basics

→ Build something with Chicago TDD:

• Open-source contribution
• Side project
• Production application
• Team migration

FAQ

Q: What's the best starting point? A: Quick Start if brand new, otherwise Introduction.

Q: How long does it take to learn? A: 2-4 hours for basics, 1-2 weeks to master all techniques.

Q: Should I read everything? A: No. Focus on tutorials matching your needs, use reference as needed.

Q: Can I skip sections? A: Yes. Each section is independent except tutorials (follow in order).

Q: Where's the API reference? A: API Reference - More coming soon!

Q: Do I need prior testing experience? A: No, but experience helps. Chicago TDD teaches a specific approach.

Document Index

Tutorials (Learning-Oriented)

• Quick Start - 25 min, beginner
• Fixtures Deep Dive - 15 min, beginner
• CLI Application - 45 min, intermediate
• REST Web Service - 50 min, intermediate

Core (How-To Guides)

• Fixtures - How to use fixtures
• Data Builders - Build complex test data
• Assertions - Make clear assertions
• Error Paths - Test failure cases

Advanced (How-To Guides)

• Property Testing - Generate test cases
• Mutation Testing - Validate tests
• Snapshot Testing - Compare golden files
• CLI Testing - Test CLI apps
• Concurrency Testing - Thread safety

Guides (How-To + Explanation)

• The Extra Mile Pattern - Design decisions
• Best Practices - Production patterns
• Coverage & Performance - Metrics
• Observability - Monitoring & telemetry
• OTEL Instrumentation - Add OpenTelemetry
• Weaver Validation - Validate telemetry
• Real-World Applications - Example projects

Reference (Lookup-Oriented)

• TestFixture API - Complete API docs

Quick Links

Tip: Bookmark this page and return when you need guidance on what to learn next.