repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
quickshell/nuguland/features/launcher/launch.test.js
Rawconst assert = require('assert');
const L = require('./launch.js');
assert.deepStrictEqual(L.prefixIntent('=2+2'), { intent: 'app', query: '=2+2' });
assert.deepStrictEqual(L.prefixIntent('firefox'), { intent: 'app', query: 'firefox' });
assert.strictEqual(L.normalize(' Déjà Dup '), 'deja dup', 'accents and case fold');
assert.deepStrictEqual(L.queryTerms(' Sys MON '), ['sys', 'mon']);
const apps = L.buildApps([
{
id: 'gimp',
name: 'GIMP',
icon: 'gimp',
comment: 'Image editor',
genericName: 'Image Editor',
categories: ['Graphics'],
keywords: ['paint', 'photo']
},
{
id: 'firefox',
name: 'Firefox',
icon: 'firefox-icon',
genericName: 'Web Browser',
categories: ['Network'],
keywords: ['web', 'browser'],
actions: [
{ id: 'new-window', name: 'New Window', icon: 'window-new', command: ['firefox', '--new-window'] },
{ id: 'private-window', name: 'Private Window', command: ['firefox', '--private-window'] }
]
}
]);
assert.deepStrictEqual(apps.map(a => a.title), ['Firefox', 'GIMP']);
assert.strictEqual(apps[0].icon, 'firefox-icon');
assert.strictEqual(apps[0].id, 'app:firefox');
assert.strictEqual(apps[0].desktopPath, 'firefox.desktop');
assert.strictEqual(apps[0].subtitle, 'Web Browser · Network');
assert.strictEqual(apps[0].details[0].value, 'Network');
assert.strictEqual(apps[0].details[1].value, 'web; browser');
assert.strictEqual(apps[0].actions[0].title, 'New Window');
assert.strictEqual(apps[0].actions[0].id, 'new-window');
assert.ok(L.buildApps([{ id: 'noname' }]).length === 0);
const titleRank = L.rankResults('Firefox', { apps });
assert.strictEqual(titleRank.providerIntent, 'app');
assert.strictEqual(titleRank.selectedIndex, 0);
assert.strictEqual(titleRank.results[0].title, 'Firefox');
assert.strictEqual(titleRank.results[0].provider, 'app');
assert.strictEqual(titleRank.results[0].icon, 'firefox-icon');
assert.strictEqual(titleRank.results[0].search, undefined, 'matching data stays out of results');
const keywordRank = L.rankResults('browser', { apps });
assert.deepStrictEqual(keywordRank.results.map(r => r.title), ['Firefox']);
const emptyRank = L.rankResults('', { apps });
assert.strictEqual(emptyRank.selectedIndex, 0);
assert.deepStrictEqual(emptyRank.results.map(r => r.title), ['Firefox', 'GIMP']);
assert.deepStrictEqual(L.rankResults('zzz', { apps }).results, []);
// Tiers on synthetic names: one app per tier, so the order is the tier order.
const tier = row => Math.floor(row.score / 1000);
const titles = (query, list, extra) => L.rankResults(query, Object.assign({ apps: list }, extra)).results.map(r => r.title);
function tierOf(query, name, fields) {
const built = L.buildApps([Object.assign({ id: 'x', name }, fields)]);
const result = L.rankResults(query, { apps: built }).results[0];
return result ? tier(result) : 0;
}
assert.strictEqual(tierOf('visual studio code', 'Visual Studio Code'), L.TIER.exact);
assert.strictEqual(tierOf('visual', 'Visual Studio Code'), L.TIER.prefix);
assert.strictEqual(tierOf('studio', 'Visual Studio Code'), L.TIER.word);
assert.strictEqual(tierOf('monitor', 'System Monitor'), L.TIER.word, 'a whole word is found, not the m of system');
assert.strictEqual(tierOf('term', 'WezTerm'), L.TIER.word, 'camelCase starts a word');
assert.strictEqual(tierOf('d-bus', 'Qt D-Bus Viewer'), L.TIER.word);
assert.strictEqual(tierOf('udi', 'Visual Studio Code'), L.TIER.substring);
assert.strictEqual(tierOf('vsc', 'Visual Studio Code'), L.TIER.initials);
assert.strictEqual(tierOf('wt', 'WezTerm'), L.TIER.initials, 'camelCase humps are initials');
assert.strictEqual(tierOf('wztm', 'WezTerm'), L.TIER.fuzzy, 'tight fuzzy over the name');
assert.strictEqual(tierOf('vsco', 'Visual Studio Code'), 0, 'scattered characters are dropped');
assert.strictEqual(tierOf('set', 'Easy Effects'), 0, 'loose subsequence no longer matches');
assert.strictEqual(tierOf('deja', 'Déjà Dup'), L.TIER.prefix, 'an unaccented query matches an accented name');
assert.strictEqual(tierOf('déjà', 'Deja Dup'), L.TIER.prefix, 'an accented query matches an unaccented name');
assert.strictEqual(tierOf('e', 'Steam'), 0, 'one character matches only at a word start');
assert.strictEqual(tierOf('editor', 'Zed', { genericName: 'Text Editor' }), L.TIER.other);
assert.strictEqual(tierOf('dit', 'Zed', { genericName: 'Text Editor' }), 0, 'other fields only match at word starts');
assert.strictEqual(tierOf('code', 'Zed', { comment: 'A multiplayer code editor.' }), L.TIER.other, 'comment words count');
assert.strictEqual(tierOf('wezterm', 'Terminal', { id: 'org.wezfurlong.wezterm' }), L.TIER.other, 'desktop id words count');
assert.strictEqual(tierOf('code visual', 'Visual Studio Code'), L.TIER.word, 'terms match in any order');
assert.strictEqual(tierOf('code zzz', 'Visual Studio Code'), 0, 'every term must match');
assert.strictEqual(tierOf('visual editor', 'Visual Studio Code', { genericName: 'Text Editor' }), L.TIER.other, 'the weakest term sets the tier');
const synthetic = L.buildApps([
{ id: 'code', name: 'Visual Studio Code', genericName: 'Text Editor', keywords: ['vscode'] },
{ id: 'monitor', name: 'Monitor Tool' },
{ id: 'sysmon', name: 'System Monitor' },
{ id: 'helper', name: 'Helper', genericName: 'Monitor' }
]);
assert.deepStrictEqual(titles('monitor', synthetic), ['Monitor Tool', 'System Monitor', 'Helper'], 'prefix > word > other field');
assert.deepStrictEqual(titles('code visual', synthetic), ['Visual Studio Code']);
assert.deepStrictEqual(titles('vsc', synthetic), ['Visual Studio Code']);
// The installed-apps snapshot: 70 desktop entries of the owner's machine (2026-11-14).
const installed = L.buildApps(require('./fixtures/installed-apps.json'));
assert.strictEqual(installed.length, 70);
const top = (query, extra) => titles(query, installed, extra);
assert.ok(['Easy Effects', 'Volume Control'].includes(top('audio')[0]), 'audio finds an audio app first');
assert.ok(!top('audio').includes('Qt Assistant'), 'audio no longer matches qt assistant');
assert.deepStrictEqual(top('calc'), [], 'no calculator is installed, so calc matches nothing');
assert.strictEqual(top('monitor')[0], 'btop++', 'monitor finds the system monitor first');
assert.ok(!top('monitor').includes('Alloy Modelling IDE'));
assert.deepStrictEqual(top('code'), ['Zed'], 'code finds the code editor, not nextcloud');
assert.strictEqual(top('term')[0], 'WezTerm');
assert.strictEqual(top('sys mon')[0], 'btop++');
assert.deepStrictEqual(top('shell java 21'), ['OpenJDK Java 21 Shell'], 'multi-word terms in any order');
assert.deepStrictEqual(top('deja'), ['Déjà Dup Backups']);
assert.strictEqual(tier(L.rankResults('deja', { apps: installed }).results[0]), L.TIER.prefix, 'the accented name itself matches');
assert.deepStrictEqual(top('yfm'), ['Yazi File Manager'], 'initials');
assert.deepStrictEqual(top('hgl'), ['Heroic Games Launcher'], 'initials');
assert.ok(top('set').length <= 6, `set matches ${top('set').length} of 70`);
assert.ok(top('e').length <= 24, `e matches ${top('e').length} of 70`);
for (const query of ['audio', 'monitor', 'term', 'file', 'web', 'java', 'qt', 'e', 'sys mon', 'set']) {
const scores = L.rankResults(query, { apps: installed }).results.map(tier);
assert.deepStrictEqual(scores, scores.slice().sort((a, b) => b - a), `${query}: a stronger tier never ranks below a weaker one`);
}
// Frecency with injected time.
const day = 24 * 60 * 60 * 1000;
const t0 = Date.UTC(2026, 10, 14);
assert.strictEqual(L.HALF_LIFE_MS, 7 * day);
assert.strictEqual(L.frecencyScore(undefined, t0), 0);
assert.strictEqual(L.frecencyScore({ score: 1, at: t0 }, t0 + 7 * day), 0.5, 'one half-life halves the score');
assert.strictEqual(L.frecencyScore({ score: 4, at: t0 }, t0 + 14 * day), 1);
let store = L.recordLaunch({}, 'firefox', t0);
store = L.recordLaunch(store, 'firefox', t0 + 7 * day);
assert.strictEqual(L.frecencyScore(store.firefox, t0 + 7 * day), 1.5, 'a launch adds 1 to the decayed score');
store = L.recordLaunch(store, 'gimp', t0 + 70 * day);
assert.deepStrictEqual(Object.keys(store), ['gimp'], 'apps decayed below the floor are forgotten');
const frecent = { 'jshell-java25-openjdk': { score: 2, at: t0 }, 'jconsole-java-openjdk': { score: 1, at: t0 }, 'dev.zellij.Zellij': { score: 50, at: t0 } };
assert.deepStrictEqual(top('java', { frecency: frecent, now: t0 }).slice(0, 2), ['OpenJDK Java 25 Shell', 'OpenJDK Java 27 Console'], 'frecency orders apps inside one tier');
assert.strictEqual(top('java', { frecency: frecent, now: t0 + 365 * day })[0], 'OpenJDK Java 21 Console', 'decayed frecency falls back to title order');
assert.deepStrictEqual(top('term', { frecency: frecent, now: t0 }).slice(0, 2), ['WezTerm', 'Zellij'], 'frecency never lifts a weaker tier, but leads inside its own');
const wordTier = L.buildApps([{ id: 'a', name: 'Alpha Term' }, { id: 'g', name: 'Gamma Term' }, { id: 'l', name: 'Longer Name Term' }]);
assert.deepStrictEqual(titles('term', wordTier), ['Alpha Term', 'Gamma Term', 'Longer Name Term'], 'match quality, then title');
assert.deepStrictEqual(titles('term', wordTier, { frecency: { g: { score: 0.1, at: t0 } }, now: t0 }), ['Gamma Term', 'Alpha Term', 'Longer Name Term'], 'frecency breaks ties');
assert.deepStrictEqual(titles('term', wordTier, { frecency: { l: { score: 1, at: t0 } }, now: t0 })[0], 'Longer Name Term', 'inside a tier frecency outranks match quality');
const empty = top('', { frecency: frecent, now: t0 });
assert.strictEqual(empty.length, 70);
assert.deepStrictEqual(empty.slice(0, 3), ['Zellij', 'OpenJDK Java 25 Shell', 'OpenJDK Java 27 Console'], 'empty query: frecent apps first by frecency');
assert.deepStrictEqual(empty.slice(3), installed.map(a => a.title).filter(t => !['Zellij', 'OpenJDK Java 25 Shell', 'OpenJDK Java 27 Console'].includes(t)), 'then the rest in title order');
assert.strictEqual(L.frecencyScore({ score: 1, at: t0 }, t0 + 35 * day), 0, 'a month without launches forgets an app');
const roundTrip = L.parseFrecency(L.serializeFrecency(store));
assert.deepStrictEqual(roundTrip, store, 'persistence round trip');
assert.deepStrictEqual(L.parseFrecency('not json'), {});
assert.deepStrictEqual(L.parseFrecency(''), {});
console.log('launch.test.js: ALL PASS');