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

<?php
declare(strict_types=1);

namespace Unsupervised\Schedular\Tests\Unit\Payment;

use Brain\Monkey\Functions;
use Mockery;
use Unsupervised\Schedular\Payment\Payment;
use Unsupervised\Schedular\Payment\PaymentRepository;
use Unsupervised\Schedular\Tests\Unit\TestCase;

class PaymentRepositoryTest extends TestCase
{
    private \wpdb $db;
    private PaymentRepository $repo;

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

        $this->db         = Mockery::mock(\wpdb::class);
        $this->db->prefix = 'wp_';
        $this->repo       = new PaymentRepository($this->db);
    }

    public function testInsertReturnsId(): void
    {
        Functions\expect('current_time')->with('mysql')->andReturn('2026-06-08 12:00:00');

        $this->db->shouldReceive('insert')
            ->once()
            ->with(
                'wp_us_payments',
                Mockery::on(static function (array $d): bool {
                    return $d['student_id'] === 5
                        && $d['amount'] === 35.00
                        && $d['method'] === Payment::METHOD_ETRANSFER
                        && $d['status'] === Payment::STATUS_PENDING;
                }),
                Mockery::type('array')
            );
        $this->db->insert_id = 50;

        self::assertSame(50, $this->repo->insert(new Payment(5, 3, Payment::REG_LESSON, 12, 35.00)));
    }

    public function testInsertPersistsScheduledDueDateAndPeriodKey(): void
    {
        Functions\expect('current_time')->with('mysql')->andReturn('2026-06-08 12:00:00');

        $this->db->shouldReceive('insert')
            ->once()
            ->with(
                'wp_us_payments',
                Mockery::on(static function (array $d): bool {
                    return $d['due_date'] === '2026-07-14'
                        && $d['period_key'] === '2026-07-15';
                }),
                Mockery::type('array')
            );
        $this->db->insert_id = 51;

        self::assertSame(
            51,
            $this->repo->insert(new Payment(5, 3, Payment::REG_LESSON, 12, 35.00, dueDate: '2026-07-14', periodKey: '2026-07-15'))
        );
    }

    public function testExistsForPeriodReturnsTrueWhenRowFound(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/registration_type = %s AND registration_id = %d AND period_key = %s/'), 'wp_us_payments', Payment::REG_ENROLLMENT, 7, '2026-07')
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_var')->once()->with('SELECT ...')->andReturn('91');

        self::assertTrue($this->repo->existsForPeriod(Payment::REG_ENROLLMENT, 7, '2026-07'));
    }

    public function testExistsForPeriodReturnsFalseWhenAbsent(): void
    {
        $this->db->shouldReceive('prepare')->once()->andReturn('SELECT ...');
        $this->db->shouldReceive('get_var')->once()->andReturn(null);

        self::assertFalse($this->repo->existsForPeriod(Payment::REG_ENROLLMENT, 7, '2026-08'));
    }

    public function testAssignNoticeBatchUpdatesRows(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/SET notice_batch = %s WHERE id IN \( %d, %d \)/'), 'wp_us_payments', 'REF12345', 5, 6)
            ->andReturn('UPDATE ...');

        $this->db->shouldReceive('query')->once()->with('UPDATE ...')->andReturn(2);

        $this->repo->assignNoticeBatch([5, 6], 'REF12345');
    }

    public function testAssignNoticeBatchNoopForEmptyIds(): void
    {
        $this->db->shouldNotReceive('prepare');
        $this->db->shouldNotReceive('query');

        $this->repo->assignNoticeBatch([], 'REF12345');
    }

    public function testMarkPaidUpdatesStatusAndReceipt(): void
    {
        Functions\expect('current_time')->with('mysql')->andReturn('2026-06-08 12:00:00');

        $this->db->shouldReceive('update')
            ->once()
            ->with(
                'wp_us_payments',
                Mockery::on(static fn (array $d): bool => $d['status'] === Payment::STATUS_PAID && $d['receipt_number'] === 'USC-50' && $d['paid_at'] === '2026-06-08 12:00:00'),
                ['id' => 50],
                ['%s', '%s', '%s'],
                ['%d']
            )
            ->andReturn(1);

        self::assertTrue($this->repo->markPaid(50, 'USC-50'));
    }

    public function testMarkNoticedStampsOnlyUnnoticedRowAndReportsTheWin(): void
    {
        Functions\expect('current_time')->with('mysql')->andReturn('2026-06-08 12:00:00');

        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/SET notice_sent_at = %s WHERE id = %d AND notice_sent_at IS NULL/'), 'wp_us_payments', '2026-06-08 12:00:00', 50)
            ->andReturn('UPDATE ...');

        // One row updated -> this call won the claim.
        $this->db->shouldReceive('query')->once()->with('UPDATE ...')->andReturn(1);

        self::assertTrue($this->repo->markNoticed(50));
    }

    public function testMarkNoticedReturnsFalseWhenAlreadyClaimed(): void
    {
        Functions\expect('current_time')->with('mysql')->andReturn('2026-06-08 12:00:00');

        $this->db->shouldReceive('prepare')->once()->andReturn('UPDATE ...');
        // Zero rows updated -> another run already stamped notice_sent_at.
        $this->db->shouldReceive('query')->once()->with('UPDATE ...')->andReturn(0);

        self::assertFalse($this->repo->markNoticed(50));
    }

    public function testBackfillNoticeSentStampsExistingScheduledRowsWhenColumnPresent(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/SHOW COLUMNS FROM %i LIKE %s/'), 'wp_us_payments', 'notice_sent_at')
            ->andReturn('SHOW ...');
        $this->db->shouldReceive('get_var')->once()->with('SHOW ...')->andReturn('notice_sent_at');

        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/SET notice_sent_at = created_at WHERE notice_sent_at IS NULL AND period_key IS NOT NULL/'), 'wp_us_payments')
            ->andReturn('UPDATE ...');
        $this->db->shouldReceive('query')->once()->with('UPDATE ...')->andReturn(3);

        self::assertTrue($this->repo->backfillNoticeSent());
    }

    public function testBackfillNoticeSentIsNoopWhenColumnAbsent(): void
    {
        $this->db->shouldReceive('prepare')->once()->andReturn('SHOW ...');
        $this->db->shouldReceive('get_var')->once()->with('SHOW ...')->andReturn(null);

        // Column not there yet: do not attempt the UPDATE, and report not-done so
        // the caller does not set its one-time flag before dbDelta has run.
        $this->db->shouldNotReceive('query');

        self::assertFalse($this->repo->backfillNoticeSent());
    }

    public function testUpdateTaxRecomputesAmountFromRate(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/tax_amount = ROUND\( amount \* %f \/ 100, 2 \)/'), 'wp_us_payments', 13.0, 13.0, 50)
            ->andReturn('UPDATE ...');

        $this->db->shouldReceive('query')->once()->with('UPDATE ...')->andReturn(1);

        self::assertTrue($this->repo->updateTax(50, 13.0));
    }

    public function testFindPaidBetweenFiltersByInstructor(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/status = %s AND paid_at >= %s AND paid_at < %s AND instructor_id = %d/'), ['wp_us_payments', 'paid', '2026-06-01 00:00:00', '2026-07-01 00:00:00', 3])
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_results')->andReturn([$this->row()]);

        self::assertCount(1, $this->repo->findPaidBetween('2026-06-01 00:00:00', '2026-07-01 00:00:00', 3));
    }

    public function testFindPaidBetweenWithoutInstructorOmitsFilter(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::on(static fn (string $sql): bool => ! str_contains($sql, 'instructor_id')), ['wp_us_payments', 'paid', '2026-06-01 00:00:00', '2026-07-01 00:00:00'])
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_results')->andReturn([]);

        self::assertCount(0, $this->repo->findPaidBetween('2026-06-01 00:00:00', '2026-07-01 00:00:00'));
    }

    public function testSetStripeIntentIdUpdatesRow(): void
    {
        $this->db->shouldReceive('update')
            ->once()
            ->with(
                'wp_us_payments',
                ['stripe_payment_intent_id' => 'pi_123'],
                ['id' => 50],
                ['%s'],
                ['%d']
            )
            ->andReturn(1);

        self::assertTrue($this->repo->setStripeIntentId(50, 'pi_123'));
    }

    public function testFindByStripeIntentIdReturnsPayment(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/stripe_payment_intent_id = %s/'), 'wp_us_payments', 'pi_123')
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_row')->andReturn($this->row());

        self::assertInstanceOf(Payment::class, $this->repo->findByStripeIntentId('pi_123'));
    }

    public function testFindByStripeIntentIdReturnsNullWhenMissing(): void
    {
        $this->db->shouldReceive('prepare')->andReturn('SELECT ...');
        $this->db->shouldReceive('get_row')->andReturn(null);

        self::assertNull($this->repo->findByStripeIntentId('pi_missing'));
    }

    public function testFindByRegistrationReturnsPayment(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/registration_type = %s AND registration_id = %d/'), 'wp_us_payments', Payment::REG_LESSON, 12)
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_row')->andReturn($this->row());

        self::assertInstanceOf(Payment::class, $this->repo->findByRegistration(Payment::REG_LESSON, 12));
    }

    public function testFindPendingMapsRows(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/status = %s/'), 'wp_us_payments', Payment::STATUS_PENDING)
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_results')->andReturn([$this->row()]);

        self::assertCount(1, $this->repo->findPending());
    }

    public function testFindByStudentPreparesQueryAndMaps(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/student_id = %d ORDER BY created_at DESC, id DESC/'), 'wp_us_payments', 5)
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_results')->andReturn([$this->row()]);

        $payments = $this->repo->findByStudent(5);

        self::assertCount(1, $payments);
        self::assertSame(5, $payments[0]->studentId);
        self::assertSame('2026-06-08 09:00:00', $payments[0]->createdAt);
    }

    private function row(): object
    {
        return (object) [
            'id'                       => '50',
            'student_id'               => '5',
            'instructor_id'            => '3',
            'registration_type'        => Payment::REG_LESSON,
            'registration_id'          => '12',
            'amount'                   => '35.00',
            'currency'                 => 'CAD',
            'method'                   => Payment::METHOD_ETRANSFER,
            'status'                   => Payment::STATUS_PENDING,
            'tax_rate'                 => '0.00',
            'tax_amount'               => '0.00',
            'etransfer_email'          => null,
            'stripe_payment_intent_id' => null,
            'receipt_number'           => null,
            'receipt_sent_at'          => null,
            'paid_at'                  => null,
            'created_at'               => '2026-06-08 09:00:00',
        ];
    }
}