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\StripeGateway;
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 StripeGateway $stripe;
    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->stripe      = Mockery::mock(StripeGateway::class);
        $this->settings->shouldReceive('etransferEmail')->andReturn('');
        $this->settings->shouldReceive('hstRate')->andReturn(0.0)->byDefault();

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

        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 testHstIsComputedAndFrozenOntoPayment(): void
    {
        $this->settings->shouldReceive('hstRate')->andReturn(13.0);
        $this->resolver->shouldReceive('resolve')->with(5)->andReturn(Payment::METHOD_ETRANSFER);
        $this->payments->shouldReceive('insert')
            ->once()
            ->with(Mockery::on(static fn (Payment $p): bool => $p->taxRate === 13.0 && $p->taxAmount === 13.00 && $p->total() === 113.00))
            ->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, 100.00, 'CAD'));
    }

    public function testCompIsNotTaxed(): void
    {
        $this->settings->shouldReceive('hstRate')->andReturn(13.0);
        $this->resolver->shouldReceive('resolve')->with(5)->andReturn(Payment::METHOD_COMP);
        $this->payments->shouldReceive('insert')
            ->once()
            ->with(Mockery::on(static fn (Payment $p): bool => $p->taxRate === 0.0 && $p->taxAmount === 0.0))
            ->andReturn(61);
        $this->bookings->shouldReceive('setPaymentId')->once()->with(12, 61);
        $this->payments->shouldReceive('markPaid')->once()->with(61, 'USC-61')->andReturn(true);
        $this->bookings->shouldReceive('updateStatus')->once()->with(12, Lesson::STATUS_CONFIRMED)->andReturn(true);
        $this->payments->shouldReceive('findById')->with(61)->andReturn($this->payment(Payment::METHOD_COMP, Payment::STATUS_PAID, 61));
        $this->mailer->shouldReceive('send')->andReturn(false);

        self::assertNotNull($this->service->createForRegistration(Payment::REG_LESSON, 12, 5, 3, 100.00, 'CAD'));
    }

    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));
    }

    public function testCreateIntentForCardReturnsClientSecret(): void
    {
        $this->payments->shouldReceive('findByRegistration')->with(Payment::REG_LESSON, 12)
            ->andReturn($this->payment(Payment::METHOD_CARD, Payment::STATUS_PENDING, 90));

        $intent = \Stripe\PaymentIntent::constructFrom(['id' => 'pi_abc', 'client_secret' => 'pi_abc_secret']);
        $this->stripe->shouldReceive('createIntent')->once()
            ->with(Mockery::on(static fn (Payment $p): bool => $p->id === 90))
            ->andReturn($intent);
        $this->payments->shouldReceive('setStripeIntentId')->once()->with(90, 'pi_abc')->andReturn(true);
        $this->settings->shouldReceive('publishableKey')->andReturn('pk_test_123');

        $result = $this->service->createIntent(Payment::REG_LESSON, 12, 5);

        self::assertSame('card', $result['method']);
        self::assertSame('pi_abc_secret', $result['client_secret']);
        self::assertSame('pk_test_123', $result['publishable_key']);
    }

    public function testCreateIntentForEtransferReturnsDisplayDataWithoutStripe(): void
    {
        $payment = new Payment(5, 3, Payment::REG_LESSON, 12, 35.00, 'CAD', Payment::METHOD_ETRANSFER, Payment::STATUS_PENDING, etransferEmail: 'pay@studio.test', id: 91);
        $this->payments->shouldReceive('findByRegistration')->with(Payment::REG_LESSON, 12)->andReturn($payment);

        $this->stripe->shouldNotReceive('createIntent');

        $result = $this->service->createIntent(Payment::REG_LESSON, 12, 5);

        self::assertSame('etransfer', $result['method']);
        self::assertSame('pay@studio.test', $result['etransfer_email']);
        self::assertArrayNotHasKey('client_secret', $result);
    }

    public function testCreateIntentReturnsNullWhenNotOwner(): void
    {
        $this->payments->shouldReceive('findByRegistration')->with(Payment::REG_LESSON, 12)
            ->andReturn($this->payment(Payment::METHOD_CARD, Payment::STATUS_PENDING, 90));

        // Student 999 does not own payment whose studentId is 5.
        self::assertNull($this->service->createIntent(Payment::REG_LESSON, 12, 999));
    }

    public function testCreateIntentReturnsNullWhenNoPayment(): void
    {
        $this->payments->shouldReceive('findByRegistration')->with(Payment::REG_LESSON, 12)->andReturn(null);

        self::assertNull($this->service->createIntent(Payment::REG_LESSON, 12, 5));
    }

    public function testCreateIntentReturnsNullWhenStripeFails(): void
    {
        $this->payments->shouldReceive('findByRegistration')->with(Payment::REG_LESSON, 12)
            ->andReturn($this->payment(Payment::METHOD_CARD, Payment::STATUS_PENDING, 90));
        $this->stripe->shouldReceive('createIntent')->once()->andReturn(null);

        self::assertNull($this->service->createIntent(Payment::REG_LESSON, 12, 5));
    }

    public function testHandleWebhookInvalidSignatureReturnsFalse(): void
    {
        $this->stripe->shouldReceive('verifyWebhook')->with('{}', 'bad-sig')->andReturn(null);

        self::assertFalse($this->service->handleWebhook('{}', 'bad-sig'));
    }

    public function testHandleWebhookSucceededFinalizesPayment(): void
    {
        $event = $this->intentEvent('payment_intent.succeeded', 'pi_ok');
        $this->stripe->shouldReceive('verifyWebhook')->andReturn($event);

        $this->payments->shouldReceive('findByStripeIntentId')->with('pi_ok')
            ->andReturn($this->payment(Payment::METHOD_CARD, Payment::STATUS_PENDING, 90));

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

        self::assertTrue($this->service->handleWebhook('{}', 'sig'));
    }

    public function testHandleWebhookSucceededIdempotentWhenAlreadyPaid(): void
    {
        $event = $this->intentEvent('payment_intent.succeeded', 'pi_ok');
        $this->stripe->shouldReceive('verifyWebhook')->andReturn($event);

        $this->payments->shouldReceive('findByStripeIntentId')->with('pi_ok')
            ->andReturn($this->payment(Payment::METHOD_CARD, Payment::STATUS_PAID, 90));

        // Already paid → no markPaid/confirm.
        self::assertTrue($this->service->handleWebhook('{}', 'sig'));
    }

    public function testHandleWebhookFailedMarksFailed(): void
    {
        $event = $this->intentEvent('payment_intent.payment_failed', 'pi_bad');
        $this->stripe->shouldReceive('verifyWebhook')->andReturn($event);

        $this->payments->shouldReceive('findByStripeIntentId')->with('pi_bad')
            ->andReturn($this->payment(Payment::METHOD_CARD, Payment::STATUS_PENDING, 90));
        $this->payments->shouldReceive('updateStatus')->once()->with(90, Payment::STATUS_FAILED)->andReturn(true);

        self::assertTrue($this->service->handleWebhook('{}', 'sig'));
    }

    public function testHandleWebhookAcknowledgesUnknownIntent(): void
    {
        $event = $this->intentEvent('payment_intent.succeeded', 'pi_unknown');
        $this->stripe->shouldReceive('verifyWebhook')->andReturn($event);
        $this->payments->shouldReceive('findByStripeIntentId')->with('pi_unknown')->andReturn(null);

        self::assertTrue($this->service->handleWebhook('{}', 'sig'));
    }

    private function intentEvent(string $type, string $intentId): \Stripe\Event
    {
        $intent = \Stripe\PaymentIntent::constructFrom(['id' => $intentId, 'object' => 'payment_intent']);

        return \Stripe\Event::constructFrom(['type' => $type, 'data' => ['object' => $intent]]);
    }
}