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

<?php
declare(strict_types=1);

namespace Unsupervised\Schedular\Tests\Unit\GroupClass;

use Brain\Monkey\Functions;
use Mockery;
use Unsupervised\Schedular\Auth\InviteRepository;
use Unsupervised\Schedular\Auth\RegistrationMailer;
use Unsupervised\Schedular\GroupClass\Enrollment;
use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
use Unsupervised\Schedular\GroupClass\GroupAccessRepository;
use Unsupervised\Schedular\GroupClass\GroupClassController;
use Unsupervised\Schedular\Offering\Offering;
use Unsupervised\Schedular\Offering\OfferingRepository;
use Unsupervised\Schedular\Payment\Payment;
use Unsupervised\Schedular\Payment\PaymentRepository;
use Unsupervised\Schedular\Payment\PaymentService;
use Unsupervised\Schedular\Tests\Unit\TestCase;

class GroupClassControllerTest extends TestCase
{
    private EnrollmentRepository&Mockery\MockInterface $enrollments;
    private OfferingRepository&Mockery\MockInterface $offerings;
    private PaymentRepository&Mockery\MockInterface $payments;
    private GroupAccessRepository&Mockery\MockInterface $access;
    private PaymentService&Mockery\MockInterface $paymentService;
    private InviteRepository&Mockery\MockInterface $invites;
    private RegistrationMailer&Mockery\MockInterface $mailer;
    private GroupClassController $controller;

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

        $this->enrollments    = Mockery::mock(EnrollmentRepository::class);
        $this->offerings      = Mockery::mock(OfferingRepository::class);
        $this->payments       = Mockery::mock(PaymentRepository::class);
        $this->access         = Mockery::mock(GroupAccessRepository::class);
        $this->paymentService = Mockery::mock(PaymentService::class);
        $this->invites        = Mockery::mock(InviteRepository::class);
        $this->mailer         = Mockery::mock(RegistrationMailer::class);
        $this->controller     = new GroupClassController(
            $this->enrollments,
            $this->offerings,
            $this->payments,
            $this->access,
            $this->paymentService,
            $this->invites,
            $this->mailer,
        );

