@sovovs/bycli 1.8.0 → 2.1.0

package/clis/reddit/subscribed.test.js

@@ -1,168 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError, LoginWallError } from '@sovovs/bycli/errors';
-import { parseRedditSubscribedLimit, unwrapEvaluateResult } from './subscribed.js';
-import './subscribed.js';
-
-function subredditThing(id, overrides = {}) {
-    const displayName = `sub${id}`;
-    return {
-        kind: 't5',
-        data: {
-            id,
-            name: `t5_${id}`,
-            display_name: displayName,
-            display_name_prefixed: `r/${displayName}`,
-            title: `Sub ${id}`,
-            subscribers: 1000,
-            public_description: `Description ${id}`,
-            url: `/r/${displayName}/`,
-            ...overrides,
-        },
-    };
-}
-
-function makePage(result) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue(result),
-    };
-}
-
-describe('reddit subscribed adapter', () => {
-    const command = getRegistry().get('reddit/subscribed');
-
-    it('registers with id-bearing output columns', () => {
-        expect(command).toBeDefined();
-        expect(command.columns).toEqual(['id', 'subreddit', 'title', 'subscribers', 'description', 'url']);
-    });
-
-    it('parseRedditSubscribedLimit rejects out-of-range values without silent clamp', () => {
-        expect(parseRedditSubscribedLimit(undefined)).toBe(100);
-        expect(parseRedditSubscribedLimit(null)).toBe(100);
-        expect(parseRedditSubscribedLimit('')).toBe(100);
-        expect(parseRedditSubscribedLimit(1)).toBe(1);
-        expect(parseRedditSubscribedLimit(1000)).toBe(1000);
-        for (const bad of [0, -1, 1001, 1.5, NaN, 'abc']) {
-            expect(() => parseRedditSubscribedLimit(bad)).toThrow(ArgumentError);
-        }
-    });
-
-    it('rejects bad limit before navigation', async () => {
-        const page = makePage({ kind: 'ok', entries: [] });
-        await expect(command.func(page, { limit: 1001 })).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-        expect(page.evaluate).not.toHaveBeenCalled();
-    });
-
-    it('unwraps Browser Bridge envelopes', () => {
-        const inner = { kind: 'ok', entries: [] };
-        expect(unwrapEvaluateResult({ session: 'browser:default', data: inner })).toBe(inner);
-        expect(unwrapEvaluateResult(inner)).toBe(inner);
-    });
-
-    it('returns subscribed subreddits from the browser-evaluated payload', async () => {
-        const page = makePage({
-            kind: 'ok',
-            entries: [
-                subredditThing('abc', {
-                    display_name: 'programming',
-                    display_name_prefixed: 'r/programming',
-                    title: 'Programming',
-                    subscribers: 6000000,
-                    public_description: 'All things code',
-                    url: '/r/programming/',
-                }),
-                subredditThing('def', {
-                    display_name: 'MachineLearning',
-                    display_name_prefixed: 'r/MachineLearning',
-                    title: 'Machine Learning',
-                    subscribers: 3000000,
-                    public_description: 'ML research',
-                    url: '/r/MachineLearning/',
-                }),
-            ],
-        });
-        const result = await command.func(page, { limit: 100 });
-        expect(page.goto).toHaveBeenCalledWith('https://www.reddit.com');
-        expect(result).toEqual([
-            { id: 't5_abc', subreddit: 'r/programming', title: 'Programming', subscribers: 6000000, description: 'All things code', url: 'https://www.reddit.com/r/programming/' },
-            { id: 't5_def', subreddit: 'r/MachineLearning', title: 'Machine Learning', subscribers: 3000000, description: 'ML research', url: 'https://www.reddit.com/r/MachineLearning/' },
-        ]);
-    });
-
-    it('throws AuthRequiredError when not logged in', async () => {
-        await expect(command.func(makePage({ kind: 'auth', detail: 'login required' }), { limit: 100 }))
-            .rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('surfaces HTTP, malformed, exception, and unexpected envelopes as CommandExecutionError', async () => {
-        await expect(command.func(makePage({ kind: 'http', httpStatus: 429, where: '/subreddits/mine/subscriptions.json?limit=100' }), { limit: 100 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-        await expect(command.func(makePage({ kind: 'malformed', detail: 'missing data.children' }), { limit: 100 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-        await expect(command.func(makePage({ kind: 'exception', detail: 'network' }), { limit: 100 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-        await expect(command.func(makePage({ ok: true }), { limit: 100 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('converts a browser-side login-wall sentinel into a typed LoginWallError', async () => {
-        const sentinel = {
-            __loginWall: true,
-            status: 200,
-            url: 'https://www.reddit.com/api/me.json?raw_json=1',
-            contentType: 'text/html; charset=utf-8',
-            bodyPreview: '<!DOCTYPE html><html><head><title>reddit.com: over 18?</title>',
-        };
-        const page = makePage({ kind: 'login-wall', sentinel, where: '/api/me.json' });
-        try {
-            await command.func(page, { limit: 100 });
-            throw new Error('expected LoginWallError, got success');
-        } catch (err) {
-            expect(err).toBeInstanceOf(LoginWallError);
-            expect(err.status).toBe(200);
-            expect(err.url).toBe('/api/me.json');
-            expect(err.bodyPreview).toContain('reddit.com: over 18');
-        }
-    });
-
-    it('throws EmptyResultError for a valid empty subscriptions list', async () => {
-        await expect(command.func(makePage({ kind: 'ok', entries: [] }), { limit: 100 }))
-            .rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError when rows lack subreddit identity', async () => {
-        await expect(command.func(makePage({ kind: 'ok', entries: [subredditThing('abc', { name: '', id: '', display_name: '', display_name_prefixed: '', url: '' })] }), { limit: 100 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('does not synthesize subreddit identity from a non-t5 listing item', async () => {
-        await expect(command.func(makePage({
-            kind: 'ok',
-            entries: [{
-                kind: 't3',
-                data: {
-                    id: 'abc',
-                    display_name: 'notasub',
-                    display_name_prefixed: 'r/notasub',
-                    url: '/r/notasub/',
-                },
-            }],
-        }), { limit: 100 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('respects --limit by slicing the final result', async () => {
-        const page = makePage({ kind: 'ok', entries: Array.from({ length: 5 }, (_, i) => subredditThing(String(i))) });
-        const result = await command.func(page, { limit: 3 });
-        expect(result).toHaveLength(3);
-        expect(result[0].subreddit).toBe('r/sub0');
-    });
-
-    it('embeds the validated limit literally in the browser script', async () => {
-        const page = makePage({ kind: 'ok', entries: [subredditThing('x')] });
-        await command.func(page, { limit: 7 });
-        const script = page.evaluate.mock.calls[0][0];
-        expect(script).toContain('const target = 7');
-    });
-});

package/clis/reddit/whoami.test.js

@@ -1,105 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
-import './whoami.js';
-
-function makePage(result) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue(result),
-    };
-}
-
-describe('reddit whoami command', () => {
-    const command = getRegistry().get('reddit/whoami');
-
-    it('registers with the expected shape', () => {
-        expect(command).toBeDefined();
-        expect(command.access).toBe('read');
-        expect(command.browser).toBe(true);
-        expect(command.columns).toEqual(['field', 'value']);
-        expect(command.args).toEqual([]);
-    });
-
-    it('throws AuthRequiredError on 401/403 from /api/me.json', async () => {
-        const page = makePage({ kind: 'auth', detail: 'Reddit /api/me.json returned HTTP 401' });
-        await expect(command.func(page, {})).rejects.toBeInstanceOf(AuthRequiredError);
-        expect(page.goto).toHaveBeenCalledWith('https://www.reddit.com');
-    });
-
-    it('throws AuthRequiredError on 200 with missing data.name (stale anon session)', async () => {
-        const page = makePage({ kind: 'auth', detail: 'Not logged in to reddit.com (no identity in /api/me.json)' });
-        await expect(command.func(page, {})).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('throws CommandExecutionError on HTTP / exception failure modes', async () => {
-        await expect(command.func(makePage({ kind: 'http', httpStatus: 500, where: '/api/me.json' }), {}))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-        await expect(command.func(makePage({ kind: 'exception', detail: 'bad json' }), {}))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('maps a full identity payload into the field/value rows', async () => {
-        const identity = {
-            name: 'alice',
-            id: 'abcdef',
-            link_karma: 1234,
-            comment_karma: 5678,
-            total_karma: 6912,
-            created_utc: 1577836800, // 2020-01-01
-            is_gold: true,
-            is_mod: false,
-            has_verified_email: true,
-            has_mail: false,
-            inbox_count: 0,
-        };
-        const page = makePage({ kind: 'ok', identity });
-        const rows = await command.func(page, {});
-
-        const byField = Object.fromEntries(rows.map((r) => [r.field, r.value]));
-        expect(byField.Username).toBe('u/alice');
-        expect(byField.ID).toBe('t2_abcdef');
-        expect(byField['Post Karma']).toBe('1234');
-        expect(byField['Comment Karma']).toBe('5678');
-        expect(byField['Total Karma']).toBe('6912');
-        expect(byField['Account Created']).toBe('2020-01-01');
-        expect(byField.Gold).toBe('Yes');
-        expect(byField.Mod).toBe('No');
-        expect(byField['Verified Email']).toBe('Yes');
-        expect(byField['Has Mail']).toBe('No');
-        expect(byField['Inbox Count']).toBe('0');
-
-        // Row shape must match the declared columns exactly so the
-        // silent-column-drop audit can't be triggered.
-        for (const row of rows) {
-            expect(Object.keys(row).sort()).toEqual(['field', 'value']);
-        }
-    });
-
-    it('falls back to null for missing numeric karma fields rather than 0 sentinels', async () => {
-        const identity = {
-            name: 'bob',
-            id: 'xyz',
-            created_utc: null,
-            is_gold: false,
-            is_mod: false,
-            has_verified_email: false,
-            has_mail: false,
-        };
-        const page = makePage({ kind: 'ok', identity });
-        const rows = await command.func(page, {});
-        const byField = Object.fromEntries(rows.map((r) => [r.field, r.value]));
-        expect(byField['Post Karma']).toBeNull();
-        expect(byField['Comment Karma']).toBeNull();
-        expect(byField['Total Karma']).toBeNull();
-        expect(byField['Account Created']).toBeNull();
-        expect(byField['Inbox Count']).toBeNull();
-    });
-
-    it('does not throw on `data.name` present even if optional booleans are missing', async () => {
-        const identity = { name: 'carol', id: 'i1' };
-        const page = makePage({ kind: 'ok', identity });
-        const rows = await command.func(page, {});
-        expect(rows[0]).toEqual({ field: 'Username', value: 'u/carol' });
-    });
-});

package/clis/rednote/navigation.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './note.js';
-import './comments.js';
-import './download.js';
-import './feed.js';
-import './notifications.js';
-import './search.js';
-import './user.js';
-
-describe('rednote navigateBefore hardening', () => {
-    const expectedFalse = [
-        'rednote/note',
-        'rednote/comments',
-        'rednote/download',
-        'rednote/feed',
-        'rednote/notifications',
-        'rednote/search',
-        'rednote/user',
-    ];
-    it.each(expectedFalse)('%s sets navigateBefore=false', (name) => {
-        const cmd = getRegistry().get(name);
-        expect(cmd).toBeDefined();
-        expect(cmd.navigateBefore).toBe(false);
-    });
-});

package/clis/rednote/rednote.test.js

@@ -1,222 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const { mockDownloadMedia, mockFormatCookieHeader } = vi.hoisted(() => ({
-    mockDownloadMedia: vi.fn(),
-    mockFormatCookieHeader: vi.fn(() => 'sid=secret'),
-}));
-
-vi.mock('@sovovs/bycli/download/media-download', () => ({
-    downloadMedia: mockDownloadMedia,
-}));
-
-vi.mock('@sovovs/bycli/download', () => ({
-    formatCookieHeader: mockFormatCookieHeader,
-}));
-
-import { getRegistry } from '@sovovs/bycli/registry';
-import './comments.js';
-import './download.js';
-import './feed.js';
-import './notifications.js';
-import './note.js';
-import './search.js';
-import './user.js';
-
-function createPageMock(evaluateResult) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue(evaluateResult),
-        wait: vi.fn().mockResolvedValue(undefined),
-        autoScroll: vi.fn().mockResolvedValue(undefined),
-        getCookies: vi.fn().mockResolvedValue([{ name: 'sid', value: 'secret', domain: 'www.rednote.com' }]),
-    };
-}
-function createSearchPageMock(evaluateResults) {
-    const page = createPageMock(undefined);
-    page.evaluate = vi.fn();
-    for (const result of evaluateResults) {
-        page.evaluate.mockResolvedValueOnce(result);
-    }
-    return page;
-}
-
-describe('rednote note URL identity', () => {
-    const download = getRegistry().get('rednote/download');
-    const comments = getRegistry().get('rednote/comments');
-
-    beforeEach(() => {
-        mockDownloadMedia.mockReset();
-        mockDownloadMedia.mockResolvedValue([{ index: 1, type: 'image', status: 'success', size: '1 KB' }]);
-        mockFormatCookieHeader.mockClear();
-    });
-
-    it('rejects xhslink short links before browser navigation', async () => {
-        const page = createPageMock({ media: [] });
-        await expect(download.func(page, {
-            'note-id': 'https://xhslink.com/o/4MKEjsZnhCz',
-            output: './out',
-        })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('signed URL'),
-            hint: expect.stringContaining('rednote.com'),
-        });
-        expect(page.goto).not.toHaveBeenCalled();
-        expect(mockDownloadMedia).not.toHaveBeenCalled();
-    });
-
-    it('rejects signed xiaohongshu URLs before browser navigation', async () => {
-        const page = createPageMock({ media: [] });
-        await expect(comments.func(page, {
-            'note-id': 'https://www.xiaohongshu.com/search_result/69aadbcb000000002202f131?xsec_token=abc',
-            limit: 20,
-        })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('signed URL'),
-            hint: expect.stringContaining('rednote.com'),
-        });
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('uses URL-scoped rednote cookies when downloading media', async () => {
-        const page = createPageMock({
-            noteId: '69bc166f000000001a02069a',
-            media: [{ type: 'image', url: 'https://ci.rednote.com/example.jpg' }],
-        });
-        await download.func(page, {
-            'note-id': 'https://www.rednote.com/search_result/69bc166f000000001a02069a?xsec_token=abc',
-            output: './out',
-        });
-        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://www.rednote.com' });
-        expect(mockDownloadMedia).toHaveBeenCalledWith([{ type: 'image', url: 'https://ci.rednote.com/example.jpg' }], expect.objectContaining({
-            cookies: 'sid=secret',
-            subdir: '69bc166f000000001a02069a',
-        }));
-    });
-
-    it('throws empty-result instead of returning a failed success row when no media exists', async () => {
-        const page = createPageMock({ noteId: '69bc166f000000001a02069a', media: [] });
-        let caught;
-        try {
-            await download.func(page, {
-                'note-id': 'https://www.rednote.com/search_result/69bc166f000000001a02069a?xsec_token=abc',
-                output: './out',
-            });
-        }
-        catch (error) {
-            caught = error;
-        }
-        expect(caught).toMatchObject({ code: 'EMPTY_RESULT' });
-        expect(caught?.hint).toContain('No downloadable media');
-        expect(mockDownloadMedia).not.toHaveBeenCalled();
-    });
-});
-
-describe('rednote argument validation', () => {
-    const comments = getRegistry().get('rednote/comments');
-    const feed = getRegistry().get('rednote/feed');
-    const notifications = getRegistry().get('rednote/notifications');
-    const user = getRegistry().get('rednote/user');
-
-    it.each([
-        ['rednote/comments', comments, { 'note-id': 'https://www.rednote.com/search_result/69aadbcb000000002202f131?xsec_token=abc', limit: 0 }],
-        ['rednote/feed', feed, { limit: 0 }],
-        ['rednote/notifications', notifications, { limit: 0 }],
-        ['rednote/user', user, { id: 'user123', limit: 0 }],
-    ])('%s rejects invalid --limit before browser navigation', async (_name, command, kwargs) => {
-        const page = createPageMock({});
-        await expect(command.func(page, kwargs)).rejects.toMatchObject({ code: 'ARGUMENT' });
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('rejects unknown notification types before browser navigation', async () => {
-        const page = createPageMock({});
-        await expect(notifications.func(page, { type: 'all', limit: 20 })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: expect.stringContaining('--type'),
-        });
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-});
-
-describe('rednote search browser-bridge envelopes', () => {
-    const search = getRegistry().get('rednote/search');
-
-    it('unwraps login-wall wait result envelopes before auth handling', async () => {
-        const page = createSearchPageMock([
-            { session: 'site:rednote', data: 'login_wall' },
-        ]);
-
-        await expect(search.func(page, { query: 'tesla', limit: 5 })).rejects.toMatchObject({
-            code: 'AUTH_REQUIRED',
-            message: expect.stringContaining('blocked behind a login wall'),
-        });
-        expect(page.evaluate).toHaveBeenCalledTimes(1);
-    });
-
-    it('unwraps search extraction envelopes and preserves rednote row shape', async () => {
-        const url = 'https://www.rednote.com/search_result/68e90be80000000004022e66?xsec_token=test-token';
-        const page = createSearchPageMock([
-            'content',
-            1,
-            {
-                session: 'site:rednote',
-                data: [{
-                    title: 'rednote result',
-                    author: 'author',
-                    likes: '12',
-                    url,
-                    author_url: 'https://www.rednote.com/user/profile/u1',
-                }],
-            },
-        ]);
-
-        await expect(search.func(page, { query: 'tesla', limit: 1 })).resolves.toEqual([{
-            rank: 1,
-            title: 'rednote result',
-            author: 'author',
-            likes: '12',
-            published_at: '2025-10-10',
-            url,
-            author_url: 'https://www.rednote.com/user/profile/u1',
-        }]);
-    });
-
-    it('fails typed instead of silently returning [] for malformed extraction payloads', async () => {
-        const page = createSearchPageMock([
-            'content',
-            1,
-            { session: 'site:rednote', data: { rows: [] } },
-        ]);
-
-        await expect(search.func(page, { query: 'tesla', limit: 1 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('payload shape'),
-        });
-    });
-});
-
-describe('rednote Pinia store failures', () => {
-    it('maps feed store read failure to CommandExecutionError', async () => {
-        const command = getRegistry().get('rednote/feed');
-        const page = createPageMock({ error: 'no_pinia' });
-        await expect(command.func(page, { limit: 20 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('no_pinia'),
-        });
-    });
-
-    it('maps notification action failure to CommandExecutionError', async () => {
-        const command = getRegistry().get('rednote/notifications');
-        const page = createPageMock({ error: 'action_failed', detail: 'blocked' });
-        await expect(command.func(page, { type: 'mentions', limit: 20 })).rejects.toMatchObject({
-            code: 'COMMAND_EXEC',
-            message: expect.stringContaining('action_failed'),
-        });
-    });
-
-    it('allows an empty notification list after a successful store read', async () => {
-        const command = getRegistry().get('rednote/notifications');
-        const page = createPageMock({ items: [] });
-        await expect(command.func(page, { type: 'mentions', limit: 20 })).resolves.toEqual([]);
-    });
-});

package/clis/rest-countries/rest-countries.test.js

@@ -1,83 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-import './country.js';
-import './region.js';
-
-afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.restoreAllMocks();
-});
-
-describe('rest-countries country adapter', () => {
-    const cmd = getRegistry().get('rest-countries/country');
-
-    it('rejects bad args before fetching', async () => {
-        const fetchMock = vi.fn();
-        vi.stubGlobal('fetch', fetchMock);
-        await expect(cmd.func({ name: '' })).rejects.toThrow(ArgumentError);
-        await expect(cmd.func({ name: 'japan', limit: 9999 })).rejects.toThrow(ArgumentError);
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-
-    it('maps HTTP 429 to CommandExecutionError', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('throttled', { status: 429 })));
-        await expect(cmd.func({ name: 'japan' })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('maps HTTP 404 to EmptyResultError', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('not found', { status: 404 })));
-        await expect(cmd.func({ name: 'no-country-by-this-name' })).rejects.toThrow(EmptyResultError);
-    });
-
-    it('round-trips cca3 from row into restcountries.com alpha URL', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify([
-            {
-                name: { common: 'Japan', official: 'Japan' },
-                cca2: 'JP', cca3: 'JPN', ccn3: '392',
-                capital: ['Tokyo'],
-                region: 'Asia', subregion: 'Eastern Asia',
-                population: 125000000, area: 377000,
-                languages: { jpn: 'Japanese' },
-                currencies: { JPY: { name: 'Japanese yen', symbol: '¥' } },
-                latlng: [36, 138], timezones: ['UTC+09:00'], independent: true, unMember: true, landlocked: false, flag: '🇯🇵',
-            },
-        ]), { status: 200 })));
-        const rows = await cmd.func({ name: 'japan', limit: 5 });
-        expect(rows[0]).toMatchObject({
-            rank: 1, commonName: 'Japan', cca2: 'JP', cca3: 'JPN',
-            capital: 'Tokyo', region: 'Asia',
-            languages: 'Japanese', currencies: 'JPY (Japanese yen)',
-            latitude: 36, longitude: 138,
-            url: 'https://restcountries.com/v3.1/alpha/jpn',
-        });
-    });
-});
-
-describe('rest-countries region adapter', () => {
-    const cmd = getRegistry().get('rest-countries/region');
-
-    it('rejects unknown regions before fetching', async () => {
-        const fetchMock = vi.fn();
-        vi.stubGlobal('fetch', fetchMock);
-        await expect(cmd.func({ region: '' })).rejects.toThrow(ArgumentError);
-        await expect(cmd.func({ region: 'middle-earth' })).rejects.toThrow(ArgumentError);
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-
-    it('throws EmptyResultError on empty payload', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify([]), { status: 200 })));
-        await expect(cmd.func({ region: 'oceania' })).rejects.toThrow(EmptyResultError);
-    });
-
-    it('sorts by population descending so largest country is rank 1', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify([
-            { name: { common: 'Tuvalu' }, cca3: 'TUV', population: 12000 },
-            { name: { common: 'Australia' }, cca3: 'AUS', population: 26000000 },
-            { name: { common: 'Fiji' }, cca3: 'FJI', population: 900000 },
-        ]), { status: 200 })));
-        const rows = await cmd.func({ region: 'oceania' });
-        expect(rows.map((r) => r.commonName)).toEqual(['Australia', 'Fiji', 'Tuvalu']);
-        expect(rows[0]).toMatchObject({ cca3: 'AUS', url: 'https://restcountries.com/v3.1/alpha/aus' });
-    });
-});