@blotch/dolan 22.2.2 → 22.2.3

package/dist/commands/update.test.js

@@ -20,6 +20,12 @@ vi.mock('@clack/prompts', () => ({
     cancel: vi.fn(),
     isCancel: vi.fn().mockReturnValue(false),
 }));
+// Vitest's stdin isn't a terminal, which reads as "nobody can answer". Most
+// tests are about the questions, so they run as if in one.
+let interactive = true;
+vi.mock('../utils/interactive.js', () => ({
+    isInteractive: () => interactive,
+}));
 let fixture;
 vi.mock('../utils/resolve-paths.js', () => ({
     getUiSourceDir: () => fixture.uiDir,
@@ -27,7 +33,16 @@ vi.mock('../utils/resolve-paths.js', () => ({
     getComponentFiles: (name) => readdirSync(join(fixture.uiDir, 'components', name)).filter((f) => f.endsWith('.ts')),
     rewriteImports: (content) => content,
 }));
+// The install step runs the project's package manager; record calls instead.
+const installComponentPackages = vi.fn();
+vi.mock('./install-packages.js', () => ({
+    installComponentPackages: (...args) => installComponentPackages(...args),
+}));
 beforeEach(() => {
+    interactive = true;
+    // Each test sees only its own calls. Without this, an assertion could pass
+    // on a message an earlier test logged.
+    vi.clearAllMocks();
     vi.spyOn(process, 'exit').mockImplementation((code) => {
         throw new Error(`process.exit(${code})`);
     });
@@ -91,28 +106,28 @@ describe('updateCommand --selective', () => {
     it('handles mixed decisions across multiple files', async () => {
         const cardOriginal = 'export const Card = { v: 1 };';
         const cardUpstream = 'export const Card = { v: 2 };';
-        const spinnerOriginal = 'export const Spinner = { v: 1 };';
-        const spinnerUpstream = 'export const Spinner = { v: 2 };';
+        const skeletonOriginal = 'export const Skeleton = { v: 1 };';
+        const skeletonUpstream = 'export const Skeleton = { v: 2 };';
         const cardHash = hashContent(cardOriginal);
-        const spinnerHash = hashContent(spinnerOriginal);
+        const skeletonHash = hashContent(skeletonOriginal);
         fixture = createFixture({
             config: DEFAULT_CONFIG,
             lockfile: {
                 version: 1,
                 components: {
                     card: { 'card.ts': { hash: cardHash } },
-                    spinner: { 'spinner.ts': { hash: spinnerHash } },
+                    skeleton: { 'skeleton.ts': { hash: skeletonHash } },
                 },
                 utils: {},
                 theme: {},
             },
             components: {
                 card: { 'card.ts': cardOriginal },
-                spinner: { 'spinner.ts': spinnerOriginal },
+                skeleton: { 'skeleton.ts': skeletonOriginal },
             },
             uiSource: {
                 card: { 'card.ts': cardUpstream },
-                spinner: { 'spinner.ts': spinnerUpstream },
+                skeleton: { 'skeleton.ts': skeletonUpstream },
             },
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
@@ -124,11 +139,11 @@ describe('updateCommand --selective', () => {
         await updateCommand({ selective: true });
         // Card should be updated (first select → upstream)
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(cardUpstream);
-        // Spinner should be skipped (second select → keep)
-        expect(readInstalledFile(fixture.dir, 'spinner', 'spinner.ts')).toBe(spinnerOriginal);
+        // Skeleton should be skipped (second select → keep)
+        expect(readInstalledFile(fixture.dir, 'skeleton', 'skeleton.ts')).toBe(skeletonOriginal);
         const lockfile = readLockfile(fixture.dir);
         expect(lockfile.components.card['card.ts'].hash).toBe(hashContent(cardUpstream));
-        expect(lockfile.components.spinner['spinner.ts'].hash).toBe(spinnerHash);
+        expect(lockfile.components.skeleton['skeleton.ts'].hash).toBe(skeletonHash);
     });
     it('does not create new-upstream file when user chooses skip', async () => {
         const upstream = 'export const Card = {};';
@@ -136,7 +151,7 @@ describe('updateCommand --selective', () => {
             config: DEFAULT_CONFIG,
             lockfile: {
                 version: 1,
-                components: {},
+                components: { card: {} },
                 utils: {},
                 theme: {},
             },
@@ -169,7 +184,6 @@ describe('updateCommand --selective', () => {
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true, selective: true });
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
@@ -219,7 +233,6 @@ describe('updateCommand --selective', () => {
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
         p.confirm.mockResolvedValue(true);
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({});
         expect(p.confirm).toHaveBeenCalled();
@@ -306,8 +319,6 @@ describe('updateCommand --force', () => {
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.select.mockClear();
-        p.confirm.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true });
         // Local edit discarded, file reset to upstream.
@@ -337,7 +348,6 @@ describe('updateCommand --force', () => {
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true });
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
@@ -345,14 +355,14 @@ describe('updateCommand --force', () => {
         const lockfile = readLockfile(fixture.dir);
         expect(lockfile.components.card['card.ts'].hash).toBe(hashContent(upstream));
     });
-    it('overwrites a drifted file with no lockfile entry (unknown base → conflict)', async () => {
+    it('overwrites a drifted file with no lockfile hash (unknown base → conflict)', async () => {
         // With no stored hash the base is unknown, so any local difference is
         // treated as a conflict. --force must still overwrite it.
         const userVersion = 'export const Card = { v: 1, local: true };';
         const upstream = 'export const Card = { v: 2 };';
         fixture = createFixture({
             config: DEFAULT_CONFIG,
-            lockfile: { version: 1, components: {}, utils: {}, theme: {} },
+            lockfile: { version: 1, components: { card: {} }, utils: {}, theme: {} },
             components: { card: { 'card.ts': userVersion } },
             uiSource: { card: { 'card.ts': upstream } },
         });
@@ -477,25 +487,25 @@ describe('updateCommand --force', () => {
                 version: 1,
                 components: {
                     card: { 'card.ts': { hash: hashContent('card-base') } },
-                    spinner: { 'spinner.ts': { hash: hashContent('spinner-base') } },
+                    skeleton: { 'skeleton.ts': { hash: hashContent('skeleton-base') } },
                 },
                 utils: {},
                 theme: {},
             },
             components: {
                 card: { 'card.ts': 'card-local' },
-                spinner: { 'spinner.ts': 'spinner-local' },
+                skeleton: { 'skeleton.ts': 'skeleton-local' },
             },
             uiSource: {
                 card: { 'card.ts': 'card-upstream' },
-                spinner: { 'spinner.ts': 'spinner-upstream' },
+                skeleton: { 'skeleton.ts': 'skeleton-upstream' },
             },
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true });
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe('card-upstream');
-        expect(readInstalledFile(fixture.dir, 'spinner', 'spinner.ts')).toBe('spinner-upstream');
+        expect(readInstalledFile(fixture.dir, 'skeleton', 'skeleton.ts')).toBe('skeleton-upstream');
     });
     it('does not delete untracked local files sitting alongside components', async () => {
         // Force overwrites tracked files but must not touch files the registry
@@ -635,8 +645,6 @@ describe('updateCommand --force', () => {
         seedTheme(fixture, 'default.css', 'theme-local'); // theme conflict
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.select.mockClear();
-        p.confirm.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({ force: true });
         expect(p.select).not.toHaveBeenCalled();
@@ -781,8 +789,6 @@ describe('updateCommand — config / no-op paths', () => {
         });
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
-        p.confirm.mockClear();
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({});
         // Nothing prompts — a lone user-modified file with no force/selective is
@@ -874,7 +880,6 @@ describe('updateCommand — config / no-op paths', () => {
         vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
         const p = await import('@clack/prompts');
         p.confirm.mockResolvedValueOnce(true);
-        p.select.mockClear();
         const { updateCommand } = await import('./update');
         await updateCommand({});
         expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(cardUpstream);
@@ -888,15 +893,15 @@ describe('updateCommand — config / no-op paths', () => {
         // The already up-to-date theme file's hash is still recorded.
         expect(lockfile.theme['default.css'].hash).toBe(hashContent(themeContent));
     });
-    it('advances the lockfile for an up-to-date component and theme file with no prior lockfile entries', async () => {
-        // Neither the component nor the theme file has ANY lockfile record at
-        // all (not just a missing hash) — buildLockfile() must create fresh
-        // entries for both from scratch on the "nothing to do" fast path.
+    it('advances the lockfile for an up-to-date component with no file hashes and a theme file with no entry', async () => {
+        // The component is tracked without file hashes, and the theme file has
+        // no lockfile record at all — buildLockfile() must create fresh entries
+        // for both on the "nothing to do" fast path.
         const cardContent = 'export const Card = {};';
         const themeContent = ':root { --primary: rgba(1, 1, 1, 1); }';
         fixture = createFixture({
             config: DEFAULT_CONFIG,
-            lockfile: { version: 1, components: {}, utils: {}, theme: {} },
+            lockfile: { version: 1, components: { card: {} }, utils: {}, theme: {} },
             components: { card: { 'card.ts': cardContent } },
             uiSource: { card: { 'card.ts': cardContent } },
             themeFiles: { 'default.css': themeContent },
@@ -1230,4 +1235,241 @@ describe('updateCommand — selective review of shared theme files', () => {
         expect(lockfile.theme['default.css'].hash).toBe(hashContent(upstream));
     });
 });
+describe('updateCommand dependencies', () => {
+    it("adds a dependency a component's new version needs, and its packages", async () => {
+        // line-chart used to stand alone; upstream it now builds on chart, which
+        // the project doesn't have yet.
+        const lineChart = "import { UiChart } from '../chart/chart';";
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: {
+                    'line-chart': { 'line-chart.ts': { hash: hashContent('old') } },
+                },
+                utils: {},
+                theme: {},
+            },
+            components: { 'line-chart': { 'line-chart.ts': 'old' } },
+            uiSource: {
+                'line-chart': { 'line-chart.ts': lineChart },
+                chart: { 'chart.ts': 'export const UiChart = {};' },
+            },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true });
+        expect(readInstalledFile(fixture.dir, 'chart', 'chart.ts')).toBe('export const UiChart = {};');
+        expect(readInstalledFile(fixture.dir, 'line-chart', 'line-chart.ts')).toBe(lineChart);
+        expect(installComponentPackages).toHaveBeenCalledWith(fixture.dir, [
+            'chart',
+            'line-chart',
+        ]);
+    });
+    it('leaves out a new dependency the user skips in selective mode', async () => {
+        const lineChart = "import { UiChart } from '../chart/chart';";
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: {
+                    'line-chart': { 'line-chart.ts': { hash: hashContent(lineChart) } },
+                },
+                utils: {},
+                theme: {},
+            },
+            components: { 'line-chart': { 'line-chart.ts': lineChart } },
+            uiSource: {
+                'line-chart': { 'line-chart.ts': lineChart },
+                chart: { 'chart.ts': 'export const UiChart = {};' },
+            },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const p = await import('@clack/prompts');
+        p.select.mockResolvedValueOnce('keep');
+        const { updateCommand } = await import('./update');
+        await updateCommand({ selective: true });
+        expect(existsSync(join(fixture.dir, DEFAULT_CONFIG.aliases.components, 'chart/chart.ts'))).toBe(false);
+        expect(readLockfile(fixture.dir).components['chart']).toEqual({});
+    });
+});
+describe('updateCommand — ejected components', () => {
+    /**
+     * `dolan eject card` deleted card's lockfile entry and kept its files,
+     * which the app has since changed.
+     */
+    const ejectedCard = (lockfileComponents = {}) => createFixture({
+        config: DEFAULT_CONFIG,
+        lockfile: {
+            version: 1,
+            components: lockfileComponents,
+            utils: {},
+            theme: {},
+        },
+        components: {
+            card: { 'card.ts': 'export const Card = { mine: true };' },
+        },
+        uiSource: { card: { 'card.ts': 'export const Card = { v: 2 };' } },
+    });
+    it("doesn't overwrite or track them again, even with --force", async () => {
+        fixture = ejectedCard();
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true });
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe('export const Card = { mine: true };');
+        expect(readLockfile(fixture.dir).components).not.toHaveProperty('card');
+    });
+    it("doesn't report them as a conflict", async () => {
+        fixture = ejectedCard();
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        const messages = p.log.message.mock.calls
+            .map((c) => c[0])
+            .join('\n');
+        expect(messages).not.toContain('card');
+        expect(p.select).not.toHaveBeenCalled();
+    });
+    it('leaves an ejected dependency of a tracked component alone', async () => {
+        // select is tracked and depends on bottom-sheet, which was ejected.
+        const select = 'export const Select = {};';
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: { select: { 'select.ts': { hash: hashContent(select) } } },
+                utils: {},
+                theme: {},
+            },
+            components: {
+                select: { 'select.ts': select },
+                'bottom-sheet': {
+                    'bottom-sheet.ts': 'export const BottomSheet = { mine: true };',
+                },
+            },
+            uiSource: {
+                select: { 'select.ts': select },
+                'bottom-sheet': { 'bottom-sheet.ts': 'export const BottomSheet = {};' },
+            },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true });
+        expect(readInstalledFile(fixture.dir, 'bottom-sheet', 'bottom-sheet.ts')).toBe('export const BottomSheet = { mine: true };');
+        expect(readLockfile(fixture.dir).components).not.toHaveProperty('bottom-sheet');
+    });
+});
+// CI, agents and scripts: a question there would wait for input that never
+// comes.
+describe('updateCommand without a terminal', () => {
+    const base = 'export const Card = { v: 1 };';
+    const userVersion = 'export const Card = { v: 1, local: true };';
+    const upstream = 'export const Card = { v: 2 };';
+    const themeBase = ':root { --primary: rgba(1, 1, 1, 1); }';
+    const themeMine = ':root { --primary: rgba(9, 9, 9, 1); }';
+    const themeUpstream = ':root { --primary: rgba(2, 2, 2, 1); }';
+    /**
+     * `card` and `default.css` conflict (both sides changed), and `skeleton` is
+     * a plain auto-update.
+     */
+    const setup = () => {
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: {
+                    card: { 'card.ts': { hash: hashContent(base) } },
+                    skeleton: { 'skeleton.ts': { hash: hashContent(base) } },
+                },
+                utils: {},
+                theme: { 'default.css': { hash: hashContent(themeBase) } },
+            },
+            components: {
+                card: { 'card.ts': userVersion },
+                skeleton: { 'skeleton.ts': base },
+            },
+            uiSource: {
+                card: { 'card.ts': upstream },
+                skeleton: { 'skeleton.ts': upstream },
+            },
+            themeFiles: { 'default.css': themeUpstream },
+        });
+        writeFileSync(join(fixture.dir, DEFAULT_CONFIG.aliases.theme, 'default.css'), themeMine);
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+    };
+    const readTheme = () => readFileSync(join(fixture.dir, DEFAULT_CONFIG.aliases.theme, 'default.css'), 'utf-8');
+    beforeEach(() => {
+        interactive = false;
+    });
+    it('applies auto-updates without asking', async () => {
+        fixture = createFixture({
+            config: DEFAULT_CONFIG,
+            lockfile: {
+                version: 1,
+                components: { card: { 'card.ts': { hash: hashContent(base) } } },
+                utils: {},
+                theme: {},
+            },
+            components: { card: { 'card.ts': base } },
+            uiSource: { card: { 'card.ts': upstream } },
+        });
+        vi.spyOn(process, 'cwd').mockReturnValue(fixture.dir);
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({});
+        expect(p.confirm).not.toHaveBeenCalled();
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
+        expect(p.outro).toHaveBeenCalledWith('Update complete.');
+    });
+    it('leaves conflicts as they are for a terminal to ask about, and exits 1', async () => {
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await expect(updateCommand({})).rejects.toThrow('process.exit(1)');
+        expect(p.select).not.toHaveBeenCalled();
+        // The count is bold, and CI turns colors on, so match the plain text.
+        const [warning] = p.log.warn.mock.calls[0];
+        // oxlint-disable-next-line no-control-regex -- matching ANSI color codes
+        expect(warning.replace(/\u001b\[\d+m/g, '')).toMatch(/2 conflict\(s\) left.*dolan update --force/);
+        // The auto-update still applies.
+        expect(readInstalledFile(fixture.dir, 'skeleton', 'skeleton.ts')).toBe(upstream);
+        // The conflicts keep both their files and their lockfile base. Keeping
+        // the user's version would advance the base and lose the upstream change.
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(userVersion);
+        expect(readTheme()).toBe(themeMine);
+        const lockfile = readLockfile(fixture.dir);
+        expect(lockfile.components.card['card.ts'].hash).toBe(hashContent(base));
+        expect(lockfile.theme['default.css'].hash).toBe(hashContent(themeBase));
+        // So an update in a terminal still asks about both.
+        interactive = true;
+        vi.clearAllMocks();
+        // A reset drops answers an earlier test queued and never used.
+        p.select
+            .mockReset()
+            .mockResolvedValue('upstream');
+        await updateCommand({});
+        expect(p.select).toHaveBeenCalledTimes(2);
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
+        expect(readTheme()).toBe(themeUpstream);
+    });
+    it("takes upstream's version of conflicts with --force, which wins over --selective", async () => {
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await updateCommand({ force: true, selective: true });
+        expect(p.log.error).not.toHaveBeenCalled();
+        expect(readInstalledFile(fixture.dir, 'card', 'card.ts')).toBe(upstream);
+        expect(readTheme()).toBe(themeUpstream);
+        expect(p.outro).toHaveBeenCalledWith('Update complete.');
+    });
+    it('fails with --selective, which asks about each file', async () => {
+        setup();
+        const p = await import('@clack/prompts');
+        const { updateCommand } = await import('./update');
+        await expect(updateCommand({ selective: true })).rejects.toThrow('process.exit(1)');
+        expect(p.log.error).toHaveBeenCalledWith(expect.stringContaining('--selective'));
+        expect(readInstalledFile(fixture.dir, 'skeleton', 'skeleton.ts')).toBe(base);
+    });
+});
 //# sourceMappingURL=update.test.js.map