@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

package/commands/__tests__/cms.test.js

@@ -0,0 +1,87 @@
+import yargs from 'yargs';
+import lighthouseScore from '../cms/lighthouseScore.js';
+import convertFields from '../cms/convertFields.js';
+import getReactModule from '../cms/getReactModule.js';
+import watchCommand from '../cms/watch.js';
+import listCommand from '../cms/list.js';
+import uploadCommand from '../cms/upload.js';
+import fetchCommand from '../cms/fetch.js';
+import deleteCommand from '../cms/delete.js';
+import mvCommand from '../cms/mv.js';
+import functionCommand from '../cms/function.js';
+import lintCommand from '../cms/lint.js';
+import themeCommand from '../cms/theme.js';
+import moduleCommand from '../cms/module.js';
+import webpackCommand from '../cms/webpack.js';
+import appCommand from '../cms/app.js';
+import templateCommand from '../cms/template.js';
+import cmsCommand from '../cms.js';
+vi.mock('../cms/lighthouseScore');
+vi.mock('../cms/convertFields');
+vi.mock('../cms/getReactModule');
+vi.mock('../cms/watch');
+vi.mock('../cms/list');
+vi.mock('../cms/upload');
+vi.mock('../cms/fetch');
+vi.mock('../cms/delete');
+vi.mock('../cms/mv');
+vi.mock('../cms/function');
+vi.mock('../cms/lint');
+vi.mock('../cms/theme');
+vi.mock('../cms/module');
+vi.mock('../cms/webpack');
+vi.mock('../cms/app');
+vi.mock('../cms/template');
+vi.mock('../../lib/commonOpts');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+const demandCommandSpy = vi
+    .spyOn(yargs, 'demandCommand')
+    .mockReturnValue(yargs);
+describe('commands/cms', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(cmsCommand.command).toEqual('cms');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(cmsCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        const subcommands = [
+            lighthouseScore,
+            convertFields,
+            getReactModule,
+            watchCommand,
+            listCommand,
+            uploadCommand,
+            fetchCommand,
+            deleteCommand,
+            mvCommand,
+            functionCommand,
+            lintCommand,
+            themeCommand,
+            moduleCommand,
+            webpackCommand,
+            appCommand,
+            templateCommand,
+        ];
+        it('should demand the command takes one positional argument', () => {
+            cmsCommand.builder(yargs);
+            expect(demandCommandSpy).toHaveBeenCalledTimes(1);
+            expect(demandCommandSpy).toHaveBeenCalledWith(1, '');
+        });
+        it('should add the correct number of sub commands', () => {
+            cmsCommand.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(subcommands.length);
+        });
+        it.each(subcommands)('should attach the %s subcommand', module => {
+            cmsCommand.builder(yargs);
+            expect(module).toBeDefined();
+            expect(commandSpy).toHaveBeenCalledWith(module);
+        });
+    });
+});

package/commands/__tests__/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/config.test.js

@@ -0,0 +1,44 @@
+import yargs from 'yargs';
+import set from '../config/set.js';
+import migrate from '../config/migrate.js';
+import configCommands from '../config.js';
+vi.mock('../config/set');
+vi.mock('../config/set');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+const demandCommandSpy = vi
+    .spyOn(yargs, 'demandCommand')
+    .mockReturnValue(yargs);
+describe('commands/config', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(configCommands.command).toEqual('config');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(configCommands.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        beforeEach(() => {
+            commandSpy.mockClear();
+            demandCommandSpy.mockClear();
+        });
+        const subcommands = [set, migrate];
+        it('should demand the command takes one positional argument', () => {
+            configCommands.builder(yargs);
+            expect(demandCommandSpy).toHaveBeenCalledTimes(1);
+            expect(demandCommandSpy).toHaveBeenCalledWith(1, '');
+        });
+        it('should add the correct number of sub commands', () => {
+            configCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(subcommands.length);
+        });
+        it.each(subcommands)('should attach the %s subcommand', module => {
+            configCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledWith(module);
+        });
+    });
+});

package/commands/__tests__/customObject.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/customObject.test.js

