@form8ion/javascript 15.6.0 → 15.6.2

package/src/vcs/ignore-lists-builder.test.js

@@ -0,0 +1,25 @@
+import any from '@travi/any';
+import {describe, expect, it} from 'vitest';
+
+import buildVcsIgnoreLists from './ignore-lists-builder.js';
+
+describe('vcs-ignore lists builder', () => {
+  const vcsIgnore = {files: any.listOf(any.word), directories: any.listOf(any.word)};
+
+  it('should define the default lists', () => {
+    expect(buildVcsIgnoreLists(vcsIgnore))
+      .toEqual({files: vcsIgnore.files, directories: ['/node_modules/', ...vcsIgnore.directories]});
+  });
+
+  it('should default the file list to empty', () => {
+    expect(buildVcsIgnoreLists({...vcsIgnore, files: undefined}).files).toEqual([]);
+  });
+
+  it('should default the directories list to contain `node_modules', () => {
+    expect(buildVcsIgnoreLists({...vcsIgnore, directories: undefined}).directories).toEqual(['/node_modules/']);
+  });
+
+  it('should produce default lists when ignores are missing', () => {
+    expect(buildVcsIgnoreLists()).toEqual({files: [], directories: ['/node_modules/']});
+  });
+});

package/src/vcs/schema.js

@@ -0,0 +1,7 @@
+import joi from 'joi';
+
+export const vcsSchema = joi.object({
+  host: joi.string().required(),
+  owner: joi.string().required(),
+  name: joi.string().required()
+});

package/src/vcs/schema.test.js

@@ -0,0 +1,40 @@
+import {validateOptions} from '@form8ion/core';
+
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import {vcsSchema} from './schema.js';
+
+describe('vcs', () => {
+  it('should require `vcs` to be an object', () => {
+    expect(() => validateOptions(vcsSchema, [])).toThrowError('"value" must be of type object');
+  });
+
+  it('should require `host`', () => {
+    expect(() => validateOptions(vcsSchema, {})).toThrowError('"host" is required');
+  });
+
+  it('should require `host` to be a string', () => {
+    expect(() => validateOptions(vcsSchema, {host: any.integer()}))
+      .toThrowError('"host" must be a string');
+  });
+
+  it('should require `owner`', () => {
+    expect(() => validateOptions(vcsSchema, {host: any.word()})).toThrowError('"owner" is required');
+  });
+
+  it('should require `owner` to be a string', () => {
+    expect(() => validateOptions(vcsSchema, {host: any.word(), owner: any.integer()}))
+      .toThrowError('"owner" must be a string');
+  });
+
+  it('should require `name`', () => {
+    expect(() => validateOptions(vcsSchema, {host: any.word(), owner: any.word()}))
+      .toThrowError('"name" is required');
+  });
+
+  it('should require `name` to be a string', () => {
+    expect(() => validateOptions(vcsSchema, {host: any.word(), owner: any.word(), name: any.integer()}))
+      .toThrowError('"name" must be a string');
+  });
+});

package/src/verification/index.js

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

package/src/verification/scaffolder.js

@@ -0,0 +1,25 @@
+import deepmerge from 'deepmerge';
+import {scaffold as scaffoldHusky} from '@form8ion/husky';
+
+import {scaffold as scaffoldTesting} from '../testing/index.js';
+import {scaffold as scaffoldLinting} from '../linting/index.js';
+
+export async function scaffoldVerification({
+  projectRoot,
+  dialect,
+  packageManager,
+  vcs,
+  registries,
+  tests,
+  unitTestFrameworks,
+  decisions,
+  pathWithinParent
+}) {
+  const [testingResults, lintingResults, huskyResults] = await Promise.all([
+    scaffoldTesting({projectRoot, tests, unitTestFrameworks, decisions, dialect}),
+    scaffoldLinting({projectRoot, packageManager, registries, vcs, pathWithinParent}),
+    scaffoldHusky({projectRoot, packageManager, pathWithinParent})
+  ]);
+
+  return deepmerge.all([testingResults, lintingResults, huskyResults]);
+}

package/src/verification/scaffolder.test.js

@@ -0,0 +1,54 @@
+import deepmerge from 'deepmerge';
+import {scaffold as scaffoldHusky} from '@form8ion/husky';
+
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {scaffold as scaffoldTesting} from '../testing/index.js';
+import {scaffold as scaffoldLinting} from '../linting/index.js';
+import {scaffoldVerification} from './scaffolder.js';
+
+vi.mock('deepmerge');
+vi.mock('@form8ion/husky');
+vi.mock('../testing/index.js');
+vi.mock('../linting/index.js');
+
+describe('verification scaffolder', () => {
+  it('should scaffold linting and testing', async () => {
+    const projectRoot = any.string();
+    const packageManager = any.string();
+    const dialect = any.word();
+    const vcs = any.simpleObject();
+    const tests = any.simpleObject();
+    const unitTestFrameworks = any.simpleObject();
+    const decisions = any.simpleObject();
+    const lintingResults = any.simpleObject();
+    const huskyResults = any.simpleObject();
+    const testingEslintResults = any.simpleObject();
+    const pathWithinParent = any.string();
+    const testingResults = {...any.simpleObject(), eslint: testingEslintResults};
+    const registries = any.simpleObject();
+    const mergedResults = any.simpleObject();
+    when(scaffoldLinting)
+      .calledWith({projectRoot, vcs, packageManager, registries, pathWithinParent})
+      .thenResolve(lintingResults);
+    when(scaffoldTesting)
+      .calledWith({projectRoot, tests, unitTestFrameworks, decisions, dialect})
+      .thenResolve(testingResults);
+    when(scaffoldHusky).calledWith({projectRoot, packageManager, pathWithinParent}).thenResolve(huskyResults);
+    when(deepmerge.all).calledWith([testingResults, lintingResults, huskyResults]).thenReturn(mergedResults);
+
+    expect(await scaffoldVerification({
+      projectRoot,
+      vcs,
+      dialect,
+      tests,
+      decisions,
+      unitTestFrameworks,
+      packageManager,
+      registries,
+      pathWithinParent
+    })).toEqual(mergedResults);
+  });
+});