Testovani Repository a inject jine tridy

$objednavka = $this->container->getByType(\App\Model\ObjednavkaRepository::class);
$objednavka->sablony_import = $this->container->getByType(SablonyImportRepository::class);
$objednavka->importujSoubor( 1 );

class ConnectionMock extends Connection {}
class SablonyImportRepositoryMock extends SablonyImportRepository {}

$objednavkaRepo = new ObjednavkaRepository(new ConnectionMock());
$objednavkaRepo->sablony_import = new SablonyImportRepositoryMock();
$objednavkaRepo->importujSoubor( xxx );

class PayPal implements PayGate
{
    ...
    public function makeRepeatedPayment(User $user, float $price): string
	{
		// uděláme reálnou platbu nad reálnou platební bránou a vrátíme identifikátor platby...
		curl...
		$response = json_decode(curl_exec...
		if ($response->status !== ok) {thr new PaymentException()}
		return $response->data->code;
	}
    ...
}

interface PayGate
{
	/**
	 * Make payment and return payment identifier
	 * @throws PaymentException
	 */
	public function makeRepeatedPayment(User $user, float $price): string;
}

/// Stejně jako jsme udělali platební bránu uděláme i UserRepository (UserRepository je interface - děkujme Grudlovi, že to musíme vysvětlovat protože udělal Nette standard bez prefixu či suffixu - a pak máme konkrétní třídy UserRepositoryNette, UserRepositoryDoctrine, UserRepositoryFirebase atp., které konkrétně implementují získávání uživatelů podle konkrétní použité databáze/driveru atp.) no a třída User je obyčejný DataHolder

class OrderCron
{
	public function __construct(
		private PayGate $payGate,
		private UserRepository $userRepository,
	) {	}

	public function makeRepeatedPayments(): void
	{
		$users = $this->userRepository->getUsersWithRepeatedPayments();
		foreach ($users as $user) {
			try {
				$response = $this->payGate->makeRepeatedPayment($user, 50);
				$this->userRepository->confirmPayment($user, $response);
			} catch (PaymentException $e) { ... }
		}
	}
}

class CallCounter
{
	private int $called = 0;
	public function __construct(
		private int $callCount;
	) {}

	public function isCalledRightTimes(): bool
	{
		return $this->callCount === $this->called;
	}
}

class PayGateMock implements PayGate extends CallCounter
{
	public function makeRepeatedPayment(User $user, float $price): string
	{
		$this->called++;
		if ($user->id === 1) {
			throw new PaymentException('Lack of funds');
		}
		if ($price !== 50) {
			throw new Exception();	// Jiná exception, než se zachytává. Ideálně nějaká TestException
		}
		return '123456789AaBb+++';
	}
}

class UserRepositoryMock implements UserRepository extends CallCounter
{
	public function getUsersWithRepeatedPayments(): array
	{
		$this->called++;
		return [
			new User(id: 1, name: '', surname: ''),	// pro testy potřebuju jen id, takže ostatní položky můžu vyplnit prázdným...
			new User(id: 8, name: '', surname: ''),
		];
	}

	public function confirmPayment(User $user, string $response): void
	{
		$this->called++;	// Ideálně by každá funkce měla mít vlastní counter...
		$wantedUser = new User(id: 8, name: '', surname: '');
		// 2 rovnítka u třídy, jelikož jsou to jiné objekty, ale my chceme porovnat jen obsahy
		if ($user != $wantedUser || $response !== '123456789AaBb+++') {
			throw new Exception();	// Jiná exception, než se zachytává. Ideálně nějaká TestException
		}
	}
}

// A teď kouzla - samotné testování:
$payGate = new PayGateMock(callCount: 2);
$userRepository = new UserRepositoryMock(callCount: 2);	// 1x getUsersWithRepeatedPayments a 1x confirmPayment kvůli exceptioně z paygate. Takto ověříme, že se opravdu funkce nevolá zbytečně.

$orderCron = new OrderCron($payGate, $userRepository); // Vytvoříme reálnou instanci toho, co chceme testovat a hodíme mu tam mocky.
$orderCron->makeRepeatedPayments(); // Tímto se otestuje že to probělo ok. Pokud nevyskočí TestException, tak je vše v pořádku

// A ještě musíme ověřit, jestli se funkce volaly tak, jak měly...
assert($payGate->isCalledRightTimes());
assert($userRepository->isCalledRightTimes());

$user1 = new User(id: 1, name: '', surname: '');
$user2 = new User(id: 8, name: '', surname: '');
// tady PayGate už nemusí být interface, ale klidně i třída se závislostmi v konstruktoru. Mockery si s tím poradí vytvořením dalších mocků pro případné konstruktorové závislosti.
$payGate = Mockery::mock(PayGate::class)
	->shouldReceive('makeRepeatedPayment')
	->with($user1, 50)
	->andThrow(PaymentException::class, 'Lack of funds', 0)
	->once()
	->shouldReceive('makeRepeatedPayment')
	->with($user2, 50)
	->andReturn('123456789AaBb+++')
	->once()
	->getMock();
$userRepository = Mockery::mock(UserRepository::class)
	->shouldReceive('getUsersWithRepeatedPayments')
	->with()
	->andReturn([
		$user1,
		$user2,
	])
	->once()
	->shouldReceive('confirmPayment')
	->with($user2, '123456789AaBb+++')
	->once()
	->getMock();

// v $payGate a $userRepository máme tedy mocky a už jen otestujeme třídu.

$orderCron = new OrderCron($payGate, $userRepository); // Vytvoříme reálnou instanci toho, co chceme testovat a hodíme mu tam mocky.
$orderCron->makeRepeatedPayments(); // Tímto se otestuje že to probělo ok. Pokud nevyskočí nějaký MockeryException, tak je vše v pořádku

// A ještě musíme ověřit, jestli se funkce volaly tolikrát, kolikrát měly:
Mockery::close();

$connection = Mockery::mock(Connection::class)
	->getMock();
$sablonyImportRepository = Mockery::mock(SablonyImportRepository::class)
	->shouldReceive('getItemsPolozky')
	->with('xxx')
	->once()
	->getMock();

$objednavkaRepository = new ObjednavkaRepository($connection);
$objednavkaRepository->sablony_import = $sablonyImportRepository;
$objednavkaRepository->importujSoubor('val');

Mockery::close();