@@ -0,0 +1,68 @@
+import yargs from 'yargs';
+import create from '../customObject/create.js';
+import createSchema from '../customObject/createSchema.js';
+import updateSchema from '../customObject/updateSchema.js';
+import listSchemas from '../customObject/listSchemas.js';
+import deleteSchema from '../customObject/deleteSchema.js';
+import fetchSchema from '../customObject/fetchSchema.js';
+import fetchAllSchemas from '../customObject/fetchAllSchemas.js';
+import customObjectCommands from '../customObject.js';
+vi.mock('../customObject/create');
+vi.mock('../customObject/schema');
+vi.mock('../customObject/createSchema');
+vi.mock('../customObject/updateSchema');
+vi.mock('../customObject/listSchemas');
+vi.mock('../customObject/deleteSchema');
+vi.mock('../customObject/fetchSchema');
+vi.mock('../customObject/fetchAllSchemas');
+vi.mock('../../lib/commonOpts');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+const demandCommandSpy = vi
+    .spyOn(yargs, 'demandCommand')
+    .mockReturnValue(yargs);
+describe('commands/customObject', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(customObjectCommands.command).toEqual([
+                'custom-object',
+                'custom-objects',
+                'co',
+            ]);
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(customObjectCommands.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        beforeEach(() => {
+            commandSpy.mockClear();
+            demandCommandSpy.mockClear();
+        });
+        const subcommands = [
+            create,
+            createSchema,
+            updateSchema,
+            listSchemas,
+            deleteSchema,
+            fetchSchema,
+            fetchAllSchemas,
+        ];
+        it('should demand the command takes one positional argument', () => {
+            customObjectCommands.builder(yargs);
+            expect(demandCommandSpy).toHaveBeenCalledTimes(1);
+            expect(demandCommandSpy).toHaveBeenCalledWith(1, '');
+        });
+        it('should add the correct number of sub commands', () => {
+            customObjectCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(subcommands.length);
+        });
+        it.each(subcommands)('should attach the %s subcommand', module => {
+            customObjectCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledWith(module);
+        });
+    });
+});

package/commands/__tests__/doctor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/doctor.test.js

