@form8ion/javascript 15.6.0 → 15.6.1

package/src/scaffolder.js

@@ -0,0 +1,155 @@
+import deepmerge from 'deepmerge';
+import {info} from '@travi/cli-messages';
+import {projectTypes, scaffoldChoice} from '@form8ion/javascript-core';
+import {scaffold as scaffoldCommitConvention} from '@form8ion/commit-convention';
+
+import {validate} from './options/validator.js';
+import {prompt} from './prompts/questions.js';
+import {scaffold as scaffoldDialect} from './dialects/index.js';
+import {scaffold as scaffoldNpmConfig} from './npm-config/index.js';
+import {scaffold as scaffoldPackageManager} from './package-managers/index.js';
+import scaffoldDocumentation from './documentation/index.js';
+import {scaffold as scaffoldNodeVersion} from './node-version/index.js';
+import buildVcsIgnoreLists from './vcs/ignore-lists-builder.js';
+import {scaffold as scaffoldPackage} from './package/index.js';
+import {scaffold as scaffoldProjectType} from './project-type/index.js';
+import {scaffold as scaffoldProjectTypePlugin} from './project-type-plugin/index.js';
+import buildDocumentationCommand from './documentation/generation-command.js';
+import {scaffold as scaffoldVerification} from './verification/index.js';
+import {scaffold as scaffoldCodeStyle} from './code-style/index.js';
+
+export default async function scaffoldJavascript(options) {
+  info('Initializing JavaScript project');
+
+  const {
+    projectRoot,
+    projectName,
+    visibility,
+    license,
+    vcs,
+    description,
+    configs,
+    decisions,
+    pathWithinParent,
+    plugins: {
+      applicationTypes,
+      packageTypes,
+      monorepoTypes,
+      packageBundlers,
+      unitTestFrameworks,
+      hosts,
+      ciServices
+    }
+  } = validate(options);
+
+  const {
+    tests,
+    projectType,
+    ci,
+    chosenHost,
+    scope,
+    nodeVersionCategory,
+    author,
+    configureLinting,
+    provideExample,
+    packageManager,
+    dialect
+  } = await prompt(ciServices, hosts, visibility, vcs, decisions, configs, pathWithinParent);
+
+  info('Writing project files', {level: 'secondary'});
+
+  const {packageName} = await scaffoldPackage({
+    projectRoot,
+    projectName,
+    scope,
+    dialect,
+    license,
+    author,
+    description
+  });
+  const projectTypeResults = await scaffoldProjectType({
+    projectType,
+    projectRoot,
+    projectName,
+    packageName,
+    packageManager,
+    visibility,
+    applicationTypes,
+    packageTypes,
+    monorepoTypes,
+    packageBundlers,
+    scope,
+    tests,
+    vcs,
+    decisions,
+    dialect,
+    provideExample,
+    publishRegistry: configs.registries.publish
+  });
+  const verificationResults = await scaffoldVerification({
+    projectRoot,
+    dialect,
+    visibility,
+    packageManager,
+    vcs,
+    registries: configs.registries,
+    tests,
+    unitTestFrameworks,
+    decisions,
+    pathWithinParent
+  });
+  const [nodeVersion, npmResults, dialectResults, codeStyleResults] = await Promise.all([
+    scaffoldNodeVersion({projectRoot, nodeVersionCategory}),
+    scaffoldNpmConfig({projectType, projectRoot}),
+    scaffoldDialect({
+      dialect,
+      configs,
+      projectRoot,
+      projectType,
+      testFilenamePattern: verificationResults.testFilenamePattern
+    }),
+    scaffoldCodeStyle({projectRoot, projectType, configs, vcs, configureLinting}),
+    scaffoldPackageManager({projectRoot, packageManager})
+  ]);
+  const projectTypePluginResults = await scaffoldProjectTypePlugin({
+    projectRoot,
+    projectType,
+    projectName,
+    packageName,
+    packageManager,
+    scope,
+    dialect,
+    tests,
+    decisions,
+    plugins: {
+      [projectTypes.PACKAGE]: packageTypes,
+      [projectTypes.APPLICATION]: applicationTypes,
+      [projectTypes.MONOREPO]: monorepoTypes
+    }
+  });
+  const mergedContributions = deepmerge.all([
+    ...(await Promise.all([
+      scaffoldChoice(
+        hosts,
+        chosenHost,
+        {buildDirectory: `./${projectTypeResults.buildDirectory}`, projectRoot, projectName, nodeVersion}
+      ),
+      scaffoldChoice(ciServices, ci, {projectRoot, vcs, visibility, projectType, projectName, nodeVersion, tests}),
+      scaffoldCommitConvention({projectRoot, projectType, configs, pathWithinParent})
+    ])),
+    projectTypeResults,
+    verificationResults,
+    codeStyleResults,
+    npmResults,
+    dialectResults,
+    projectTypePluginResults
+  ]);
+
+  return {
+    ...mergedContributions,
+    documentation: scaffoldDocumentation({projectTypeResults, packageManager}),
+    tags: projectTypeResults.tags,
+    vcsIgnore: buildVcsIgnoreLists(mergedContributions.vcsIgnore),
+    verificationCommand: `${buildDocumentationCommand(packageManager)} && ${packageManager} test`
+  };
+}

