unsupervised-scheduler/tests/Unit/GroupClass/EnrollmentRepositoryTest.php

<?php
declare(strict_types=1);

namespace Unsupervised\Schedular\Tests\Unit\GroupClass;

use Brain\Monkey\Functions;
use Mockery;
use Unsupervised\Schedular\GroupClass\Enrollment;
use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
use Unsupervised\Schedular\Tests\Unit\TestCase;

class EnrollmentRepositoryTest extends TestCase
{
    private \wpdb $db;
    private EnrollmentRepository $repo;

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

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

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

        $this->db->shouldReceive('insert')
            ->once()
            ->with(
                'wp_us_group_enrollments',
                Mockery::on(static function (array $d): bool {
                    return $d['offering_id'] === 7
                        && $d['student_id'] === 5
                        && $d['instructor_id'] === 3
                        && $d['status'] === Enrollment::STATUS_ACTIVE
                        // Enrolled through the student-facing flow: no staff enroller.
                        && $d['enrolled_by'] === 0;
                }),
                ['%d', '%d', '%d', '%s', '%d', '%d', '%s']
            );
        $this->db->insert_id = 12;

        self::assertSame(12, $this->repo->insert(new Enrollment(7, 5, 3)));
    }

    public function testCountActiveForOffering(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/COUNT\(\*\).*offering_id = %d AND status = %s/s'), 'wp_us_group_enrollments', 7, Enrollment::STATUS_ACTIVE)
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_var')->andReturn('4');

        self::assertSame(4, $this->repo->countActiveForOffering(7));
    }

    public function testCountActiveForStudent(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/student_id = %d AND status = %s/'), 'wp_us_group_enrollments', 5, Enrollment::STATUS_ACTIVE)
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_var')->andReturn('2');

        self::assertSame(2, $this->repo->countActiveForStudent(5));
    }

    public function testHasActiveEnrollmentTrueWhenCountPositive(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(Mockery::pattern('/offering_id = %d AND student_id = %d AND status = %s/'), 'wp_us_group_enrollments', 7, 5, Enrollment::STATUS_ACTIVE)
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_var')->andReturn('1');

        self::assertTrue($this->repo->hasActiveEnrollment(7, 5));
    }

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

        self::assertFalse($this->repo->hasActiveEnrollment(7, 5));
    }

    public function testFindAllActiveMapsRows(): void
    {
        $this->db->shouldReceive('prepare')->andReturn('SELECT ...');
        $this->db->shouldReceive('get_results')->andReturn([
            (object) [
                'id'            => '12',
                'offering_id'   => '7',
                'student_id'    => '5',
                'instructor_id' => '3',
                'status'        => Enrollment::STATUS_ACTIVE,
                'payment_id'    => null,
            ],
        ]);

        $all = $this->repo->findAllActive();

        self::assertCount(1, $all);
        self::assertInstanceOf(Enrollment::class, $all[0]);
    }

    public function testFindActiveByBillingModesJoinsOfferingAndFiltersModes(): void
    {
        $this->db->shouldReceive('prepare')
            ->once()
            ->with(
                Mockery::pattern('/e.status = %s.*o.billing_mode IN \( %s, %s \)/s'),
                'wp_us_group_enrollments',
                'wp_us_offerings',
                Enrollment::STATUS_ACTIVE,
                'weekly',
                'monthly'
            )
            ->andReturn('SELECT ...');

        $this->db->shouldReceive('get_results')->andReturn([
            (object) [
                'id'            => '12',
                'offering_id'   => '7',
                'student_id'    => '5',
                'instructor_id' => '3',
                'status'        => Enrollment::STATUS_ACTIVE,
                'payment_id'    => null,
            ],
        ]);

        $found = $this->repo->findActiveByBillingModes(['weekly', 'monthly']);

        self::assertCount(1, $found);
        self::assertInstanceOf(Enrollment::class, $found[0]);
    }

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

        self::assertSame([], $this->repo->findActiveByBillingModes([]));
    }

    public function testUpdateStatusRejectsInvalid(): void
    {
        self::assertFalse($this->repo->updateStatus(1, 'bogus'));
    }

    public function testUpdateStatusCallsWpdb(): void
    {
        $this->db->shouldReceive('update')
            ->once()
            ->with('wp_us_group_enrollments', ['status' => Enrollment::STATUS_CANCELLED], ['id' => 1], ['%s'], ['%d'])
            ->andReturn(1);

        self::assertTrue($this->repo->updateStatus(1, Enrollment::STATUS_CANCELLED));
    }
}