unsupervised-scheduler/tests/Unit/Auth/InviteTest.php

<?php
declare(strict_types=1);

namespace Unsupervised\Schedular\Tests\Unit\Auth;

use Unsupervised\Schedular\Auth\Invite;
use Unsupervised\Schedular\Auth\RoleManager;
use Unsupervised\Schedular\Tests\Unit\TestCase;

class InviteTest extends TestCase
{
    public function testDefaults(): void
    {
        $invite = new Invite('[email protected]', 'tok123');

        self::assertSame('[email protected]', $invite->email);
        self::assertSame('tok123', $invite->token);
        self::assertSame(RoleManager::STUDENT, $invite->role);
        self::assertSame(Invite::STATUS_PENDING, $invite->status);
        self::assertTrue($invite->isPending());
        self::assertNull($invite->invitedBy);
        self::assertNull($invite->acceptedUserId);
        self::assertNull($invite->id);
    }

    public function testFromRowMapsCorrectly(): void
    {
        $invite = Invite::fromRow((object) [
            'id'               => '5',
            'email'            => '[email protected]',
            'token'            => 'tok123',
            'role'             => RoleManager::STUDENT,
            'status'           => Invite::STATUS_ACCEPTED,
            'invited_by'       => '2',
            'accepted_user_id' => '9',
            'accepted_at'      => '2026-06-02 09:00:00',
        ]);

        self::assertSame(5, $invite->id);
        self::assertSame(2, $invite->invitedBy);
        self::assertSame(9, $invite->acceptedUserId);
        self::assertFalse($invite->isPending());
    }

    public function testFromRowHandlesNullableIds(): void
    {
        $invite = Invite::fromRow((object) [
            'id'               => '5',
            'email'            => '[email protected]',
            'token'            => 'tok123',
            'role'             => RoleManager::STUDENT,
            'status'           => Invite::STATUS_PENDING,
            'invited_by'       => null,
            'accepted_user_id' => null,
            'accepted_at'      => null,
        ]);

        self::assertNull($invite->invitedBy);
        self::assertNull($invite->acceptedUserId);
        self::assertTrue($invite->isPending());
    }

    public function testIsExpiredWhenOlderThanExpiryWindow(): void
    {
        $created = gmdate('Y-m-d H:i:s', strtotime('2026-06-01 09:00:00'));
        $now     = '2026-06-20 09:00:00'; // 19 days later, beyond the 14-day window.

        $invite = new Invite('[email protected]', 'tok', createdAt: $created);

        self::assertTrue($invite->isExpired($now));
        self::assertFalse($invite->isAcceptable($now));
    }

    public function testIsNotExpiredWithinExpiryWindow(): void
    {
        $invite = new Invite('[email protected]', 'tok', createdAt: '2026-06-01 09:00:00');
        $now    = '2026-06-10 09:00:00'; // 9 days later, inside the window.

        self::assertFalse($invite->isExpired($now));
        self::assertTrue($invite->isAcceptable($now));
    }

    public function testIsNotExpiredWhenCreatedAtUnknown(): void
    {
        $invite = new Invite('[email protected]', 'tok');

        self::assertFalse($invite->isExpired('2030-01-01 00:00:00'));
        self::assertTrue($invite->isAcceptable('2030-01-01 00:00:00'));
    }

    public function testAcceptedInviteIsNotAcceptableEvenWhenFresh(): void
    {
        $invite = new Invite('[email protected]', 'tok', status: Invite::STATUS_ACCEPTED, createdAt: '2026-06-01 09:00:00');

        self::assertFalse($invite->isAcceptable('2026-06-02 09:00:00'));
    }

    public function testGroupInviteHonoursExplicitExpiry(): void
    {
        $invite = new Invite(
            '',
            'tok',
            createdAt: '2026-06-01 09:00:00',
            kind: Invite::KIND_GROUP,
            expiresAt: '2026-08-31 23:59:59'
        );

        self::assertTrue($invite->isGroup());
        // 19 days after creation — past the personal 14-day window, but the
        // explicit expiry governs.
        self::assertFalse($invite->isExpired('2026-06-20 09:00:00'));
        self::assertTrue($invite->isAcceptable('2026-06-20 09:00:00'));

        self::assertTrue($invite->isExpired('2026-09-01 00:00:00'));
        self::assertFalse($invite->isAcceptable('2026-09-01 00:00:00'));
    }

    public function testExplicitExpiryWinsOverCreationWindowForPersonalInvites(): void
    {
        $invite = new Invite('[email protected]', 'tok', createdAt: '2026-06-01 09:00:00', expiresAt: '2026-06-02 23:59:59');

        // One day old (inside the 14-day window) but past its explicit expiry.
        self::assertTrue($invite->isExpired('2026-06-03 09:00:00'));
    }

    public function testFromRowDefaultsKindWhenColumnMissing(): void
    {
        $invite = Invite::fromRow((object) [
            'id'               => '5',
            'email'            => '[email protected]',
            'token'            => 'tok123',
            'role'             => RoleManager::STUDENT,
            'status'           => Invite::STATUS_PENDING,
            'invited_by'       => null,
            'accepted_user_id' => null,
            'accepted_at'      => null,
        ]);

        self::assertSame(Invite::KIND_PERSONAL, $invite->kind);
        self::assertFalse($invite->isGroup());
        self::assertNull($invite->expiresAt);
    }

    public function testHashTokenIsDeterministicSha256(): void
    {
        $hash = Invite::hashToken('raw-token');

        self::assertSame(hash('sha256', 'raw-token'), $hash);
        self::assertSame($hash, Invite::hashToken('raw-token'));
        self::assertNotSame($hash, Invite::hashToken('other-token'));
        self::assertSame(64, strlen($hash));
    }

    public function testToArrayContainsExpectedKeys(): void
    {
        $arr = (new Invite('[email protected]', 'tok', id: 1))->toArray();

        foreach (['id', 'email', 'token', 'role', 'kind', 'status', 'invited_by', 'accepted_user_id', 'accepted_at', 'expires_at', 'offering_id'] as $key) {
            self::assertArrayHasKey($key, $arr);
        }
    }

    public function testOfferingIdRoundTrips(): void
    {
        $invite = Invite::fromRow((object) [
            'id'               => '5',
            'email'            => '[email protected]',
            'token'            => 'tok123',
            'role'             => RoleManager::STUDENT,
            'status'           => Invite::STATUS_PENDING,
            'invited_by'       => '2',
            'accepted_user_id' => null,
            'accepted_at'      => null,
            'offering_id'      => '8',
        ]);

        self::assertSame(8, $invite->offeringId);
        self::assertSame(8, $invite->toArray()['offering_id']);
    }

    public function testOfferingIdDefaultsToNullWhenColumnMissing(): void
    {
        $invite = Invite::fromRow((object) [
            'id'               => '5',
            'email'            => '[email protected]',
            'token'            => 'tok123',
            'role'             => RoleManager::STUDENT,
            'status'           => Invite::STATUS_PENDING,
            'invited_by'       => null,
            'accepted_user_id' => null,
            'accepted_at'      => null,
        ]);

        self::assertNull($invite->offeringId);
    }
}