Test-Driven Development Across Languages: Practical Patterns for Python, Go, TypeScript, and Rust
Test-Driven Development (TDD) is one of those rare practices that genuinely improves code quality, design, and long-term maintainability — yet its application looks remarkably different depending on the language and ecosystem you're working in. Whether you're building microservices in Go, REST API handlers in Python, frontend logic in TypeScript, or performance-critical systems in Rust, the core TDD loop of Red → Green → Refactor stays constant. What changes is the tooling, the idioms, and the traps waiting to catch you off guard.
This article walks through practical TDD patterns in each of these four languages, highlighting what makes each environment unique and how to write clean, testable code from the start.
Python: Embracing Dynamic Typing Without Losing Safety
Python's dynamic nature makes it wonderfully expressive for rapid prototyping, but that same flexibility can make test suites brittle if you're not deliberate. The standard library's unittest module provides a solid foundation, though most modern Python projects reach for pytest, which offers a more ergonomic experience with fixtures, parametrize decorators, and rich plugin support.
A key TDD pattern in Python is writing tests before you define your interfaces. This forces you to think about how a function or class will be consumed, rather than how it's implemented.
# test_payment_processor.py
import pytest
from payment_processor import PaymentProcessor
def test_successful_charge_returns_transaction_id():
processor = PaymentProcessor(api_key="test_key")
result = processor.charge(amount=100, currency="USD")
assert result.transaction_id is not None
assert result.status == "success"
Notice that PaymentProcessor doesn't exist yet — and that's the point. Writing this test first forces a design decision about what the interface looks like. Combine this with unittest.mock to isolate external dependencies like databases or third-party services, and you can move fast without requiring a live environment.
For CI/CD pipelines, pytest integrates cleanly with tools like GitHub Actions or GitLab CI. Adding pytest-cov gives you coverage reports with minimal configuration, keeping your team honest about untested code paths.
Go: Simplicity as a Testing Superpower
Go's standard library includes a built-in testing package that handles the majority of real-world needs. The language's emphasis on simplicity and explicit error handling makes it surprisingly well-suited for TDD, particularly in microservices contexts.
The idiomatic Go approach uses table-driven tests — a pattern that keeps test cases organized and reduces repetition:
// parser_test.go
package parser
import "testing"
func TestParseTemperature(t *testing.T) {
cases := []struct {
input string
expected float64
wantErr bool
}{
{"98.6F", 37.0, false},
{"invalid", 0, true},
{"0C", 0.0, false},
}
for _, tc := range cases {
result, err := ParseTemperature(tc.input)
if tc.wantErr && err == nil {
t.Errorf("expected error for input %q", tc.input)
}
if !tc.wantErr && result != tc.expected {
t.Errorf("got %v, want %v", result, tc.expected)
}
}
}
Go's interface system is another TDD asset. Because interfaces are satisfied implicitly, you can write a test against an interface before any concrete implementation exists. This pattern naturally promotes dependency injection, clean code boundaries, and easier mocking — all without a heavyweight framework.
For integration testing, tools like testcontainers-go let you spin up real database containers during tests, which pairs well with Docker-based development workflows without requiring a full Kubernetes cluster locally.
TypeScript: Type Safety Meets Testing Rigor
TypeScript brings static typing to the JavaScript ecosystem, and when combined with TDD, it creates a powerful feedback loop: the compiler catches structural errors, while tests catch behavioral ones. The dominant testing ecosystem centers around Jest, which handles both unit and integration testing with minimal setup.
A critical TypeScript TDD pattern is writing tests against interfaces and types before implementing classes or functions. This ensures your types are designed for usability, not just correctness:
// userService.test.ts
import { UserService } from './userService';
import { MockUserRepository } from './mocks/mockUserRepository';
describe('UserService', () => {
it('should return null when user does not exist', async () => {
const repo = new MockUserRepository([]);
const service = new UserService(repo);
const result = await service.findById('nonexistent-id');
expect(result).toBeNull();
});
});
TypeScript's type system also makes security-sensitive code easier to test correctly. You can model domain concepts — like authenticated versus unauthenticated requests — at the type level, making entire categories of bugs impossible to introduce without a failing test.
Rust: When the Compiler Is Your First Test
Rust's ownership model and type system eliminate entire classes of bugs at compile time, which changes the TDD calculus significantly. You're not writing tests to prevent null pointer exceptions or data races — the compiler handles those. Instead, your tests focus on business logic, edge cases, and integration boundaries.
Rust has excellent built-in test support: tests live right alongside the code they're testing using the #[test] attribute, and the cargo test command handles discovery and execution automatically.
// src/pricing.rs
pub fn apply_discount(price: f64, discount_pct: f64) -> f64 {
price * (1.0 - discount_pct / 100.0)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_fifty_percent_discount() {
assert_eq!(apply_discount(100.0, 50.0), 50.0);
}
#[test]
fn test_zero_discount_returns_original_price() {
assert_eq!(apply_discount(75.0, 0.0), 75.0);
}
}
For performance optimization testing in Rust, the criterion crate provides statistically rigorous benchmarking that integrates naturally into a TDD workflow. You can write a benchmark test before optimizing, then verify your changes deliver measurable improvements.
Cross-Language Principles That Always Apply
Despite the differences in tooling and idiom, a few TDD principles hold true across all four languages. First, test behavior, not implementation — fragile tests that break on every refactor are worse than no tests at all. Second, keep your test setup minimal; if arranging a test requires twenty lines of boilerplate, your design probably needs simplification. Third, integrate tests into your CI/CD pipeline from day one — a test suite that only runs locally isn't protecting your codebase.
TDD is less about writing tests and more about using tests to drive better design decisions. Pick up the practice in whichever language you're working in today, and you'll quickly find that the discipline transfers cleanly across all of them.