Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

4.4 KB
Raw Blame
import crypto from 'node:crypto';
import { readFileSync } from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { runInNewContext } from 'node:vm';
import { describe, expect, it, vi } from 'vitest';

const uiDirectory = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../ui_tests');

function loadCommonJS(sourceName, modules, env) {
    const filename = path.join(uiDirectory, sourceName);
    const module = { exports: {} };
    runInNewContext(readFileSync(filename, 'utf8'), {
        module,
        require(name) {
            if (!Object.hasOwn(modules, name)) throw new Error(`Unexpected require: ${name}`);
            return modules[name];
        },
        __dirname: uiDirectory,
        process: { env },
        console: { log() {}, error() {} },
        setTimeout,
        clearTimeout,
    }, { filename });
    return module.exports;
}

function setup(env = { CI: 'true' }) {
    // Keep the real helper's account-selection and timeout behavior. Only the
    // browser operations are replaced, so registering the existing CI user
    // would reproduce the release failure rather than pass this regression.
    const AuthHelper = loadCommonJS('auth_helper.js', { crypto }, env);
    const login = vi.spyOn(AuthHelper.prototype, 'login').mockResolvedValue(true);
    const register = vi.spyOn(AuthHelper.prototype, 'register').mockResolvedValue(true);
    vi.spyOn(AuthHelper.prototype, 'isLoggedIn').mockResolvedValue(false);
    const recoveredPage = { recovered: true };
    vi.spyOn(AuthHelper.prototype, 'getPage').mockReturnValue(recoveredPage);
    const page = { setViewport: vi.fn().mockResolvedValue() };
    const browser = {
        newPage: vi.fn().mockResolvedValue(page),
        close: vi.fn().mockResolvedValue(),
    };
    const { ResponsiveUITester } = loadCommonJS('test_responsive_ui_comprehensive.js', {
        puppeteer: { launch: vi.fn().mockResolvedValue(browser) },
        './auth_helper': AuthHelper,
        './puppeteer_config': { getPuppeteerLaunchOptions: () => ({}) },
        fs: { existsSync: () => true },
        path,
    }, env);
    const tester = new ResponsiveUITester('mobile');
    tester.captureLoginPageScreenshots = vi.fn().mockResolvedValue();
    return { tester, login, register, recoveredPage, AuthHelper, browser };
}

describe('responsive UI authentication', () => {
    it('logs in as the pre-created CI user without re-registering it', async () => {
        const { tester, login, register, recoveredPage, AuthHelper } = setup();

        await tester.init();

        expect(login).toHaveBeenCalledExactlyOnceWith(
            AuthHelper.CI_TEST_USER.username, AuthHelper.CI_TEST_USER.password,
        );
        expect(register).not.toHaveBeenCalled();
        expect(tester.page).toBe(recoveredPage);
    });

    it('retains fresh-user fallback when the CI account is unavailable', async () => {
        const { tester, login, register, AuthHelper } = setup();
        login.mockRejectedValue(new Error('CI account unavailable'));

        await tester.init();

        expect(register).toHaveBeenCalledTimes(1);
        expect(register.mock.calls[0][0]).not.toBe(AuthHelper.CI_TEST_USER.username);
        expect(register.mock.calls[0][0]).toMatch(/^testuser_/);
    });

    it('propagates authentication failures instead of testing unauthenticated pages', async () => {
        const { tester, login, register } = setup();
        login.mockRejectedValue(new Error('CI account unavailable'));
        const failure = new Error('Registration rejected');
        register.mockRejectedValue(failure);

        await expect(tester.init()).rejects.toBe(failure);
    });

    it('still registers a fresh user outside CI', async () => {
        const { tester, login, register } = setup({});

        await tester.init();

        expect(login).not.toHaveBeenCalled();
        expect(register).toHaveBeenCalledTimes(1);
    });

    it('closes the browser when authentication fails before layout checks', async () => {
        const { tester, login, register, browser } = setup();
        login.mockRejectedValue(new Error('CI account unavailable'));
        const failure = new Error('Registration rejected');
        register.mockRejectedValue(failure);
        tester.testPage = vi.fn();

        await expect(tester.runTests()).rejects.toBe(failure);

        expect(tester.testPage).not.toHaveBeenCalled();
        expect(browser.close).toHaveBeenCalledTimes(1);
    });
});