@@ -0,0 +1,132 @@
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import yargs from 'yargs';
+import doctorCommand from '../doctor.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { Doctor } from '../../lib/doctor/Doctor.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import fs from 'fs';
+import { getCwd as __getCwd } from '@hubspot/local-dev-lib/path';
+vi.mock('../../lib/doctor/Doctor');
+vi.mock('@hubspot/local-dev-lib/path');
+vi.mock('fs');
+// @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+const DoctorMock = Doctor;
+const mockedFs = vi.mocked(fs);
+const getCwd = __getCwd;
+const optionSpy = vi
+    .spyOn(yargs, 'option')
+    .mockReturnValue(yargs);
+const date = new Date('2022-02-22');
+vi.useFakeTimers().setSystemTime(date);
+describe('doctor', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let processExitSpy;
+    const accountId = 123456;
+    beforeEach(() => {
+        // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
+        processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { });
+    });
+    describe('command', () => {
+        it('should have the proper command name', () => {
+            expect(doctorCommand.command).toEqual('doctor');
+        });
+    });
+    describe('describe', () => {
+        it('should have a description', () => {
+            expect(doctorCommand.describe).toEqual('Retrieve diagnostic information about your local HubSpot configurations.');
+        });
+    });
+    describe('builder', () => {
+        it('should apply the correct options', () => {
+            doctorCommand.builder(yargs);
+            expect(optionSpy).toHaveBeenCalledWith('output-dir', {
+                describe: 'Directory to save a detailed diagnosis JSON file in',
+                type: 'string',
+            });
+        });
+    });
+    describe('handler', () => {
+        let diagnosis;
+        beforeEach(() => {
+            diagnosis = 'Yooooooooooooooo';
+            DoctorMock.mockImplementation(() => {
+                return {
+                    diagnose: vi.fn().mockResolvedValue({ diagnosis }),
+                    accountId,
+                };
+            });
+        });
+        it('should track the command usage', async () => {
+            await doctorCommand.handler({});
+            expect(trackCommandUsage).toHaveBeenCalledTimes(1);
+            expect(trackCommandUsage).toHaveBeenCalledWith('doctor', undefined, accountId);
+        });
+        it('should log the diagnosis if it is defined', async () => {
+            await doctorCommand.handler({});
+            expect(uiLogger.log).toHaveBeenCalledTimes(1);
+            expect(uiLogger.log).toHaveBeenCalledWith(diagnosis);
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should log an error if the diagnosis is undefined', async () => {
+            DoctorMock.mockImplementationOnce(() => {
+                return {
+                    diagnose: vi.fn().mockResolvedValue(undefined),
+                    accountId,
+                };
+            });
+            await doctorCommand.handler({});
+            expect(uiLogger.error).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledWith('Error generating diagnosis');
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('should write the output to a file if output-dir is defined', async () => {
+            mockedFs.writeFileSync.mockImplementationOnce(() => { });
+            const expectedOutputFile = `/foo/hubspot-doctor-${date.toISOString()}.json`;
+            await doctorCommand.handler({
+                outputDir: '/foo',
+            });
+            expect(uiLogger.log).not.toHaveBeenCalled();
+            expect(uiLogger.error).not.toHaveBeenCalled();
+            expect(mockedFs.writeFileSync).toHaveBeenCalledTimes(1);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith(expectedOutputFile, expect.stringContaining(diagnosis));
+            expect(uiLogger.success).toHaveBeenCalledTimes(1);
+            expect(uiLogger.success).toHaveBeenCalledWith(expect.stringMatching(/Output written to /));
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should handle absolute paths', async () => {
+            mockedFs.writeFileSync.mockImplementationOnce(() => { });
+            const cwd = '/some/path/to';
+            getCwd.mockImplementationOnce(() => cwd);
+            const expectedOutputFile = `${cwd}/foo/hubspot-doctor-${date.toISOString()}.json`;
+            await doctorCommand.handler({
+                outputDir: './foo',
+            });
+            expect(uiLogger.log).not.toHaveBeenCalled();
+            expect(uiLogger.error).not.toHaveBeenCalled();
+            expect(mockedFs.writeFileSync).toHaveBeenCalledTimes(1);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith(expectedOutputFile, expect.stringContaining(diagnosis));
+            expect(uiLogger.success).toHaveBeenCalledTimes(1);
+            expect(uiLogger.success).toHaveBeenCalledWith(expect.stringMatching(/Output written to /));
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should log an error message when writing the output fails', async () => {
+            const errorMessage = 'Something bad happened';
+            mockedFs.writeFileSync.mockImplementationOnce(() => {
+                throw new Error(errorMessage);
+            });
+            await doctorCommand.handler({
+                outputDir: '/foo',
+            });
+            expect(uiLogger.error).toHaveBeenCalledTimes(1);
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Unable to write output to/));
+            expect(mockedFs.writeFileSync).toHaveBeenCalledTimes(1);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith(`/foo/hubspot-doctor-${date.toISOString()}.json`, expect.stringContaining(diagnosis));
+            expect(processExitSpy).toHaveBeenCalledTimes(1);
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
+});

package/commands/__tests__/feedback.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/feedback.test.js

@@ -0,0 +1,24 @@
+import yargs from 'yargs';
+import * as commonOpts from '../../lib/commonOpts.js';
+import feedbackCommand from '../feedback.js';
+vi.mock('yargs');
+vi.mock('../../lib/commonOpts');
+describe('commands/feedback', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(feedbackCommand.command).toEqual('feedback');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(feedbackCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            feedbackCommand.builder(yargs);
+            expect(commonOpts.addGlobalOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addGlobalOptions).toHaveBeenCalledWith(yargs);
+        });
+    });
+});

package/commands/__tests__/filemanager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/filemanager.test.js

@@ -0,0 +1,45 @@
+import yargs from 'yargs';
+import fetch from '../filemanager/fetch.js';
+import upload from '../filemanager/upload.js';
+import fileManagerCommands from '../filemanager.js';
+vi.mock('../filemanager/fetch');
+vi.mock('../filemanager/upload');
+vi.mock('../../lib/commonOpts');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+const demandCommandSpy = vi
+    .spyOn(yargs, 'demandCommand')
+    .mockReturnValue(yargs);
+describe('commands/filemanager', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(fileManagerCommands.command).toEqual('filemanager');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(fileManagerCommands.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        beforeEach(() => {
+            commandSpy.mockClear();
+            demandCommandSpy.mockClear();
+        });
+        const subcommands = [fetch, upload];
+        it('should demand the command takes one positional argument', () => {
+            fileManagerCommands.builder(yargs);
+            expect(demandCommandSpy).toHaveBeenCalledTimes(1);
+            expect(demandCommandSpy).toHaveBeenCalledWith(1, '');
+        });
+        it('should add the correct number of sub commands', () => {
+            fileManagerCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(subcommands.length);
+        });
+        it.each(subcommands)('should attach the %s subcommand', module => {
+            fileManagerCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledWith(module);
+        });
+    });
+});

