slp-modular-cms/frontend/src/features/auth/schemas/auth.test.ts

import { describe, expect, it } from 'vitest';
import {
    passwordSchema,
    setupFormSchema,
    loginFormSchema,
    invitationCompleteFormSchema,
} from '@/features/auth/schemas/auth';

describe('passwordSchema', () => {
    it('accepts a valid password', () => {
        expect(passwordSchema.safeParse('Password1!').success).toBe(true);
    });

    it('rejects a password that is too short', () => {
        expect(passwordSchema.safeParse('Pass1!').success).toBe(false);
    });

    it('rejects a password without an uppercase letter', () => {
        expect(passwordSchema.safeParse('password1!').success).toBe(false);
    });

    it('rejects a password without a digit', () => {
        expect(passwordSchema.safeParse('Password!').success).toBe(false);
    });

    it('rejects a password without a special character', () => {
        expect(passwordSchema.safeParse('Password1').success).toBe(false);
    });
});

describe('setupFormSchema', () => {
    const valid = {
        name: 'Admin',
        email: 'admin@example.com',
        password: 'Password1!',
        confirmPassword: 'Password1!',
        language: 'nl' as const,
    };

    it('accepts valid setup data', () => {
        expect(setupFormSchema.safeParse(valid).success).toBe(true);
    });

    it('rejects when passwords do not match', () => {
        const result = setupFormSchema.safeParse({ ...valid, confirmPassword: 'Different1!' });
        expect(result.success).toBe(false);
    });

    it('rejects empty name', () => {
        expect(setupFormSchema.safeParse({ ...valid, name: '' }).success).toBe(false);
    });

    it('rejects name exceeding 255 characters', () => {
        expect(setupFormSchema.safeParse({ ...valid, name: 'a'.repeat(256) }).success).toBe(false);
    });

    it('rejects invalid email format', () => {
        expect(setupFormSchema.safeParse({ ...valid, email: 'not-an-email' }).success).toBe(false);
    });

    it('rejects empty email', () => {
        expect(setupFormSchema.safeParse({ ...valid, email: '' }).success).toBe(false);
    });

    it('rejects invalid language', () => {
        expect(setupFormSchema.safeParse({ ...valid, language: 'fr' }).success).toBe(false);
    });

    it('accepts "en" as language', () => {
        expect(setupFormSchema.safeParse({ ...valid, language: 'en' }).success).toBe(true);
    });
});

describe('loginFormSchema', () => {
    it('accepts valid login credentials', () => {
        expect(loginFormSchema.safeParse({ email: 'user@example.com', password: 'anypass' }).success).toBe(true);
    });

    it('rejects empty email', () => {
        expect(loginFormSchema.safeParse({ email: '', password: 'pass' }).success).toBe(false);
    });

    it('rejects invalid email format', () => {
        expect(loginFormSchema.safeParse({ email: 'not-email', password: 'pass' }).success).toBe(false);
    });

    it('rejects empty password', () => {
        expect(loginFormSchema.safeParse({ email: 'user@example.com', password: '' }).success).toBe(false);
    });
});

describe('invitationCompleteFormSchema', () => {
    const valid = {
        name: 'New User',
        password: 'Password1!',
        confirmPassword: 'Password1!',
    };

    it('accepts valid invitation completion data', () => {
        expect(invitationCompleteFormSchema.safeParse(valid).success).toBe(true);
    });

    it('rejects when passwords do not match', () => {
        expect(
            invitationCompleteFormSchema.safeParse({ ...valid, confirmPassword: 'Different1!' }).success,
        ).toBe(false);
    });

    it('rejects empty name', () => {
        expect(invitationCompleteFormSchema.safeParse({ ...valid, name: '' }).success).toBe(false);
    });

    it('rejects weak password', () => {
        expect(
            invitationCompleteFormSchema.safeParse({
                ...valid,
                password: 'weak',
                confirmPassword: 'weak',
            }).success,
        ).toBe(false);
    });
});