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.

16.9 KB
Raw Blame
/**
 * Test for autocomplete selection behavior
 * Tests that clicking on autocomplete suggestions properly selects the item
 * for both LLM model and search engine dropdowns
 */

const puppeteer = require('puppeteer');
const AuthHelper = require('./auth_helper');

// Default timeout for tests
const TEST_TIMEOUT = 30000;

// Test configuration
const config = {
    baseUrl: process.env.BASE_URL || 'http://127.0.0.1:5000',
    headless: process.env.HEADLESS !== 'false',
    slowMo: parseInt(process.env.SLOW_MO || '0', 10),
    devtools: process.env.DEVTOOLS === 'true'
};

// Function to run tests when file is executed directly
async function runTests() {
    let browser;
    let allTestsPassed = true;

    try {
        console.log('\n📋 Autocomplete Selection Tests\n');
        console.log(`Configuration: headless=${config.headless}, baseUrl=${config.baseUrl}\n`);

        browser = await puppeteer.launch({
            headless: config.headless,
            slowMo: config.slowMo,
            devtools: config.devtools,
            args: [
                '--no-sandbox',
                '--disable-setuid-sandbox',
                '--disable-dev-shm-usage',
                '--disable-web-security',
                '--disable-features=IsolateOrigins,site-per-process'
            ]
        });

        // Test 1: LLM model autocomplete selection
        console.log('🧪 Test 1: Should select LLM model from autocomplete when clicked');
        try {
            const page = await browser.newPage();
            await page.setViewport({ width: 1280, height: 800 });
            const authHelper = new AuthHelper(page, config.baseUrl);
            page.setDefaultTimeout(TEST_TIMEOUT);

            await authHelper.ensureAuthenticated();
            await page.goto(`${config.baseUrl}/`, { waitUntil: 'domcontentloaded' });

            // Wait for and click the model input
            await page.waitForSelector('#model', { visible: true });
            await page.click('#model');

            // Wait for dropdown to appear
            await page.waitForSelector('#model-dropdown-list', { visible: true });
            await page.waitForSelector('.ldr-custom-dropdown-item', { visible: true });

            const dropdownItems = await page.$$('.ldr-custom-dropdown-item');
            console.log(`  Found ${dropdownItems.length} model options`);

            if (dropdownItems.length > 0) {
                // Get the first item's text
                const firstItemText = await page.evaluate(el => el.textContent, dropdownItems[0]);

                // Clear input and type part of the model name
                await page.evaluate(() => { document.getElementById('model').value = ''; });
                const searchText = firstItemText.substring(0, Math.min(3, firstItemText.length));
                await page.type('#model', searchText);
                console.log(`  Typed "${searchText}" to filter models`);

                await new Promise(resolve => setTimeout(resolve, 500));

                // Check if dropdown is still visible
                const dropdownVisible = await page.evaluate(() => {
                    const dropdown = document.getElementById('model-dropdown-list');
                    return dropdown && window.getComputedStyle(dropdown).display !== 'none';
                });

                if (!dropdownVisible) {
                    console.log('  Dropdown closed, reopening...');
                    await page.click('#model');
                    await page.waitForSelector('#model-dropdown-list', { visible: true });
                }

                // Click the first filtered item
                const filteredItems = await page.$$('.ldr-custom-dropdown-item');
                if (filteredItems.length > 0) {
                    const itemToClick = await page.evaluate(el => el.textContent, filteredItems[0]);
                    console.log(`  Clicking on: "${itemToClick}"`);
                    await filteredItems[0].click();
                    await new Promise(resolve => setTimeout(resolve, 500));

                    // Check the selected value
                    const selectedModel = await page.evaluate(() => document.getElementById('model').value);
                    const hiddenValue = await page.evaluate(() => {
                        const hidden = document.getElementById('model_hidden');
                        return hidden ? hidden.value : null;
                    });

                    console.log(`  Display value: "${selectedModel}"`);
                    console.log(`  Hidden value: "${hiddenValue}"`);

                    if (selectedModel && selectedModel !== searchText) {
                        console.log('  ✅ Model autocomplete selection works correctly');
                    } else {
                        console.log('  ❌ Model was not properly selected from autocomplete');
                        console.log('     Issue confirmed: Clicking autocomplete does not select the item');
                        allTestsPassed = false;
                    }
                } else {
                    console.log('  ⚠️ No filtered items found');
                }
            } else {
                console.log('  ⚠️ No model options available');
            }

            await page.close();
        } catch (error) {
            console.error(`  ❌ Test failed: ${error.message}`);
            allTestsPassed = false;
        }

        // Test 2: Search engine autocomplete selection
        console.log('\n🧪 Test 2: Should select search engine from autocomplete when clicked');
        try {
            const page = await browser.newPage();
            await page.setViewport({ width: 1280, height: 800 });
            const authHelper = new AuthHelper(page, config.baseUrl);
            page.setDefaultTimeout(TEST_TIMEOUT);

            await authHelper.ensureAuthenticated();
            await page.goto(`${config.baseUrl}/`, { waitUntil: 'domcontentloaded' });

            // Wait for and click the search engine input
            await page.waitForSelector('#search_engine', { visible: true });
            await page.click('#search_engine');

            // Wait for dropdown to appear
            await page.waitForSelector('#search-engine-dropdown-list', { visible: true });

            await page.waitForFunction(() => {
                const items = document.querySelectorAll('#search-engine-dropdown-list .ldr-custom-dropdown-item');
                return items.length > 0;
            });

            const dropdownItems = await page.$$('#search-engine-dropdown-list .ldr-custom-dropdown-item');
            console.log(`  Found ${dropdownItems.length} search engine options`);

            if (dropdownItems.length > 0) {
                // Get the first item's text
                const firstItemText = await page.evaluate(el => el.textContent, dropdownItems[0]);

                // Clear input and type part of the search engine name
                await page.evaluate(() => { document.getElementById('search_engine').value = ''; });
                const searchText = firstItemText.substring(0, Math.min(3, firstItemText.length));
                await page.type('#search_engine', searchText);
                console.log(`  Typed "${searchText}" to filter search engines`);

                await new Promise(resolve => setTimeout(resolve, 500));

                // Click the first filtered item
                const filteredItems = await page.$$('#search-engine-dropdown-list .ldr-custom-dropdown-item');
                if (filteredItems.length > 0) {
                    const itemToClick = await page.evaluate(el => el.textContent, filteredItems[0]);
                    console.log(`  Clicking on: "${itemToClick}"`);
                    await filteredItems[0].click();
                    await new Promise(resolve => setTimeout(resolve, 500));

                    // Check the selected value
                    const selectedEngine = await page.evaluate(() => document.getElementById('search_engine').value);
                    const hiddenValue = await page.evaluate(() => {
                        const hidden = document.getElementById('search_engine_hidden');
                        return hidden ? hidden.value : null;
                    });

                    console.log(`  Display value: "${selectedEngine}"`);
                    console.log(`  Hidden value: "${hiddenValue}"`);

                    if (selectedEngine && selectedEngine !== searchText) {
                        console.log('  ✅ Search engine autocomplete selection works correctly');
                    } else {
                        console.log('  ❌ Search engine was not properly selected from autocomplete');
                        console.log('     Issue confirmed: Clicking autocomplete does not select the item');
                        allTestsPassed = false;
                    }
                } else {
                    console.log('  ⚠️ No filtered items found');
                }
            } else {
                console.log('  ⚠️ No search engine options available');
            }

            await page.close();
        } catch (error) {
            console.error(`  ❌ Test failed: ${error.message}`);
            allTestsPassed = false;
        }

        // Test 3: Keyboard navigation
        console.log('\n🧪 Test 3: Should verify keyboard navigation works for selection');
        try {
            const page = await browser.newPage();
            await page.setViewport({ width: 1280, height: 800 });
            const authHelper = new AuthHelper(page, config.baseUrl);
            page.setDefaultTimeout(TEST_TIMEOUT);

            await authHelper.ensureAuthenticated();
            await page.goto(`${config.baseUrl}/`, { waitUntil: 'domcontentloaded' });

            // Test with model dropdown
            await page.waitForSelector('#model', { visible: true });
            await page.click('#model');
            await page.waitForSelector('#model-dropdown-list .ldr-custom-dropdown-item', { visible: true });

            const itemCount = await page.evaluate(() => {
                return document.querySelectorAll('#model-dropdown-list .ldr-custom-dropdown-item').length;
            });
            console.log(`  Found ${itemCount} items in dropdown`);

            if (itemCount > 0) {
                // Use arrow key to navigate
                await page.keyboard.press('ArrowDown');

                // Check if first item is highlighted
                const firstItemActive = await page.evaluate(() => {
                    const items = document.querySelectorAll('#model-dropdown-list .ldr-custom-dropdown-item');
                    return items[0] && items[0].classList.contains('active');
                });
                console.log(`  First item highlighted: ${firstItemActive}`);

                // Press Enter to select
                await page.keyboard.press('Enter');
                await new Promise(resolve => setTimeout(resolve, 500));

                // Check the selected value
                const selectedModel = await page.evaluate(() => document.getElementById('model').value);

                if (selectedModel) {
                    console.log(`  ✅ Keyboard navigation selected: "${selectedModel}"`);
                } else {
                    console.log('  ❌ Keyboard navigation failed to select');
                    allTestsPassed = false;
                }
            }

            await page.close();
        } catch (error) {
            console.error(`  ❌ Test failed: ${error.message}`);
            allTestsPassed = false;
        }

        // Test 4: Type and Enter behavior (typed text that does not exactly
        // match a known option label or value is preserved as custom text)
        console.log('\n🧪 Test 4: Type and immediate Enter (unmatched text is preserved)');
        try {
            const page = await browser.newPage();
            await page.setViewport({ width: 1280, height: 800 });
            const authHelper = new AuthHelper(page, config.baseUrl);
            page.setDefaultTimeout(TEST_TIMEOUT);

            await authHelper.ensureAuthenticated();
            await page.goto(`${config.baseUrl}/`, { waitUntil: 'domcontentloaded' });

            // Open model dropdown
            await page.waitForSelector('#model', { visible: true });
            await page.click('#model');
            await page.waitForSelector('#model-dropdown-list .ldr-custom-dropdown-item', { visible: true });

            // Get a model name to type
            const firstModelText = await page.evaluate(() => {
                const firstItem = document.querySelector('#model-dropdown-list .ldr-custom-dropdown-item');
                return firstItem ? firstItem.textContent : null;
            });

            if (firstModelText) {
                // Derive the prefix from the TRIMMED label, and require that
                // prefix to itself have no leading/trailing whitespace.
                // custom_dropdown.js's Enter handler trims the typed text
                // before comparing or committing it, so a fixed-length cut
                // that happens to land on whitespace inside the label (e.g.
                // "phi4 (Ollama)".substring(0, 5) === "phi4 ") gets rewritten
                // by that trim -- correctly -- which would otherwise make
                // this equality check fail on a correct build. Skip the
                // check rather than fail when the prefix isn't strict in
                // that sense; only assert equality when trimming cannot
                // alter what was typed.
                const trimmedLabel = firstModelText.trim();
                const searchText = trimmedLabel.substring(0, Math.min(5, trimmedLabel.length));
                const isStrictPrefix = searchText.length > 0 && searchText === searchText.trim();

                if (!isStrictPrefix) {
                    console.log(`  ⚠️ Skipping: prefix "${searchText}" of "${trimmedLabel}" is not a strict prefix after trimming`);
                } else {
                    // Clear and type part of the model name
                    await page.evaluate(() => { document.getElementById('model').value = ''; });
                    await page.type('#model', searchText);
                    console.log(`  Typed "${searchText}"`);

                    await new Promise(resolve => setTimeout(resolve, 300));

                    // Press Enter without using arrow keys
                    await page.keyboard.press('Enter');
                    await new Promise(resolve => setTimeout(resolve, 500));

                    // Check what was selected
                    const selectedValue = await page.evaluate(() => document.getElementById('model').value);

                    if (selectedValue === searchText) {
                        console.log(`  ✅ Enter kept the typed custom text: "${selectedValue}"`);
                        console.log('  📝 A typed prefix that does not exactly match a known option');
                        console.log('     label or value is preserved as-is, enabling free-text custom');
                        console.log('     model entry.');
                    } else {
                        console.log(`  ❌ Enter did not preserve the typed text; got: "${selectedValue}"`);
                        console.log('     Expected the typed prefix to remain untouched, since it does not');
                        console.log('     exactly match a known option label or value.');
                        allTestsPassed = false;
                    }
                }
            }

            await page.close();
        } catch (error) {
            console.error(`  ❌ Test failed: ${error.message}`);
            allTestsPassed = false;
        }

    } catch (error) {
        console.error(`\n❌ Test suite failed: ${error.message}`);
        allTestsPassed = false;
    } finally {
        if (browser) {
            await browser.close();
        }

        console.log('\n' + '='.repeat(60));
        console.log('📊 Test Summary:');
        console.log('  - Model autocomplete: Tests if clicking selects the item');
        console.log('  - Search engine autocomplete: Tests if clicking selects the item');
        console.log('  - Keyboard navigation: Tests arrow key + Enter selection');
        console.log('  - Type and Enter: Unmatched typed text is preserved, not silently replaced');
        console.log('='.repeat(60));

        if (allTestsPassed) {
            console.log('✅ All tests completed successfully\n');
            process.exit(0);
        } else {
            console.log('❌ One or more autocomplete selection checks failed\n');
            console.log('Review the ❌ lines above for which check failed and why -- each');
            console.log('test logs its own expectation next to the value it observed.\n');
            process.exit(1);
        }
    }
}

// Run tests if this file is executed directly
if (require.main === module) {
    runTests().catch(error => {
        console.error('Fatal error:', error);
        process.exit(1);
    });
}

module.exports = { runTests };