749 lines
25 KiB
JavaScript
749 lines
25 KiB
JavaScript
const sinon = require('sinon');
|
|
const pathLib = require('path');
|
|
const { expect } = require('chai');
|
|
const commander = require('commander');
|
|
const {
|
|
mockProject,
|
|
restoreMockedProjects,
|
|
mockTargetAndReferenceProject,
|
|
} = require('../../test-helpers/mock-project-helpers.js');
|
|
const {
|
|
mockWriteToJson,
|
|
restoreWriteToJson,
|
|
} = require('../../test-helpers/mock-report-service-helpers.js');
|
|
const {
|
|
suppressNonCriticalLogs,
|
|
restoreSuppressNonCriticalLogs,
|
|
} = require('../../test-helpers/mock-log-service-helpers.js');
|
|
const { InputDataService } = require('../../src/program/services/InputDataService.js');
|
|
const { QueryService } = require('../../src/program/services/QueryService.js');
|
|
const providenceModule = require('../../src/program/providence.js');
|
|
const extendDocsModule = require('../../src/cli/launch-providence-with-extend-docs.js');
|
|
const cliHelpersModule = require('../../src/cli/cli-helpers.js');
|
|
const { cli } = require('../../src/cli/cli.js');
|
|
const promptAnalyzerModule = require('../../src/cli/prompt-analyzer-menu.js');
|
|
const { toPosixPath } = require('../../src/program/utils/to-posix-path.js');
|
|
const { getExtendDocsResults } = require('../../src/cli/launch-providence-with-extend-docs.js');
|
|
|
|
const { pathsArrayFromCs, pathsArrayFromCollectionName, appendProjectDependencyPaths } =
|
|
cliHelpersModule;
|
|
|
|
const queryResults = [];
|
|
|
|
const rootDir = toPosixPath(pathLib.resolve(__dirname, '../../'));
|
|
|
|
const externalCfgMock = {
|
|
searchTargetCollections: {
|
|
'lion-collection': [
|
|
'./providence-input-data/search-targets/example-project-a',
|
|
'./providence-input-data/search-targets/example-project-b',
|
|
// ...etc
|
|
],
|
|
},
|
|
referenceCollections: {
|
|
'lion-based-ui-collection': [
|
|
'./providence-input-data/references/lion-based-ui',
|
|
'./providence-input-data/references/lion-based-ui-labs',
|
|
],
|
|
},
|
|
};
|
|
|
|
async function runCli(args, cwd) {
|
|
process.argv = [
|
|
...process.argv.slice(0, 2),
|
|
...args.split(' ').map(a => a.replace(/^("|')?(.*)("|')?$/, '$2')),
|
|
];
|
|
await cli({ cwd });
|
|
}
|
|
|
|
describe('Providence CLI', () => {
|
|
let providenceStub;
|
|
let promptCfgStub;
|
|
let iExtConfStub;
|
|
let promptStub;
|
|
let qConfStub;
|
|
|
|
before(() => {
|
|
// Prevent MaxListenersExceededWarning
|
|
commander.setMaxListeners(100);
|
|
|
|
mockWriteToJson(queryResults);
|
|
suppressNonCriticalLogs();
|
|
|
|
mockProject(
|
|
{
|
|
'./src/OriginalComp.js': `export class OriginalComp {}`,
|
|
'./src/inbetween.js': `export { OriginalComp as InBetweenComp } from './OriginalComp.js'`,
|
|
'./index.js': `export { InBetweenComp as MyComp } from './src/inbetween.js'`,
|
|
'./node_modules/dependency-a/index.js': '',
|
|
'./bower_components/dependency-b/index.js': '',
|
|
},
|
|
{
|
|
projectName: 'example-project',
|
|
projectPath: '/mocked/path/example-project',
|
|
},
|
|
);
|
|
|
|
providenceStub = sinon.stub(providenceModule, 'providence').returns(
|
|
new Promise(resolve => {
|
|
resolve();
|
|
}),
|
|
);
|
|
|
|
promptCfgStub = sinon
|
|
.stub(promptAnalyzerModule, 'promptAnalyzerConfigMenu')
|
|
.returns({ analyzerConfig: { con: 'fig' } });
|
|
|
|
iExtConfStub = sinon.stub(InputDataService, 'getExternalConfig').returns(externalCfgMock);
|
|
|
|
promptStub = sinon
|
|
.stub(promptAnalyzerModule, 'promptAnalyzerMenu')
|
|
.returns({ analyzerName: 'mock-analyzer' });
|
|
|
|
qConfStub = sinon.stub(QueryService, 'getQueryConfigFromAnalyzer').returns({
|
|
analyzer: {
|
|
name: 'mock-analyzer',
|
|
requiresReference: true,
|
|
},
|
|
});
|
|
});
|
|
|
|
after(() => {
|
|
commander.setMaxListeners(10);
|
|
|
|
restoreSuppressNonCriticalLogs();
|
|
restoreMockedProjects();
|
|
restoreWriteToJson();
|
|
|
|
providenceStub.restore();
|
|
promptCfgStub.restore();
|
|
iExtConfStub.restore();
|
|
promptStub.restore();
|
|
qConfStub.restore();
|
|
});
|
|
|
|
afterEach(() => {
|
|
providenceStub.resetHistory();
|
|
promptCfgStub.resetHistory();
|
|
iExtConfStub.resetHistory();
|
|
promptStub.resetHistory();
|
|
qConfStub.resetHistory();
|
|
});
|
|
|
|
const analyzeCmd = 'analyze mock-analyzer';
|
|
|
|
it('calls providence', async () => {
|
|
await runCli(`${analyzeCmd} -t /mocked/path/example-project`);
|
|
expect(providenceStub.called).to.be.true;
|
|
});
|
|
|
|
it('creates a QueryConfig', async () => {
|
|
await runCli(`${analyzeCmd} -t /mocked/path/example-project`);
|
|
expect(qConfStub.called).to.be.true;
|
|
expect(qConfStub.args[0][0]).to.equal('mock-analyzer');
|
|
});
|
|
|
|
describe('Global options', () => {
|
|
let pathsArrayFromCollectionStub;
|
|
let pathsArrayFromCsStub;
|
|
let appendProjectDependencyPathsStub;
|
|
|
|
before(() => {
|
|
pathsArrayFromCsStub = sinon
|
|
.stub(cliHelpersModule, 'pathsArrayFromCs')
|
|
.returns(['/mocked/path/example-project']);
|
|
pathsArrayFromCollectionStub = sinon
|
|
.stub(cliHelpersModule, 'pathsArrayFromCollectionName')
|
|
.returns(['/mocked/path/example-project']);
|
|
appendProjectDependencyPathsStub = sinon
|
|
.stub(cliHelpersModule, 'appendProjectDependencyPaths')
|
|
.returns([
|
|
'/mocked/path/example-project',
|
|
'/mocked/path/example-project/node_modules/mock-dep-a',
|
|
'/mocked/path/example-project/bower_components/mock-dep-b',
|
|
]);
|
|
});
|
|
|
|
after(() => {
|
|
pathsArrayFromCsStub.restore();
|
|
pathsArrayFromCollectionStub.restore();
|
|
appendProjectDependencyPathsStub.restore();
|
|
});
|
|
|
|
afterEach(() => {
|
|
pathsArrayFromCsStub.resetHistory();
|
|
pathsArrayFromCollectionStub.resetHistory();
|
|
appendProjectDependencyPathsStub.resetHistory();
|
|
});
|
|
|
|
it('"-e --extensions"', async () => {
|
|
await runCli(`${analyzeCmd} -e bla,blu`);
|
|
expect(providenceStub.args[0][1].gatherFilesConfig.extensions).to.eql(['.bla', '.blu']);
|
|
|
|
providenceStub.resetHistory();
|
|
|
|
await runCli(`${analyzeCmd} --extensions bla,blu`);
|
|
expect(providenceStub.args[0][1].gatherFilesConfig.extensions).to.eql(['.bla', '.blu']);
|
|
});
|
|
|
|
it('"-t --search-target-paths"', async () => {
|
|
await runCli(`${analyzeCmd} -t /mocked/path/example-project`, rootDir);
|
|
expect(pathsArrayFromCsStub.args[0][0]).to.equal('/mocked/path/example-project');
|
|
expect(providenceStub.args[0][1].targetProjectPaths).to.eql(['/mocked/path/example-project']);
|
|
|
|
pathsArrayFromCsStub.resetHistory();
|
|
providenceStub.resetHistory();
|
|
|
|
await runCli(`${analyzeCmd} --search-target-paths /mocked/path/example-project`, rootDir);
|
|
expect(pathsArrayFromCsStub.args[0][0]).to.equal('/mocked/path/example-project');
|
|
expect(providenceStub.args[0][1].targetProjectPaths).to.eql(['/mocked/path/example-project']);
|
|
});
|
|
|
|
it('"-r --reference-paths"', async () => {
|
|
await runCli(`${analyzeCmd} -r /mocked/path/example-project`, rootDir);
|
|
expect(pathsArrayFromCsStub.args[0][0]).to.equal('/mocked/path/example-project');
|
|
expect(providenceStub.args[0][1].referenceProjectPaths).to.eql([
|
|
'/mocked/path/example-project',
|
|
]);
|
|
|
|
pathsArrayFromCsStub.resetHistory();
|
|
providenceStub.resetHistory();
|
|
|
|
await runCli(`${analyzeCmd} --reference-paths /mocked/path/example-project`, rootDir);
|
|
expect(pathsArrayFromCsStub.args[0][0]).to.equal('/mocked/path/example-project');
|
|
expect(providenceStub.args[0][1].referenceProjectPaths).to.eql([
|
|
'/mocked/path/example-project',
|
|
]);
|
|
});
|
|
|
|
it('"--search-target-collection"', async () => {
|
|
await runCli(`${analyzeCmd} --search-target-collection lion-collection`, rootDir);
|
|
expect(pathsArrayFromCollectionStub.args[0][0]).to.equal('lion-collection');
|
|
expect(providenceStub.args[0][1].targetProjectPaths).to.eql(['/mocked/path/example-project']);
|
|
});
|
|
|
|
it('"--reference-collection"', async () => {
|
|
await runCli(`${analyzeCmd} --reference-collection lion-based-ui-collection`, rootDir);
|
|
expect(pathsArrayFromCollectionStub.args[0][0]).to.equal('lion-based-ui-collection');
|
|
expect(providenceStub.args[0][1].referenceProjectPaths).to.eql([
|
|
'/mocked/path/example-project',
|
|
]);
|
|
});
|
|
|
|
it('"-a --allowlist"', async () => {
|
|
await runCli(`${analyzeCmd} -a mocked/**/*,rocked/*`, rootDir);
|
|
expect(providenceStub.args[0][1].gatherFilesConfig.allowlist).to.eql([
|
|
'mocked/**/*',
|
|
'rocked/*',
|
|
]);
|
|
|
|
providenceStub.resetHistory();
|
|
|
|
await runCli(`${analyzeCmd} --allowlist mocked/**/*,rocked/*`, rootDir);
|
|
expect(providenceStub.args[0][1].gatherFilesConfig.allowlist).to.eql([
|
|
'mocked/**/*',
|
|
'rocked/*',
|
|
]);
|
|
});
|
|
|
|
it('"--allowlist-reference"', async () => {
|
|
await runCli(`${analyzeCmd} --allowlist-reference mocked/**/*,rocked/*`, rootDir);
|
|
expect(providenceStub.args[0][1].gatherFilesConfigReference.allowlist).to.eql([
|
|
'mocked/**/*',
|
|
'rocked/*',
|
|
]);
|
|
});
|
|
|
|
it('--allowlist-mode', async () => {
|
|
await runCli(`${analyzeCmd} --allowlist-mode git`, rootDir);
|
|
expect(providenceStub.args[0][1].gatherFilesConfig.allowlistMode).to.equal('git');
|
|
});
|
|
|
|
it('--allowlist-mode-reference', async () => {
|
|
await runCli(`${analyzeCmd} --allowlist-mode-reference npm`, rootDir);
|
|
expect(providenceStub.args[0][1].gatherFilesConfigReference.allowlistMode).to.equal('npm');
|
|
});
|
|
|
|
it('"-D --debug"', async () => {
|
|
await runCli(`${analyzeCmd} -D`, rootDir);
|
|
expect(providenceStub.args[0][1].debugEnabled).to.equal(true);
|
|
|
|
providenceStub.resetHistory();
|
|
|
|
await runCli(`${analyzeCmd} --debug`, rootDir);
|
|
expect(providenceStub.args[0][1].debugEnabled).to.equal(true);
|
|
});
|
|
|
|
it('--write-log-file"', async () => {
|
|
await runCli(`${analyzeCmd} --write-log-file`, rootDir);
|
|
expect(providenceStub.args[0][1].writeLogFile).to.equal(true);
|
|
});
|
|
|
|
it('--target-dependencies"', async () => {
|
|
await runCli(`${analyzeCmd}`, rootDir);
|
|
expect(appendProjectDependencyPathsStub.called).to.be.false;
|
|
|
|
appendProjectDependencyPathsStub.resetHistory();
|
|
providenceStub.resetHistory();
|
|
|
|
await runCli(`${analyzeCmd} --target-dependencies`, rootDir);
|
|
expect(appendProjectDependencyPathsStub.called).to.be.true;
|
|
expect(providenceStub.args[0][1].targetProjectPaths).to.eql([
|
|
'/mocked/path/example-project',
|
|
'/mocked/path/example-project/node_modules/mock-dep-a',
|
|
'/mocked/path/example-project/bower_components/mock-dep-b',
|
|
]);
|
|
});
|
|
|
|
it('--target-dependencies /^with-regex/"', async () => {
|
|
await runCli(`${analyzeCmd} --target-dependencies /^mock-/`, rootDir);
|
|
expect(appendProjectDependencyPathsStub.args[0][1]).to.equal('/^mock-/');
|
|
});
|
|
|
|
it('"--skip-check-match-compatibility"', async () => {
|
|
await runCli(`${analyzeCmd} --skip-check-match-compatibility`, rootDir);
|
|
expect(providenceStub.args[0][1].skipCheckMatchCompatibility).to.equal(true);
|
|
});
|
|
});
|
|
|
|
describe('Commands', () => {
|
|
describe('Analyze', () => {
|
|
it('calls providence', async () => {
|
|
await runCli(`${analyzeCmd}`, rootDir);
|
|
expect(providenceStub.called).to.be.true;
|
|
});
|
|
|
|
describe('Options', () => {
|
|
it('"-o --prompt-optional-config"', async () => {
|
|
await runCli(`analyze -o`, rootDir);
|
|
expect(promptStub.called).to.be.true;
|
|
|
|
promptStub.resetHistory();
|
|
|
|
await runCli(`analyze --prompt-optional-config`, rootDir);
|
|
expect(promptStub.called).to.be.true;
|
|
});
|
|
|
|
it('"-c --config"', async () => {
|
|
await runCli(`analyze mock-analyzer -c {"a":"2"}`, rootDir);
|
|
expect(qConfStub.args[0][0]).to.equal('mock-analyzer');
|
|
expect(qConfStub.args[0][1]).to.eql({ a: '2', metaConfig: {} });
|
|
|
|
qConfStub.resetHistory();
|
|
|
|
await runCli(`analyze mock-analyzer --config {"a":"2"}`, rootDir);
|
|
expect(qConfStub.args[0][0]).to.equal('mock-analyzer');
|
|
expect(qConfStub.args[0][1]).to.eql({ a: '2', metaConfig: {} });
|
|
});
|
|
|
|
it('calls "promptAnalyzerConfigMenu" without config given', async () => {
|
|
await runCli(`analyze mock-analyzer`, rootDir);
|
|
expect(promptCfgStub.called).to.be.true;
|
|
});
|
|
});
|
|
});
|
|
|
|
describe.skip('Query', () => {});
|
|
describe.skip('Search', () => {});
|
|
|
|
describe('Manage', () => {});
|
|
|
|
describe('Extend docs', () => {
|
|
let extendDocsStub;
|
|
|
|
before(() => {
|
|
extendDocsStub = sinon
|
|
.stub(extendDocsModule, 'launchProvidenceWithExtendDocs')
|
|
.returns(Promise.resolve());
|
|
});
|
|
|
|
after(() => {
|
|
extendDocsStub.restore();
|
|
});
|
|
|
|
afterEach(() => {
|
|
extendDocsStub.resetHistory();
|
|
});
|
|
|
|
it('allows configuration', async () => {
|
|
await runCli(
|
|
[
|
|
'extend-docs',
|
|
'-t /xyz',
|
|
'-r /xyz/x',
|
|
'--prefix-from pfrom --prefix-to pto',
|
|
'--output-folder /outp',
|
|
'--extensions bla',
|
|
'--allowlist al --allowlist-reference alr',
|
|
].join(' '),
|
|
rootDir,
|
|
);
|
|
expect(extendDocsStub.called).to.be.true;
|
|
expect(extendDocsStub.args[0][0]).to.eql({
|
|
referenceProjectPaths: ['/xyz/x'],
|
|
prefixCfg: {
|
|
from: 'pfrom',
|
|
to: 'pto',
|
|
},
|
|
outputFolder: '/outp',
|
|
extensions: ['.bla'],
|
|
allowlist: ['al'],
|
|
allowlistReference: ['alr'],
|
|
cwd: undefined,
|
|
skipCheckMatchCompatibility: true,
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('CLI helpers', () => {
|
|
describe('pathsArrayFromCs', () => {
|
|
it('allows absolute paths', async () => {
|
|
expect(pathsArrayFromCs('/mocked/path/example-project', rootDir)).to.eql([
|
|
'/mocked/path/example-project',
|
|
]);
|
|
});
|
|
|
|
it('allows relative paths', async () => {
|
|
expect(
|
|
pathsArrayFromCs('./test-helpers/project-mocks/importing-target-project', rootDir),
|
|
).to.eql([`${rootDir}/test-helpers/project-mocks/importing-target-project`]);
|
|
expect(
|
|
pathsArrayFromCs('test-helpers/project-mocks/importing-target-project', rootDir),
|
|
).to.eql([`${rootDir}/test-helpers/project-mocks/importing-target-project`]);
|
|
});
|
|
|
|
it('allows globs', async () => {
|
|
expect(pathsArrayFromCs('test-helpers/project-mocks*', rootDir)).to.eql([
|
|
`${rootDir}/test-helpers/project-mocks`,
|
|
`${rootDir}/test-helpers/project-mocks-analyzer-outputs`,
|
|
]);
|
|
});
|
|
|
|
it('allows multiple comma separated paths', async () => {
|
|
const paths =
|
|
'test-helpers/project-mocks*, ./test-helpers/project-mocks/importing-target-project,/mocked/path/example-project';
|
|
expect(pathsArrayFromCs(paths, rootDir)).to.eql([
|
|
`${rootDir}/test-helpers/project-mocks`,
|
|
`${rootDir}/test-helpers/project-mocks-analyzer-outputs`,
|
|
`${rootDir}/test-helpers/project-mocks/importing-target-project`,
|
|
'/mocked/path/example-project',
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('pathsArrayFromCollectionName', () => {
|
|
it('gets collections from external target config', async () => {
|
|
expect(
|
|
pathsArrayFromCollectionName('lion-collection', 'search-target', externalCfgMock, rootDir),
|
|
).to.eql(
|
|
externalCfgMock.searchTargetCollections['lion-collection'].map(p =>
|
|
toPosixPath(pathLib.join(rootDir, p)),
|
|
),
|
|
);
|
|
});
|
|
|
|
it('gets collections from external reference config', async () => {
|
|
expect(
|
|
pathsArrayFromCollectionName(
|
|
'lion-based-ui-collection',
|
|
'reference',
|
|
externalCfgMock,
|
|
rootDir,
|
|
),
|
|
).to.eql(
|
|
externalCfgMock.referenceCollections['lion-based-ui-collection'].map(p =>
|
|
toPosixPath(pathLib.join(rootDir, p)),
|
|
),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('appendProjectDependencyPaths', () => {
|
|
before(() => {
|
|
mockWriteToJson(queryResults);
|
|
suppressNonCriticalLogs();
|
|
|
|
mockProject(
|
|
{
|
|
'./src/OriginalComp.js': `export class OriginalComp {}`,
|
|
'./src/inbetween.js': `export { OriginalComp as InBetweenComp } from './OriginalComp.js'`,
|
|
'./index.js': `export { InBetweenComp as MyComp } from './src/inbetween.js'`,
|
|
'./node_modules/dependency-a/index.js': '',
|
|
'./bower_components/dependency-b/index.js': '',
|
|
},
|
|
{
|
|
projectName: 'example-project',
|
|
projectPath: '/mocked/path/example-project',
|
|
},
|
|
);
|
|
});
|
|
|
|
it('adds bower and node dependencies', async () => {
|
|
const result = await appendProjectDependencyPaths(['/mocked/path/example-project']);
|
|
expect(result).to.eql([
|
|
'/mocked/path/example-project/node_modules/dependency-a',
|
|
'/mocked/path/example-project/bower_components/dependency-b',
|
|
'/mocked/path/example-project',
|
|
]);
|
|
});
|
|
|
|
it('allows a regex filter', async () => {
|
|
const result = await appendProjectDependencyPaths(
|
|
['/mocked/path/example-project'],
|
|
'/^dependency-/',
|
|
);
|
|
expect(result).to.eql([
|
|
'/mocked/path/example-project/node_modules/dependency-a',
|
|
'/mocked/path/example-project/bower_components/dependency-b',
|
|
'/mocked/path/example-project',
|
|
]);
|
|
|
|
const result2 = await appendProjectDependencyPaths(['/mocked/path/example-project'], '/b$/');
|
|
expect(result2).to.eql([
|
|
'/mocked/path/example-project/bower_components/dependency-b',
|
|
'/mocked/path/example-project',
|
|
]);
|
|
});
|
|
|
|
it('allows to filter out only npm or bower deps', async () => {
|
|
const result = await appendProjectDependencyPaths(['/mocked/path/example-project'], null, [
|
|
'npm',
|
|
]);
|
|
expect(result).to.eql([
|
|
'/mocked/path/example-project/node_modules/dependency-a',
|
|
'/mocked/path/example-project',
|
|
]);
|
|
|
|
const result2 = await appendProjectDependencyPaths(['/mocked/path/example-project'], null, [
|
|
'bower',
|
|
]);
|
|
expect(result2).to.eql([
|
|
'/mocked/path/example-project/bower_components/dependency-b',
|
|
'/mocked/path/example-project',
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('Extend docs', () => {
|
|
afterEach(() => {
|
|
restoreMockedProjects();
|
|
});
|
|
it('rewrites monorepo package paths when analysis is run from monorepo root', async () => {
|
|
const theirProjectFiles = {
|
|
'./package.json': JSON.stringify({
|
|
name: 'their-components',
|
|
version: '1.0.0',
|
|
}),
|
|
'./src/TheirButton.js': `export class TheirButton extends HTMLElement {}`,
|
|
'./src/TheirTooltip.js': `export class TheirTooltip extends HTMLElement {}`,
|
|
'./their-button.js': `
|
|
import { TheirButton } from './src/TheirButton.js';
|
|
|
|
customElements.define('their-button', TheirButton);
|
|
`,
|
|
'./demo.js': `
|
|
import { TheirTooltip } from './src/TheirTooltip.js';
|
|
import './their-button.js';
|
|
`,
|
|
};
|
|
|
|
const myProjectFiles = {
|
|
'./package.json': JSON.stringify({
|
|
name: '@my/root',
|
|
workspaces: ['packages/*', 'another-folder/my-tooltip'],
|
|
dependencies: {
|
|
'their-components': '1.0.0',
|
|
},
|
|
}),
|
|
// Package 1: @my/button
|
|
'./packages/button/package.json': JSON.stringify({
|
|
name: '@my/button',
|
|
}),
|
|
'./packages/button/src/MyButton.js': `
|
|
import { TheirButton } from 'their-components/src/TheirButton.js';
|
|
|
|
export class MyButton extends TheirButton {}
|
|
`,
|
|
'./packages/button/src/my-button.js': `
|
|
import { MyButton } from './MyButton.js';
|
|
|
|
customElements.define('my-button', MyButton);
|
|
`,
|
|
|
|
// Package 2: @my/tooltip
|
|
'./packages/tooltip/package.json': JSON.stringify({
|
|
name: '@my/tooltip',
|
|
}),
|
|
'./packages/tooltip/src/MyTooltip.js': `
|
|
import { TheirTooltip } from 'their-components/src/TheirTooltip.js';
|
|
|
|
export class MyTooltip extends TheirTooltip {}
|
|
`,
|
|
};
|
|
|
|
const theirProject = {
|
|
path: '/my-components/node_modules/their-components',
|
|
name: 'their-components',
|
|
files: Object.entries(theirProjectFiles).map(([file, code]) => ({ file, code })),
|
|
};
|
|
|
|
const myProject = {
|
|
path: '/my-components',
|
|
name: 'my-components',
|
|
files: Object.entries(myProjectFiles).map(([file, code]) => ({ file, code })),
|
|
};
|
|
|
|
mockTargetAndReferenceProject(theirProject, myProject);
|
|
|
|
const result = await getExtendDocsResults({
|
|
referenceProjectPaths: [theirProject.path],
|
|
prefixCfg: { from: 'their', to: 'my' },
|
|
extensions: ['.js'],
|
|
cwd: '/my-components',
|
|
});
|
|
|
|
expect(result).to.eql([
|
|
{
|
|
name: 'TheirButton',
|
|
variable: {
|
|
from: 'TheirButton',
|
|
to: 'MyButton',
|
|
paths: [
|
|
{
|
|
from: './src/TheirButton.js',
|
|
to: '@my/button/src/MyButton.js', // rewritten from './packages/button/src/MyButton.js',
|
|
},
|
|
{
|
|
from: 'their-components/src/TheirButton.js',
|
|
to: '@my/button/src/MyButton.js', // rewritten from './packages/button/src/MyButton.js',
|
|
},
|
|
],
|
|
},
|
|
tag: {
|
|
from: 'their-button',
|
|
to: 'my-button',
|
|
paths: [
|
|
{
|
|
from: './their-button.js',
|
|
to: '@my/button/src/my-button.js', // rewritten from './packages/button/src/MyButton.js',
|
|
},
|
|
{
|
|
from: 'their-components/their-button.js',
|
|
to: '@my/button/src/my-button.js', // rewritten from './packages/button/src/MyButton.js',
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
name: 'TheirTooltip',
|
|
variable: {
|
|
from: 'TheirTooltip',
|
|
to: 'MyTooltip',
|
|
paths: [
|
|
{
|
|
from: './src/TheirTooltip.js',
|
|
to: '@my/tooltip/src/MyTooltip.js', // './packages/tooltip/src/MyTooltip.js',
|
|
},
|
|
{
|
|
from: 'their-components/src/TheirTooltip.js',
|
|
to: '@my/tooltip/src/MyTooltip.js', // './packages/tooltip/src/MyTooltip.js',
|
|
},
|
|
],
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('does not check for match compatibility (target and reference) in monorepo targets', async () => {
|
|
// ===== REFERENCE AND TARGET PROJECTS =====
|
|
|
|
const theirProjectFiles = {
|
|
'./package.json': JSON.stringify({
|
|
name: 'their-components',
|
|
version: '1.0.0',
|
|
}),
|
|
'./src/TheirButton.js': `export class TheirButton extends HTMLElement {}`,
|
|
};
|
|
|
|
// This will be detected as being a monorepo
|
|
const monoProjectFiles = {
|
|
'./package.json': JSON.stringify({
|
|
name: '@mono/root',
|
|
workspaces: ['packages/*'],
|
|
dependencies: {
|
|
'their-components': '1.0.0',
|
|
},
|
|
}),
|
|
// Package: @mono/button
|
|
'./packages/button/package.json': JSON.stringify({
|
|
name: '@mono/button',
|
|
}),
|
|
};
|
|
|
|
// This will be detected as NOT being a monorepo
|
|
const nonMonoProjectFiles = {
|
|
'./package.json': JSON.stringify({
|
|
name: 'non-mono',
|
|
dependencies: {
|
|
'their-components': '1.0.0',
|
|
},
|
|
}),
|
|
};
|
|
|
|
const theirProject = {
|
|
path: '/their-components',
|
|
name: 'their-components',
|
|
files: Object.entries(theirProjectFiles).map(([file, code]) => ({ file, code })),
|
|
};
|
|
|
|
const monoProject = {
|
|
path: '/mono-components',
|
|
name: 'mono-components',
|
|
files: Object.entries(monoProjectFiles).map(([file, code]) => ({ file, code })),
|
|
};
|
|
|
|
const nonMonoProject = {
|
|
path: '/non-mono-components',
|
|
name: 'non-mono-components',
|
|
files: Object.entries(nonMonoProjectFiles).map(([file, code]) => ({ file, code })),
|
|
};
|
|
|
|
// ===== TESTS =====
|
|
|
|
const providenceStub = sinon.stub(providenceModule, 'providence').returns(
|
|
new Promise(resolve => {
|
|
resolve([]);
|
|
}),
|
|
);
|
|
|
|
// ===== mono =====
|
|
|
|
mockTargetAndReferenceProject(theirProject, monoProject);
|
|
await getExtendDocsResults({
|
|
referenceProjectPaths: ['/their-components'],
|
|
prefixCfg: { from: 'their', to: 'my' },
|
|
extensions: ['.js'],
|
|
cwd: '/mono-components',
|
|
});
|
|
|
|
expect(providenceStub.args[0][1].skipCheckMatchCompatibility).to.equal(true);
|
|
providenceStub.resetHistory();
|
|
restoreMockedProjects();
|
|
|
|
// ===== non mono =====
|
|
|
|
mockTargetAndReferenceProject(theirProject, nonMonoProject);
|
|
await getExtendDocsResults({
|
|
referenceProjectPaths: ['/their-components'],
|
|
prefixCfg: { from: 'their', to: 'my' },
|
|
extensions: ['.js'],
|
|
cwd: '/non-mono-components',
|
|
});
|
|
expect(providenceStub.args[0][1].skipCheckMatchCompatibility).to.equal(false);
|
|
|
|
providenceStub.restore();
|
|
});
|
|
});
|
|
});
|