package/src/scaffolder.test.js

@@ -0,0 +1,239 @@
+import deepmerge from 'deepmerge';
+import {projectTypes, scaffoldChoice} from '@form8ion/javascript-core';
+import {scaffold as scaffoldCommitConvention} from '@form8ion/commit-convention';
+
+import {beforeEach, describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {scaffold as scaffoldPackage} from './package/index.js';
+import {scaffold as scaffoldVerification} from './verification/index.js';
+import {scaffold as scaffoldCodeStyle} from './code-style/index.js';
+import {scaffold as scaffoldDialect} from './dialects/index.js';
+import {scaffold as scaffoldNpmConfig} from './npm-config/index.js';
+import {scaffold as scaffoldPackageManager} from './package-managers/index.js';
+import {scaffold as scaffoldNodeVersion} from './node-version/index.js';
+import {scaffold as scaffoldProjectTypePlugin} from './project-type-plugin/index.js';
+import buildVcsIgnoreLists from './vcs/ignore-lists-builder.js';
+import {scaffold as scaffoldProjectType} from './project-type/index.js';
+import buildDocumentationCommand from './documentation/generation-command.js';
+import scaffoldDocumentation from './documentation/index.js';
+import {validate} from './options/validator.js';
+import {prompt} from './prompts/questions.js';
+import scaffold from './scaffolder.js';
+
+vi.mock('deepmerge');
+vi.mock('@form8ion/javascript-core');
+vi.mock('@form8ion/commit-convention');
+vi.mock('./package/index.js');
+vi.mock('./code-style/index.js');
+vi.mock('./dialects/index.js');
+vi.mock('./npm-config/index.js');
+vi.mock('./package-managers/index.js');
+vi.mock('./node-version/index.js');
+vi.mock('./project-type-plugin/index.js');
+vi.mock('./vcs/ignore-lists-builder.js');
+vi.mock('./project-type/index.js');
+vi.mock('./documentation/generation-command.js');
+vi.mock('./documentation/index.js');
+vi.mock('./options/validator.js');
+vi.mock('./prompts/questions.js');
+vi.mock('./documentation/badges.js');
+vi.mock('./verification/index.js');
+
+describe('javascript project scaffolder', () => {
+  const options = any.simpleObject();
+  const projectRoot = any.string();
+  const vcs = any.simpleObject();
+  const pathWithinParent = any.string();
+  const publishRegistry = any.url();
+  const registries = {...any.simpleObject(), publish: publishRegistry};
+  const configs = {...any.simpleObject(), registries};
+  const packageManager = any.word();
+  const visibility = any.word();
+  const decisions = any.simpleObject();
+  const documentationCommand = any.string();
+  const documentation = any.string();
+  const tags = any.listOf(any.word);
+  const dialect = any.word();
+  const provideExample = any.boolean();
+  const scope = any.word();
+  const vcsIgnore = any.simpleObject();
+  const mergedVcsIgnore = any.simpleObject();
+  const mergedNextSteps = any.listOf(any.simpleObject);
+  const mergedResults = {...any.simpleObject(), vcsIgnore: mergedVcsIgnore, nextSteps: mergedNextSteps};
+
+  beforeEach(() => {
+    const projectName = any.word();
+    const packageName = any.string();
+    const description = any.sentence();
+    const projectType = any.word();
+    const ciChoice = any.word();
+    const hostChoice = any.word();
+    const license = any.word();
+    const nodeVersionCategory = any.word();
+    const author = any.simpleObject();
+    const configureLinting = any.boolean();
+    const tests = any.simpleObject();
+    const ciServices = any.simpleObject();
+    const hosts = any.simpleObject();
+    const applicationTypes = any.simpleObject();
+    const packageTypes = any.simpleObject();
+    const monorepoTypes = any.simpleObject();
+    const packageBundlers = any.simpleObject();
+    const unitTestFrameworks = any.simpleObject();
+    const testFilenamePattern = any.string();
+    const buildDirectory = any.string();
+    const packageResults = {...any.simpleObject(), packageName};
+    const projectTypeResults = {...any.simpleObject(), tags, buildDirectory};
+    const projectTypePluginResults = any.simpleObject();
+    const nodeVersionResults = any.simpleObject();
+    const ciServiceResults = any.simpleObject();
+    const npmConfigResults = any.simpleObject();
+    const dialectResults = any.simpleObject();
+    const commitConventionResults = any.simpleObject();
+    const codeStyleResults = any.simpleObject();
+    const hostResults = any.simpleObject();
+    const verificationResults = {...any.simpleObject(), testFilenamePattern};
+
+    when(validate)
+      .calledWith(options)
+      .thenReturn({
+        projectRoot,
+        projectName,
+        description,
+        vcs,
+        pathWithinParent,
+        configs,
+        visibility,
+        license,
+        decisions,
+        plugins: {ciServices, hosts, applicationTypes, packageTypes, monorepoTypes, packageBundlers, unitTestFrameworks}
+      });
+    when(prompt)
+      .calledWith(ciServices, hosts, visibility, vcs, decisions, configs, pathWithinParent)
+      .thenResolve({
+        packageManager,
+        dialect,
+        scope,
+        author,
+        provideExample,
+        projectType,
+        tests,
+        ci: ciChoice,
+        chosenHost: hostChoice,
+        nodeVersionCategory,
+        configureLinting
+      });
+    when(scaffoldDocumentation).calledWith({packageManager, projectTypeResults}).thenReturn(documentation);
+    when(buildDocumentationCommand).calledWith(packageManager).thenReturn(documentationCommand);
+    when(scaffoldPackage)
+      .calledWith({projectRoot, projectName, scope, dialect, license, author, description})
+      .thenResolve(packageResults);
+    when(scaffoldProjectType)
+      .calledWith({
+        projectRoot,
+        projectName,
+        packageName,
+        projectType,
+        packageManager,
+        visibility,
+        vcs,
+        decisions,
+        applicationTypes,
+        packageTypes,
+        monorepoTypes,
+        packageBundlers,
+        dialect,
+        provideExample,
+        scope,
+        tests,
+        publishRegistry
+      })
+      .thenResolve(projectTypeResults);
+    when(scaffoldVerification)
+      .calledWith({
+        projectRoot,
+        dialect,
+        visibility,
+        packageManager,
+        vcs,
+        registries,
+        tests,
+        decisions,
+        pathWithinParent,
+        unitTestFrameworks
+      })
+      .thenResolve(verificationResults);
+    when(scaffoldNodeVersion).calledWith({projectRoot, nodeVersionCategory}).thenResolve(nodeVersionResults);
+    when(scaffoldDialect)
+      .calledWith({dialect, configs, projectRoot, projectType, testFilenamePattern})
+      .thenResolve(dialectResults);
+    when(scaffoldNpmConfig).calledWith({projectType, projectRoot}).thenResolve(npmConfigResults);
+    when(scaffoldCodeStyle)
+      .calledWith({projectRoot, projectType, configs, vcs, configureLinting})
+      .thenResolve(codeStyleResults);
+    when(scaffoldChoice)
+      .calledWith(
+        ciServices,
+        ciChoice,
+        {projectRoot, vcs, visibility, projectType, projectName, nodeVersion: nodeVersionResults, tests}
+      )
+      .thenResolve(ciServiceResults);
+    when(scaffoldChoice)
+      .calledWith(
+        hosts,
+        hostChoice,
+        {projectRoot, projectName, nodeVersion: nodeVersionResults, buildDirectory: `./${buildDirectory}`}
+      )
+      .thenResolve(hostResults);
+    when(scaffoldCommitConvention)
+      .calledWith({projectRoot, projectType, configs, pathWithinParent})
+      .thenResolve(commitConventionResults);
+    when(scaffoldProjectTypePlugin)
+      .calledWith({
+        projectRoot,
+        projectType,
+        projectName,
+        packageName,
+        packageManager,
+        scope,
+        dialect,
+        tests,
+        decisions,
+        plugins: {
+          [projectTypes.PACKAGE]: packageTypes,
+          [projectTypes.APPLICATION]: applicationTypes,
+          [projectTypes.MONOREPO]: monorepoTypes
+        }
+      })
+      .thenResolve(projectTypePluginResults);
+    when(buildVcsIgnoreLists).calledWith(mergedVcsIgnore).thenReturn(vcsIgnore);
+    when(deepmerge.all)
+      .calledWith([
+        hostResults,
+        ciServiceResults,
+        commitConventionResults,
+        projectTypeResults,
+        verificationResults,
+        codeStyleResults,
+        npmConfigResults,
+        dialectResults,
+        projectTypePluginResults
+      ])
+      .thenReturn(mergedResults);
+  });
+
+  it('should scaffold the javascript details', async () => {
+    const results = await scaffold(options);
+
+    expect(scaffoldPackageManager).toHaveBeenCalledWith({projectRoot, packageManager});
+    expect(results).toEqual({
+      ...mergedResults,
+      documentation,
+      tags,
+      vcsIgnore,
+      verificationCommand: `${documentationCommand} && ${packageManager} test`
+    });
+  });
+});

package/src/tester.js

@@ -0,0 +1,17 @@
+import {info} from '@travi/cli-messages';
+
+import {test as nvmIsUsed} from './node-version/index.js';
+import {test as jsPackageManagerIsUsed} from './package-managers/index.js';
+
+export default async function projectUsesJavaScript({projectRoot}) {
+  const [nvmFound, jsPackageManagerFound] = await Promise.all([
+    nvmIsUsed({projectRoot}),
+    jsPackageManagerIsUsed({projectRoot})
+  ]);
+
+  const jsProjectFound = nvmFound || jsPackageManagerFound;
+
+  if (jsProjectFound) info('JavaScript Project Detected');
+
+  return jsProjectFound;
+}

package/src/tester.test.js

@@ -0,0 +1,37 @@
+import {vi, it, describe, afterEach, expect} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {test as nvmIsUsed} from './node-version/index.js';
+import {test as jsPackageManagerIsUsed} from './package-managers/index.js';
+import testApplicability from './tester.js';
+
+vi.mock('./node-version/index.js');
+vi.mock('./package-managers/index.js');
+
+describe('javascript predicate', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return `true` if nvm is detected', async () => {
+    when(nvmIsUsed).calledWith({projectRoot}).thenResolve(true);
+
+    expect(await testApplicability({projectRoot})).toBe(true);
+  });
+
+  it('should return `true` if a javascript package manager is detected', async () => {
+    when(jsPackageManagerIsUsed).calledWith({projectRoot}).thenResolve(true);
+
+    expect(await testApplicability({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` if neither nvm nor a js package manager is found', async () => {
+    when(nvmIsUsed).calledWith({projectRoot}).thenResolve(false);
+    when(jsPackageManagerIsUsed).calledWith({projectRoot}).thenResolve(false);
+
+    expect(await testApplicability({projectRoot})).toBe(false);
+  });
+});

package/src/testing/index.js

@@ -0,0 +1 @@
+export {default as scaffold} from './scaffolder.js';

package/src/testing/scaffolder.js

@@ -0,0 +1,31 @@
+import deepmerge from 'deepmerge';
+
+import {scaffold as scaffoldUnitTesting} from './unit/index.js';
+
+export default async function scaffoldTesting({
+  projectRoot,
+  visibility,
+  tests: {unit, integration},
+  vcs,
+  unitTestFrameworks,
+  decisions,
+  dialect,
+  pathWithinParent
+}) {
+  const unitResults = unit
+    ? await scaffoldUnitTesting({
+      projectRoot,
+      visibility,
+      vcs,
+      frameworks: unitTestFrameworks,
+      decisions,
+      dialect,
+      pathWithinParent
+    })
+    : {};
+
+  return deepmerge(
+    {dependencies: {javascript: {development: [...(unit || integration) ? ['@travi/any'] : []]}}, eslint: {}},
+    unitResults
+  );
+}

package/src/testing/scaffolder.test.js

@@ -0,0 +1,63 @@
+import any from '@travi/any';
+import {it, expect, describe, vi, beforeEach} from 'vitest';
+import {when} from 'vitest-when';
+
+import {scaffold as scaffoldUnitTesting} from './unit/index.js';
+import scaffoldTesting from './scaffolder.js';
+
+vi.mock('./unit/index.js');
+
+describe('testing scaffolder', () => {
+  const projectRoot = any.string();
+  const visibility = any.word();
+  const dialect = any.word();
+  const unitTestingDevDependencies = any.listOf(any.string);
+  const unitTestNextSteps = any.listOf(any.simpleObject);
+  const unitTestScripts = any.simpleObject();
+  const unitTestFilesToIgnoreFromVcs = any.listOf(any.string);
+  const unitTestDirectoriesToIgnoreFromVcs = any.listOf(any.string);
+  const vcs = any.simpleObject();
+  const unitTestFrameworks = any.simpleObject();
+  const decisions = any.simpleObject();
+  const pathWithinParent = any.string();
+
+  beforeEach(() => {
+    when(scaffoldUnitTesting)
+      .calledWith({projectRoot, visibility, vcs, frameworks: unitTestFrameworks, decisions, dialect, pathWithinParent})
+      .thenResolve({
+        dependencies: {javascript: {development: unitTestingDevDependencies}},
+        scripts: unitTestScripts,
+        vcsIgnore: {files: unitTestFilesToIgnoreFromVcs, directories: unitTestDirectoriesToIgnoreFromVcs},
+        nextSteps: unitTestNextSteps
+      });
+  });
+
+  it('should scaffold unit testing if the project will be unit test', async () => {
+    expect(await scaffoldTesting({
+      projectRoot,
+      visibility,
+      tests: {unit: true},
+      vcs,
+      unitTestFrameworks,
+      decisions,
+      dialect,
+      pathWithinParent
+    })).toEqual({
+      dependencies: {javascript: {development: ['@travi/any', ...unitTestingDevDependencies]}},
+      scripts: unitTestScripts,
+      vcsIgnore: {files: unitTestFilesToIgnoreFromVcs, directories: unitTestDirectoriesToIgnoreFromVcs},
+      eslint: {},
+      nextSteps: unitTestNextSteps
+    });
+  });
+
+  it('should not scaffold unit testing if the project will not be unit tested', async () => {
+    expect(await scaffoldTesting({projectRoot, visibility, tests: {unit: false, integration: true}, pathWithinParent}))
+      .toEqual({dependencies: {javascript: {development: ['@travi/any']}}, eslint: {}});
+  });
+
+  it('should not scaffold testing if the project will not be tested', async () => {
+    expect(await scaffoldTesting({projectRoot, visibility, tests: {unit: false, integration: false}, pathWithinParent}))
+      .toEqual({dependencies: {javascript: {development: []}}, eslint: {}});
+  });
+});

package/src/testing/unit/index.js

@@ -0,0 +1 @@
+export {default as scaffold} from './scaffolder.js';

package/src/testing/unit/prompt.js

@@ -0,0 +1,15 @@
+import {prompt} from '@form8ion/overridable-prompts';
+import {questionNames} from '../../prompts/question-names.js';
+
+export default async function gatherUnitTestingInput({frameworks, decisions}) {
+  if (!Object.keys(frameworks).length) return 'Other';
+
+  const answers = await prompt([{
+    name: questionNames.UNIT_TEST_FRAMEWORK,
+    type: 'list',
+    message: 'Which type of unit testing framework should be used?',
+    choices: [...Object.keys(frameworks), 'Other']
+  }], decisions);
+
+  return answers[questionNames.UNIT_TEST_FRAMEWORK];
+}

package/src/testing/unit/prompt.test.js

@@ -0,0 +1,33 @@
+import * as prompts from '@form8ion/overridable-prompts';
+
+import any from '@travi/any';
+import {when} from 'vitest-when';
+import {describe, expect, it, vi} from 'vitest';
+
+import {questionNames} from '../../prompts/question-names.js';
+import prompt from './prompt.js';
+
+vi.mock('@form8ion/overridable-prompts');
+
+describe('project-type prompts', () => {
+  it('should preset the choice of application-type', async () => {
+    const chosenType = any.word();
+    const decisions = any.simpleObject();
+    const answers = {...any.simpleObject(), [questionNames.UNIT_TEST_FRAMEWORK]: chosenType};
+    const frameworks = any.simpleObject();
+    when(prompts.prompt)
+      .calledWith([{
+        name: questionNames.UNIT_TEST_FRAMEWORK,
+        type: 'list',
+        message: 'Which type of unit testing framework should be used?',
+        choices: [...Object.keys(frameworks), 'Other']
+      }], decisions)
+      .thenResolve(answers);
+
+    expect(await prompt({frameworks, decisions})).toEqual(chosenType);
+  });
+
+  it('should skip the prompt and return `Other` when no options are provided', async () => {
+    expect(await prompt({frameworks: {}})).toEqual('Other');
+  });
+});

package/src/testing/unit/scaffolder.js

@@ -0,0 +1,30 @@
+import deepmerge from 'deepmerge';
+import {validateOptions} from '@form8ion/core';
+import {scaffoldChoice as scaffoldFrameworkChoice} from '@form8ion/javascript-core';
+
+import {scaffold as scaffoldCoverage} from '../../coverage/index.js';
+import chooseFramework from './prompt.js';
+import {pluginsSchema} from '../../plugins-schemas.js';
+
+export default async function scaffoldUnitTesting({
+  projectRoot,
+  frameworks,
+  decisions,
+  visibility,
+  vcs,
+  pathWithinParent,
+  dialect
+}) {
+  const validatedFrameworks = validateOptions(pluginsSchema, frameworks);
+  const [framework, coverage] = await Promise.all([
+    chooseFramework({frameworks: validatedFrameworks, decisions})
+      .then(chosenFramework => scaffoldFrameworkChoice(validatedFrameworks, chosenFramework, {projectRoot, dialect})),
+    scaffoldCoverage({projectRoot, vcs, visibility, pathWithinParent})
+  ]);
+
+  return deepmerge.all([
+    {scripts: {'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'}},
+    framework,
+    coverage
+  ]);
+}

package/src/testing/unit/scaffolder.test.js

@@ -0,0 +1,54 @@
+import {validateOptions} from '@form8ion/core';
+import {scaffoldChoice} from '@form8ion/javascript-core';
+import deepmerge from 'deepmerge';
+
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import scaffoldCoverage from '../../coverage/scaffolder.js';
+import prompt from './prompt.js';
+import scaffoldUnitTesting from './scaffolder.js';
+import {pluginsSchema} from '../../plugins-schemas.js';
+
+vi.mock('deepmerge');
+vi.mock('@form8ion/core');
+vi.mock('@form8ion/javascript-core');
+vi.mock('../../coverage/scaffolder.js');
+vi.mock('./prompt.js');
+
+describe('unit testing scaffolder', () => {
+  const projectRoot = any.string();
+  const vcs = any.simpleObject();
+  const frameworks = any.simpleObject();
+  const decisions = any.simpleObject();
+  const chosenFramework = any.word();
+  const dialect = any.word();
+  const pathWithinParent = any.string();
+  const coverageResults = any.simpleObject();
+  const unitTestFrameworkResults = any.simpleObject();
+  const mergedResults = any.simpleObject();
+
+  it('should scaffold the chosen framework', async () => {
+    const visibility = any.word();
+    const validatedFrameworks = any.simpleObject();
+    when(validateOptions).calledWith(pluginsSchema, frameworks).thenReturn(validatedFrameworks);
+    when(prompt).calledWith({frameworks: validatedFrameworks, decisions}).thenResolve(chosenFramework);
+    when(scaffoldChoice)
+      .calledWith(validatedFrameworks, chosenFramework, {projectRoot, dialect})
+      .thenResolve(unitTestFrameworkResults);
+    when(scaffoldCoverage)
+      .calledWith({projectRoot, vcs, visibility, pathWithinParent})
+      .thenResolve(coverageResults);
+    when(deepmerge.all)
+      .calledWith([
+        {scripts: {'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'}},
+        unitTestFrameworkResults,
+        coverageResults
+      ])
+      .thenReturn(mergedResults);
+
+    expect(await scaffoldUnitTesting({projectRoot, frameworks, decisions, vcs, visibility, pathWithinParent, dialect}))
+      .toEqual(mergedResults);
+  });
+});