From 920fbfc5ea27f689aeb38beb6540c41838225c8d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20O=C3=9Fwald?= <1410947+matz3@users.noreply.github.com> Date: Wed, 1 Apr 2020 11:41:05 +0200 Subject: [PATCH] [FEATURE] Add "ui5 use/add" commands (#315) Co-authored-by: Merlin Beutlberger --- bin/ui5.js | 4 + lib/cli/commands/add.js | 88 ++++ lib/cli/commands/use.js | 83 +++ lib/framework/add.js | 77 +++ lib/framework/updateYaml.js | 250 +++++++++ lib/framework/use.js | 72 +++ lib/framework/utils.js | 28 ++ npm-shrinkwrap.json | 19 +- package.json | 2 + test/lib/cli/commands/add.js | 186 +++++++ test/lib/cli/commands/use.js | 228 +++++++++ test/lib/framework/add.js | 564 +++++++++++++++++++++ test/lib/framework/updateYaml.js | 511 +++++++++++++++++++ test/lib/framework/use.js | 837 +++++++++++++++++++++++++++++++ 14 files changed, 2946 insertions(+), 3 deletions(-) create mode 100644 lib/cli/commands/add.js create mode 100644 lib/cli/commands/use.js create mode 100644 lib/framework/add.js create mode 100644 lib/framework/updateYaml.js create mode 100644 lib/framework/use.js create mode 100644 lib/framework/utils.js create mode 100644 test/lib/cli/commands/add.js create mode 100644 test/lib/cli/commands/use.js create mode 100644 test/lib/framework/add.js create mode 100644 test/lib/framework/updateYaml.js create mode 100644 test/lib/framework/use.js diff --git a/bin/ui5.js b/bin/ui5.js index 847d506e..618a20cd 100755 --- a/bin/ui5.js +++ b/bin/ui5.js @@ -45,6 +45,10 @@ setTimeout(() => { shouldNotifyInNpmScript: true }).notify(); + cli.parserConfiguration({ + "parse-numbers": false + }); + // Explicitly set CLI version as the yargs default might // be wrong in case a local CLI installation is used // Also add CLI location diff --git a/lib/cli/commands/add.js b/lib/cli/commands/add.js new file mode 100644 index 00000000..5c590ace --- /dev/null +++ b/lib/cli/commands/add.js @@ -0,0 +1,88 @@ +// Add +const addCommand = { + command: "add [--development] [--optional] ", + describe: "Add SAPUI5/OpenUI5 framework libraries to the project configuration.", + middlewares: [require("../middlewares/base.js")] +}; + +addCommand.builder = function(cli) { + return cli + .positional("framework-libraries", { + describe: "Framework library names", + type: "string" + }).option("development", { + describe: "Add as development dependency", + alias: ["D", "dev"], + default: false, + type: "boolean" + }).option("optional", { + describe: "Add as optional dependency", + alias: ["O"], + default: false, + type: "boolean" + }) + .example("$0 add sap.ui.core sap.m", "Add the framework libraries sap.ui.core and sap.m as dependencies") + .example("$0 add -D sap.ui.support", "Add the framework library sap.ui.support as development dependency") + .example("$0 add --optional themelib_sap_fiori_3", + "Add the framework library themelib_sap_fiori_3 as optional dependency"); +}; + +addCommand.handler = async function(argv) { + const libraryNames = argv["framework-libraries"] || []; + const development = argv["development"]; + const optional = argv["optional"]; + + if (libraryNames.length === 0) { + // Should not happen via yargs as parameter is mandatory + throw new Error("Missing mandatory parameter framework-libraries"); + } + + if (development && optional) { + throw new Error("Options 'development' and 'optional' cannot be combined"); + } + + const normalizerOptions = { + translatorName: argv.translator, + configPath: argv.config + }; + + const libraries = libraryNames.map((name) => { + const library = {name}; + if (optional) { + library.optional = true; + } else if (development) { + library.development = true; + } + return library; + }); + + const {yamlUpdated} = await require("../../framework/add")({ + normalizerOptions, + libraries + }); + + const library = libraries.length === 1 ? "library": "libraries"; + if (!yamlUpdated) { + if (argv.config) { + throw new Error( + `Internal error while adding framework ${library} ${libraryNames.join(" ")} to config at ${argv.config}` + ); + } else { + throw new Error( + `Internal error while adding framework ${library} ${libraryNames.join(" ")} to ui5.yaml` + ); + } + } else { + console.log(`Updated configuration written to ${argv.config || "ui5.yaml"}`); + let logMessage = `Added framework ${library} ${libraryNames.join(" ")} as`; + if (development) { + logMessage += " development"; + } else if (optional) { + logMessage += " optional"; + } + logMessage += libraries.length === 1 ? " dependency": " dependencies"; + console.log(logMessage); + } +}; + +module.exports = addCommand; diff --git a/lib/cli/commands/use.js b/lib/cli/commands/use.js new file mode 100644 index 00000000..8e9b01ef --- /dev/null +++ b/lib/cli/commands/use.js @@ -0,0 +1,83 @@ +// Use +const useCommand = { + command: "use ", + describe: "Initialize or update the project's framework configuration.", + middlewares: [require("../middlewares/base.js")] +}; + +useCommand.builder = function(cli) { + return cli + .positional("framework-info", { + describe: "Framework name, version or both (name@version).\n" + + "Name can be \"SAPUI5\" or \"OpenUI5\" (case-insensitive).\n" + + "Version can be \"latest\", \"1.xx\" or \"1.xx.x\".", + type: "string" + }) + .example("$0 use sapui5@latest", "Use SAPUI5 in the latest available version") + .example("$0 use openui5@1.76", "Use OpenUI5 in the latest available 1.76 patch version") + .example("$0 use latest", "Use the latest available version of the configured framework") + .example("$0 use openui5", "Use OpenUI5 without a version (or use existing version)"); +}; + +const versionRegExp = /^(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/; + +function parseFrameworkInfo(frameworkInfo) { + const parts = frameworkInfo.split("@"); + if (parts.length > 2) { + // More than one @ sign + throw new Error("Invalid framework info: " + frameworkInfo); + } + if (parts.length === 1) { + // No @ sign, only name or version + const nameOrVersion = parts[0]; + if (!nameOrVersion) { + throw new Error("Invalid framework info: " + frameworkInfo); + } + if (nameOrVersion === "latest" || versionRegExp.test(nameOrVersion)) { + return { + name: null, + version: nameOrVersion + }; + } else { + return { + name: nameOrVersion, + version: null + }; + } + } else { + const [name, version] = parts; + if (!name || !version) { + throw new Error("Invalid framework info: " + frameworkInfo); + } + return {name, version}; + } +} + +useCommand.handler = async function(argv) { + const frameworkOptions = parseFrameworkInfo(argv["framework-info"]); + + const normalizerOptions = { + translatorName: argv.translator, + configPath: argv.config + }; + + const {usedFramework, usedVersion, yamlUpdated} = await require("../../framework/use")({ + normalizerOptions, + frameworkOptions + }); + + if (!yamlUpdated) { + if (argv.config) { + throw new Error( + `Internal error while updating config at ${argv.config} to ${usedFramework} version ${usedVersion}` + ); + } else { + throw new Error(`Internal error while updating ui5.yaml to ${usedFramework} version ${usedVersion}`); + } + } else { + console.log(`Updated configuration written to ${argv.config || "ui5.yaml"}`); + console.log(`This project is now using ${usedFramework} version ${usedVersion}`); + } +}; + +module.exports = useCommand; diff --git a/lib/framework/add.js b/lib/framework/add.js new file mode 100644 index 00000000..e53448f8 --- /dev/null +++ b/lib/framework/add.js @@ -0,0 +1,77 @@ +const {getRootProjectConfiguration, getFrameworkResolver, isValidSpecVersion} = require("./utils"); + +module.exports = async function({normalizerOptions, libraries}) { + const project = await getRootProjectConfiguration({normalizerOptions}); + + if (!isValidSpecVersion(project.specVersion)) { + throw new Error( + `ui5 add command requires specVersion "2.0" or higher. ` + + `Project ${project.metadata.name} uses specVersion "${project.specVersion}"` + ); + } + + if (!project.framework) { + throw new Error( + `Project ${project.metadata.name} is missing a framework configuration. ` + + `Please use "ui5 use" to configure a framework and version.` + ); + } + if (!project.framework.version) { + throw new Error( + `Project ${project.metadata.name} does not define a framework version configuration. ` + + `Please use "ui5 use" to configure a version.` + ); + } + + const Resolver = getFrameworkResolver(project.framework.name); + + const resolver = new Resolver({ + cwd: project.path, + version: project.framework.version + }); + + // Get metadata of all libraries to verify that they can be installed + await Promise.all(libraries.map(async ({name}) => { + try { + await resolver.getLibraryMetadata(name); + } catch (err) { + throw new Error(`Failed to find ${project.framework.name} framework library ${name}: ` + err.message); + } + })); + + // Shallow copy of given libraries to not modify the input parameter when pushing other libraries + const allLibraries = [...libraries]; + + if (project.framework.libraries) { + project.framework.libraries.forEach((library) => { + // Don't add libraries twice! + if (allLibraries.findIndex(($) => $.name === library.name) === -1) { + allLibraries.push(library); + } + }); + } + allLibraries.sort((a, b) => { + return a.name.localeCompare(b.name); + }); + + // Try to update YAML file but still return with name and resolved version in case it failed + let yamlUpdated = false; + try { + await require("./updateYaml")({ + project, + data: { + framework: { + libraries: allLibraries + } + } + }); + yamlUpdated = true; + } catch (err) { + if (err.name !== "FrameworkUpdateYamlFailed") { + throw err; + } + } + return { + yamlUpdated + }; +}; diff --git a/lib/framework/updateYaml.js b/lib/framework/updateYaml.js new file mode 100644 index 00000000..850b3e17 --- /dev/null +++ b/lib/framework/updateYaml.js @@ -0,0 +1,250 @@ +const path = require("path"); +const log = require("@ui5/logger").getLogger("cli:framework:updateYaml"); +const {loadAll, safeDump, DEFAULT_SAFE_SCHEMA} = require("js-yaml"); +const {fromYaml, getPosition, getValue} = require("data-with-position"); + +function safeLoadAll({configFile, configPath}) { + // Using loadAll with DEFAULT_SAFE_SCHEMA instead of safeLoadAll to pass "filename". + // safeLoadAll doesn't handle its parameters properly. + // See https://github.com/nodeca/js-yaml/issues/456 and https://github.com/nodeca/js-yaml/pull/381 + return loadAll(configFile, undefined, { + filename: configPath, + schema: DEFAULT_SAFE_SCHEMA + }); +} + +function getProjectYamlDocument({project, configFile, configPath}) { + const configs = safeLoadAll({configFile, configPath}); + + const projectDocumentIndex = configs.findIndex((config) => { + return config.metadata && config.metadata.name === project.metadata.name; + }); + if (projectDocumentIndex === -1) { + throw new Error( + `Could not find project with name ${project.metadata.name} in YAML: ${configPath}` + ); + } + + const matchAll = require("string.prototype.matchall"); + const matchDocumentSeparator = /^---/gm; + const documents = matchAll(configFile, matchDocumentSeparator); + let currentDocumentIndex = 0; + let currentIndex = 0; + for (const document of documents) { + // If the first separator is not at the beginning of the file + // we are already at document index 1 + // Using String#trim() to remove any whitespace characters + if (currentDocumentIndex === 0 && configFile.substring(0, document.index).trim().length > 0) { + currentDocumentIndex = 1; + } + + if (currentDocumentIndex === projectDocumentIndex) { + currentIndex = document.index; + break; + } + + currentDocumentIndex++; + } + + return { + projectDocumentContent: configFile.substring(currentIndex), + projectDocumentStartIndex: currentIndex + }; +} + +function applyChanges(string, changes) { + function positionToIndex(position) { + // Match the n-th line-ending to find the start of the given line + const lineStartPattern = new RegExp("(?:(?:\r?\n)([^\r\n]*)){" + (position.line - 1) + "}"); + const lineStartMatch = lineStartPattern.exec(string); + if (!lineStartMatch) { + throw new Error("Could not find line start!"); + } + // Add column number -1 (as column 1 starts at index 0) + return lineStartMatch.index + lineStartMatch[0].length - lineStartMatch[1].length + position.column - 1; + } + + const indexReplacements = changes.map((change) => { + if (change.type === "update") { + return { + startIndex: positionToIndex(change.position.start), + endIndex: positionToIndex(change.position.end), + value: change.value + }; + } else if (change.type === "insert") { + return { + startIndex: positionToIndex(change.parentPosition.end) + 1, + endIndex: positionToIndex(change.parentPosition.end) + 1, + value: change.value + }; + } + }).sort((a, b) => { + // Sort decending by endIndex + // This means replacements are done from bottom to top to not affect length/index of upcoming replacements + + if (a.endIndex < b.endIndex) { + return 1; + } + if (a.endIndex > b.endIndex) { + return -1; + } + return 0; + }); + + const array = Array.from(string); + indexReplacements.forEach((indexReplacement) => { + array.splice( + /* index */ indexReplacement.startIndex, + /* count */ indexReplacement.endIndex - indexReplacement.startIndex, + /* insert */ indexReplacement.value + ); + }); + return array.join(""); +} + +function getValueFromPath(data, path) { + return path.reduce((currentData, pathSegment) => { + return currentData[pathSegment]; + }, data); +} + +function getPositionFromPath(positionData, path) { + return getPosition(getValueFromPath(positionData, path)); +} + +function formatValue(value, indent) { + if (typeof value === "string") { + // TOOD: Use better logic? + if (value.includes(".")) { + return ` "${value}"`; // Put quotes around versions + } else { + return " " + value; + } + } else if (typeof value === "object" && !Array.isArray(value)) { + let string = "\n"; + Object.keys(value).forEach((key, i, arr) => { + const entry = value[key]; + string += " ".repeat(indent) + key + ":" + formatValue(entry); + if (i < arr.length - 1) { + string += "\n"; + } + }); + return string; + } else if (Array.isArray(value)) { + const indentString = " ".repeat(indent); + const string = safeDump(value); + const arr = string.split("\n"); + arr.pop(); + return "\n" + indentString + arr.join("\n" + indentString); + } +} + +module.exports = async function({project, data}) { + const {promisify} = require("util"); + const fs = require("fs"); + const readFile = promisify(fs.readFile); + const writeFile = promisify(fs.writeFile); + + const configPath = project.configPath || path.join(project.path, "ui5.yaml"); + const configFile = await readFile(configPath, {encoding: "utf8"}); + + let { + projectDocumentContent, + projectDocumentStartIndex + } = await getProjectYamlDocument({ + project, + configFile, + configPath + }); + + const positionData = fromYaml(projectDocumentContent); + + const changes = []; + + function addInsert(entryPath, newValue) { + // New + const parentPath = entryPath.slice(0, -1); + const parentData = getValueFromPath(positionData, parentPath); + const parentPosition = getPosition(parentData); + const siblings = Object.keys(parentData); + let indent; + if (siblings.length === 0) { + indent = parentPosition.start.column - 1; + } else { + const firstSiblingPosition = getPosition(parentData[siblings[0]]); + indent = firstSiblingPosition.start.column - 1; + } + changes.push({ + type: "insert", + parentPosition, + value: `${" ".repeat(indent)}${entryPath[entryPath.length - 1]}:${formatValue(newValue, indent + 2)}\n` + }); + } + + function addUpdate(entryPath, newValue) { + const position = getPositionFromPath(positionData, entryPath); + // -1 as column 1 starts at index 0 + const indent = position.start.column - 1; + changes.push({ + type: "update", + position: getPositionFromPath(positionData, entryPath), + value: `${entryPath[entryPath.length - 1]}:${formatValue(newValue, indent + 2)}` + }); + } + + if (!positionData.framework) { + addInsert(["framework"], data.framework); + } else { + if (data.framework.name) { + if (!positionData.framework.name) { + addInsert(["framework", "name"], data.framework.name); + } else if (getValue(positionData.framework.name) !== data.framework.name) { + addUpdate(["framework", "name"], data.framework.name); + } + } + if (data.framework.version) { + if (!positionData.framework.version) { + addInsert(["framework", "version"], data.framework.version); + } else if (getValue(positionData.framework.version) !== data.framework.version) { + addUpdate(["framework", "version"], data.framework.version); + } + } + if (data.framework.libraries) { + if (!positionData.framework.libraries) { + addInsert(["framework", "libraries"], data.framework.libraries); + } else { + addUpdate(["framework", "libraries"], data.framework.libraries); + } + } + } + + // TODO: detect windows line-endings + if (!projectDocumentContent.endsWith("\n")) { + projectDocumentContent += "\n"; + } + + const adoptedProjectYaml = applyChanges(projectDocumentContent, changes); + + const array = Array.from(configFile); + array.splice(projectDocumentStartIndex, projectDocumentContent.length, adoptedProjectYaml); + let adoptedYaml = array.join(""); + + // TODO: detect windows line-endings + if (!adoptedYaml.endsWith("\n")) { + adoptedYaml += "\n"; + } + + // Validate content before writing + try { + safeLoadAll({configFile: adoptedYaml}); + } catch (err) { + const error = new Error("Failed to update YAML file: " + err.message); + error.name = "FrameworkUpdateYamlFailed"; + log.verbose(error.message); + log.verbose(`Original YAML (${configPath}):\n` + configFile); + log.verbose("Updated YAML:\n" + adoptedYaml); + throw error; + } + + await writeFile(configPath, adoptedYaml); +}; diff --git a/lib/framework/use.js b/lib/framework/use.js new file mode 100644 index 00000000..4730400c --- /dev/null +++ b/lib/framework/use.js @@ -0,0 +1,72 @@ +const {getRootProjectConfiguration, getFrameworkResolver, isValidSpecVersion} = require("./utils"); + +async function resolveVersion({frameworkName, frameworkVersion}, resolverOptions) { + return await getFrameworkResolver(frameworkName).resolveVersion(frameworkVersion, resolverOptions); +} + +function getEffectiveFrameworkName({project, frameworkOptions}) { + if (!project.framework && !frameworkOptions.name) { + throw new Error("No framework configuration defined. Make sure to also provide the framework name."); + } + if (project.framework && !project.framework.name) { + // This should not happen as the configuration should have been validated against the schema + throw new Error(`Project ${project.metadata.name} does not define a framework name configuration`); + } + if (frameworkOptions.name) { + if (frameworkOptions.name.toLowerCase() === "openui5") { + return "OpenUI5"; + } else if (frameworkOptions.name.toLowerCase() === "sapui5") { + return "SAPUI5"; + } else { + throw new Error("Invalid framework name: " + frameworkOptions.name); + } + } else { + return project.framework.name; + } +} + +module.exports = async function({normalizerOptions, frameworkOptions}) { + const project = await getRootProjectConfiguration({normalizerOptions}); + + if (!isValidSpecVersion(project.specVersion)) { + throw new Error( + `ui5 use command requires specVersion "2.0" or higher. ` + + `Project ${project.metadata.name} uses specVersion "${project.specVersion}"` + ); + } + + const framework = { + name: getEffectiveFrameworkName({project, frameworkOptions}) + }; + + const frameworkVersion = frameworkOptions.version || (project.framework && project.framework.version); + if (frameworkVersion) { + framework.version = await resolveVersion({ + frameworkName: framework.name, + frameworkVersion + }, { + cwd: project.path + }); + } + + // Try to update YAML file but still return with name and resolved version in case it failed + let yamlUpdated = false; + try { + await require("./updateYaml")({ + project, + data: { + framework: framework + } + }); + yamlUpdated = true; + } catch (err) { + if (err.name !== "FrameworkUpdateYamlFailed") { + throw err; + } + } + return { + yamlUpdated, + usedFramework: framework.name, + usedVersion: framework.version || null + }; +}; diff --git a/lib/framework/utils.js b/lib/framework/utils.js new file mode 100644 index 00000000..90c8b542 --- /dev/null +++ b/lib/framework/utils.js @@ -0,0 +1,28 @@ +module.exports = { + getRootProjectConfiguration: async function({normalizerOptions}) { + const {normalizer, projectPreprocessor} = require("@ui5/project"); + + const tree = await normalizer.generateDependencyTree(normalizerOptions); + + if (normalizerOptions.configPath) { + tree.configPath = normalizerOptions.configPath; + } + + // Prevent dependencies from being processed + tree.dependencies = []; + + return projectPreprocessor.processTree(tree); + }, + getFrameworkResolver: function(frameworkName) { + if (frameworkName === "SAPUI5") { + return require("@ui5/project").ui5Framework.Sapui5Resolver; + } else if (frameworkName === "OpenUI5") { + return require("@ui5/project").ui5Framework.Openui5Resolver; + } else { + throw new Error("Invalid framework.name: " + frameworkName); + } + }, + isValidSpecVersion: function(specVersion) { + return specVersion && (specVersion !== "0.1" && specVersion !== "1.0" && specVersion !== "1.1"); + } +}; diff --git a/npm-shrinkwrap.json b/npm-shrinkwrap.json index 36c81b1e..a3a7b18f 100644 --- a/npm-shrinkwrap.json +++ b/npm-shrinkwrap.json @@ -2726,6 +2726,14 @@ "assert-plus": "^1.0.0" } }, + "data-with-position": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/data-with-position/-/data-with-position-0.4.0.tgz", + "integrity": "sha512-pMjD0tsOtUrYaCn0oQs1WcHwsPiqCIb4OnO0kcCIdcnfUbPUU9hEok5ug7pLZHSrzgA3lQCoFQqeXRTe5RFE5w==", + "requires": { + "yaml-ast-parser": "^0.0.43" + } + }, "date-time": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/date-time/-/date-time-2.1.0.tgz", @@ -3149,9 +3157,9 @@ } }, "es-abstract": { - "version": "1.17.5", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.17.5.tgz", - "integrity": "sha512-BR9auzDbySxOcfog0tLECW8l28eRGpDpU3Dm3Hp4q/N+VtLTmyj4EUN088XZWQDW/hzj6sYRDXeOFsaAODKvpg==", + "version": "1.17.4", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.17.4.tgz", + "integrity": "sha512-Ae3um/gb8F0mui/jPL+QiqmglkUsaQf7FwBEHYIFkztkneosu9imhqHpBzQ3h1vit8t5iQ74t6PEVvphBZiuiQ==", "requires": { "es-to-primitive": "^1.2.1", "function-bind": "^1.1.1", @@ -8865,6 +8873,11 @@ "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==" }, + "yaml-ast-parser": { + "version": "0.0.43", + "resolved": "https://registry.npmjs.org/yaml-ast-parser/-/yaml-ast-parser-0.0.43.tgz", + "integrity": "sha512-2PTINUwsRqSd+s8XxKaJWQlUuEMHJQyEuh2edBbW8KNJz0SJPwUSD2zRWqezFEdN7IzAgeuYHFUCF7o8zRdZ0A==" + }, "yargs": { "version": "15.3.1", "resolved": "https://registry.npmjs.org/yargs/-/yargs-15.3.1.tgz", diff --git a/package.json b/package.json index 9ad6f6ec..b698cf51 100644 --- a/package.json +++ b/package.json @@ -108,10 +108,12 @@ "@ui5/project": "^2.0.2", "@ui5/server": "^2.0.0", "chalk": "^3.0.0", + "data-with-position": "^0.4.0", "import-local": "^3.0.2", "js-yaml": "^3.13.1", "open": "^7.0.3", "semver": "^7.1.3", + "string.prototype.matchall": "^4.0.2", "supports-color": "^7.1.0", "treeify": "^1.0.1", "update-notifier": "^4.1.0", diff --git a/test/lib/cli/commands/add.js b/test/lib/cli/commands/add.js new file mode 100644 index 00000000..d77eaacb --- /dev/null +++ b/test/lib/cli/commands/add.js @@ -0,0 +1,186 @@ +const test = require("ava"); +const sinon = require("sinon"); +const mock = require("mock-require"); + +const addCommand = require("../../../../lib/cli/commands/add"); + +async function assertAddHandler(t, {argv, expectedLibraries, expectedConsoleLog}) { + const frameworkAddStub = sinon.stub().resolves({ + yamlUpdated: true + }); + mock("../../../../lib/framework/add", frameworkAddStub); + + await addCommand.handler(argv); + + t.is(frameworkAddStub.callCount, 1, "Add function should be called once"); + t.deepEqual(frameworkAddStub.getCall(0).args, [ + { + libraries: expectedLibraries, + normalizerOptions: { + configPath: undefined, + translatorName: undefined + } + }], + "Add function should be called with expected args"); + + t.is(t.context.consoleLogStub.callCount, expectedConsoleLog.length, + "console.log should be called " + expectedConsoleLog.length + " times"); + expectedConsoleLog.forEach((expectedLog, i) => { + t.deepEqual(t.context.consoleLogStub.getCall(i).args, [expectedLog], + "console.log should be called with expected string on call index " + i); + }); +} + +async function assertFailingAddHandler(t, {argv, expectedMessage}) { + const frameworkAddStub = sinon.stub().resolves({ + yamlUpdated: true + }); + mock("../../../../lib/framework/add", frameworkAddStub); + + const exception = await t.throwsAsync(addCommand.handler(argv)); + + t.is(exception.message, expectedMessage, "Add handler should throw expected error"); + t.is(frameworkAddStub.callCount, 0, "Add function should not be called"); +} + +async function assertFailingYamlUpdateAddHandler(t, {argv, expectedMessage}) { + const frameworkAddStub = sinon.stub().resolves({ + yamlUpdated: false + }); + mock("../../../../lib/framework/add", frameworkAddStub); + + const exception = await t.throwsAsync(addCommand.handler(argv)); + + t.is(exception.message, expectedMessage, "Add handler should throw expected error"); + t.is(frameworkAddStub.callCount, 1, "Add function should be called once"); +} + +test.beforeEach((t) => { + t.context.consoleLogStub = sinon.stub(console, "log"); +}); + +test.afterEach.always(() => { + mock.stopAll(); + sinon.restore(); +}); + +test.serial("Accepts single library", async (t) => { + await assertAddHandler(t, { + argv: {"framework-libraries": ["sap.ui.lib1"]}, + expectedLibraries: [{name: "sap.ui.lib1"}], + expectedConsoleLog: [ + "Updated configuration written to ui5.yaml", + "Added framework library sap.ui.lib1 as dependency" + ] + }); +}); + +test.serial("Accepts multiple libraries", async (t) => { + await assertAddHandler(t, { + argv: {"framework-libraries": ["sap.ui.lib1", "sap.ui.lib2"]}, + expectedLibraries: [{name: "sap.ui.lib1"}, {name: "sap.ui.lib2"}], + expectedConsoleLog: [ + "Updated configuration written to ui5.yaml", + "Added framework libraries sap.ui.lib1 sap.ui.lib2 as dependencies" + ] + }); +}); + +test.serial("Accepts multiple libraries (--development)", async (t) => { + await assertAddHandler(t, { + argv: { + "framework-libraries": [ + "sap.ui.lib1", + "sap.ui.lib2" + ], + "development": true + }, + expectedLibraries: [ + { + name: "sap.ui.lib1", + development: true + }, + { + name: "sap.ui.lib2", + development: true + } + ], + expectedConsoleLog: [ + "Updated configuration written to ui5.yaml", + "Added framework libraries sap.ui.lib1 sap.ui.lib2 as development dependencies" + ] + }); +}); + +test.serial("Accepts multiple libraries (--optional)", async (t) => { + await assertAddHandler(t, { + argv: { + "framework-libraries": [ + "sap.ui.lib1", + "sap.ui.lib2" + ], + "optional": true + }, + expectedLibraries: [ + { + name: "sap.ui.lib1", + optional: true + }, + { + name: "sap.ui.lib2", + optional: true + } + ], + expectedConsoleLog: [ + "Updated configuration written to ui5.yaml", + "Added framework libraries sap.ui.lib1 sap.ui.lib2 as optional dependencies" + ] + }); +}); + +test.serial("Rejects when development and optional are true", async (t) => { + await assertFailingAddHandler(t, { + argv: { + "framework-libraries": ["sap.ui.lib1"], + "development": true, + "optional": true + }, + expectedMessage: "Options 'development' and 'optional' cannot be combined" + }); +}); + +test.serial("Rejects on empty framework-libraries", async (t) => { + await assertFailingAddHandler(t, { + argv: {"framework-libraries": ""}, + expectedMessage: "Missing mandatory parameter framework-libraries" + }); +}); + +test.serial("Rejects when YAML could not be updated (single library)", async (t) => { + await assertFailingYamlUpdateAddHandler(t, { + argv: {"framework-libraries": ["sap.ui.lib1"]}, + expectedMessage: "Internal error while adding framework library sap.ui.lib1 to ui5.yaml" + }); +}); + +test.serial("Rejects when YAML could not be updated (multiple libraries)", async (t) => { + await assertFailingYamlUpdateAddHandler(t, { + argv: {"framework-libraries": ["sap.ui.lib1", "sap.ui.lib2"]}, + expectedMessage: "Internal error while adding framework libraries sap.ui.lib1 sap.ui.lib2 to ui5.yaml" + }); +}); + +test.serial("Rejects when YAML could not be updated (single library; with config path)", async (t) => { + await assertFailingYamlUpdateAddHandler(t, { + argv: {"framework-libraries": ["sap.ui.lib1"], "config": "/path/to/ui5.yaml"}, + expectedMessage: "Internal error while adding framework library sap.ui.lib1 to config at /path/to/ui5.yaml" + }); +}); + +test.serial("Rejects when YAML could not be updated (multiple libraries; with config path)", async (t) => { + await assertFailingYamlUpdateAddHandler(t, { + argv: {"framework-libraries": ["sap.ui.lib1", "sap.ui.lib2"], "config": "/path/to/ui5.yaml"}, + expectedMessage: + "Internal error while adding framework libraries sap.ui.lib1 sap.ui.lib2 to config at /path/to/ui5.yaml" + }); +}); diff --git a/test/lib/cli/commands/use.js b/test/lib/cli/commands/use.js new file mode 100644 index 00000000..54826f99 --- /dev/null +++ b/test/lib/cli/commands/use.js @@ -0,0 +1,228 @@ +const test = require("ava"); +const sinon = require("sinon"); +const mock = require("mock-require"); + +const useCommand = require("../../../../lib/cli/commands/use"); + +async function assertUseHandler(t, {argv, expectedFrameworkOptions}) { + const frameworkUseStub = sinon.stub().resolves({ + usedFramework: undefined, // not required for this test + usedVersion: undefined, // not required for this test + yamlUpdated: true + }); + mock("../../../../lib/framework/use", frameworkUseStub); + + await useCommand.handler(argv); + + t.is(frameworkUseStub.callCount, 1, "Use function should be called once"); + t.deepEqual(frameworkUseStub.getCall(0).args, [ + { + frameworkOptions: expectedFrameworkOptions, + normalizerOptions: { + configPath: undefined, + translatorName: undefined + } + }], + "Use function should be called with expected args"); +} + +async function assertFailingUseHandler(t, {argv, expectedMessage}) { + const frameworkUseStub = sinon.stub().resolves({ + usedFramework: undefined, // not required for this test + usedVersion: undefined // not required for this test + }); + mock("../../../../lib/framework/use", frameworkUseStub); + + const exception = await t.throwsAsync(useCommand.handler(argv)); + + t.is(exception.message, expectedMessage, "Use handler should throw expected error"); + t.is(frameworkUseStub.callCount, 0, "Use function should not be called"); +} + +async function assertFailingYamlUpdateUseHandler(t, {argv, expectedMessage}) { + const frameworkUseStub = sinon.stub().resolves({ + usedFramework: "SAPUI5", + usedVersion: "1.76.0", + yamlUpdated: false + }); + mock("../../../../lib/framework/use", frameworkUseStub); + + const exception = await t.throwsAsync(useCommand.handler(argv)); + + t.is(exception.message, expectedMessage, "Use handler should throw expected error"); + t.is(frameworkUseStub.callCount, 1, "Use function should be called once"); +} + +test.afterEach.always(() => { + mock.stopAll(); + sinon.restore(); +}); + +test.serial("Accepts framework name and version (SAPUI5@1.76.0)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "SAPUI5@1.76.0"}, + expectedFrameworkOptions: { + name: "SAPUI5", + version: "1.76.0" + } + }); +}); + +test.serial("Accepts framework name and version (OpenUI5@1.76.0)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "OpenUI5@1.76.0"}, + expectedFrameworkOptions: { + name: "OpenUI5", + version: "1.76.0" + } + }); +}); + +test.serial("Accepts framework name and version (SAPUI5@1.76)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "SAPUI5@1.76"}, + expectedFrameworkOptions: { + name: "SAPUI5", + version: "1.76" + } + }); +}); + +test.serial("Accepts framework name and version (OpenUI5@1.76)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "OpenUI5@1.76"}, + expectedFrameworkOptions: { + name: "OpenUI5", + version: "1.76" + } + }); +}); + +test.serial("Accepts framework name and version (SAPUI5@latest)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "SAPUI5@latest"}, + expectedFrameworkOptions: { + name: "SAPUI5", + version: "latest" + } + }); +}); + +test.serial("Accepts framework name and version (OpenUI5@latest)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "OpenUI5@latest"}, + expectedFrameworkOptions: { + name: "OpenUI5", + version: "latest" + } + }); +}); + +test.serial("Accepts framework name (SAPUI5)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "SAPUI5"}, + expectedFrameworkOptions: { + name: "SAPUI5", + version: null + } + }); +}); + +test.serial("Accepts framework name (sapui5)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "sapui5"}, + expectedFrameworkOptions: { + name: "sapui5", + version: null + } + }); +}); + +test.serial("Accepts framework name (OpenUI5)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "OpenUI5"}, + expectedFrameworkOptions: { + name: "OpenUI5", + version: null + } + }); +}); + +test.serial("Accepts framework version (1.76.0)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "1.76.0"}, + expectedFrameworkOptions: { + name: null, + version: "1.76.0" + } + }); +}); + +test.serial("Accepts framework version (1.76)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "1.76"}, + expectedFrameworkOptions: { + name: null, + version: "1.76" + } + }); +}); + +test.serial("Accepts framework version (latest)", async (t) => { + await assertUseHandler(t, { + argv: {"framework-info": "latest"}, + expectedFrameworkOptions: { + name: null, + version: "latest" + } + }); +}); + +test.serial("Rejects on empty framework-info", async (t) => { + await assertFailingUseHandler(t, { + argv: {"framework-info": ""}, + expectedMessage: "Invalid framework info: " + }); +}); + +test.serial("Rejects on invalid framework-info (@1.2.3)", async (t) => { + await assertFailingUseHandler(t, { + argv: {"framework-info": "@1.2.3"}, + expectedMessage: "Invalid framework info: @1.2.3" + }); +}); + +test.serial("Rejects on invalid framework-info (SAPUI5@)", async (t) => { + await assertFailingUseHandler(t, { + argv: {"framework-info": "SAPUI5@"}, + expectedMessage: "Invalid framework info: SAPUI5@" + }); +}); + +test.serial("Rejects on invalid framework-info (@SAPUI5@)", async (t) => { + await assertFailingUseHandler(t, { + argv: {"framework-info": "@SAPUI5@"}, + expectedMessage: "Invalid framework info: @SAPUI5@" + }); +}); + +test.serial("Rejects on invalid framework-info (SAPUI5@1.2.3@4.5.6)", async (t) => { + await assertFailingUseHandler(t, { + argv: {"framework-info": "SAPUI5@1.2.3@4.5.6"}, + expectedMessage: "Invalid framework info: SAPUI5@1.2.3@4.5.6" + }); +}); + +test.serial("Rejects when YAML could not be updated", async (t) => { + await assertFailingYamlUpdateUseHandler(t, { + argv: {"framework-info": "SAPUI5@1.76.0"}, + expectedMessage: "Internal error while updating ui5.yaml to SAPUI5 version 1.76.0" + }); +}); + +test.serial("Rejects when YAML could not be updated (with config path)", async (t) => { + await assertFailingYamlUpdateUseHandler(t, { + argv: {"framework-info": "SAPUI5@1.76.0", "config": "/path/to/ui5.yaml"}, + expectedMessage: "Internal error while updating config at /path/to/ui5.yaml to SAPUI5 version 1.76.0" + }); +}); diff --git a/test/lib/framework/add.js b/test/lib/framework/add.js new file mode 100644 index 00000000..7e892ebd --- /dev/null +++ b/test/lib/framework/add.js @@ -0,0 +1,564 @@ +const test = require("ava"); +const sinon = require("sinon"); +const mock = require("mock-require"); + +const ui5Project = require("@ui5/project"); + +let addFramework; + +test.beforeEach((t) => { + t.context.generateDependencyTreeStub = sinon.stub(ui5Project.normalizer, "generateDependencyTree"); + t.context.processTreeStub = sinon.stub(ui5Project.projectPreprocessor, "processTree"); + t.context.Openui5GetLibraryMetadataStub = sinon.stub( + ui5Project.ui5Framework.Openui5Resolver.prototype, "getLibraryMetadata"); + t.context.Sapui5GetLibraryMetadataStub = sinon.stub( + ui5Project.ui5Framework.Sapui5Resolver.prototype, "getLibraryMetadata"); + + t.context.updateYamlStub = sinon.stub(); + mock("../../../lib/framework/updateYaml", t.context.updateYamlStub); + + addFramework = mock.reRequire("../../../lib/framework/add"); +}); + +test.afterEach.always(() => { + mock.stopAll(); + sinon.restore(); +}); + +test.serial("Add without existing libraries in config", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5GetLibraryMetadataStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + framework: { + name: "OpenUI5", + version: "1.76.0" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Openui5GetLibraryMetadataStub.resolves(); + + const result = await addFramework({ + normalizerOptions, + libraries: [{name: "sap.ui.lib1"}] + }); + + t.deepEqual(result, {yamlUpdated: true}, "yamlUpdated should be true"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5GetLibraryMetadataStub.callCount, 1, "Openui5Resolver.getLibraryMetadata should be called once"); + t.deepEqual(Openui5GetLibraryMetadataStub.getCall(0).args, ["sap.ui.lib1"], + "Openui5Resolver.getLibraryMetadata should be called with expected args"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: {libraries: [{name: "sap.ui.lib1"}]} + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Add with existing libraries in config", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5GetLibraryMetadataStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + framework: { + name: "OpenUI5", + version: "1.76.0", + libraries: [{ + name: "sap.ui.lib2" + }, { + name: "sap.ui.lib1" + }] + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Openui5GetLibraryMetadataStub.resolves(); + + const result = await addFramework({ + normalizerOptions, + libraries: [{name: "sap.ui.lib1"}, {name: "sap.ui.lib3"}] + }); + + t.deepEqual(result, {yamlUpdated: true}, "yamlUpdated should be true"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5GetLibraryMetadataStub.callCount, 2, "Openui5Resolver.getLibraryMetadata should be called twice"); + t.deepEqual(Openui5GetLibraryMetadataStub.getCall(0).args, ["sap.ui.lib1"], + "Openui5Resolver.getLibraryMetadata should be called with expected args on first call"); + t.deepEqual(Openui5GetLibraryMetadataStub.getCall(1).args, ["sap.ui.lib3"], + "Openui5Resolver.getLibraryMetadata should be called with expected args on second call"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + libraries: [ + {name: "sap.ui.lib1"}, + {name: "sap.ui.lib2"}, + {name: "sap.ui.lib3"} + ] + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Add optional with existing libraries in config", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5GetLibraryMetadataStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + framework: { + name: "OpenUI5", + version: "1.76.0", + libraries: [{ + name: "sap.ui.lib2", + development: true + }, { + name: "sap.ui.lib1", + development: true + }] + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Openui5GetLibraryMetadataStub.resolves(); + + const result = await addFramework({ + normalizerOptions, + libraries: [{name: "sap.ui.lib1", optional: true}, {name: "sap.ui.lib3", optional: true}] + }); + + t.deepEqual(result, {yamlUpdated: true}, "yamlUpdated should be true"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5GetLibraryMetadataStub.callCount, 2, "Openui5Resolver.getLibraryMetadata should be called twice"); + t.deepEqual(Openui5GetLibraryMetadataStub.getCall(0).args, ["sap.ui.lib1"], + "Openui5Resolver.getLibraryMetadata should be called with expected args on first call"); + t.deepEqual(Openui5GetLibraryMetadataStub.getCall(1).args, ["sap.ui.lib3"], + "Openui5Resolver.getLibraryMetadata should be called with expected args on second call"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + libraries: [ + {name: "sap.ui.lib1", optional: true}, + {name: "sap.ui.lib2", development: true}, + {name: "sap.ui.lib3", optional: true} + ] + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Add with specVersion 1.0", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5GetLibraryMetadataStub, Sapui5GetLibraryMetadataStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "1.0", + metadata: { + name: "my-project" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(addFramework({ + normalizerOptions + })); + + t.is(error.message, + `ui5 add command requires specVersion "2.0" or higher. Project my-project uses specVersion "1.0"`); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5GetLibraryMetadataStub.callCount, 0, "Openui5Resolver.getLibraryMetadata should not be called"); + t.is(Sapui5GetLibraryMetadataStub.callCount, 0, "Sapui5Resolver.getLibraryMetadata should not be called"); + + t.is(updateYamlStub.callCount, 0, "updateYaml should not be called"); +}); + +test.serial("Add without framework configuration", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5GetLibraryMetadataStub, Sapui5GetLibraryMetadataStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(addFramework({ + normalizerOptions + })); + + t.is(error.message, `Project my-project is missing a framework configuration. ` + + `Please use "ui5 use" to configure a framework and version.`); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5GetLibraryMetadataStub.callCount, 0, "Openui5Resolver.getLibraryMetadata should not be called"); + t.is(Sapui5GetLibraryMetadataStub.callCount, 0, "Sapui5Resolver.getLibraryMetadata should not be called"); + + t.is(updateYamlStub.callCount, 0, "updateYaml should not be called"); +}); + +test.serial("Add without framework version configuration", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5GetLibraryMetadataStub, Sapui5GetLibraryMetadataStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + framework: { + name: "OpenUI5" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(addFramework({ + normalizerOptions + })); + + t.is(error.message, `Project my-project does not define a framework version configuration. ` + + `Please use "ui5 use" to configure a version.`); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5GetLibraryMetadataStub.callCount, 0, "Openui5Resolver.getLibraryMetadata should not be called"); + t.is(Sapui5GetLibraryMetadataStub.callCount, 0, "Sapui5Resolver.getLibraryMetadata should not be called"); + + t.is(updateYamlStub.callCount, 0, "updateYaml should not be called"); +}); + +test.serial("Add with failing library metadata call", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Sapui5GetLibraryMetadataStub, updateYamlStub} = t.context; + + Sapui5GetLibraryMetadataStub.rejects(new Error("Failed to load library sap.ui.lib1")); + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + framework: { + name: "SAPUI5", + version: "1.76.0" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(addFramework({ + normalizerOptions, + libraries: [{name: "sap.ui.lib1"}] + })); + + t.is(error.message, `Failed to find SAPUI5 framework library sap.ui.lib1: Failed to load library sap.ui.lib1`); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Sapui5GetLibraryMetadataStub.callCount, 1, "Sapui5Resolver.getLibraryMetadata should be called once"); + t.deepEqual(Sapui5GetLibraryMetadataStub.getCall(0).args, ["sap.ui.lib1"], + "Sapui5Resolver.getLibraryMetadata should be called with expected args on first call"); + + t.is(updateYamlStub.callCount, 0, "updateYaml should not be called"); +}); + +test.serial("Add with failing YAML update", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Sapui5GetLibraryMetadataStub, updateYamlStub} = t.context; + + const yamlUpdateError = new Error("Failed to update YAML file"); + yamlUpdateError.name = "FrameworkUpdateYamlFailed"; + updateYamlStub.rejects(yamlUpdateError); + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + framework: { + name: "SAPUI5", + version: "1.76.0" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const result = await addFramework({ + normalizerOptions, + libraries: [{name: "sap.ui.lib1"}] + }); + + t.deepEqual(result, {yamlUpdated: false}, "yamlUpdated should be false"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Sapui5GetLibraryMetadataStub.callCount, 1, "Sapui5Resolver.getLibraryMetadata should be called once"); + t.deepEqual(Sapui5GetLibraryMetadataStub.getCall(0).args, ["sap.ui.lib1"], + "Sapui5Resolver.getLibraryMetadata should be called with expected args on first call"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + libraries: [{name: "sap.ui.lib1"}] + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Add with failing YAML update (unexpected error)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Sapui5GetLibraryMetadataStub, updateYamlStub} = t.context; + + updateYamlStub.rejects(new Error("Some unexpected error")); + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + framework: { + name: "SAPUI5", + version: "1.76.0" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(addFramework({ + normalizerOptions, + libraries: [{name: "sap.ui.lib1"}] + })); + + t.is(error.message, `Some unexpected error`); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Sapui5GetLibraryMetadataStub.callCount, 1, "Sapui5Resolver.getLibraryMetadata should be called once"); + t.deepEqual(Sapui5GetLibraryMetadataStub.getCall(0).args, ["sap.ui.lib1"], + "Sapui5Resolver.getLibraryMetadata should be called with expected args on first call"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + libraries: [{name: "sap.ui.lib1"}] + } + } + }], "updateYaml should be called with expected args"); +}); + + +test.serial("Add should not modify input parameters", async (t) => { + const {generateDependencyTreeStub, processTreeStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + framework: { + name: "SAPUI5", + version: "1.76.0", + libraries: [{"name": "sap.ui.lib1"}] + } + }; + + const libraries = [{name: "sap.ui.lib2"}]; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + await addFramework({ + normalizerOptions, + libraries + }); + + t.deepEqual(libraries, [{name: "sap.ui.lib2"}], "libraries array should not be changed"); +}); diff --git a/test/lib/framework/updateYaml.js b/test/lib/framework/updateYaml.js new file mode 100644 index 00000000..d4422561 --- /dev/null +++ b/test/lib/framework/updateYaml.js @@ -0,0 +1,511 @@ +const test = require("ava"); +const sinon = require("sinon"); +const mock = require("mock-require"); + +const fs = require("fs"); +const path = require("path"); + +let updateYaml; + +test.beforeEach((t) => { + t.context.fsReadFileStub = sinon.stub(fs, "readFile"); + t.context.fsWriteFileStub = sinon.stub(fs, "writeFile").yieldsAsync(null); + + updateYaml = mock.reRequire("../../../lib/framework/updateYaml"); +}); + +test.afterEach.always(() => { + mock.stopAll(); + sinon.restore(); +}); + +test.serial("Should update single document", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +--- +metadata: + name: my-project +framework: + name: SAPUI5 + version: 1.0.0 +`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +--- +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" +`, "writeFile should be called with expected content"); +}); + +test.serial("Should update first document", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +specVersion: "2.0" +metadata: + name: my-project +framework: + name: SAPUI5 + version: 1.0.0 +--- +specVersion: "1.0" +kind: extension +metadata: + name: my-extension +type: project-shim +shims: + configurations: {} +`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +specVersion: "2.0" +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" +--- +specVersion: "1.0" +kind: extension +metadata: + name: my-extension +type: project-shim +shims: + configurations: {} +`, "writeFile should be called with expected content"); +}); + + +test.serial("Should update second document", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +specVersion: "1.0" +kind: extension +metadata: + name: my-extension +type: project-shim +shims: + configurations: {} +framework: + name: SAPUI5 + version: 1.0.0 +--- +specVersion: "2.0" +metadata: + name: my-project +framework: + name: SAPUI5 + version: 1.0.0 +`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +specVersion: "1.0" +kind: extension +metadata: + name: my-extension +type: project-shim +shims: + configurations: {} +framework: + name: SAPUI5 + version: 1.0.0 +--- +specVersion: "2.0" +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" +`, "writeFile should be called with expected content"); +}); + +test.serial("Should add new object with one property to document", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + name: "OpenUI5" + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +metadata: + name: my-project +framework: + name: OpenUI5 +`, "writeFile should be called with expected content"); +}); + +test.serial("Should add new object with two properties to document", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" +`, "writeFile should be called with expected content"); +}); + +test.serial("Should add version property to document and keep name", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project +framework: + name: "OpenUI5" +`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +metadata: + name: my-project +framework: + name: "OpenUI5" + version: "1.76.0" +`, "writeFile should be called with expected content"); +}); + +test.serial("Should add name property to document and keep version", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project +framework: + version: 1.76.0 +`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +metadata: + name: my-project +framework: + version: 1.76.0 + name: OpenUI5 +`, "writeFile should be called with expected content"); +}); + +test.serial("Should add new array to document", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" +`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + libraries: [ + {name: "sap.ui.core"}, + {name: "sap.m"} + ] + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" + libraries: + - name: sap.ui.core + - name: sap.m +`, "writeFile should be called with expected content"); +}); + +test.serial("Should add new array element to document", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" + libraries: + - name: sap.ui.core +`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + libraries: [ + {name: "sap.ui.core"}, + {name: "sap.m"} + ] + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" + libraries: + - name: sap.ui.core + - name: sap.m +`, "writeFile should be called with expected content"); +}); + +test.serial("Should add new array elements to document", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" + libraries: + - name: sap.ui.core +`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + libraries: [ + {name: "sap.ui.core"}, + {name: "sap.m"}, + {name: "sap.ui.layout"} + ] + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" + libraries: + - name: sap.ui.core + - name: sap.m + - name: sap.ui.layout +`, "writeFile should be called with expected content"); +}); + +test.serial("Should add new array elements with multiple properties to document", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" + libraries: + - name: sap.ui.core + development: true +`); + + await updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + libraries: [ + {name: "sap.ui.core", optional: true}, + {name: "sap.m", optional: true}, + {name: "sap.ui.layout", optional: true} + ] + } + } + }); + + t.is(t.context.fsWriteFileStub.callCount, 1, "fs.writeFile should be called once"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[0], path.join("my-project", "ui5.yaml"), + "writeFile should be called with expected path"); + t.deepEqual(t.context.fsWriteFileStub.getCall(0).args[1], ` +metadata: + name: my-project +framework: + name: OpenUI5 + version: "1.76.0" + libraries: + - name: sap.ui.core + optional: true + - name: sap.m + optional: true + - name: sap.ui.layout + optional: true +`, "writeFile should be called with expected content"); +}); + +test.serial("Should validate YAML before writing file", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project +framework: { name: "SAPUI5" } +`); // Using JSON object notation is currently not supported + + const error = await t.throwsAsync(updateYaml({ + project: { + path: "my-project", + metadata: {"name": "my-project"} + }, + data: { + framework: { + name: "SAPUI5", + version: "1.76.0" + } + } + })); + + t.is(error.message, + "Failed to update YAML file: bad indentation of a mapping entry at line 5, column 14:\n" + + " version: \"1.76.0\"\n" + + " ^" + ); + t.is(t.context.fsWriteFileStub.callCount, 0, "fs.writeFile should not be called"); +}); + +test.serial("Should throw error when project document can't be found", async (t) => { + t.context.fsReadFileStub.yieldsAsync(null, ` +metadata: + name: my-project-1 +--- +metadata: + name: my-project-2 +`); + + const error = await t.throwsAsync(updateYaml({ + project: { + path: "my-project", + configPath: "ui5.yaml", + metadata: {"name": "my-project-3"} + }, + data: {} + })); + + t.is(error.message, "Could not find project with name my-project-3 in YAML: ui5.yaml"); + t.is(t.context.fsWriteFileStub.callCount, 0, "fs.writeFile should not be called"); +}); diff --git a/test/lib/framework/use.js b/test/lib/framework/use.js new file mode 100644 index 00000000..5cfdcd7f --- /dev/null +++ b/test/lib/framework/use.js @@ -0,0 +1,837 @@ +const test = require("ava"); +const sinon = require("sinon"); +const mock = require("mock-require"); + +const ui5Project = require("@ui5/project"); + +let useFramework; + +test.beforeEach((t) => { + t.context.generateDependencyTreeStub = sinon.stub(ui5Project.normalizer, "generateDependencyTree"); + t.context.processTreeStub = sinon.stub(ui5Project.projectPreprocessor, "processTree"); + t.context.Openui5ResolveVersionStub = sinon.stub(ui5Project.ui5Framework.Openui5Resolver, "resolveVersion"); + t.context.Sapui5ResolveVersionStub = sinon.stub(ui5Project.ui5Framework.Sapui5Resolver, "resolveVersion"); + + t.context.updateYamlStub = sinon.stub(); + mock("../../../lib/framework/updateYaml", t.context.updateYamlStub); + + useFramework = mock.reRequire("../../../lib/framework/use"); +}); + +test.afterEach.always(() => { + mock.stopAll(); + sinon.restore(); +}); + +test.serial("Use with name and version (OpenUI5)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, Openui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project" + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Openui5ResolveVersionStub.resolves("1.76.0"); + + const result = await useFramework({ + normalizerOptions, + frameworkOptions: { + name: "openui5", + version: "latest" + } + }); + + t.deepEqual(result, { + usedFramework: "OpenUI5", + usedVersion: "1.76.0", + yamlUpdated: true + }, "useFramework should return expected result object"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5ResolveVersionStub.callCount, 1, "Openui5Resolver.resolveVersion should be called once"); + t.deepEqual(Openui5ResolveVersionStub.getCall(0).args, ["latest", {cwd: "my-project"}], + "Openui5Resolver.resolveVersion should be called with expected args"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Use with name and version (SAPUI5)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project" + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Sapui5ResolveVersionStub.resolves("1.76.0"); + + const result = await useFramework({ + normalizerOptions, + frameworkOptions: { + name: "sapui5", + version: "latest" + } + }); + + t.deepEqual(result, { + usedFramework: "SAPUI5", + usedVersion: "1.76.0", + yamlUpdated: true + }, "useFramework should return expected result object"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Sapui5ResolveVersionStub.callCount, 1, "Sapui5Resolver.resolveVersion should be called once"); + t.deepEqual(Sapui5ResolveVersionStub.getCall(0).args, ["latest", {cwd: "my-project"}], + "Sapui5Resolver.resolveVersion should be called with expected args"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + name: "SAPUI5", + version: "1.76.0" + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Use with version only (OpenUI5)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, Openui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project", + framework: { + name: "OpenUI5" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Openui5ResolveVersionStub.resolves("1.76.0"); + + const result = await useFramework({ + normalizerOptions, + frameworkOptions: { + name: null, + version: "latest" + } + }); + + t.deepEqual(result, { + usedFramework: "OpenUI5", + usedVersion: "1.76.0", + yamlUpdated: true + }, "useFramework should return expected result object"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5ResolveVersionStub.callCount, 1, "Openui5Resolver.resolveVersion should be called once"); + t.deepEqual(Openui5ResolveVersionStub.getCall(0).args, ["latest", {cwd: "my-project"}], + "Openui5Resolver.resolveVersion should be called with expected args"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Use with version only (SAPUI5)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project", + framework: { + name: "SAPUI5" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Sapui5ResolveVersionStub.resolves("1.76.0"); + + const result = await useFramework({ + normalizerOptions, + frameworkOptions: { + name: null, + version: "latest" + } + }); + + t.deepEqual(result, { + usedFramework: "SAPUI5", + usedVersion: "1.76.0", + yamlUpdated: true + }, "useFramework should return expected result object"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Sapui5ResolveVersionStub.callCount, 1, "Sapui5Resolver.resolveVersion should be called once"); + t.deepEqual(Sapui5ResolveVersionStub.getCall(0).args, ["latest", {cwd: "my-project"}], + "Sapui5Resolver.resolveVersion should be called with expected args"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + name: "SAPUI5", + version: "1.76.0" + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Use with name only (no existing framework configuration)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project" + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const result = await useFramework({ + normalizerOptions, + frameworkOptions: { + name: "SAPUI5", + version: null + } + }); + + t.deepEqual(result, { + usedFramework: "SAPUI5", + usedVersion: null, + yamlUpdated: true + }, "useFramework should return expected result object"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Sapui5ResolveVersionStub.callCount, 0, "Sapui5Resolver.resolveVersion should not be called"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + name: "SAPUI5" + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Use with name only (existing framework configuration)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project", + framework: { + name: "OpenUI5", + version: "1.76.0" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Sapui5ResolveVersionStub.resolves("1.76.0"); + + const result = await useFramework({ + normalizerOptions, + frameworkOptions: { + name: "SAPUI5", + version: null + } + }); + + t.deepEqual(result, { + usedFramework: "SAPUI5", + usedVersion: "1.76.0", + yamlUpdated: true + }, "useFramework should return expected result object"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Sapui5ResolveVersionStub.callCount, 1, "Sapui5Resolver.resolveVersion should be called once"); + t.deepEqual(Sapui5ResolveVersionStub.getCall(0).args, ["1.76.0", {cwd: "my-project"}], + "Sapui5Resolver.resolveVersion should be called with expected args"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + name: "SAPUI5", + version: "1.76.0" + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Use with normalizerOptions.configPath", async (t) => { + const {generateDependencyTreeStub, processTreeStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + configPath: "/path/to/ui5.yaml" + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project" + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Sapui5ResolveVersionStub.resolves("1.76.0"); + + const result = await useFramework({ + normalizerOptions, + frameworkOptions: { + name: "SAPUI5", + version: "latest" + } + }); + + t.deepEqual(result, { + usedFramework: "SAPUI5", + usedVersion: "1.76.0", + yamlUpdated: true + }, "useFramework should return expected result object"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{configPath: "/path/to/ui5.yaml"}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + configPath: "/path/to/ui5.yaml", + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Sapui5ResolveVersionStub.callCount, 1, "Sapui5Resolver.resolveVersion should be called once"); + t.deepEqual(Sapui5ResolveVersionStub.getCall(0).args, ["latest", {cwd: "my-project"}], + "Sapui5Resolver.resolveVersion should be called with expected args"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + name: "SAPUI5", + version: "1.76.0" + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Use with version only (no framework name)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5ResolveVersionStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project" + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(useFramework({ + normalizerOptions, + frameworkOptions: { + name: null, + version: "latest" + } + })); + + t.is(error.message, "No framework configuration defined. Make sure to also provide the framework name."); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5ResolveVersionStub.callCount, 0, "Openui5Resolver.resolveVersion should not be called"); + t.is(Sapui5ResolveVersionStub.callCount, 0, "Sapui5Resolver.resolveVersion should not be called"); + + t.is(updateYamlStub.callCount, 0, "updateYaml should not be called"); +}); + +test.serial("Use with invalid name", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5ResolveVersionStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project" + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(useFramework({ + normalizerOptions, + frameworkOptions: { + name: "Foo", + version: "latest" + } + })); + + t.is(error.message, "Invalid framework name: Foo"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5ResolveVersionStub.callCount, 0, "Openui5Resolver.resolveVersion should not be called"); + t.is(Sapui5ResolveVersionStub.callCount, 0, "Sapui5Resolver.resolveVersion should not be called"); + + t.is(updateYamlStub.callCount, 0, "updateYaml should not be called"); +}); + +test.serial("Use with specVersion 1.0", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5ResolveVersionStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "1.0", + metadata: { + name: "my-project" + }, + path: "my-project" + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(useFramework({ + normalizerOptions, + frameworkOptions: { + name: "Foo", + version: "latest" + } + })); + + t.is(error.message, + `ui5 use command requires specVersion "2.0" or higher. Project my-project uses specVersion "1.0"`); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5ResolveVersionStub.callCount, 0, "Openui5Resolver.resolveVersion should not be called"); + t.is(Sapui5ResolveVersionStub.callCount, 0, "Sapui5Resolver.resolveVersion should not be called"); + + t.is(updateYamlStub.callCount, 0, "updateYaml should not be called"); +}); + +test.serial("Use without framework.name (should actually be validated via ui5-project)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5ResolveVersionStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project", + framework: {} + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(useFramework({ + normalizerOptions, + frameworkOptions: { + name: "SAPUI5", + version: "latest" + } + })); + + t.is(error.message, + `Project my-project does not define a framework name configuration`); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5ResolveVersionStub.callCount, 0, "Openui5Resolver.resolveVersion should not be called"); + t.is(Sapui5ResolveVersionStub.callCount, 0, "Sapui5Resolver.resolveVersion should not be called"); + + t.is(updateYamlStub.callCount, 0, "updateYaml should not be called"); +}); + +test.serial("Use with invalid framework name in config (should actually be validated via ui5-project)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, + Openui5ResolveVersionStub, Sapui5ResolveVersionStub, updateYamlStub} = t.context; + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project", + framework: { + name: "Foo" + } + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + + const error = await t.throwsAsync(useFramework({ + normalizerOptions, + frameworkOptions: { + name: null, + version: "latest" + } + })); + + t.is(error.message, "Invalid framework.name: Foo"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5ResolveVersionStub.callCount, 0, "Openui5Resolver.resolveVersion should not be called"); + t.is(Sapui5ResolveVersionStub.callCount, 0, "Sapui5Resolver.resolveVersion should not be called"); + + t.is(updateYamlStub.callCount, 0, "updateYaml should not be called"); +}); + +test.serial("Use with name and version (YAML update fails)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, Openui5ResolveVersionStub, updateYamlStub} = t.context; + + const yamlUpdateError = new Error("Failed to update YAML file"); + yamlUpdateError.name = "FrameworkUpdateYamlFailed"; + updateYamlStub.rejects(yamlUpdateError); + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project" + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Openui5ResolveVersionStub.resolves("1.76.0"); + + const result = await useFramework({ + normalizerOptions, + frameworkOptions: { + name: "openui5", + version: "latest" + } + }); + + t.deepEqual(result, { + usedFramework: "OpenUI5", + usedVersion: "1.76.0", + yamlUpdated: false + }, "useFramework should return expected result object"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5ResolveVersionStub.callCount, 1, "Openui5Resolver.resolveVersion should be called once"); + t.deepEqual(Openui5ResolveVersionStub.getCall(0).args, ["latest", {cwd: "my-project"}], + "Openui5Resolver.resolveVersion should be called with expected args"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }], "updateYaml should be called with expected args"); +}); + +test.serial("Use with name and version (YAML update fails with unexpected error)", async (t) => { + const {generateDependencyTreeStub, processTreeStub, Openui5ResolveVersionStub, updateYamlStub} = t.context; + + updateYamlStub.rejects(new Error("Some unexpected error")); + + const normalizerOptions = { + "fakeNormalizerOption": true + }; + + const tree = { + dependencies: [{id: "fake-dependency"}] + }; + const project = { + specVersion: "2.0", + metadata: { + name: "my-project" + }, + path: "my-project" + }; + + generateDependencyTreeStub.resolves(tree); + processTreeStub.resolves(project); + Openui5ResolveVersionStub.resolves("1.76.0"); + + const error = await t.throwsAsync(useFramework({ + normalizerOptions, + frameworkOptions: { + name: "openui5", + version: "latest" + } + })); + + t.is(error.message, "Some unexpected error"); + + t.is(generateDependencyTreeStub.callCount, 1, "normalizer.generateDependencyTree should be called once"); + t.deepEqual(generateDependencyTreeStub.getCall(0).args, [{"fakeNormalizerOption": true}], + "normalizer.generateDependencyTree should be called with expected args"); + + t.is(processTreeStub.callCount, 1, "projectPreprocessor.processTree should be called once"); + t.deepEqual(processTreeStub.getCall(0).args, [{ + dependencies: [] + }], + "projectPreprocessor.processTree should be called with expected args"); + + t.is(Openui5ResolveVersionStub.callCount, 1, "Openui5Resolver.resolveVersion should be called once"); + t.deepEqual(Openui5ResolveVersionStub.getCall(0).args, ["latest", {cwd: "my-project"}], + "Openui5Resolver.resolveVersion should be called with expected args"); + + t.is(updateYamlStub.callCount, 1, "updateYaml should be called once"); + t.deepEqual(updateYamlStub.getCall(0).args, [{ + project, + data: { + framework: { + name: "OpenUI5", + version: "1.76.0" + } + } + }], "updateYaml should be called with expected args"); +});