package/commands/__tests__/getStarted.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/getStarted.test.js

@@ -0,0 +1,173 @@
+import getStartedCommand from '../getStarted.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { projectNameAndDestPrompt } from '../../lib/prompts/projectNameAndDestPrompt.js';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { getProjectConfig, writeProjectConfig, } from '../../lib/projects/config.js';
+import { getProjectPackageJsonLocations, installPackages, } from '../../lib/dependencyManagement.js';
+import { GET_STARTED_OPTIONS } from '../../lib/constants.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import open from 'open';
+import { renderInteractive } from '../../ui/render.js';
+import { getGetStartedFlow } from '../../ui/components/getStarted/GetStartedFlow.js';
+vi.mock('../../lib/prompts/promptUtils');
+vi.mock('../../lib/prompts/projectNameAndDestPrompt');
+vi.mock('../../lib/projects/config');
+vi.mock('../../lib/errorHandlers');
+vi.mock('@hubspot/local-dev-lib/github');
+vi.mock('../../lib/dependencyManagement');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../ui/render');
+vi.mock('../../ui/components/getStarted/GetStartedFlow');
+vi.mock('open');
+vi.mock('fs-extra', () => ({
+    default: {
+        readFileSync: vi.fn().mockReturnValue('{"name": "test-project"}'),
+        existsSync: vi.fn().mockReturnValue(false),
+        readdirSync: vi.fn().mockReturnValue(['file1.js', 'file2.js']),
+    },
+}));
+describe('commands/get-started', () => {
+    beforeEach(() => {
+        // @TODO Revisit config mocking in tests
+        getConfigAccountById.mockReturnValue({
+            accountId: 12345,
+            name: 'Test Account',
+            authType: 'personalaccesskey',
+            personalAccessKey: 'test-key',
+            env: 'prod',
+        });
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(getStartedCommand.command).toEqual('get-started');
+        });
+    });
+    describe('describe', () => {
+        it('should have a defined describe property', () => {
+            expect(getStartedCommand.describe).toBeDefined();
+        });
+    });
+    describe('command structure', () => {
+        it('should have handler function', () => {
+            expect(getStartedCommand.handler).toBeDefined();
+            expect(typeof getStartedCommand.handler).toBe('function');
+        });
+        it('should have builder function', () => {
+            expect(getStartedCommand.builder).toBeDefined();
+            expect(typeof getStartedCommand.builder).toBe('function');
+        });
+    });
+    describe('handler', () => {
+        const mockArgs = {
+            derivedAccountId: 12345,
+            templateSource: undefined,
+            name: 'test-project',
+            dest: 'test-destination',
+            d: false,
+            debug: false,
+            c: undefined,
+            config: undefined,
+            a: undefined,
+            account: undefined,
+            'use-env': undefined,
+            useEnv: undefined,
+            _: [],
+            $0: 'hs',
+        };
+        beforeEach(() => {
+            trackCommandUsage.mockResolvedValue(undefined);
+            projectNameAndDestPrompt.mockResolvedValue({
+                dest: 'test-destination',
+                name: 'test-project',
+            });
+            cloneGithubRepo.mockResolvedValue(true);
+            getProjectConfig.mockResolvedValue({
+                projectConfig: null,
+                projectDir: null,
+            });
+            writeProjectConfig.mockResolvedValue(true);
+            getProjectPackageJsonLocations.mockResolvedValue(['/path/to/package/dir']);
+            installPackages.mockResolvedValue(undefined);
+            process.exit = vi.fn();
+        });
+        describe('CMS flow', () => {
+            it('should handle CMS option selection', async () => {
+                promptUser.mockResolvedValue({
+                    default: GET_STARTED_OPTIONS.CMS,
+                });
+                await getStartedCommand.handler(mockArgs);
+                expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            });
+            it('should open Design Manager when user confirms and browser is available', async () => {
+                promptUser
+                    .mockResolvedValueOnce({ default: GET_STARTED_OPTIONS.CMS })
+                    .mockResolvedValueOnce({ shouldOpen: true });
+                await getStartedCommand.handler(mockArgs);
+                expect(open).toHaveBeenCalledWith(expect.stringContaining('design-manager'), { url: true });
+            });
+            it('should use Ink flow when v2 flag is enabled', async () => {
+                getGetStartedFlow.mockImplementation(() => null);
+                renderInteractive.mockResolvedValue(undefined);
+                await getStartedCommand.handler({ ...mockArgs, v2: true });
+                expect(renderInteractive).toHaveBeenCalled();
+                expect(promptUser).not.toHaveBeenCalled();
+                expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            });
+        });
+        describe('App flow', () => {
+            beforeEach(() => {
+                promptUser
+                    .mockResolvedValueOnce({
+                    default: GET_STARTED_OPTIONS.APP,
+                })
+                    .mockResolvedValueOnce({
+                    shouldUpload: true,
+                });
+            });
+            it('should handle App option selection', async () => {
+                await getStartedCommand.handler(mockArgs);
+                expect(projectNameAndDestPrompt).toHaveBeenCalledWith(mockArgs);
+                expect(cloneGithubRepo).toHaveBeenCalled();
+            });
+            it('should handle upload flow when user confirms', async () => {
+                promptUser
+                    .mockResolvedValueOnce({ default: GET_STARTED_OPTIONS.APP })
+                    .mockResolvedValueOnce({ shouldUpload: true });
+                const mockProjectConfig = {
+                    name: 'test-project',
+                    srcDir: 'src',
+                    platformVersion: '1.0.0',
+                };
+                getProjectConfig
+                    .mockResolvedValueOnce({
+                    projectConfig: null,
+                    projectDir: null,
+                })
+                    .mockResolvedValueOnce({
+                    projectConfig: mockProjectConfig,
+                    projectDir: '/path/to/project',
+                });
+                await getStartedCommand.handler(mockArgs);
+                expect(promptUser).toHaveBeenCalledWith([
+                    expect.objectContaining({
+                        type: 'confirm',
+                        name: 'shouldUpload',
+                        message: expect.any(String),
+                        default: true,
+                    }),
+                ]);
+            });
+        });
+        describe('tracking', () => {
+            it('should track command usage', async () => {
+                promptUser.mockResolvedValue({
+                    default: GET_STARTED_OPTIONS.APP,
+                });
+                await getStartedCommand.handler(mockArgs);
+                expect(trackCommandUsage).toHaveBeenCalledWith('get-started', {}, mockArgs.derivedAccountId);
+            });
+        });
+    });
+});

