Dependency injection

// ---- The dependencies, as interfaces. ----
interface PaymentGateway { charge(rider: string, pence: number): string; }
interface Clock { hour(): number; }
interface Notifier { send(rider: string, text: string): void; }

// ---- The service: asks for what it needs in its constructor, and creates none of it. ----
class RentalService {
  constructor(private readonly payments: PaymentGateway, private readonly clock: Clock, private readonly notifier: Notifier) {}

  startRental(rider: string): string {
    const fee = this.clock.hour() >= 22 ? 0 : 100;   // late-night unlocks are free
    const ref = this.payments.charge(rider, fee);
    this.notifier.send(rider, "ride started");
    return `${rider}: unlock fee ${fee}p, payment ${ref}`;
  }

  wiring(): string {
    return `RentalService(${this.payments.constructor.name}, ${this.clock.constructor.name}, ${this.notifier.constructor.name})`;
  }
}

// ---- Real implementations, used in production. ----
class LumenGateway implements PaymentGateway {
  charge(): string { throw new Error("would call the real payment provider"); }
}
class WallClock implements Clock {
  hour(): number { return new Date().getHours(); }
}
class PushNotifier implements Notifier {
  send(): void { throw new Error("would send a real phone notification"); }
}

// ---- Test doubles: predictable and harmless. ----
class FakeGateway implements PaymentGateway {
  readonly charges: number[] = [];
  charge(rider: string, pence: number): string { void rider; this.charges.push(pence); return `FAKE-${this.charges.length}`; }
}
class FixedClock implements Clock {
  constructor(public at: number) {}
  hour(): number { return this.at; }
}
class RecordingNotifier implements Notifier {
  readonly sent: string[] = [];
  send(rider: string, text: string): void { this.sent.push(`${rider}: ${text}`); }
}

// The composition root: the one place that chooses real implementations.
const buildProduction = (): RentalService => new RentalService(new LumenGateway(), new WallClock(), new PushNotifier());

console.log(`production wiring: ${buildProduction().wiring()}`);
const gateway = new FakeGateway(), clock = new FixedClock(14), notifier = new RecordingNotifier();
const service = new RentalService(gateway, clock, notifier);
console.log(`test at 14:00 -> ${service.startRental("mia")}`);
clock.at = 23;
console.log(`test at 23:00 -> ${service.startRental("leo")}`);
console.log(`fake gateway charged: [${gateway.charges.join(", ")}] | messages: ${notifier.sent.join("; ")}`);
console.log(`test wiring: ${service.wiring()}`);

import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;

public class Main {
    // ---- The dependencies, as interfaces. ----
    interface PaymentGateway { String charge(String rider, int pence); }
    interface Clock { int hour(); }
    interface Notifier { void send(String rider, String text); }

    // ---- The service: asks for what it needs in its constructor, and creates none of it. ----
    static class RentalService {
        private final PaymentGateway payments;
        private final Clock clock;
        private final Notifier notifier;
        RentalService(PaymentGateway payments, Clock clock, Notifier notifier) { this.payments = payments; this.clock = clock; this.notifier = notifier; }

        String startRental(String rider) {
            int fee = clock.hour() >= 22 ? 0 : 100;   // late-night unlocks are free
            String ref = payments.charge(rider, fee);
            notifier.send(rider, "ride started");
            return rider + ": unlock fee " + fee + "p, payment " + ref;
        }

        String wiring() {
            return "RentalService(" + payments.getClass().getSimpleName() + ", " + clock.getClass().getSimpleName() + ", " + notifier.getClass().getSimpleName() + ")";
        }
    }

    // ---- Real implementations, used in production. ----
    static class LumenGateway implements PaymentGateway {
        public String charge(String rider, int pence) { throw new UnsupportedOperationException("would call the real payment provider"); }
    }
    static class WallClock implements Clock {
        public int hour() { return LocalTime.now().getHour(); }
    }
    static class PushNotifier implements Notifier {
        public void send(String rider, String text) { throw new UnsupportedOperationException("would send a real phone notification"); }
    }

    // ---- Test doubles: predictable and harmless. ----
    static class FakeGateway implements PaymentGateway {
        final List<Integer> charges = new ArrayList<>();
        public String charge(String rider, int pence) { charges.add(pence); return "FAKE-" + charges.size(); }
    }
    static class FixedClock implements Clock {
        int at;
        FixedClock(int at) { this.at = at; }
        public int hour() { return at; }
    }
    static class RecordingNotifier implements Notifier {
        final List<String> sent = new ArrayList<>();
        public void send(String rider, String text) { sent.add(rider + ": " + text); }
    }

    // The composition root: the one place that chooses real implementations.
    static RentalService buildProduction() { return new RentalService(new LumenGateway(), new WallClock(), new PushNotifier()); }

    public static void main(String[] args) {
        System.out.println("production wiring: " + buildProduction().wiring());
        FakeGateway gateway = new FakeGateway();
        FixedClock clock = new FixedClock(14);
        RecordingNotifier notifier = new RecordingNotifier();
        RentalService service = new RentalService(gateway, clock, notifier);
        System.out.println("test at 14:00 -> " + service.startRental("mia"));
        clock.at = 23;
        System.out.println("test at 23:00 -> " + service.startRental("leo"));
        System.out.println("fake gateway charged: " + gateway.charges + " | messages: " + String.join("; ", notifier.sent));
        System.out.println("test wiring: " + service.wiring());
    }
}