PHP Static Singleton — Cache Contaminated by Test Order

<?php

/**
 * Money value object demonstrating static factory methods.
 * Multiple ways to construct — all clear, all explicit.
 */
class Money
{
    // Private constructor forces callers to use the named factory methods.
    // This prevents ambiguous construction like: new Money(150, 'cents') vs new Money(1.50, 'dollars')
    private function __construct(
        private readonly int    $amountInCents,
        private readonly string $currencyCode
    ) {}

    // Factory method 1: construct from an integer number of cents.
    public static function fromCents(int $cents, string $currency = 'USD'): self
    {
        // Validate here before the object is even created — impossible in a single constructor.
        if ($cents < 0) {
            throw new InvalidArgumentException('Amount cannot be negative.');
        }
        return new self($cents, strtoupper($currency));
    }

    // Factory method 2: construct from a float (handles the cents conversion internally).
    public static function fromFloat(float $amount, string $currency = 'USD'): self
    {
        if ($amount < 0.0) {
            throw new InvalidArgumentException('Amount cannot be negative.');
        }
        // Round to avoid floating-point dust (e.g., 1.005 * 100 = 100.4999...)
        $cents = (int) round($amount * 100);
        return new self($cents, strtoupper($currency));
    }

    // Factory method 3: construct from a formatted string like "$9.99".
    public static function fromFormattedString(string $formattedAmount, string $currency = 'USD'): self
    {
        // Strip currency symbols and whitespace before parsing.
        $cleaned = preg_replace('/[^0-9.]/', '', $formattedAmount);
        return self::fromFloat((float) $cleaned, $currency);
    }

    public function getAmountInCents(): int
    {
        return $this->amountInCents;
    }

    public function format(): string
    {
        return sprintf('%s %.2f', $this->currencyCode, $this->amountInCents / 100);
    }

    // A pure utility — doesn't need instance state, belongs to the concept of Money.
    public static function zero(string $currency = 'USD'): self
    {
        return new self(0, strtoupper($currency));
    }
}

// --- Three crystal-clear ways to create Money objects ---

$productPrice   = Money::fromCents(1999);             // $19.99 from a database integer
$shippingFee    = Money::fromFloat(4.99);              // $4.99 from user input
$discountAmount = Money::fromFormattedString('$2.50'); // $2.50 from a config file
$emptyWallet    = Money::zero();

echo $productPrice->format()   . PHP_EOL;
echo $shippingFee->format()    . PHP_EOL;
echo $discountAmount->format() . PHP_EOL;
echo $emptyWallet->format()    . PHP_EOL;

echo 'Product in cents: ' . $productPrice->getAmountInCents() . PHP_EOL;

<?php

/**
 * A utility class whose methods are genuinely context-free.
 * These are good static candidates — they take input, return output,
 * hold no state, and never need to be swapped for a test double.
 */
class StringHelper
{
    // Pure function: same input always gives same output, no side effects.
    public static function toTitleCase(string $sentence): string
    {
        // ucwords converts first letter of each word to uppercase.
        return ucwords(strtolower(trim($sentence)));
    }

    // Pure function: strips non-alphanumeric characters for use in URLs.
    public static function toSlug(string $title): string
    {
        $lowercased  = strtolower(trim($title));
        $spaceless   = preg_replace('/[\s_]+/', '-', $lowercased);  // spaces and underscores become hyphens
        $clean       = preg_replace('/[^a-z0-9\-]/', '', $spaceless); // strip everything else
        return rtrim($clean, '-'); // remove any trailing hyphens
    }

    // Pure function: truncates a string and appends ellipsis if needed.
    public static function truncate(string $text, int $maxLength = 100, string $suffix = '...'): string
    {
        if (mb_strlen($text) <= $maxLength) {
            return $text; // Already short enough — return as-is.
        }

        // Cut at a word boundary so we don't slice mid-word.
        $truncated = mb_substr($text, 0, $maxLength);
        $lastSpace = mb_strrpos($truncated, ' ');

        return ($lastSpace !== false)
            ? mb_substr($truncated, 0, $lastSpace) . $suffix
            : $truncated . $suffix;
    }
}

// These static calls are totally fine — no hidden state, fully testable as pure functions.
$articleTitle   = StringHelper::toTitleCase('  the QUICK brown FOX  ');
$urlSlug        = StringHelper::toSlug('The Quick Brown Fox! (2024)');
$previewText    = StringHelper::truncate(
    'Static methods in PHP can be extremely useful when applied thoughtfully to the right problems.',
    50
);

echo $articleTitle . PHP_EOL;
echo $urlSlug      . PHP_EOL;
echo $previewText  . PHP_EOL;

<?php

// Step 1: Define an interface for the service.
interface OrderTotalCalculatorInterface
{
    public function calculate(Order $order): Money;
}

// Step 2: Create a wrapper that delegates to the existing static method.
class LegacyOrderTotalCalculator implements OrderTotalCalculatorInterface
{
    public function calculate(Order $order): Money
    {
        // Delegate to the static method (temporarily).
        return OrderService::calculateTotal($order);
    }
}

// Step 3: In your controller, inject the interface instead of calling static.
class OrderController
{
    public function __construct(
        private OrderTotalCalculatorInterface $calculator
    ) {}

    public function show(int $orderId): array
    {
        $order = Order::findOrFail($orderId);
        $total = $this->calculator->calculate($order);
        return ['total' => $total->format()];
    }
}

// Step 4: In a test, bind a mock implementation.
class OrderTest extends TestCase
{
    public function test_total_is_calculated(): void
    {
        $mock = $this->createMock(OrderTotalCalculatorInterface::class);
        $mock->method('calculate')->willReturn(Money::fromCents(1000));

        app()->instance(OrderTotalCalculatorInterface::class, $mock);

        $response = $this->get('/orders/1');
        $response->assertJson(['total' => 'USD 10.00']);
    }
}

// io.thecodeforge — php tutorial

class PaymentGateway {
    private string $apiKey;

    public function __construct(string $apiKey) {
        $this->apiKey = $apiKey;
    }

    // This will blow up — static method using $this
    public static function charge(float $amount): bool {
        // Fatal error: Using $this when not in object context
        $this->validateApiKey();
        return true;
    }

    private function validateApiKey(): void {
        if (empty($this->apiKey)) {
            throw new \RuntimeException('API key missing');
        }
    }
}

$gateway = new PaymentGateway('sk_live_abc123');
$gateway::charge(49.99);

// io.thecodeforge — php tutorial

abstract class Repository {
    protected static string $table = 'default_table';

    public static function getTable(): string {
        // self:: binds to Repository, not the child
        return 'self: ' . self::$table;
    }

    public static function getTableLate(): string {
        // static:: binds to the calling class at runtime
        return 'static: ' . static::$table;
    }
}

class UserRepository extends Repository {
    protected static string $table = 'users';
}

echo UserRepository::getTable() . "\n";
echo UserRepository::getTableLate() . "\n";

echo Repository::getTable() . "\n";
echo Repository::getTableLate() . "\n";