unsupervised-scheduler/tests/Unit/Payment/PaymentServiceTest.php

<?php
declare(strict_types=1);

namespace Unsupervised\Schedular\Tests\Unit\Payment;

use Brain\Monkey\Functions;
use Mockery;
use Unsupervised\Schedular\Booking\BookingRepository;
use Unsupervised\Schedular\Booking\Lesson;
use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
use Unsupervised\Schedular\Payment\BillingMethodResolver;
use Unsupervised\Schedular\Payment\Payment;
use Unsupervised\Schedular\Payment\PaymentRepository;
use Unsupervised\Schedular\Payment\PaymentService;
use Unsupervised\Schedular\Payment\ReceiptMailer;
use Unsupervised\Schedular\Payment\StudioSettings;
use Unsupervised\Schedular\Tests\Unit\TestCase;

class PaymentServiceTest extends TestCase
{
    private PaymentRepository $payments;
    private BillingMethodResolver $resolver;
    private ReceiptMailer $mailer;
    private BookingRepository $bookings;
    private EnrollmentRepository $enrollments;
    private StudioSettings $settings;
    private PaymentService $service;

    protected function setUp(): void
    {
        parent::setUp();

        $this->payments    = Mockery::mock(PaymentRepository::class);
        $this->resolver    = Mockery::mock(BillingMethodResolver::class);
        $this->mailer      = Mockery::mock(ReceiptMailer::class);
        $this->bookings    = Mockery::mock(BookingRepository::class);
        $this->enrollments = Mockery::mock(EnrollmentRepository::class);
        $this->settings    = Mockery::mock(StudioSettings::class);
        $this->settings->shouldReceive('etransferEmail')->andReturn('');

        $this->service = new PaymentService(
            $this->payments,
            $this->resolver,
            $this->mailer,
            $this->bookings,
            $this->enrollments,
            $this->settings
        );

        Functions\when('get_userdata')->justReturn(false);
    }

    private function payment(string $method, string $status, int $id): Payment
    {
        return new Payment(5, 3, Payment::REG_LESSON, 12, 35.00, 'CAD', $method, $status, id: $id);
    }

    public function testFreeRegistrationCreatesNoPayment(): void
    {
        self::assertNull($this->service->createForRegistration(Payment::REG_LESSON, 12, 5, 3, 0.0, 'CAD'));
    }

    public function testEtransferStaysPending(): void
    {
        $this->resolver->shouldReceive('resolve')->with(5)->andReturn(Payment::METHOD_ETRANSFER);
        $this->payments->shouldReceive('insert')
            ->once()
            ->with(Mockery::on(static fn (Payment $p): bool => $p->method === Payment::METHOD_ETRANSFER && $p->status === Payment::STATUS_PENDING))
            ->andReturn(50);
        $this->bookings->shouldReceive('setPaymentId')->once()->with(12, 50);
        $this->payments->shouldReceive('findById')->with(50)->andReturn($this->payment(Payment::METHOD_ETRANSFER, Payment::STATUS_PENDING, 50));

        // No markPaid / confirm for a pending e-transfer.
        $result = $this->service->createForRegistration(Payment::REG_LESSON, 12, 5, 3, 35.00, 'CAD');

        self::assertSame(Payment::STATUS_PENDING, $result->status);
    }

    public function testOfferingEtransferEmailIsFrozenOntoPayment(): void
    {
        $this->resolver->shouldReceive('resolve')->with(5)->andReturn(Payment::METHOD_ETRANSFER);
        $this->payments->shouldReceive('insert')
            ->once()
            ->with(Mockery::on(static fn (Payment $p): bool => $p->etransferEmail === 'pay@studio.test'))
            ->andReturn(50);
        $this->bookings->shouldReceive('setPaymentId')->once()->with(12, 50);
        $this->payments->shouldReceive('findById')->with(50)->andReturn($this->payment(Payment::METHOD_ETRANSFER, Payment::STATUS_PENDING, 50));

        self::assertNotNull(
            $this->service->createForRegistration(Payment::REG_LESSON, 12, 5, 3, 35.00, 'CAD', 'pay@studio.test')
        );
    }

    public function testCompIsPaidAndConfirmsImmediately(): void
    {
        $this->resolver->shouldReceive('resolve')->with(5)->andReturn(Payment::METHOD_COMP);
        $this->payments->shouldReceive('insert')
            ->once()
            ->with(Mockery::on(static fn (Payment $p): bool => $p->method === Payment::METHOD_COMP && $p->status === Payment::STATUS_PAID))
            ->andReturn(60);
        $this->bookings->shouldReceive('setPaymentId')->once()->with(12, 60);

        $this->payments->shouldReceive('markPaid')->once()->with(60, 'USC-60')->andReturn(true);
        $this->bookings->shouldReceive('updateStatus')->once()->with(12, Lesson::STATUS_CONFIRMED)->andReturn(true);
        $this->payments->shouldReceive('findById')->with(60)->andReturn($this->payment(Payment::METHOD_COMP, Payment::STATUS_PAID, 60));
        $this->mailer->shouldReceive('send')->andReturn(false);

        $result = $this->service->createForRegistration(Payment::REG_LESSON, 12, 5, 3, 35.00, 'CAD');

        self::assertSame(Payment::STATUS_PAID, $result->status);
    }

    public function testMarkPaidConfirmsAndReturnsTrue(): void
    {
        $this->payments->shouldReceive('findById')->with(70)->andReturn($this->payment(Payment::METHOD_ETRANSFER, Payment::STATUS_PENDING, 70));
        $this->payments->shouldReceive('markPaid')->once()->with(70, 'USC-70')->andReturn(true);
        $this->bookings->shouldReceive('updateStatus')->once()->with(12, Lesson::STATUS_CONFIRMED)->andReturn(true);
        $this->mailer->shouldReceive('send')->andReturn(false);

        self::assertTrue($this->service->markPaid(70));
    }

    public function testMarkPaidReturnsFalseWhenMissing(): void
    {
        $this->payments->shouldReceive('findById')->with(99)->andReturn(null);

        self::assertFalse($this->service->markPaid(99));
    }

    public function testMarkPaidIdempotentWhenAlreadyPaid(): void
    {
        $this->payments->shouldReceive('findById')->with(80)->andReturn($this->payment(Payment::METHOD_ETRANSFER, Payment::STATUS_PAID, 80));

        // Already paid → no markPaid/confirm calls.
        self::assertTrue($this->service->markPaid(80));
    }
}