        Functions\when('current_user_can')->justReturn(true);
        Functions\when('get_current_user_id')->justReturn(3);
        Functions\when('get_users')->justReturn([]);
        Functions\when('esc_attr')->returnArg();
        Functions\when('esc_attr_e')->returnArg();
    }

    private function offering(int $id, string $title, ?int $capacity): Offering
    {
        return new Offering(
            instructorId: 3,
            kind: Offering::KIND_GROUP_CLASS,
            title: $title,
            capacity: $capacity,
            id: $id,
        );
    }

    private function renderInstructor(): string
    {
        ob_start();
        $this->controller->renderInstructorPage();

        return (string) ob_get_clean();
    }

    public function testInstructorPageListsClassWithCapacityAndRoster(): void
    {
        Functions\when('get_userdata')->justReturn((object) ['display_name' => 'Ada Lovelace']);

        $offering   = $this->offering(8, 'Choir', 10);
        $enrollment = new Enrollment(offeringId: 8, studentId: 5, instructorId: 3, paymentId: 42, id: 1);

        $this->offerings->shouldReceive('findAll')->once()
            ->with(3, Offering::KIND_GROUP_CLASS)->andReturn([$offering]);
        $this->enrollments->shouldReceive('findByInstructor')->once()->with(3)->andReturn([$enrollment]);
        $this->payments->shouldReceive('findById')->once()->with(42)->andReturn(
            new Payment(studentId: 5, instructorId: 3, registrationType: Payment::REG_ENROLLMENT, registrationId: 1, amount: 100.0, status: Payment::STATUS_PAID, id: 42)
        );

        $html = $this->renderInstructor();

        self::assertStringContainsString('Choir', $html);
        self::assertStringContainsString('(1 / 10 enrolled)', $html);
        self::assertStringContainsString('Ada Lovelace', $html);
        self::assertStringContainsString('paid', $html);
    }

    public function testEnrolmentCountExcludesCancelledButRosterKeepsThem(): void
    {
        Functions\when('get_userdata')->justReturn((object) ['display_name' => 'Grace Hopper']);

        $offering  = $this->offering(8, 'Band', null);
        $active    = new Enrollment(offeringId: 8, studentId: 5, instructorId: 3, id: 1);
        $cancelled = new Enrollment(offeringId: 8, studentId: 6, instructorId: 3, status: Enrollment::STATUS_CANCELLED, id: 2);

        $this->offerings->shouldReceive('findAll')->once()->andReturn([$offering]);
        $this->enrollments->shouldReceive('findByInstructor')->once()->andReturn([$active, $cancelled]);

        $html = $this->renderInstructor();

        // Unlimited capacity offering counts only the active enrolment.
        self::assertStringContainsString('(1 enrolled)', $html);
        // But the roster still shows the cancelled row.
        self::assertStringContainsString('cancelled', $html);
    }

    public function testFreeEnrolmentShowsDashForPayment(): void
    {
        Functions\when('get_userdata')->justReturn((object) ['display_name' => 'Alan Turing']);

        $offering   = $this->offering(8, 'Theory', 5);
        $enrollment = new Enrollment(offeringId: 8, studentId: 5, instructorId: 3, paymentId: null, id: 1);

        $this->offerings->shouldReceive('findAll')->once()->andReturn([$offering]);
        $this->enrollments->shouldReceive('findByInstructor')->once()->andReturn([$enrollment]);
        $this->payments->shouldReceive('findById')->never();

        $html = $this->renderInstructor();

        self::assertStringContainsString('—', $html);
    }

    public function testEnrolmentsForOtherClassesAreNotMixedIn(): void
    {
        Functions\when('get_userdata')->justReturn((object) ['display_name' => 'Katherine Johnson']);

        $offering = $this->offering(8, 'Choir', 5);
        $mine     = new Enrollment(offeringId: 8, studentId: 5, instructorId: 3, id: 1);
        $other    = new Enrollment(offeringId: 9, studentId: 6, instructorId: 3, id: 2);

        $this->offerings->shouldReceive('findAll')->once()->andReturn([$offering]);
        $this->enrollments->shouldReceive('findByInstructor')->once()->andReturn([$mine, $other]);

        $html = $this->renderInstructor();

        self::assertStringContainsString('(1 / 5 enrolled)', $html);
    }

    public function testClassWithNoEnrolmentsShowsEmptyMessage(): void
    {
        $offering = $this->offering(8, 'Jazz', 5);

        $this->offerings->shouldReceive('findAll')->once()->andReturn([$offering]);
        $this->enrollments->shouldReceive('findByInstructor')->once()->andReturn([]);

        $html = $this->renderInstructor();

        self::assertStringContainsString('No enrolments yet.', $html);
    }

    public function testInstructorWithNoClassesShowsEmptyMessage(): void
    {
        $this->offerings->shouldReceive('findAll')->once()->andReturn([]);
        $this->enrollments->shouldReceive('findByInstructor')->once()->andReturn([]);

        $html = $this->renderInstructor();

        self::assertStringContainsString('You have no group classes.', $html);
    }

    public function testDeniesUsersWithoutViewLessonsCapability(): void
    {
        Functions\when('current_user_can')->justReturn(false);
        Functions\expect('wp_die')->once()->andThrow(new \RuntimeException('denied'));

        $this->expectException(\RuntimeException::class);

        $this->controller->renderInstructorPage();
    }

    protected function tearDown(): void
    {
        $_POST = [];
        parent::tearDown();
    }

    private function inviteOnlyOffering(float $price = 0.0): Offering
    {
        return new Offering(
            instructorId: 3,
            kind:         Offering::KIND_GROUP_CLASS,
            title:        'Private Choir',
            price:        $price,
            accessMode:   Offering::ACCESS_INVITE_ONLY,
            id:           8,
        );
    }

    /** Stub the form-processing helpers and the render tail shared by all action tests. */
    private function stubActionContext(): void
    {
        Functions\when('check_admin_referer')->justReturn(true);
        Functions\when('sanitize_key')->alias(static fn ($v) => strtolower((string) $v));
        Functions\when('wp_unslash')->returnArg();
        Functions\when('sanitize_email')->returnArg();
        Functions\when('absint')->alias(static fn ($v) => abs((int) $v));

        // Render tail: no classes/enrolments to draw so the assertion targets the notice.
        $this->offerings->shouldReceive('findAll')->with(3, Offering::KIND_GROUP_CLASS)->andReturn([]);
        $this->enrollments->shouldReceive('findByInstructor')->with(3)->andReturn([]);
    }

    public function testAddDirectEnrolsStudentWithPendingPayment(): void
    {
        $_POST = ['usc_action' => 'add_direct', 'offering_id' => 8, 'student_ids' => [5]];
        $this->stubActionContext();

        $this->offerings->shouldReceive('findById')->with(8)->andReturn($this->inviteOnlyOffering(100.0));
        $this->enrollments->shouldReceive('hasActiveEnrollment')->with(8, 5)->andReturn(false);
        $this->enrollments->shouldReceive('insert')->once()->andReturn(44);

        $payment = new Payment(
            studentId:        5,
            instructorId:     3,
            registrationType: Payment::REG_ENROLLMENT,
            registrationId:   44,
            amount:           100.0,
            method:           Payment::METHOD_ETRANSFER,
            status:           Payment::STATUS_PENDING,
            id:               12,
        );
        $this->paymentService->shouldReceive('createForRegistration')
            ->once()
            ->with(Payment::REG_ENROLLMENT, 44, 5, 3, 100.0, 'CAD', null)
            ->andReturn($payment);
        $this->enrollments->shouldReceive('setPaymentId')->once()->with(44, 12)->andReturn(true);
        $this->access->shouldReceive('markEnrolled')->once()->with(8, 5);

        $html = $this->renderInstructor();

        self::assertStringContainsString('1 student(s) added to the class.', $html);
    }

    public function testGrantAccessCreatesGrantAndEmailsStudent(): void
    {
        $_POST = ['usc_action' => 'grant_access', 'offering_id' => 8, 'student_ids' => [5]];
        $this->stubActionContext();

        $this->offerings->shouldReceive('findById')->with(8)->andReturn($this->inviteOnlyOffering());
        $this->enrollments->shouldReceive('hasActiveEnrollment')->with(8, 5)->andReturn(false);
        $this->access->shouldReceive('hasGrant')->with(8, 5)->andReturn(false);
        $this->access->shouldReceive('insert')->once()->andReturn(1);

        $user = Mockery::mock(\WP_User::class);
        $user->user_email = '[email protected]';
        Functions\when('get_userdata')->justReturn($user);
        $this->mailer->shouldReceive('sendClassAccessGranted')->once()->with($user, 'Private Choir')->andReturn(true);

        $html = $this->renderInstructor();

        self::assertStringContainsString('1 student(s) granted access.', $html);
    }

    public function testInviteEmailForNewAddressCreatesInviteAndSendsLink(): void
    {
        $_POST = ['usc_action' => 'invite_email', 'offering_id' => 8, 'email' => '[email protected]'];
        $this->stubActionContext();

        $this->offerings->shouldReceive('findById')->with(8)->andReturn($this->inviteOnlyOffering());
        Functions\when('is_email')->justReturn(true);
        Functions\when('email_exists')->justReturn(false);
        $this->invites->shouldReceive('findPendingByEmail')->with('[email protected]')->andReturn(null);
        Functions\when('wp_generate_password')->justReturn('rawtoken');
        Functions\when('get_option')->justReturn(0);
        Functions\when('home_url')->justReturn('http://home.test/');
        Functions\when('add_query_arg')->justReturn('http://home.test/?us_invite=rawtoken');

        $this->invites->shouldReceive('insert')->once()->andReturn(7);
        $this->access->shouldReceive('insert')->once()->andReturn(2);
        $this->mailer->shouldReceive('sendClassInvite')->once()->with('[email protected]', 'http://home.test/?us_invite=rawtoken', 'Private Choir')->andReturn(true);

        $html = $this->renderInstructor();

        self::assertStringContainsString('Invitation sent.', $html);
    }

    public function testInviteEmailReusesPendingInviteWithoutSendingLink(): void
    {
        $_POST = ['usc_action' => 'invite_email', 'offering_id' => 8, 'email' => '[email protected]'];
        $this->stubActionContext();

        $this->offerings->shouldReceive('findById')->with(8)->andReturn($this->inviteOnlyOffering());
        Functions\when('is_email')->justReturn(true);
        Functions\when('email_exists')->justReturn(false);
        $this->invites->shouldReceive('findPendingByEmail')->with('[email protected]')->andReturn(
            new \Unsupervised\Schedular\Auth\Invite(email: '[email protected]', token: 'hash', id: 9)
        );

        // No new invite row and no email — just a grant attached to the existing invite.
        $this->invites->shouldReceive('insert')->never();
        $this->mailer->shouldReceive('sendClassInvite')->never();
        $this->access->shouldReceive('insert')->once()->andReturn(2);

        $html = $this->renderInstructor();

        self::assertStringContainsString('No new link was sent.', $html);
    }

    public function testInviteEmailForExistingAccountGrantsAccess(): void
    {
        $_POST = ['usc_action' => 'invite_email', 'offering_id' => 8, 'email' => '[email protected]'];
        $this->stubActionContext();

        $this->offerings->shouldReceive('findById')->with(8)->andReturn($this->inviteOnlyOffering());
        Functions\when('is_email')->justReturn(true);
        Functions\when('email_exists')->justReturn(55);

        $this->enrollments->shouldReceive('hasActiveEnrollment')->with(8, 55)->andReturn(false);
        $this->access->shouldReceive('hasGrant')->with(8, 55)->andReturn(false);
        $this->access->shouldReceive('insert')->once()->andReturn(3);

        $user = Mockery::mock(\WP_User::class);
        $user->user_email = '[email protected]';
        Functions\when('get_userdata')->justReturn($user);
        $this->mailer->shouldReceive('sendClassAccessGranted')->once()->andReturn(true);

        $html = $this->renderInstructor();

        self::assertStringContainsString('1 student(s) granted access.', $html);
    }

    public function testActionRejectedForClassNotOwnedByInstructor(): void
    {
        $_POST = ['usc_action' => 'add_direct', 'offering_id' => 8, 'student_ids' => [5]];
        $this->stubActionContext();

        // Offering owned by a different instructor (7, not the current user 3).
        $foreign = new Offering(instructorId: 7, kind: Offering::KIND_GROUP_CLASS, title: 'Other', accessMode: Offering::ACCESS_INVITE_ONLY, id: 8);
        $this->offerings->shouldReceive('findById')->with(8)->andReturn($foreign);
        $this->enrollments->shouldReceive('insert')->never();

        $html = $this->renderInstructor();

        self::assertStringContainsString('That group class was not found.', $html);
    }
}