395 reads

Code Smell 293 - You Should Avoid Adding isTesting or Similar Flags

by Maximiliano ContieriMarch 6th, 2025

Too Long; Didn't Read

When you add flags like isTesting, you mix testing and production code. This creates hidden paths that are only active in tests.

Companies Mentioned

featured image - Code Smell 293 - You Should Avoid Adding isTesting or Similar Flags

Don’t let test code sneak into production

TL;DR: Avoid adding isTesting or similar flags.

Problems 😔

Leaky abstraction
Non-Business code pollution
Fragile Code
Inconsistent behavior
Hidden dependencies
Difficult debugging
Boolean flags
Untrusted tests
Production dependant code

Solutions 😃

Remove behavior Ifs
Use dependency injection
Model external services (Don't mock them)
Separate configurations
Isolate test logic
Maintain clean behavior boundaries

Refactorings ⚙️

Context 💬

When you add flags like isTesting, you mix testing and production code.

This creates hidden paths that are only active in tests.

Also, you don't cover real production code.

You risk shipping testing behavior to production, leading to bugs and unpredictable behavior.

Sample Code 📖

Wrong ❌

struct PaymentService {
    is_testing: bool,
}

impl PaymentService {
    fn process_payment(&self, amount: f64) {
        if self.is_testing {
            println!("Testing mode: Skipping real payment");
            return;
        }
        println!("Processing payment of ${}", amount);
    }
}

Right 👉

trait PaymentProcessor {
    fn process(&self, amount: f64);
}

struct RealPaymentProcessor;
impl PaymentProcessor for RealPaymentProcessor {
    fn process(&self, amount: f64) {
        println!("Processing payment of ${}", amount);
    }
}

struct TestingPaymentProcessor;
impl PaymentProcessor for TestingPaymentProcessor {
    // Notice this is not a mock
    fn process(&self, _: f64) {
        println!("No payment: Skipping real transaction");
    }
}

struct PaymentService<T: PaymentProcessor> {
    processor: T,
}

impl<T: PaymentProcessor> PaymentService<T> {
    fn process_payment(&self, amount: f64) {
        self.processor.process(amount);
    }
}