@servicetitan/startup 39.0.1 → 39.2.0

package/src/cli/commands/mfe-publish.ts

@@ -1,3 +1,4 @@
+import { isCI } from '@servicetitan/install';
 import { getPackages, isWebComponent, logErrors, PackageType } from '../../utils';
 import { lernaExec } from '../utils';
 import { entry as mfePackageClean } from './registry/mfe-package-clean';
@@ -5,6 +6,7 @@ import { entry as mfePackagePublish } from './registry/mfe-package-publish';
 import { entry as mfePackageRollback } from './registry/mfe-package-rollback';
 import type { entry } from './registry/mfe-publish';
 import { Command } from './types';
+import { getMfeRegistry, login } from './utils';
 
 type MFEPublishOptions = (typeof entry)['options'] &
     (typeof mfePackagePublish)['options'] &
@@ -25,6 +27,10 @@ export class MFEPublish extends Command<{ options: MFEPublishOptions }> {
             throw new Error('no packages found for publication');
         }
 
+        if (!isCI()) {
+            await login(this.registry);
+        }
+
         const isRollback = !!this.args.rollback;
         const isClean = !!this.args.clean;
 
@@ -48,26 +54,21 @@ export class MFEPublish extends Command<{ options: MFEPublishOptions }> {
         });
     }
 