package/commands/__tests__/hubdb.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/hubdb.test.js

@@ -0,0 +1,50 @@
+import yargs from 'yargs';
+import clear from '../hubdb/clear.js';
+import create from '../hubdb/create.js';
+import deleteCommand from '../hubdb/delete.js';
+import fetch from '../hubdb/fetch.js';
+import list from '../hubdb/list.js';
+import hubdbCommands from '../hubdb.js';
+vi.mock('../hubdb/clear');
+vi.mock('../hubdb/create');
+vi.mock('../hubdb/delete');
+vi.mock('../hubdb/fetch');
+vi.mock('../../lib/commonOpts');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+const demandCommandSpy = vi
+    .spyOn(yargs, 'demandCommand')
+    .mockReturnValue(yargs);
+describe('commands/hubdb', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(hubdbCommands.command).toEqual('hubdb');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(hubdbCommands.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        beforeEach(() => {
+            commandSpy.mockClear();
+            demandCommandSpy.mockClear();
+        });
+        const subcommands = [clear, create, deleteCommand, fetch, list];
+        it('should demand the command takes one positional argument', () => {
+            hubdbCommands.builder(yargs);
+            expect(demandCommandSpy).toHaveBeenCalledTimes(1);
+            expect(demandCommandSpy).toHaveBeenCalledWith(1, '');
+        });
+        it('should add the correct number of sub commands', () => {
+            hubdbCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(subcommands.length);
+        });
+        it.each(subcommands)('should attach the %s subcommand', module => {
+            hubdbCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledWith(module);
+        });
+    });
+});

package/commands/__tests__/init.test.d.ts

@@ -0,0 +1 @@
+export {};