1/* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use rollupObject file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 17import { expect } from 'chai'; 18import mocha from 'mocha'; 19import path from 'path'; 20import fs from 'fs'; 21import ts from 'typescript'; 22import sinon from 'sinon'; 23 24import RollUpPluginMock from '../mock/rollup_mock/rollup_plugin_mock'; 25import { ModuleSourceFile } from '../../../lib/fast_build/ark_compiler/module/module_source_file'; 26import { ModuleInfo } from '../../../lib/fast_build/ark_compiler/module/module_mode'; 27import ModuleModeMock from '../mock/class_mock/module_mode_mock'; 28import { 29 EXPECT_ENTRY_TS, 30 EXPECT_INDEX_ETS, 31 MODULE_TEST_PATH, 32 EXPECT_TO_JS 33} from '../mock/rollup_mock/path_config'; 34import { 35 RELEASE, 36 EXTNAME_ETS, 37 EXTNAME_TS, 38 EXTNAME_JS 39} from '../../../lib/fast_build/ark_compiler/common/ark_define'; 40import { 41 META, 42 ENTRYABILITY_TS_PATH_DEFAULT, 43 INDEX_ETS_PATH_DEFAULT, 44 OHURL_RES, 45 ENTRYABILITY_TS, 46 INDEX_ETS, 47 OHURL_SHAREDLIBRARY, 48 OH_UIABILITY, 49 OH_HILOG 50} from '../mock/rollup_mock/common'; 51import projectConfig from '../utils/processProjectConfig'; 52import { ModuleInfo as ModuleInfoMock } from '../mock/rollup_mock/module_info'; 53import { scanFiles } from "../utils/utils"; 54import { SourceMapGenerator } from '../../../lib/fast_build/ark_compiler/generate_sourcemap'; 55import { 56 TRANSFORMED_MOCK_CONFIG, 57 USER_DEFINE_MOCK_CONFIG 58} from '../../../lib/pre_define'; 59import { 60 ArkTSInternalErrorDescription, 61 ErrorCode 62} from '../../../lib/fast_build/ark_compiler/error_code'; 63import { 64 CommonLogger, 65 LogData, 66 LogDataFactory 67} from '../../../lib/fast_build/ark_compiler/logger'; 68 69const ROLLUP_IMPORT_NODE: string = 'ImportDeclaration'; 70const ROLLUP_EXPORTNAME_NODE: string = 'ExportNamedDeclaration'; 71const ROLLUP_EXPORTALL_NODE: string = 'ExportAllDeclaration'; 72const ROLLUP_DYNAMICIMPORT_NODE: string = 'ImportExpression'; 73const ROLLUP_LITERAL_NODE: string = 'Literal'; 74 75mocha.describe('test module_source_file file api', function () { 76 mocha.before(function () { 77 this.rollup = new RollUpPluginMock(); 78 }); 79 80 mocha.after(() => { 81 delete this.rollup; 82 }); 83 84 mocha.it('1-1-1: test getOhmUrl under build debug: systemOrLibOhmUrl is not undefined', function () { 85 this.rollup.build(); 86 SourceMapGenerator.initInstance(this.rollup); 87 const modeMock = new ModuleModeMock(this.rollup); 88 const mockFileList: object = this.rollup.getModuleIds(); 89 this.moduleInfos = new Map<String, ModuleInfo>(); 90 91 for (const moduleId of mockFileList) { 92 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 93 const code: string = fs.readFileSync(moduleId, 'utf-8'); 94 const moduleSource = new ModuleSourceFile(moduleId, code); 95 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 96 const metaInfo: object = moduleInfo[META]; 97 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 98 moduleInfo.setImportedIdMaps(); 99 moduleInfo.setNodeImportDeclaration(); 100 const importMap: object = moduleInfo.importedIdMaps; 101 const moduleNodeMap: Map<string, any> = 102 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 103 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 104 let hasDynamicImport: boolean = false; 105 for (const nodeSet of moduleNodeMap.values()) { 106 nodeSet.forEach(node => { 107 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 108 hasDynamicImport = true; 109 } 110 if (node.source) { 111 if (node.source.type === ROLLUP_LITERAL_NODE) { 112 const ohmUrl: string | undefined = 113 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap[node.source.value]); 114 expect(ohmUrl === OH_UIABILITY || ohmUrl === OH_HILOG).to.be.true; 115 } else { 116 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 117 + `DynamicImport only accept stringLiteral as argument currently.\n`; 118 console.log(errorMsg); 119 } 120 } 121 }); 122 } 123 } 124 } 125 SourceMapGenerator.cleanSourceMapObject(); 126 }); 127 128 mocha.it('1-1-2: test getOhmUrl under build debug: filePath exist', function () { 129 this.rollup.build(); 130 SourceMapGenerator.initInstance(this.rollup); 131 const modeMock = new ModuleModeMock(this.rollup); 132 const mockFileList: object = this.rollup.getModuleIds(); 133 this.moduleInfos = new Map<String, ModuleInfo>(); 134 135 for (const moduleId of mockFileList) { 136 if (moduleId.endsWith(EXTNAME_ETS)) { 137 const code: string = fs.readFileSync(moduleId, 'utf-8'); 138 const moduleSource = new ModuleSourceFile(moduleId, code); 139 ModuleSourceFile.projectConfig = modeMock.projectConfig; 140 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 141 const metaInfo: object = moduleInfo[META]; 142 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 143 moduleInfo.setImportedIdMaps(moduleId); 144 moduleInfo.setNodeImportExpression(); 145 const importMap: object = moduleInfo.importedIdMaps; 146 const moduleNodeMap: Map<string, any> = 147 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 148 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 149 let hasDynamicImport: boolean = false; 150 for (const nodeSet of moduleNodeMap.values()) { 151 nodeSet.forEach(node => { 152 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 153 hasDynamicImport = true; 154 } 155 if (node.source) { 156 if (node.source.type === ROLLUP_LITERAL_NODE) { 157 const ohmUrl: string | undefined = 158 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap['requestFile']); 159 expect(ohmUrl === OHURL_RES).to.be.true; 160 } else { 161 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 162 + `DynamicImport only accept stringLiteral as argument currently.\n`; 163 console.log(errorMsg); 164 } 165 } 166 }); 167 } 168 } 169 } 170 SourceMapGenerator.cleanSourceMapObject(); 171 }); 172 173 mocha.it('1-1-3: test getOhmUrl under build debug: harOhmUrl is not undefined', function () { 174 this.rollup.build(); 175 SourceMapGenerator.initInstance(this.rollup); 176 const modeMock = new ModuleModeMock(this.rollup); 177 const mockFileList: object = this.rollup.getModuleIds(); 178 this.moduleInfos = new Map<String, ModuleInfo>(); 179 180 for (const moduleId of mockFileList) { 181 if (moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 182 const code: string = fs.readFileSync(moduleId, 'utf-8'); 183 const moduleSource = new ModuleSourceFile(moduleId, code); 184 ModuleSourceFile.projectConfig = modeMock.projectConfig; 185 ModuleSourceFile.projectConfig.harNameOhmMap = projectConfig.harNameOhmMap; 186 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 187 const metaInfo: object = moduleInfo[META]; 188 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 189 moduleInfo.setImportedIdMaps(moduleId); 190 moduleInfo.setNodeImportExpression(); 191 const importMap: object = moduleInfo.importedIdMaps; 192 const moduleNodeMap: Map<string, any> = 193 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 194 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 195 let hasDynamicImport: boolean = false; 196 for (const nodeSet of moduleNodeMap.values()) { 197 nodeSet.forEach(node => { 198 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 199 hasDynamicImport = true; 200 } 201 if (node.source) { 202 if (node.source.type === ROLLUP_LITERAL_NODE) { 203 const ohmUrl: string | undefined = 204 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap['requestFile']); 205 expect(ohmUrl === OHURL_SHAREDLIBRARY).to.be.true; 206 } else { 207 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 208 + `DynamicImport only accept stringLiteral as argument currently.\n`; 209 console.log(errorMsg); 210 } 211 } 212 }); 213 } 214 } 215 } 216 SourceMapGenerator.cleanSourceMapObject(); 217 }); 218 219 mocha.it('1-2: test getOhmUrl under build release', function () { 220 this.rollup.build(RELEASE); 221 SourceMapGenerator.initInstance(this.rollup); 222 const modeMock = new ModuleModeMock(this.rollup); 223 const mockFileList: object = this.rollup.getModuleIds(); 224 this.moduleInfos = new Map<String, ModuleInfo>(); 225 for (const moduleId of mockFileList) { 226 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 227 const code: string = fs.readFileSync(moduleId, 'utf-8'); 228 const moduleSource = new ModuleSourceFile(moduleId, code); 229 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 230 const metaInfo: object = moduleInfo[META]; 231 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 232 moduleInfo.setImportedIdMaps(); 233 moduleInfo.setNodeImportDeclaration(); 234 const importMap: object = moduleInfo.importedIdMaps; 235 const moduleNodeMap: Map<string, any> = 236 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 237 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 238 let hasDynamicImport: boolean = false; 239 for (const nodeSet of moduleNodeMap.values()) { 240 nodeSet.forEach(node => { 241 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 242 hasDynamicImport = true; 243 } 244 if (node.source) { 245 if (node.source.type === ROLLUP_LITERAL_NODE) { 246 const ohmUrl: string | undefined = 247 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap[node.source.value]); 248 expect(ohmUrl === OH_UIABILITY || ohmUrl === OH_HILOG).to.be.true; 249 } else { 250 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 251 + `DynamicImport only accept stringLiteral as argument currently.\n`; 252 console.log(errorMsg); 253 } 254 } 255 }); 256 } 257 } 258 } 259 SourceMapGenerator.cleanSourceMapObject(); 260 }); 261 262 mocha.it('1-3: test getOhmUrl under preview debug', function () { 263 this.rollup.preview(); 264 SourceMapGenerator.initInstance(this.rollup); 265 const modeMock = new ModuleModeMock(this.rollup); 266 const mockFileList: object = this.rollup.getModuleIds(); 267 this.moduleInfos = new Map<String, ModuleInfo>(); 268 for (const moduleId of mockFileList) { 269 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 270 const code: string = fs.readFileSync(moduleId, 'utf-8'); 271 const moduleSource = new ModuleSourceFile(moduleId, code); 272 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 273 const metaInfo: object = moduleInfo[META]; 274 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 275 moduleInfo.setImportedIdMaps(); 276 moduleInfo.setNodeImportDeclaration(); 277 const importMap: object = moduleInfo.importedIdMaps; 278 const moduleNodeMap: Map<string, any> = 279 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 280 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 281 let hasDynamicImport: boolean = false; 282 for (const nodeSet of moduleNodeMap.values()) { 283 nodeSet.forEach(node => { 284 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 285 hasDynamicImport = true; 286 } 287 if (node.source) { 288 if (node.source.type === ROLLUP_LITERAL_NODE) { 289 const ohmUrl: string | undefined = 290 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap[node.source.value]); 291 expect(ohmUrl === OH_UIABILITY || ohmUrl === OH_HILOG).to.be.true; 292 } else { 293 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 294 + `DynamicImport only accept stringLiteral as argument currently.\n`; 295 console.log(errorMsg); 296 } 297 } 298 }); 299 } 300 } 301 } 302 SourceMapGenerator.cleanSourceMapObject(); 303 }); 304 305 mocha.it('1-4: test getOhmUrl under hot reload debug', function () { 306 this.rollup.hotReload(); 307 SourceMapGenerator.initInstance(this.rollup); 308 const modeMock = new ModuleModeMock(this.rollup); 309 const mockFileList: object = this.rollup.getModuleIds(); 310 this.moduleInfos = new Map<String, ModuleInfo>(); 311 for (const moduleId of mockFileList) { 312 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 313 const code: string = fs.readFileSync(moduleId, 'utf-8'); 314 const moduleSource = new ModuleSourceFile(moduleId, code); 315 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 316 const metaInfo: object = moduleInfo[META]; 317 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 318 moduleInfo.setImportedIdMaps(); 319 moduleInfo.setNodeImportDeclaration(); 320 const importMap: object = moduleInfo.importedIdMaps; 321 const moduleNodeMap: Map<string, any> = 322 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 323 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 324 let hasDynamicImport: boolean = false; 325 for (const nodeSet of moduleNodeMap.values()) { 326 nodeSet.forEach(node => { 327 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 328 hasDynamicImport = true; 329 } 330 if (node.source) { 331 if (node.source.type === ROLLUP_LITERAL_NODE) { 332 const ohmUrl: string | undefined = 333 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap[node.source.value]); 334 expect(ohmUrl === OH_UIABILITY || ohmUrl === OH_HILOG).to.be.true; 335 } else { 336 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 337 + `DynamicImport only accept stringLiteral as argument currently.\n`; 338 console.log(errorMsg); 339 } 340 } 341 }); 342 } 343 } 344 } 345 SourceMapGenerator.cleanSourceMapObject(); 346 }); 347 348 mocha.it('1-5: test the error message of getOhmUrl: GetModuleInfoFaild', function () { 349 this.rollup.build(); 350 const filePath: string = 'test.ets'; 351 const moduleSourceFile = new ModuleSourceFile(filePath, '', undefined); 352 const errInfo: LogData = LogDataFactory.newInstance( 353 ErrorCode.ETS2BUNDLE_INTERNAL_GET_MODULE_INFO_FAILED, 354 ArkTSInternalErrorDescription, 355 'Failed to get ModuleInfo, moduleId: test.ets' 356 ); 357 ModuleSourceFile.initPluginEnv(this.rollup); 358 const stub = sinon.stub(ModuleSourceFile.logger.getLoggerFromErrorCode(errInfo.code), 'printError'); 359 moduleSourceFile.getOhmUrl(this.rollup, '', filePath, undefined); 360 expect(stub.calledWith(errInfo)).to.be.true; 361 stub.restore(); 362 }); 363 364 mocha.it('1-5-1: test the error message of getOhmUrl: GetModuleInfoFaild ' + 365 'without getHvigorConsoleLogger', function () { 366 this.rollup.build(); 367 const filePath: string = 'test.ets'; 368 const moduleSourceFile = new ModuleSourceFile(filePath, '', undefined); 369 const errInfo: LogData = LogDataFactory.newInstance( 370 ErrorCode.ETS2BUNDLE_INTERNAL_GET_MODULE_INFO_FAILED, 371 ArkTSInternalErrorDescription, 372 'Failed to get ModuleInfo, moduleId: test.ets' 373 ); 374 CommonLogger.destroyInstance(); 375 const getHvigorConsoleLogger = this.rollup.share.getHvigorConsoleLogger; 376 this.rollup.share.getHvigorConsoleLogger = undefined; 377 ModuleSourceFile.initPluginEnv(this.rollup); 378 const stub = sinon.stub(ModuleSourceFile.logger.logger, 'error'); 379 moduleSourceFile.getOhmUrl(this.rollup, '', filePath, undefined); 380 expect(stub.calledWith(errInfo.toString())).to.be.true; 381 CommonLogger.destroyInstance(); 382 this.rollup.share.getHvigorConsoleLogger = getHvigorConsoleLogger; 383 stub.restore(); 384 }); 385 386 mocha.it('1-6: test the error message of getOhmUrl: UnableToGetModuleInfoMeta', function () { 387 this.rollup.build(); 388 const filePath: string = 'test.ets'; 389 const moduleInfo: Object = { 390 id: filePath, 391 meta: null 392 } 393 this.rollup.moduleInfos.push(moduleInfo); 394 const moduleSourceFile = new ModuleSourceFile(filePath, '', undefined); 395 const errInfo: LogData = LogDataFactory.newInstance( 396 ErrorCode.ETS2BUNDLE_INTERNAL_UNABLE_TO_GET_MODULE_INFO_META, 397 ArkTSInternalErrorDescription, 398 "Failed to get ModuleInfo properties 'meta', moduleId: test.ets" 399 ); 400 ModuleSourceFile.initPluginEnv(this.rollup); 401 const stub = sinon.stub(ModuleSourceFile.logger.getLoggerFromErrorCode(errInfo.code), 'printError'); 402 moduleSourceFile.getOhmUrl(this.rollup, '', filePath, undefined); 403 expect(stub.calledWith(errInfo)).to.be.true; 404 stub.restore(); 405 }); 406 407 mocha.it('1-7: test the error message of getOhmUrl: UnableToGetModuleInfoMeta ' + 408 'without getHvigorConsoleLogger', function () { 409 this.rollup.build(); 410 const filePath: string = 'test.ets'; 411 const moduleInfo: Object = { 412 id: filePath, 413 meta: null 414 } 415 this.rollup.moduleInfos.push(moduleInfo); 416 const moduleSourceFile = new ModuleSourceFile(filePath, '', undefined); 417 const errInfo: LogData = LogDataFactory.newInstance( 418 ErrorCode.ETS2BUNDLE_INTERNAL_UNABLE_TO_GET_MODULE_INFO_META, 419 ArkTSInternalErrorDescription, 420 "Failed to get ModuleInfo properties 'meta', moduleId: test.ets" 421 ); 422 CommonLogger.destroyInstance(); 423 const getHvigorConsoleLogger = this.rollup.share.getHvigorConsoleLogger; 424 this.rollup.share.getHvigorConsoleLogger = undefined; 425 ModuleSourceFile.initPluginEnv(this.rollup); 426 const stub = sinon.stub(ModuleSourceFile.logger.logger, 'error'); 427 moduleSourceFile.getOhmUrl(this.rollup, '', filePath, undefined); 428 expect(stub.calledWith(errInfo.toString())).to.be.true; 429 CommonLogger.destroyInstance(); 430 this.rollup.share.getHvigorConsoleLogger = getHvigorConsoleLogger; 431 stub.restore(); 432 }); 433 434 mocha.it('2-1: test processJsModuleRequest under build debug', function () { 435 this.rollup.build(); 436 SourceMapGenerator.initInstance(this.rollup); 437 const modeMock = new ModuleModeMock(this.rollup); 438 const mockFileList: object = this.rollup.getModuleIds(); 439 this.moduleInfos = new Map<String, ModuleInfo>(); 440 for (const moduleId of mockFileList) { 441 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 442 const code: string = fs.readFileSync(moduleId, 'utf-8'); 443 const moduleSource = new ModuleSourceFile(moduleId, code); 444 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 445 const metaInfo: object = moduleInfo[META]; 446 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 447 moduleInfo.setImportedIdMaps(); 448 moduleSource.processJsModuleRequest(this.rollup); 449 const EntryAbility_ts = fs.readFileSync(EXPECT_ENTRY_TS).toString(); 450 const Index_ets = fs.readFileSync(EXPECT_INDEX_ETS).toString(); 451 expect(moduleSource.source === EntryAbility_ts || moduleSource.source === Index_ets).to.be.true; 452 } 453 } 454 SourceMapGenerator.cleanSourceMapObject(); 455 }); 456 457 mocha.it('2-2: test processJsModuleRequest under build release', function () { 458 this.rollup.build(RELEASE); 459 SourceMapGenerator.initInstance(this.rollup); 460 const modeMock = new ModuleModeMock(this.rollup); 461 const mockFileList: object = this.rollup.getModuleIds(); 462 this.moduleInfos = new Map<String, ModuleInfo>(); 463 for (const moduleId of mockFileList) { 464 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 465 const code: string = fs.readFileSync(moduleId, 'utf-8'); 466 const moduleSource = new ModuleSourceFile(moduleId, code); 467 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 468 const metaInfo: object = moduleInfo[META]; 469 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 470 moduleInfo.setImportedIdMaps(); 471 moduleSource.processJsModuleRequest(this.rollup); 472 const EntryAbility_ts = fs.readFileSync(EXPECT_ENTRY_TS).toString(); 473 const Index_ets = fs.readFileSync(EXPECT_INDEX_ETS).toString(); 474 expect(moduleSource.source === EntryAbility_ts || moduleSource.source === Index_ets).to.be.true; 475 } 476 } 477 SourceMapGenerator.cleanSourceMapObject(); 478 }); 479 480 mocha.it('2-3: test processJsModuleRequest under preview debug', function () { 481 this.rollup.preview(); 482 SourceMapGenerator.initInstance(this.rollup); 483 const modeMock = new ModuleModeMock(this.rollup); 484 const mockFileList: object = this.rollup.getModuleIds(); 485 this.moduleInfos = new Map<String, ModuleInfo>(); 486 for (const moduleId of mockFileList) { 487 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 488 const code: string = fs.readFileSync(moduleId, 'utf-8'); 489 const moduleSource = new ModuleSourceFile(moduleId, code); 490 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 491 const metaInfo: object = moduleInfo[META]; 492 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 493 moduleInfo.setImportedIdMaps(); 494 moduleSource.processJsModuleRequest(this.rollup); 495 const EntryAbility_ts = fs.readFileSync(EXPECT_ENTRY_TS).toString(); 496 const Index_ets = fs.readFileSync(EXPECT_INDEX_ETS).toString(); 497 expect(moduleSource.source === EntryAbility_ts || moduleSource.source === Index_ets).to.be.true; 498 } 499 } 500 SourceMapGenerator.cleanSourceMapObject(); 501 }); 502 503 mocha.it('2-4: test processJsModuleRequest under hot reload debug', function () { 504 this.rollup.hotReload(); 505 SourceMapGenerator.initInstance(this.rollup); 506 const modeMock = new ModuleModeMock(this.rollup); 507 const mockFileList: object = this.rollup.getModuleIds(); 508 this.moduleInfos = new Map<String, ModuleInfo>(); 509 for (const moduleId of mockFileList) { 510 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 511 const code: string = fs.readFileSync(moduleId, 'utf-8'); 512 const moduleSource = new ModuleSourceFile(moduleId, code); 513 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 514 const metaInfo: object = moduleInfo[META]; 515 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 516 moduleInfo.setImportedIdMaps(); 517 moduleSource.processJsModuleRequest(this.rollup); 518 const EntryAbility_ts = fs.readFileSync(EXPECT_ENTRY_TS).toString(); 519 const Index_ets = fs.readFileSync(EXPECT_INDEX_ETS).toString(); 520 expect(moduleSource.source === EntryAbility_ts || moduleSource.source === Index_ets).to.be.true; 521 } 522 } 523 SourceMapGenerator.cleanSourceMapObject(); 524 }); 525 526 mocha.it('3-1-1: test processTransformedJsModuleRequest under build debug: hasDynamicImport is false', function () { 527 this.rollup.build(); 528 SourceMapGenerator.initInstance(this.rollup); 529 const modeMock = new ModuleModeMock(this.rollup); 530 const mockFileList: object = this.rollup.getModuleIds(); 531 this.moduleInfos = new Map<String, ModuleInfo>(); 532 for (const moduleId of mockFileList) { 533 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 534 const code: string = JSON.stringify(fs.readFileSync(moduleId, 'utf-8')); 535 const moduleSource = new ModuleSourceFile(moduleId, code); 536 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 537 const metaInfo: object = moduleInfo[META]; 538 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 539 moduleInfo.setImportedIdMaps(); 540 moduleInfo.setNodeImportDeclaration(); 541 moduleSource.processTransformedJsModuleRequest(this.rollup); 542 const json = fs.readFileSync(EXPECT_TO_JS, 'utf-8'); 543 const etsToJs = JSON.parse(json).expect_index_ets_to_js; 544 const tsToJs = JSON.parse(json).expect_entryability_ts_to_js; 545 expect(moduleSource.source === etsToJs || moduleSource.source === tsToJs).to.be.true; 546 } 547 } 548 SourceMapGenerator.cleanSourceMapObject(); 549 }); 550 551 mocha.it('3-1-2: test processTransformedJsModuleRequest under build debug: hasDynamicImport is true', async function () { 552 this.rollup.build(); 553 const sourceMapGenerator: SourceMapGenerator = SourceMapGenerator.initInstance(this.rollup); 554 let newSourceMaps = sourceMapGenerator.getSourceMaps(); 555 556 const modeMock = new ModuleModeMock(this.rollup); 557 const mockFileList: object = this.rollup.getModuleIds(); 558 this.moduleInfos = new Map<String, ModuleInfo>(); 559 for (const moduleId of mockFileList) { 560 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 561 const code: string = JSON.stringify(fs.readFileSync(moduleId, 'utf-8')); 562 const moduleSource = new ModuleSourceFile(moduleId, code); 563 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 564 const metaInfo: object = moduleInfo[META]; 565 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 566 moduleInfo.setImportedIdMaps(); 567 moduleInfo.setNodeImportExpression(); 568 ModuleSourceFile.projectConfig = modeMock.projectConfig; 569 await moduleSource.processTransformedJsModuleRequest(this.rollup); 570 for (const key in newSourceMaps) { 571 expect(newSourceMaps[key].mappings.length > 0).to.be.true; 572 expect(newSourceMaps[key].file.includes(ENTRYABILITY_TS) !== -1 573 || newSourceMaps[key].file.includes(INDEX_ETS) !== -1).to.be.true; 574 expect(newSourceMaps[key].sources.includes(ENTRYABILITY_TS_PATH_DEFAULT) !== -1 575 || newSourceMaps[key].sources.includes(INDEX_ETS_PATH_DEFAULT) !== -1).to.be.true; 576 } 577 } 578 } 579 580 for (const key of Object.keys(newSourceMaps)) { 581 delete newSourceMaps[key]; 582 } 583 SourceMapGenerator.cleanSourceMapObject(); 584 }); 585 586 mocha.it('3-2: test processTransformedJsModuleRequest under build release', function () { 587 this.rollup.build(RELEASE); 588 SourceMapGenerator.initInstance(this.rollup); 589 const modeMock = new ModuleModeMock(this.rollup); 590 const mockFileList: object = this.rollup.getModuleIds(); 591 this.moduleInfos = new Map<String, ModuleInfo>(); 592 for (const moduleId of mockFileList) { 593 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 594 const code: string = JSON.stringify(fs.readFileSync(moduleId, 'utf-8')); 595 const moduleSource = new ModuleSourceFile(moduleId, code); 596 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 597 const metaInfo: object = moduleInfo[META]; 598 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 599 moduleInfo.setImportedIdMaps(); 600 moduleInfo.setNodeImportDeclaration(); 601 moduleSource.processTransformedJsModuleRequest(this.rollup); 602 const json = fs.readFileSync(EXPECT_TO_JS, 'utf-8'); 603 const etsToJs = JSON.parse(json).expect_index_ets_to_js; 604 const tsToJs = JSON.parse(json).expect_entryability_ts_to_js; 605 expect(moduleSource.source === etsToJs || moduleSource.source === tsToJs).to.be.true; 606 } 607 } 608 SourceMapGenerator.cleanSourceMapObject(); 609 }); 610 611 mocha.it('3-3: test processTransformedJsModuleRequest under preview debug', function () { 612 this.rollup.preview(); 613 SourceMapGenerator.initInstance(this.rollup); 614 const modeMock = new ModuleModeMock(this.rollup); 615 const mockFileList: object = this.rollup.getModuleIds(); 616 this.moduleInfos = new Map<String, ModuleInfo>(); 617 for (const moduleId of mockFileList) { 618 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 619 const code: string = JSON.stringify(fs.readFileSync(moduleId, 'utf-8')); 620 const moduleSource = new ModuleSourceFile(moduleId, code); 621 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 622 const metaInfo: object = moduleInfo[META]; 623 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 624 moduleInfo.setImportedIdMaps(); 625 moduleInfo.setNodeImportDeclaration(); 626 moduleSource.processTransformedJsModuleRequest(this.rollup); 627 const json = fs.readFileSync(EXPECT_TO_JS, 'utf-8'); 628 const etsToJs = JSON.parse(json).expect_index_ets_to_js; 629 const tsToJs = JSON.parse(json).expect_entryability_ts_to_js; 630 expect(moduleSource.source === etsToJs || moduleSource.source === tsToJs).to.be.true; 631 } 632 } 633 SourceMapGenerator.cleanSourceMapObject(); 634 }); 635 636 mocha.it('3-4: test processTransformedJsModuleRequest under hot reload debug', function () { 637 this.rollup.hotReload(); 638 SourceMapGenerator.initInstance(this.rollup); 639 const modeMock = new ModuleModeMock(this.rollup); 640 const mockFileList: object = this.rollup.getModuleIds(); 641 this.moduleInfos = new Map<String, ModuleInfo>(); 642 for (const moduleId of mockFileList) { 643 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 644 const code: string = JSON.stringify(fs.readFileSync(moduleId, 'utf-8')); 645 const moduleSource = new ModuleSourceFile(moduleId, code); 646 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 647 const metaInfo: object = moduleInfo[META]; 648 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 649 moduleInfo.setImportedIdMaps(); 650 moduleInfo.setNodeImportDeclaration(); 651 moduleSource.processTransformedJsModuleRequest(this.rollup); 652 const json = fs.readFileSync(EXPECT_TO_JS, 'utf-8'); 653 const etsToJs = JSON.parse(json).expect_index_ets_to_js; 654 const tsToJs = JSON.parse(json).expect_entryability_ts_to_js; 655 expect(moduleSource.source === etsToJs || moduleSource.source === tsToJs).to.be.true; 656 } 657 } 658 SourceMapGenerator.cleanSourceMapObject(); 659 }); 660 661 mocha.it('4-1: test processTransformedTsModuleRequest under build debug', function () { 662 this.rollup.build(); 663 const modeMock = new ModuleModeMock(this.rollup); 664 const allFiles = new Set<string>(); 665 this.moduleInfos = new Map<String, ModuleInfo>(); 666 scanFiles(MODULE_TEST_PATH, allFiles); 667 for (const moduleId of allFiles.values()) { 668 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 669 const code: string = fs.readFileSync(moduleId, 'utf-8'); 670 const moduleInfo = new ModuleInfoMock(moduleId, 671 this.rollup.share.projectConfig.entryModuleName, 672 this.rollup.share.projectConfig.modulePath); 673 moduleInfo.setImportedIdMaps(); 674 this.rollup.moduleInfos.push(moduleInfo); 675 const metaInfo: object = moduleInfo[META]; 676 SourceMapGenerator.initInstance(this.rollup); 677 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 678 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 679 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 680 ModuleSourceFile.processModuleSourceFiles(this.rollup); 681 moduleSource.processTransformedTsModuleRequest(this.rollup); 682 expect(moduleSource.source.fileName === moduleId).to.be.true; 683 expect(moduleSource.source.text === code).to.be.true; 684 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 685 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 686 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 687 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 688 SourceMapGenerator.cleanSourceMapObject(); 689 } 690 } 691 }); 692 693 mocha.it('4-1-1: test single file processTransformedTsModuleRequest under build debug', function () { 694 this.rollup.build(); 695 this.rollup.share.projectConfig.singleFileEmit = true; 696 const modeMock = new ModuleModeMock(this.rollup); 697 const allFiles = new Set<string>(); 698 this.moduleInfos = new Map<String, ModuleInfo>(); 699 scanFiles(MODULE_TEST_PATH, allFiles); 700 for (const moduleId of allFiles.values()) { 701 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 702 const code: string = fs.readFileSync(moduleId, 'utf-8'); 703 const moduleInfo = new ModuleInfoMock(moduleId, 704 this.rollup.share.projectConfig.entryModuleName, 705 this.rollup.share.projectConfig.modulePath); 706 moduleInfo.setImportedIdMaps(); 707 this.rollup.moduleInfos.push(moduleInfo); 708 const metaInfo: object = moduleInfo[META]; 709 SourceMapGenerator.initInstance(this.rollup); 710 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 711 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 712 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 713 ModuleSourceFile.processSingleModuleSourceFile(this.rollup, moduleInfo.id); 714 moduleSource.processTransformedTsModuleRequest(this.rollup); 715 expect(moduleSource.source.fileName === moduleId).to.be.true; 716 expect(moduleSource.source.text === code).to.be.true; 717 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 718 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 719 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 720 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 721 SourceMapGenerator.cleanSourceMapObject(); 722 } 723 } 724 }); 725 726 mocha.it('4-2: test processTransformedTsModuleRequest under build release', function () { 727 this.rollup.build(RELEASE); 728 const modeMock = new ModuleModeMock(this.rollup); 729 const allFiles = new Set<string>(); 730 scanFiles(MODULE_TEST_PATH, allFiles); 731 for (const moduleId of allFiles.values()) { 732 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 733 const code: string = fs.readFileSync(moduleId, 'utf-8'); 734 const moduleInfo = new ModuleInfoMock(moduleId, 735 this.rollup.share.projectConfig.entryModuleName, 736 this.rollup.share.projectConfig.modulePath); 737 moduleInfo.setImportedIdMaps(); 738 this.rollup.moduleInfos.push(moduleInfo); 739 const metaInfo: object = moduleInfo[META]; 740 SourceMapGenerator.initInstance(this.rollup); 741 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 742 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 743 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 744 ModuleSourceFile.processModuleSourceFiles(this.rollup); 745 moduleSource.processTransformedTsModuleRequest(this.rollup); 746 expect(moduleSource.source.fileName === moduleId).to.be.true; 747 expect(moduleSource.source.text === code).to.be.true; 748 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 749 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 750 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 751 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 752 SourceMapGenerator.cleanSourceMapObject(); 753 } 754 } 755 }); 756 757 mocha.it('4-3: test processTransformedTsModuleRequest under preview debug', function () { 758 this.rollup.preview(); 759 const modeMock = new ModuleModeMock(this.rollup); 760 const allFiles = new Set<string>(); 761 scanFiles(MODULE_TEST_PATH, allFiles); 762 for (const moduleId of allFiles.values()) { 763 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 764 const code: string = fs.readFileSync(moduleId, 'utf-8'); 765 const moduleInfo = new ModuleInfoMock(moduleId, 766 this.rollup.share.projectConfig.entryModuleName, 767 this.rollup.share.projectConfig.modulePath); 768 moduleInfo.setImportedIdMaps(); 769 this.rollup.moduleInfos.push(moduleInfo); 770 const metaInfo: object = moduleInfo[META]; 771 SourceMapGenerator.initInstance(this.rollup); 772 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 773 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 774 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 775 ModuleSourceFile.processModuleSourceFiles(this.rollup); 776 moduleSource.processTransformedTsModuleRequest(this.rollup); 777 expect(moduleSource.source.fileName === moduleId).to.be.true; 778 expect(moduleSource.source.text === code).to.be.true; 779 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 780 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 781 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 782 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 783 SourceMapGenerator.cleanSourceMapObject(); 784 } 785 } 786 }); 787 788 mocha.it('4-3-1: test single file processTransformedTsModuleRequest under preview debug', function () { 789 this.rollup.preview(); 790 this.rollup.share.projectConfig.singleFileEmit = true; 791 const modeMock = new ModuleModeMock(this.rollup); 792 const allFiles = new Set<string>(); 793 scanFiles(MODULE_TEST_PATH, allFiles); 794 for (const moduleId of allFiles.values()) { 795 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 796 const code: string = fs.readFileSync(moduleId, 'utf-8'); 797 const moduleInfo = new ModuleInfoMock(moduleId, 798 this.rollup.share.projectConfig.entryModuleName, 799 this.rollup.share.projectConfig.modulePath); 800 moduleInfo.setImportedIdMaps(); 801 this.rollup.moduleInfos.push(moduleInfo); 802 const metaInfo: object = moduleInfo[META]; 803 SourceMapGenerator.initInstance(this.rollup); 804 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 805 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 806 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 807 ModuleSourceFile.processSingleModuleSourceFile(this.rollup, moduleInfo.id); 808 moduleSource.processTransformedTsModuleRequest(this.rollup); 809 expect(moduleSource.source.fileName === moduleId).to.be.true; 810 expect(moduleSource.source.text === code).to.be.true; 811 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 812 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 813 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 814 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 815 SourceMapGenerator.cleanSourceMapObject(); 816 } 817 } 818 }); 819 820 mocha.it('4-4: test processTransformedTsModuleRequest under reload debug', function () { 821 this.rollup.hotReload(); 822 const modeMock = new ModuleModeMock(this.rollup); 823 const allFiles = new Set<string>(); 824 scanFiles(MODULE_TEST_PATH, allFiles); 825 for (const moduleId of allFiles.values()) { 826 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 827 const code: string = fs.readFileSync(moduleId, 'utf-8'); 828 const moduleInfo = new ModuleInfoMock(moduleId, 829 this.rollup.share.projectConfig.entryModuleName, 830 this.rollup.share.projectConfig.modulePath); 831 moduleInfo.setImportedIdMaps(); 832 this.rollup.moduleInfos.push(moduleInfo); 833 const metaInfo: object = moduleInfo[META]; 834 SourceMapGenerator.initInstance(this.rollup); 835 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 836 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 837 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 838 ModuleSourceFile.processModuleSourceFiles(this.rollup); 839 moduleSource.processTransformedTsModuleRequest(this.rollup); 840 expect(moduleSource.source.fileName === moduleId).to.be.true; 841 expect(moduleSource.source.text === code).to.be.true; 842 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 843 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 844 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 845 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 846 SourceMapGenerator.cleanSourceMapObject(); 847 } 848 } 849 }); 850 851 mocha.it('4-4-1: test single file processTransformedTsModuleRequest under reload debug', function () { 852 this.rollup.hotReload(); 853 this.rollup.share.projectConfig.singleFileEmit = true; 854 const modeMock = new ModuleModeMock(this.rollup); 855 const allFiles = new Set<string>(); 856 scanFiles(MODULE_TEST_PATH, allFiles); 857 for (const moduleId of allFiles.values()) { 858 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 859 const code: string = fs.readFileSync(moduleId, 'utf-8'); 860 const moduleInfo = new ModuleInfoMock(moduleId, 861 this.rollup.share.projectConfig.entryModuleName, 862 this.rollup.share.projectConfig.modulePath); 863 moduleInfo.setImportedIdMaps(); 864 this.rollup.moduleInfos.push(moduleInfo); 865 const metaInfo: object = moduleInfo[META]; 866 SourceMapGenerator.initInstance(this.rollup); 867 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 868 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 869 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 870 ModuleSourceFile.processSingleModuleSourceFile(this.rollup, moduleInfo.id); 871 moduleSource.processTransformedTsModuleRequest(this.rollup); 872 expect(moduleSource.source.fileName === moduleId).to.be.true; 873 expect(moduleSource.source.text === code).to.be.true; 874 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 875 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 876 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 877 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 878 SourceMapGenerator.cleanSourceMapObject(); 879 } 880 } 881 }); 882 883 mocha.it('5-1: test setProcessMock under LocalTest mode', function () { 884 this.rollup.share.projectConfig.isPreview = true; 885 this.rollup.share.projectConfig.isOhosTest = true; 886 this.rollup.share.projectConfig.isLocalTest = true; 887 this.rollup.share.projectConfig.mockParams = { 888 decorator: "@MockSetup", 889 packageName: "@ohos/hamock", 890 etsSourceRootPath: "src/main", 891 mockConfigPath: this.rollup.share.projectConfig.aceModuleRoot + '/mock/mock-config.json5', 892 } 893 ModuleSourceFile.setProcessMock(this.rollup); 894 expect(ModuleSourceFile.needProcessMock).to.be.true; 895 }); 896 897 mocha.it('5-2: test collectMockConfigInfo under LocalTest mode', function () { 898 this.rollup.share.projectConfig.isLocalTest = true; 899 this.rollup.share.projectConfig.mockParams = { 900 decorator: "@MockSetup", 901 packageName: "@ohos/hamock", 902 etsSourceRootPath: "src/main", 903 mockConfigPath: this.rollup.share.projectConfig.aceModuleRoot + '/mock/mock-config.json5', 904 } 905 ModuleSourceFile.collectMockConfigInfo(this.rollup); 906 let EXPECT_MOCKFILES = [ 907 "src/mock/ohos/I18nMock.ts", 908 "src/mock/ohos/bluetooth.mock.ts", 909 "src/mock/module/calc.mock.ts", 910 "src/mock/module/bigInt.mock.ts", 911 "src/mock/native/libentry.mock.ts" 912 ]; 913 expect(ModuleSourceFile.mockFiles).to.deep.equal(EXPECT_MOCKFILES); 914 }); 915 916 mocha.it('5-3: test addMockConfig under LocalTest mode', function () { 917 ModuleSourceFile.newMockConfigInfo = { 918 "@ohos:i18n": { 919 "source": "@bundle:com.example.demo/entry/src/mock/ohos/I18nMock" 920 }, 921 "@ohos:bluetooth": { 922 "source": "@bundle:com.example.demo/entry/src/mock/ohos/bluetooth.mock" 923 }, 924 "@bundle:com.example.demo/entry/ets/calc": { 925 "source": "@bundle:com.example.demo/entry/src/mock/module/calc.mock" 926 }, 927 "@bundle:/testProjectRootPath/oh_modules/lib/dist/index.js": { 928 "source": "@bundle:com.example.demo/entry/src/mock/module/bigInt.mock" 929 }, 930 "@app:UtTestApplication/entry/entry": { 931 "source": "@bundle:com.example.demo/entry/src/mock/native/libentry.mock" 932 } 933 }; 934 935 ModuleSourceFile.addMockConfig(ModuleSourceFile.newMockConfigInfo, "@ohos:i18n", "@bundle:com.example.demo/entry/src/mock/I18nMock"); 936 expect(ModuleSourceFile.newMockConfigInfo).to.deep.equal(ModuleSourceFile.newMockConfigInfo); 937 }); 938 939 mocha.it('5-4: test generateNewMockInfo under LocalTest mode', function () { 940 this.rollup.share.projectConfig.isLocalTest = true; 941 ModuleSourceFile.mockConfigInfo = { 942 "@ohos:i18n": { 943 "source": "src/mock/ohos/I18nMock.ts" 944 }, 945 } 946 let originKey = "@ohos.i18n"; 947 let transKey = "@ohos:i18n"; 948 let importerFile = this.rollup.share.projectConfig.aceModuleRoot + '/mock/ohos/I18nMock.ts'; 949 ModuleSourceFile.generateNewMockInfo(originKey, transKey, this.rollup, importerFile); 950 let EXPECT_NEW_MOCK_INFO = { 951 "@ohos:i18n": { 952 "source": "@bundle:com.example.demo/entry/src/mock/ohos/I18nMock" 953 }, 954 "@ohos:bluetooth": { 955 "source": "@bundle:com.example.demo/entry/src/mock/ohos/bluetooth.mock" 956 }, 957 "@bundle:com.example.demo/entry/ets/calc": { 958 "source": "@bundle:com.example.demo/entry/src/mock/module/calc.mock" 959 }, 960 "@bundle:/testProjectRootPath/oh_modules/lib/dist/index.js": { 961 "source": "@bundle:com.example.demo/entry/src/mock/module/bigInt.mock" 962 }, 963 "@app:UtTestApplication/entry/entry": { 964 "source": "@bundle:com.example.demo/entry/src/mock/native/libentry.mock" 965 } 966 }; 967 expect(ModuleSourceFile.newMockConfigInfo).to.deep.equal(EXPECT_NEW_MOCK_INFO); 968 }); 969 970 mocha.it('5-5: test generateMockConfigFile under LocalTest mode', function () { 971 this.rollup.share.projectConfig.isLocalTest = true; 972 ModuleSourceFile.newMockConfigInfo = { 973 "@ohos:i18n": { 974 "source": "@bundle:com.example.demo/entry/src/mock/I18nMock" 975 }, 976 "@ohos:bluetooth": { 977 "source": "@bundle:com.example.demo/entry/src/mock/ohos/bluetooth.mock" 978 }, 979 "@bundle:com.example.demo/entry/ets/calc": { 980 "source": "@bundle:com.example.demo/entry/src/mock/module/calc.mock" 981 }, 982 "@bundle:/testProjectRootPath/oh_modules/lib/dist/index.js": { 983 "source": "@bundle:com.example.demo/entry/src/mock/module/bigInt.mock" 984 }, 985 "@app:UtTestApplication/entry/entry": { 986 "source": "@bundle:com.example.demo/entry/src/mock/native/libentry.mock" 987 } 988 } 989 this.rollup.share.projectConfig.mockParams = { 990 decorator: "@MockSetup", 991 packageName: "@ohos/hamock", 992 etsSourceRootPath: "src/main", 993 mockConfigPath: this.rollup.share.projectConfig.aceModuleRoot + '/mock/mock-config.json5', 994 } 995 ModuleSourceFile.generateMockConfigFile(this.rollup); 996 let EXPECT_MOCK_CONFIG_FILE = path.resolve(this.rollup.share.projectConfig.aceModuleJsonPath, `../mock-config.json`); 997 expect(fs.existsSync(EXPECT_MOCK_CONFIG_FILE)).to.be.true; 998 let EXPECT_MOCK_CONFIG_CONTENT = JSON.stringify(ModuleSourceFile.newMockConfigInfo); 999 let ACTUAL_MOCK_CONFIG_CONTENT = JSON.stringify(require(EXPECT_MOCK_CONFIG_FILE)); 1000 expect(EXPECT_MOCK_CONFIG_CONTENT).to.equal(ACTUAL_MOCK_CONFIG_CONTENT); 1001 fs.unlinkSync(this.rollup.share.projectConfig.cachePath + '/mock-config.json'); 1002 fs.unlinkSync(this.rollup.share.projectConfig.cachePath + '/mock-config.json5'); 1003 }); 1004 1005 mocha.it('5-6: test generateNewMockInfo under LocalTest mode (useNormalizedOHMUrl is true)', function () { 1006 this.rollup.share.projectConfig.isLocalTest = true; 1007 this.rollup.share.projectConfig.useNormalizedOHMUrl = true; 1008 ModuleSourceFile.projectConfig.pkgContextInfo = { 1009 'entry': { 1010 'packageName': 'entry', 1011 'bundleName': '', 1012 'moduleName': '', 1013 'version': '', 1014 'entryPath': 'Index.ets', 1015 'isSO': false 1016 } 1017 } 1018 ModuleSourceFile.mockConfigInfo = { 1019 "@ohos.utils": { 1020 "source": "src/mock/utilsMock.ts" 1021 }, 1022 } 1023 let originKey = "@ohos.utils"; 1024 let transKey = "@ohos:utils"; 1025 ModuleSourceFile.generateNewMockInfo(originKey, transKey, this.rollup, ''); 1026 let expectOHMUrl: string = "@normalized:N&&&entry/src/mock/utilsMock&"; 1027 expect(ModuleSourceFile.newMockConfigInfo[transKey].source === expectOHMUrl).to.be.true; 1028 this.rollup.share.projectConfig.useNormalizedOHMUrl = false; 1029 ModuleSourceFile.projectConfig.pkgContextInfo = {}; 1030 }); 1031 1032 mocha.it('5-7: test generateNewMockInfo under LocalTest mode (has source2ModuleIdMap)', function () { 1033 this.rollup.share.projectConfig.isLocalTest = true; 1034 this.rollup.share.projectConfig.useNormalizedOHMUrl = true; 1035 const mockFilePath = `${this.rollup.share.projectConfig.modulePath}/src/mock/utilsMock.ts`; 1036 const moduleInfo = { 1037 mockFilePath: { 1038 meta: { 1039 pkgName: 'entry', 1040 pkgPath: this.rollup.share.projectConfig.modulePath 1041 } 1042 } 1043 }; 1044 this.rollup.moduleInfos.push(moduleInfo); 1045 this.rollup.share.projectConfig.mockParams = { 1046 decorator: "@MockSetup", 1047 packageName: "@ohos/hamock", 1048 etsSourceRootPath: "src/main", 1049 mockConfigPath: this.rollup.share.projectConfig.aceModuleRoot + '/mock/mock-config.json5', 1050 source2ModuleIdMap: { 1051 "src/mock/utilsMock.ts": mockFilePath 1052 } 1053 } 1054 ModuleSourceFile.projectConfig.pkgContextInfo = { 1055 'entry': { 1056 'packageName': 'entry', 1057 'bundleName': '', 1058 'moduleName': '', 1059 'version': '', 1060 'entryPath': 'Index.ets', 1061 'isSO': false 1062 } 1063 } 1064 ModuleSourceFile.mockConfigInfo = { 1065 "@ohos.utils": { 1066 "source": "src/mock/utilsMock.ts" 1067 }, 1068 } 1069 let originKey = "@ohos.utils"; 1070 let transKey = "@ohos:utils"; 1071 ModuleSourceFile.generateNewMockInfo(originKey, transKey, this.rollup, ''); 1072 let expectOHMUrl: string = "@normalized:N&&&entry/src/mock/utilsMock&"; 1073 expect(ModuleSourceFile.newMockConfigInfo[transKey].source === expectOHMUrl).to.be.true; 1074 this.rollup.share.projectConfig.useNormalizedOHMUrl = false; 1075 ModuleSourceFile.projectConfig.pkgContextInfo = {}; 1076 }); 1077 1078 mocha.it('6-1: test removePotentialMockConfigCache delete mock-config', function () { 1079 const transformedMockConfigCache: string = 1080 path.resolve(this.rollup.share.projectConfig.cachePath, `./${TRANSFORMED_MOCK_CONFIG}`); 1081 const userDefinedMockConfigCache: string = 1082 path.resolve(this.rollup.share.projectConfig.cachePath, `./${USER_DEFINE_MOCK_CONFIG}`); 1083 fs.writeFileSync(transformedMockConfigCache, '{}'); 1084 fs.writeFileSync(userDefinedMockConfigCache, '{}'); 1085 ModuleSourceFile.removePotentialMockConfigCache(this.rollup); 1086 expect(!fs.existsSync(transformedMockConfigCache)).to.be.true; 1087 expect(!fs.existsSync(userDefinedMockConfigCache)).to.be.true; 1088 }); 1089 1090 mocha.it('7-1: test the error message of generateTransformedMockInfo', function () { 1091 this.rollup.build(); 1092 const moduleInfo: Object = { 1093 filePath: '' 1094 }; 1095 const errInfo: LogData = LogDataFactory.newInstance( 1096 ErrorCode.ETS2BUNDLE_INTERNAL_MOCK_CONFIG_KEY_TO_OHM_URL_CONVERSION_FAILED, 1097 ArkTSInternalErrorDescription, 1098 'Failed to convert the key in mock-config to ohmurl, ' + 1099 'because the file path corresponding to the key in mock-config is empty.' 1100 ); 1101 ModuleSourceFile.initPluginEnv(this.rollup); 1102 const stub = sinon.stub(ModuleSourceFile.logger.getLoggerFromErrorCode(errInfo.code), 'printError'); 1103 this.rollup.moduleInfos.push(moduleInfo); 1104 ModuleSourceFile.generateTransformedMockInfo(moduleInfo, '', 'filePath', this.rollup); 1105 expect(stub.calledWith(errInfo)).to.be.true; 1106 stub.restore(); 1107 }); 1108 1109 mocha.it('7-2: test the error message of generateTransformedMockInfo' + 1110 'without getHvigorConsoleLogger', function () { 1111 this.rollup.build(); 1112 const moduleInfo: Object = { 1113 filePath: '' 1114 }; 1115 const errInfo: LogData = LogDataFactory.newInstance( 1116 ErrorCode.ETS2BUNDLE_INTERNAL_MOCK_CONFIG_KEY_TO_OHM_URL_CONVERSION_FAILED, 1117 ArkTSInternalErrorDescription, 1118 'Failed to convert the key in mock-config to ohmurl, ' + 1119 'because the file path corresponding to the key in mock-config is empty.' 1120 ); 1121 CommonLogger.destroyInstance(); 1122 const getHvigorConsoleLogger = this.rollup.share.getHvigorConsoleLogger; 1123 this.rollup.share.getHvigorConsoleLogger = undefined; 1124 ModuleSourceFile.initPluginEnv(this.rollup); 1125 const stub = sinon.stub(ModuleSourceFile.logger.logger, 'error'); 1126 this.rollup.moduleInfos.push(moduleInfo); 1127 ModuleSourceFile.generateTransformedMockInfo(moduleInfo, '', 'filePath', this.rollup); 1128 expect(stub.calledWith(errInfo.toString())).to.be.true; 1129 CommonLogger.destroyInstance(); 1130 this.rollup.share.getHvigorConsoleLogger = getHvigorConsoleLogger; 1131 stub.restore(); 1132 }); 1133 1134 mocha.it('8-1: test isMockFile under LocalTest mode', function () { 1135 ModuleSourceFile.needProcessMock = true; 1136 ModuleSourceFile.mockFiles = ["src/mock/ohos/I18nMock.ts"]; 1137 let file = this.rollup.share.projectConfig.aceModuleRoot +'/mock/ohos/I18nMock.ts'; 1138 expect(ModuleSourceFile.isMockFile(file, this.rollup)).to.be.true; 1139 ModuleSourceFile.needProcessMock = false; 1140 }); 1141});