+    private get registry() {
+        return getMfeRegistry(this.args.registry);
+    }
+
     getPublishOptions() {
-        const {
-            build,
-            branch,
-            dry,
-            force,
-            purgeCache,
-            registry,
-            tag,
-            uploadSourcemaps,
-            trackHistory,
-        } = this.args;
+        const { build, branch, dry, force, purgeCache, tag, uploadSourcemaps, trackHistory } =
+            this.args;
         return [
+            `--registry ${this.registry}`,
             ...[branch && `--branch ${branch}`],
             ...[build && `--build ${build}`],
             ...[dry && '--dry'],
             ...[force && '--force'],
             ...[purgeCache === true && '--purge-cache'],
             ...[purgeCache === false && '--no-purge-cache'],
-            ...[registry && `--registry ${registry}`],
             ...[typeof tag === 'string' && `--tag ${tag}`],
             ...[trackHistory === true && '--track-history'],
             ...[trackHistory === false && '--no-track-history'],
@@ -77,22 +78,22 @@ export class MFEPublish extends Command<{ options: MFEPublishOptions }> {
     }
 
     getRollbackOptions() {
-        const { dry, registry, tag } = this.args;
+        const { dry, tag } = this.args;
         return [
+            `--registry ${this.registry}`,
             ...[dry && '--dry'],
-            ...[registry && `--registry ${registry}`],
             ...[typeof tag === 'string' && `--tag ${tag}`],
         ].filter(item => !!item) as string[];
     }
 
     getCleanOptions() {
-        const { all, branch, count, dry, registry } = this.args;
+        const { all, branch, count, dry } = this.args;
         return [
+            `--registry ${this.registry}`,
             ...[all && '--all'],
             ...[typeof branch === 'string' && `--branch ${branch}`],
             ...[count && `--count ${count}`],
             ...[dry && '--dry'],
-            ...[registry && `--registry ${registry}`],
         ].filter(item => !!item) as string[];
     }
 }

package/src/cli/commands/registry/mfe-list.ts

@@ -1,4 +1,5 @@
 import type { CommandEntry } from '../types';
+import { PROD_MFE_REGISTRY } from '../utils/get-mfe-registry';
 import { defineEntry } from './define-entry';
 
 export const entry = defineEntry({
@@ -19,7 +20,11 @@ export const entry = defineEntry({
             description: 'List only the specified number of published versions',
         },
         packageNames: { array: true, string: true, hidden: true },
-        registry: { string: true, hidden: true },
+        registry: {
+            string: true,
+            description: 'List packages published to the specified registry',
+            defaultDescription: PROD_MFE_REGISTRY,
+        },
         tagged: { boolean: true, description: 'List only tagged versions' },
     },
 } satisfies CommandEntry);

package/src/cli/commands/registry/mfe-package-clean.ts

@@ -1,4 +1,5 @@
 import type { CommandEntry } from '../types';
+import { getMfeRegistry } from '../utils/get-mfe-registry';
 import { defineEntry } from './define-entry';
 
 export const entry = defineEntry({
@@ -22,6 +23,11 @@ export const entry = defineEntry({
             boolean: true,
             description: 'Take no action and only log what would be unpublished',
         },
-        registry: { string: true, hidden: true, description: 'Registry url' },
+        registry: {
+            string: true,
+            hidden: false,
+            description: 'Registry to remove old versions from',
+            defaultDescription: getMfeRegistry(),
+        },
     },
 } satisfies CommandEntry);

package/src/cli/commands/registry/mfe-package-publish.ts

@@ -1,4 +1,5 @@
 import type { CommandEntry } from '../types';
+import { getMfeRegistry } from '../utils/get-mfe-registry';
 import { defineEntry } from './define-entry';
 
 export const entry = defineEntry({
@@ -21,7 +22,12 @@ export const entry = defineEntry({
             boolean: true,
             description: 'Force publishing from an unrecognized branch',
         },
-        registry: { string: true, hidden: true, description: 'Registry url' },
+        registry: {
+            string: true,
+            hidden: false,
+            description: 'Registry to publish to',
+            defaultDescription: getMfeRegistry(),
+        },
         trackHistory: {
             boolean: true,
             description: 'Tag the previous release, to support rollbacks',

package/src/cli/commands/registry/mfe-package-rollback.ts

@@ -1,4 +1,5 @@
 import type { CommandEntry } from '../types';
+import { getMfeRegistry } from '../utils/get-mfe-registry';
 import { defineEntry } from './define-entry';
 
 export const entry = defineEntry({
@@ -9,8 +10,9 @@ export const entry = defineEntry({
         },
         registry: {
             string: true,
-            hidden: true,
-            description: 'Registry url',
+            hidden: false,
+            description: 'Registry to roll back within',
+            defaultDescription: getMfeRegistry(),
         },
         tag: {
             string: true,

package/src/cli/commands/registry/upload-sourcemaps.ts

@@ -4,6 +4,7 @@ import { defineEntry } from './define-entry';
 export const entry = defineEntry({
     options: {
         dry: { boolean: true, description: 'Dry run mode' },
+        registry: { string: true, hidden: true, description: 'Registry url' },
         releaseVersion: {
             string: true,
             demandOption: true,

package/src/cli/commands/upload-sourcemaps.ts

@@ -1,10 +1,10 @@
-import { isCI } from '@servicetitan/install';
 import { execSync } from 'child_process';
 import path from 'path';
 import { getTsConfig, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { TSConfig } from '../utils';
 import type { entry } from './registry/upload-sourcemaps';
 import { Command } from './types';
+import { getUnpkgHost } from './utils';
 
 interface PackageJson {
     name: string;
@@ -29,11 +29,7 @@ export class UploadSourcemaps extends Command<typeof entry> {
 
     private checkArgs() {
         if (!process.env.DATADOG_API_KEY) {
-            const message = 'DATADOG_API_KEY environment variable is not set';
-            if (!isCI()) {
-                throw new Error(message);
-            }
-            log.warning(`${message}; skipping sourcemaps`);
+            log.warning('DATADOG_API_KEY environment variable is not set; skipping sourcemaps');
             return false;
         }
 
@@ -52,7 +48,8 @@ export class UploadSourcemaps extends Command<typeof entry> {
 
     private getMinifiedPrefixPath() {
         const { name } = this.getPackageJson();
-        const baseUrl = `https://unpkg.servicetitan.com/${name}@${this.args.releaseVersion}`;
+        const host = getUnpkgHost(this.args.registry);
+        const baseUrl = `${host}/${name}@${this.args.releaseVersion}`;
         return `${baseUrl}/${this.getBundleDir().replace(/\\/g, '/')}`;
     }
 

package/src/cli/commands/utils/__tests__/get-mfe-registry.test.ts

@@ -0,0 +1,24 @@
+import { PROD_MFE_REGISTRY, getMfeRegistry } from '../get-mfe-registry';
+
+describe(`[startup] ${getMfeRegistry.name}`, () => {
+    let registry: string | undefined;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        registry = undefined;
+    });
+
+    const subject = () => getMfeRegistry(registry);
+
+    test('returns the production registry', () => {
+        expect(subject()).toBe(PROD_MFE_REGISTRY);
+    });
+
+    describe('with an explicit registry', () => {
+        beforeEach(() => (registry = 'https://foo.com'));
+
+        test('returns the specified registry', () => {
+            expect(subject()).toBe(registry);
+        });
+    });
+});

package/src/cli/commands/utils/__tests__/get-unpkg-host.test.ts

@@ -0,0 +1,32 @@
+import { DEV_MFE_REGISTRY, getMfeRegistry, PROD_MFE_REGISTRY } from '../get-mfe-registry';
+import { getUnpkgHost } from '../get-unpkg-host';
+
+jest.mock('../get-mfe-registry', () => ({
+    ...jest.requireActual('../get-mfe-registry'),
+    getMfeRegistry: jest.fn(),
+}));
+
+describe(`[startup] ${getUnpkgHost.name}`, () => {
+    const registry = 'http://foo.com';
+
+    const subject = () => getUnpkgHost(registry);
+
+    test('fetches MFE registry', () => {
+        subject();
+
+        expect(getMfeRegistry).toHaveBeenCalledWith(registry);
+    });
+
+    describe.each([
+        [DEV_MFE_REGISTRY, 'https://unpkg.st.dev'],
+        [PROD_MFE_REGISTRY, 'https://unpkg.servicetitan.com'],
+    ])('when the MFE registry is %s', (mfeRegistry, expected) => {
+        beforeEach(() => {
+            jest.mocked(getMfeRegistry).mockImplementation(() => mfeRegistry);
+        });
+
+        test(`returns ${expected}`, () => {
+            expect(subject()).toBe(expected);
+        });
+    });
+});

package/src/cli/commands/utils/__tests__/login.test.ts

@@ -0,0 +1,122 @@
+import { npmWhoAmI } from '@servicetitan/install';
+import { createInterface } from 'readline/promises';
+import { isTTY, runCommand } from '../../../utils';
+import { DEV_MFE_REGISTRY, PROD_MFE_REGISTRY } from '../get-mfe-registry';
+import { login } from '../login';
+
+jest.mock('@servicetitan/install');
+jest.mock('readline/promises', () => ({ createInterface: jest.fn() }));
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    isTTY: jest.fn(),
+    runCommand: jest.fn(),
+}));
+
+describe(`[startup] ${login.name}`, () => {
+    const readline = { question: jest.fn(), close: jest.fn() };
+    let answer: string;
+    let registry: string;
+    let user: string | undefined;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        answer = 'Y';
+        registry = PROD_MFE_REGISTRY;
+        user = undefined;
+        jest.mocked(readline.question).mockImplementation(() => Promise.resolve(answer));
+        jest.mocked(createInterface).mockReturnValue(readline as any);
+        jest.mocked(npmWhoAmI).mockImplementation(() => user);
+        jest.mocked(isTTY).mockReturnValue(true);
+    });
+
+    const subject = () => login(registry);
+
+    test('prompts to authorize the machine', async () => {
+        await subject();
+
+        expect(readline.question).toHaveBeenCalledWith(
+            expect.stringMatching(/machine is not authorized.*Authorize\? \[Y\/n\]/)
+        );
+    });
+
+    test('closes the prompt', async () => {
+        await subject();
+
+        expect(readline.close).toHaveBeenCalled();
+    });
+
+    function itAuthorizesTheMachine() {
+        test('authorizes the machine against the registry', async () => {
+            await subject();
+
+            expect(runCommand).toHaveBeenCalledWith(
+                `npx --yes verdaccio-okta-oauth@latest --registry=${registry}`,
+                { quiet: true }
+            );
+        });
+    }
+
+    itAuthorizesTheMachine();
+
+    describe('when user does not answer', () => {
+        beforeEach(() => (answer = ''));
+
+        itAuthorizesTheMachine();
+    });
+
+    describe('when user declines', () => {
+        beforeEach(() => (answer = 'n'));
+
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow(/Not authorized/);
+        });
+    });
+
+    describe('when terminal is not interactive', () => {
+        beforeEach(() => jest.mocked(isTTY).mockReturnValue(false));
+
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow(/machine is not authorized/);
+        });
+    });
+
+    function itSkipsPrompt() {
+        test('skips the prompt', async () => {
+            await subject();
+
+            expect(readline.question).not.toHaveBeenCalled();
+        });
+    }
+
+    describe('when machine is already authorized', () => {
+        beforeEach(() => (user = 'someone'));
+
+        itSkipsPrompt();
+    });
+
+    describe(`when the registry is ${DEV_MFE_REGISTRY}`, () => {
+        beforeEach(() => (registry = DEV_MFE_REGISTRY));
+
+        itAuthorizesTheMachine();
+    });
+
+    describe('with an unrecognized registry', () => {
+        beforeEach(() => (registry = 'https://foo.com'));
+
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow(/is not recognized/);
+        });
+
+        test('does not attempt oauth', async () => {
+            await expect(subject()).rejects.toThrow();
+
+            expect(runCommand).not.toHaveBeenCalled();
+        });
+
+        describe('when machine is already authorized', () => {
+            beforeEach(() => (user = 'someone'));
+
+            itSkipsPrompt();
+        });
+    });
+});

package/src/cli/commands/utils/__tests__/purge-cache.test.ts

@@ -1,40 +1,42 @@
 import { runCommandOutput } from '../../../utils';
+import { getUnpkgHost } from '../get-unpkg-host';
 import { purgeCache } from '../purge-cache';
 
+jest.mock('@servicetitan/install', () => ({ isCI: jest.fn() }));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     runCommandOutput: jest.fn(),
 }));
+jest.mock('../get-unpkg-host', () => ({
+    getUnpkgHost: jest.fn(),
+}));
 
 describe(purgeCache.name, () => {
-    let args: Parameters<typeof purgeCache>[0];
+    const unpkgHost = 'https://foo.com';
     const packageName = '@servicetitan/foo';
+    const registry = 'https://bar.com';
     const tag = 'prod';
+    let args: Parameters<typeof purgeCache>[0];
 
     beforeEach(() => {
         jest.clearAllMocks();
-        args = { packageName, tag };
+        jest.mocked(getUnpkgHost).mockReturnValue(unpkgHost);
+        args = { packageName, registry, tag };
     });
 
     const subject = () => purgeCache(args);
 
-    test('runs mfe-purge-cache with host "https://unpkg.servicetitan.com", package name and tag', () => {
+    test('fetches host for registry', () => {
         subject();
 
-        expect(runCommandOutput).toHaveBeenCalledWith(
-            `npx startup mfe-purge-cache --host https://unpkg.servicetitan.com --package-name ${packageName} --tag ${tag}`
-        );
+        expect(getUnpkgHost).toHaveBeenCalledWith(registry);
     });
 
-    describe('when registry is "https://verdaccio.st.dev"', () => {
-        beforeEach(() => (args.registry = 'https://verdaccio.st.dev'));
-
-        test('runs mfe-purge-cache with host "https://unpkg.st.dev"', () => {
-            subject();
+    test('runs mfe-purge-cache', () => {
+        subject();
 
-            expect(runCommandOutput).toHaveBeenCalledWith(
-                expect.stringContaining(`--host https://unpkg.st.dev`)
-            );
-        });
+        expect(runCommandOutput).toHaveBeenCalledWith(
+            `npx startup mfe-purge-cache --host ${unpkgHost} --package-name ${packageName} --tag ${tag}`
+        );
     });
 });

package/src/cli/commands/utils/get-mfe-registry.ts

@@ -0,0 +1,6 @@
+export const PROD_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';
+export const DEV_MFE_REGISTRY = 'https://verdaccio.st.dev';
+
+export function getMfeRegistry(registry?: string): string {
+    return registry ?? PROD_MFE_REGISTRY;
+}

package/src/cli/commands/utils/get-unpkg-host.ts

@@ -0,0 +1,8 @@
+import { DEV_MFE_REGISTRY, getMfeRegistry } from './get-mfe-registry';
+
+const PROD_UNPKG_HOST = 'https://unpkg.servicetitan.com';
+const DEV_UNPKG_HOST = 'https://unpkg.st.dev';
+
+export function getUnpkgHost(registry?: string): string {
+    return getMfeRegistry(registry) === DEV_MFE_REGISTRY ? DEV_UNPKG_HOST : PROD_UNPKG_HOST;
+}

package/src/cli/commands/utils/index.ts

@@ -1,3 +1,5 @@
 export * from './build-rollback-tag';
-export * from './constants';
+export * from './get-mfe-registry';
+export * from './get-unpkg-host';
+export * from './login';
 export * from './purge-cache';

package/src/cli/commands/utils/login.ts

@@ -0,0 +1,38 @@
+import { npmWhoAmI } from '@servicetitan/install';
+import chalk from 'chalk';
+import readline from 'readline/promises';
+import { isTTY, runCommand } from '../../utils';
+import { DEV_MFE_REGISTRY, PROD_MFE_REGISTRY } from './get-mfe-registry';
+
+const OKTA_REGISTRIES: string[] = [PROD_MFE_REGISTRY, DEV_MFE_REGISTRY];
+
+export async function login(registry: string) {
+    if (npmWhoAmI({ registry }) !== undefined) {
+        return;
+    }
+
+    if (!OKTA_REGISTRIES.includes(registry)) {
+        throw new Error(`Registry ${registry} is not recognized. Please log in manually.`);
+    }
+
+    const message = `This machine is not authorized to access ${registry}.`;
+    if (!isTTY()) {
+        throw new Error(message);
+    }
+
+    const answer = await ask(chalk.bold.cyan(`${message} Authorize? [Y/n] `));
+    if (answer && answer !== 'y') {
+        throw new Error('Not authorized');
+    }
+
+    await runCommand(`npx --yes verdaccio-okta-oauth@latest --registry=${registry}`, {
+        quiet: true,
+    });
+}
+
+async function ask(question: string) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question(question);
+    rl.close();
+    return answer.trim().toLowerCase();
+}

package/src/cli/commands/utils/purge-cache.ts

@@ -1,12 +1,9 @@
 import { runCommandOutput } from '../../utils';
-
-const DEV_MFE_REGISTRY = 'https://verdaccio.st.dev';
-const DEFAULT_UNPKG_HOST = 'https://unpkg.servicetitan.com';
-const DEV_UNPKG_HOST = 'https://unpkg.st.dev';
+import { getUnpkgHost } from './get-unpkg-host';
 
 export function purgeCache(options: { packageName: string; registry?: string; tag: string }) {
     const { packageName, registry, tag } = options;
-    const host = registry === DEV_MFE_REGISTRY ? DEV_UNPKG_HOST : DEFAULT_UNPKG_HOST;
+    const host = getUnpkgHost(registry);
     runCommandOutput(
         `npx startup mfe-purge-cache --host ${host} --package-name ${packageName} --tag ${tag}`
     );

package/src/cli/index.ts

@@ -40,7 +40,8 @@ function addCommand(name: CommandName, y: typeof yargs) {
     const { description, options: { _, ...options } = {} } = entry;
     const nameWithArgs = name + (_?.description ? ` ${_.description}` : '');
     const groupedOptions = Object.entries(options).reduce((result, [key, value]) => {
-        result[kebabCase(key)] = { group: 'Command Options:', ...value };
+        const suffix = /\W+$/.exec(key)?.[0] ?? ''; // fix for kebabCase dropping `\u00A0` suffixes
+        result[kebabCase(key) + suffix] = { group: 'Command Options:', ...value };
         return result;
     }, {} as CommandOptions);
     const handler = (argv: any) => handleCommand(name, argv);

package/src/vite/__tests__/build-escaped-reg-exp.test.ts

@@ -0,0 +1,25 @@
+import { buildEscapedRegExp } from '../build-escaped-reg-exp';
+
+describe('buildEscapedRegExp', () => {
+    test.each(['react', '@servicetitan/startup-utils', 'react-refresh/runtime'])(
+        'matches %s exactly',
+        specifier => {
+            expect(buildEscapedRegExp(specifier).test(specifier)).toBe(true);
+        }
+    );
+
+    test.each([
+        ['lodash.throttle', 'lodashxthrottle'],
+        ['lodash.throttle', 'lodash.throttle/extra'],
+        ['react', 'react-dom'],
+        ['react', 'preact'],
+    ])('built from %s does not match %s', (specifier, other) => {
+        expect(buildEscapedRegExp(specifier).test(other)).toBe(false);
+    });
+
+    /* Unescaped, a backslash would turn the next character into an escape sequence. */
+    test('escapes backslashes rather than emitting them raw', () => {
+        expect(buildEscapedRegExp('we\\d').test('we\\d')).toBe(true);
+        expect(buildEscapedRegExp('we\\d').test('we5')).toBe(false);
+    });
+});

package/src/vite/build-escaped-reg-exp.ts

@@ -0,0 +1,6 @@
+/*
+ * Dots are the only regex-special character valid in a package name; the
+ * backslash is escaped because it is the escape character itself.
+ */
+export const buildEscapedRegExp = (specifier: string) =>
+    new RegExp(`^${specifier.replace(/[\\.]/g, '\\$&')}$`);

package/src/vite/config/__tests__/base-config.test.ts

@@ -102,7 +102,7 @@ describe(createBaseConfig.name, () => {
         context = {
             build: { isProduction: false },
             options: {},
-            package: { isWebComponent: false, destination: 'dist/bundle/full' },
+            package: { isWebComponent: false, destination: 'dist/bundle/full', source: 'src' },
             bundlerConfig: {
                 omitDefault: [],
                 minify: {},

package/src/vite/config/__tests__/create-resolve-config.test.ts

@@ -0,0 +1,85 @@
+import { createRequire } from 'module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { buildEscapedRegExp } from '../../build-escaped-reg-exp';
+import { ViteBuildContext } from '../../types';
+import { createResolveConfig } from '../create-resolve-config';
+
+jest.mock('module', () => ({
+    ...jest.requireActual('module'),
+    createRequire: jest.fn(() => ({ resolve: jest.fn() })),
+}));
+
+describe(`[startup] ${createResolveConfig.name}`, () => {
+    let startupRequire: { resolve: (specifier: string) => string };
+    let context: Partial<ViteBuildContext>;
+    let specifiers: string[];
+
+    beforeAll(() => {
+        startupRequire = jest.mocked(createRequire).mock.results[0].value;
+    });
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.mocked(startupRequire.resolve).mockImplementation(() => {
+            throw new Error('Module not found');
+        });
+        const source = fs.mkdtempSync(path.join(os.tmpdir(), 'create-resolve-config-'));
+        context = { package: { source } as any };
+        specifiers = ['a', '@b/c'];
+    });
+
+    afterEach(() => fs.rmSync(context.package!.source, { recursive: true, force: true }));
+
+    function mockNodeModules(root: string, modules: string[]) {
+        modules.forEach(name => {
+            const dir = path.join(root, 'node_modules', ...name.split('/'));
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(path.join(dir, 'index.js'), '');
+        });
+    }
+
+    const subject = () =>
+        createResolveConfig(context as any, specifiers) as {
+            alias: { find: RegExp; replacement: string }[];
+        };
+
+    test('throws error', () => {
+        expect(() => subject()).toThrow(/cannot resolve/i);
+    });
+
+    describe('when specifier is resolvable', () => {
+        beforeEach(() => mockNodeModules(context.package!.source, specifiers));
+
+        test('does nothing', () => {
+            expect(subject().alias).toEqual([]);
+        });
+    });
+
+    describe('when specifier is resolvable from startup', () => {
+        beforeEach(() => {
+            jest.mocked(startupRequire.resolve).mockImplementation(
+                (specifier: string) => `startup/${specifier}`
+            );
+        });
+
+        test('emits alias', () => {
+            const { alias } = subject();
+
+            specifiers.forEach(specifier => {
+                expect(alias.find(({ find }) => find.test(specifier))?.replacement).toEqual(
+                    `startup/${specifier}`
+                );
+            });
+        });
+
+        test('alias matches whole specifier', () => {
+            const { alias } = subject();
+
+            specifiers.forEach((specifier, i) =>
+                expect(alias[i].find).toEqual(buildEscapedRegExp(specifier))
+            );
+        });
+    });
+});