Atomcms-edit/tests/Unit/UserTest.php

<?php

use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

uses(TestCase::class, RefreshDatabase::class);

test('user can be created with factory', function () {
    installHotel();

    $user = User::factory()->create([
        'username' => 'TestUser',
        'mail' => 'test@example.com',
    ]);

    // Basic property checks
    expect($user->username)->toBe('TestUser');
    expect($user->mail)->toBe('test@example.com');
    expect($user->password)->not->toBe('password'); // Should be hashed
    expect($user->id)->toBeInt();
    expect($user->id)->toBeGreaterThan(0);

    // Type checks
    expect($user->username)->toBeString();
    expect($user->mail)->toBeString();
    expect($user->password)->toBeString();
    expect($user->id)->toBeNumeric();

    // String length checks
    expect($user->username)->toHaveLength(8);
    expect($user->mail)->toHaveLength(16);
    expect($user->password)->toHaveLength(60); // Bcrypt hash length

    // Not null checks
    expect($user->username)->not->toBeNull();
    expect($user->mail)->not->toBeNull();
    expect($user->password)->not->toBeNull();
    expect($user->id)->not->toBeNull();

    // Contains checks
    expect($user->mail)->toContain('@');
    expect($user->mail)->toContain('example.com');

    // Verify user exists in database with all fields
    $this->assertDatabaseHas('users', [
        'id' => $user->id,
        'username' => 'TestUser',
        'mail' => 'test@example.com',
    ]);

    // Verify count
    expect(User::count())->toBe(1);

    // Verify we can retrieve the user
    $retrievedUser = User::find($user->id);
    expect($retrievedUser)->not->toBeNull();
    expect($retrievedUser->username)->toBe('TestUser');
    expect($retrievedUser->mail)->toBe('test@example.com');
});

test('user factory creates proper defaults', function () {
    installHotel();

    $user = User::factory()->create();

    // Basic default checks
    expect($user->username)->toBe('NewRetro');
    expect((int) $user->credits)->toBeGreaterThan(0);
    expect($user->ip_register)->toBe('127.0.0.1');
    expect($user->ip_current)->toBe('127.0.0.1');
    expect($user->id)->toBeInt();
    expect($user->id)->toBeGreaterThan(0);
    expect($user->account_created)->toBeInt();
    expect($user->last_login)->toBeInt();
    expect($user->password)->not->toBeEmpty();

    // Type checks
    expect($user->username)->toBeString();
    expect($user->credits)->toBeInt();
    expect($user->ip_register)->toBeString();
    expect($user->ip_current)->toBeString();
    expect($user->account_created)->toBeInt();
    expect($user->last_login)->toBeInt();
    expect($user->password)->toBeString();

    // IP format checks
    expect($user->ip_register)->toContain('.');
    expect($user->ip_current)->toContain('.');
    expect($user->ip_register)->toHaveLength(9);
    expect($user->ip_current)->toHaveLength(9);

    // Credits checks
    expect($user->credits)->toBeGreaterThanOrEqual(0);
    expect($user->credits)->toBeLessThan(10000);

    // Timestamp checks
    expect($user->account_created)->toBeGreaterThan(0);
    expect($user->last_login)->toBeGreaterThan(0);
    expect($user->account_created)->toBeLessThan(time() + 10);
    expect($user->last_login)->toBeLessThan(time() + 10);

    // Verify user exists in database
    $this->assertDatabaseHas('users', [
        'id' => $user->id,
        'username' => 'NewRetro',
        'ip_register' => '127.0.0.1',
        'ip_current' => '127.0.0.1',
    ]);

    // Verify count
    expect(User::count())->toBe(1);

    // Verify we can retrieve the user
    $retrievedUser = User::find($user->id);
    expect($retrievedUser)->not->toBeNull();
    expect($retrievedUser->username)->toBe('NewRetro');
});

test('user can be updated', function () {
    installHotel();

    $user = User::factory()->create([
        'username' => 'OriginalUser',
        'mail' => 'original@example.com',
    ]);

    $originalId = $user->id;

    // Update user
    $user->username = 'UpdatedUser';
    $user->mail = 'updated@example.com';
    $user->save();

    // Refresh from database
    $user->refresh();

    // Verify updates
    expect($user->username)->toBe('UpdatedUser');
    expect($user->mail)->toBe('updated@example.com');
    expect($user->id)->toBe($originalId);

    // Database verification
    $this->assertDatabaseHas('users', [
        'id' => $originalId,
        'username' => 'UpdatedUser',
        'mail' => 'updated@example.com',
    ]);

    $this->assertDatabaseMissing('users', [
        'id' => $originalId,
        'username' => 'OriginalUser',
    ]);
});

test('user can be deleted', function () {
    installHotel();

    $user = User::factory()->create([
        'username' => 'DeleteMe',
        'mail' => 'delete@example.com',
    ]);

    $userId = $user->id;

    // Verify user exists
    expect(User::find($userId))->not->toBeNull();
    expect(User::count())->toBe(1);

    // Delete user
    $user->delete();

    // Verify user is deleted
    expect(User::find($userId))->toBeNull();
    expect(User::count())->toBe(0);

    // Database verification
    $this->assertDatabaseMissing('users', [
        'id' => $userId,
    ]);
});

test('user password is hashed', function () {
    installHotel();

    $user = User::factory()->create([
        'username' => 'PasswordTest',
        'mail' => 'password@example.com',
        'password' => 'mysecretpassword',
    ]);

    // Verify password is hashed (bcrypt starts with $2y$)
    expect($user->password)->toStartWith('$2y$');
    expect($user->password)->toHaveLength(60);
    expect($user->password)->not->toBe('mysecretpassword');

    // Verify we can check the password
    expect(password_verify('mysecretpassword', $user->password))->toBeTrue();
    expect(password_verify('wrongpassword', $user->password))->toBeFalse();
});

test('multiple users can be created', function () {
    installHotel();

    $user1 = User::factory()->create(['username' => 'User1', 'mail' => 'user1@example.com']);
    $user2 = User::factory()->create(['username' => 'User2', 'mail' => 'user2@example.com']);
    $user3 = User::factory()->create(['username' => 'User3', 'mail' => 'user3@example.com']);

    // Verify count
    expect(User::count())->toBe(3);

    // Verify all users exist
    expect(User::find($user1->id))->not->toBeNull();
    expect(User::find($user2->id))->not->toBeNull();
    expect(User::find($user3->id))->not->toBeNull();

    // Verify usernames are unique
    expect($user1->username)->not->toBe($user2->username);
    expect($user2->username)->not->toBe($user3->username);
    expect($user1->username)->not->toBe($user3->username);

    // Verify emails are unique
    expect($user1->mail)->not->toBe($user2->mail);
    expect($user2->mail)->not->toBe($user3->mail);
    expect($user1->mail)->not->toBe($user3->mail);

    // Database verification
    $this->assertDatabaseHas('users', ['username' => 'User1']);
    $this->assertDatabaseHas('users', ['username' => 'User2']);
    $this->assertDatabaseHas('users', ['username' => 'User3']);
});