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'; 22 23import RollUpPluginMock from '../mock/rollup_mock/rollup_plugin_mock'; 24import { ModuleSourceFile } from '../../../lib/fast_build/ark_compiler/module/module_source_file'; 25import { ModuleInfo } from '../../../lib/fast_build/ark_compiler/module/module_mode'; 26import ModuleModeMock from '../mock/class_mock/module_mode_mock'; 27import { 28 EXPECT_ENTRY_TS, 29 EXPECT_INDEX_ETS, 30 MODULE_TEST_PATH, 31 EXPECT_TO_JS 32} from '../mock/rollup_mock/path_config'; 33import { 34 RELEASE, 35 EXTNAME_ETS, 36 EXTNAME_TS, 37 EXTNAME_JS 38} from '../../../lib/fast_build/ark_compiler/common/ark_define'; 39import { 40 META, 41 ENTRYABILITY_TS_PATH_DEFAULT, 42 INDEX_ETS_PATH_DEFAULT, 43 OHURL_RES, 44 ENTRYABILITY_TS, 45 INDEX_ETS, 46 OHURL_SHAREDLIBRARY, 47 OH_UIABILITY, 48 OH_HILOG 49} from '../mock/rollup_mock/common'; 50import projectConfig from '../utils/processProjectConfig'; 51import { ModuleInfo as ModuleInfoMock } from '../mock/rollup_mock/module_info'; 52import { scanFiles } from "../utils/utils"; 53import { SourceMapGenerator } from '../../../lib/fast_build/ark_compiler/generate_sourcemap'; 54import { 55 TRANSFORMED_MOCK_CONFIG, 56 USER_DEFINE_MOCK_CONFIG 57} from '../../../lib/pre_define'; 58 59const ROLLUP_IMPORT_NODE: string = 'ImportDeclaration'; 60const ROLLUP_EXPORTNAME_NODE: string = 'ExportNamedDeclaration'; 61const ROLLUP_EXPORTALL_NODE: string = 'ExportAllDeclaration'; 62const ROLLUP_DYNAMICIMPORT_NODE: string = 'ImportExpression'; 63const ROLLUP_LITERAL_NODE: string = 'Literal'; 64 65mocha.describe('test module_source_file file api', function () { 66 mocha.before(function () { 67 this.rollup = new RollUpPluginMock(); 68 }); 69 70 mocha.after(() => { 71 delete this.rollup; 72 }); 73 74 mocha.it('1-1-1: test getOhmUrl under build debug: systemOrLibOhmUrl is not undefined', function () { 75 this.rollup.build(); 76 SourceMapGenerator.initInstance(this.rollup); 77 const modeMock = new ModuleModeMock(this.rollup); 78 const mockFileList: object = this.rollup.getModuleIds(); 79 this.moduleInfos = new Map<String, ModuleInfo>(); 80 81 for (const moduleId of mockFileList) { 82 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 83 const code: string = fs.readFileSync(moduleId, 'utf-8'); 84 const moduleSource = new ModuleSourceFile(moduleId, code); 85 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 86 const metaInfo: object = moduleInfo[META]; 87 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 88 moduleInfo.setImportedIdMaps(); 89 moduleInfo.setNodeImportDeclaration(); 90 const importMap: object = moduleInfo.importedIdMaps; 91 const moduleNodeMap: Map<string, any> = 92 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 93 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 94 let hasDynamicImport: boolean = false; 95 for (const nodeSet of moduleNodeMap.values()) { 96 nodeSet.forEach(node => { 97 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 98 hasDynamicImport = true; 99 } 100 if (node.source) { 101 if (node.source.type === ROLLUP_LITERAL_NODE) { 102 const ohmUrl: string | undefined = 103 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap[node.source.value]); 104 expect(ohmUrl === OH_UIABILITY || ohmUrl === OH_HILOG).to.be.true; 105 } else { 106 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 107 + `DynamicImport only accept stringLiteral as argument currently.\n`; 108 console.log(errorMsg); 109 } 110 } 111 }); 112 } 113 } 114 } 115 SourceMapGenerator.cleanSourceMapObject(); 116 }); 117 118 mocha.it('1-1-2: test getOhmUrl under build debug: filePath exist', function () { 119 this.rollup.build(); 120 SourceMapGenerator.initInstance(this.rollup); 121 const modeMock = new ModuleModeMock(this.rollup); 122 const mockFileList: object = this.rollup.getModuleIds(); 123 this.moduleInfos = new Map<String, ModuleInfo>(); 124 125 for (const moduleId of mockFileList) { 126 if (moduleId.endsWith(EXTNAME_ETS)) { 127 const code: string = fs.readFileSync(moduleId, 'utf-8'); 128 const moduleSource = new ModuleSourceFile(moduleId, code); 129 ModuleSourceFile.projectConfig = modeMock.projectConfig; 130 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 131 const metaInfo: object = moduleInfo[META]; 132 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 133 moduleInfo.setImportedIdMaps(moduleId); 134 moduleInfo.setNodeImportExpression(); 135 const importMap: object = moduleInfo.importedIdMaps; 136 const moduleNodeMap: Map<string, any> = 137 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 138 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 139 let hasDynamicImport: boolean = false; 140 for (const nodeSet of moduleNodeMap.values()) { 141 nodeSet.forEach(node => { 142 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 143 hasDynamicImport = true; 144 } 145 if (node.source) { 146 if (node.source.type === ROLLUP_LITERAL_NODE) { 147 const ohmUrl: string | undefined = 148 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap['requestFile']); 149 expect(ohmUrl === OHURL_RES).to.be.true; 150 } else { 151 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 152 + `DynamicImport only accept stringLiteral as argument currently.\n`; 153 console.log(errorMsg); 154 } 155 } 156 }); 157 } 158 } 159 } 160 SourceMapGenerator.cleanSourceMapObject(); 161 }); 162 163 mocha.it('1-1-3: test getOhmUrl under build debug: harOhmUrl is not undefined', function () { 164 this.rollup.build(); 165 SourceMapGenerator.initInstance(this.rollup); 166 const modeMock = new ModuleModeMock(this.rollup); 167 const mockFileList: object = this.rollup.getModuleIds(); 168 this.moduleInfos = new Map<String, ModuleInfo>(); 169 170 for (const moduleId of mockFileList) { 171 if (moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 172 const code: string = fs.readFileSync(moduleId, 'utf-8'); 173 const moduleSource = new ModuleSourceFile(moduleId, code); 174 ModuleSourceFile.projectConfig = modeMock.projectConfig; 175 ModuleSourceFile.projectConfig.harNameOhmMap = projectConfig.harNameOhmMap; 176 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 177 const metaInfo: object = moduleInfo[META]; 178 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 179 moduleInfo.setImportedIdMaps(moduleId); 180 moduleInfo.setNodeImportExpression(); 181 const importMap: object = moduleInfo.importedIdMaps; 182 const moduleNodeMap: Map<string, any> = 183 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 184 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 185 let hasDynamicImport: boolean = false; 186 for (const nodeSet of moduleNodeMap.values()) { 187 nodeSet.forEach(node => { 188 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 189 hasDynamicImport = true; 190 } 191 if (node.source) { 192 if (node.source.type === ROLLUP_LITERAL_NODE) { 193 const ohmUrl: string | undefined = 194 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap['requestFile']); 195 expect(ohmUrl === OHURL_SHAREDLIBRARY).to.be.true; 196 } else { 197 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 198 + `DynamicImport only accept stringLiteral as argument currently.\n`; 199 console.log(errorMsg); 200 } 201 } 202 }); 203 } 204 } 205 } 206 SourceMapGenerator.cleanSourceMapObject(); 207 }); 208 209 mocha.it('1-2: test getOhmUrl under build release', function () { 210 this.rollup.build(RELEASE); 211 SourceMapGenerator.initInstance(this.rollup); 212 const modeMock = new ModuleModeMock(this.rollup); 213 const mockFileList: object = this.rollup.getModuleIds(); 214 this.moduleInfos = new Map<String, ModuleInfo>(); 215 for (const moduleId of mockFileList) { 216 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 217 const code: string = fs.readFileSync(moduleId, 'utf-8'); 218 const moduleSource = new ModuleSourceFile(moduleId, code); 219 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 220 const metaInfo: object = moduleInfo[META]; 221 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 222 moduleInfo.setImportedIdMaps(); 223 moduleInfo.setNodeImportDeclaration(); 224 const importMap: object = moduleInfo.importedIdMaps; 225 const moduleNodeMap: Map<string, any> = 226 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 227 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 228 let hasDynamicImport: boolean = false; 229 for (const nodeSet of moduleNodeMap.values()) { 230 nodeSet.forEach(node => { 231 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 232 hasDynamicImport = true; 233 } 234 if (node.source) { 235 if (node.source.type === ROLLUP_LITERAL_NODE) { 236 const ohmUrl: string | undefined = 237 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap[node.source.value]); 238 expect(ohmUrl === OH_UIABILITY || ohmUrl === OH_HILOG).to.be.true; 239 } else { 240 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 241 + `DynamicImport only accept stringLiteral as argument currently.\n`; 242 console.log(errorMsg); 243 } 244 } 245 }); 246 } 247 } 248 } 249 SourceMapGenerator.cleanSourceMapObject(); 250 }); 251 252 mocha.it('1-3: test getOhmUrl under preview debug', function () { 253 this.rollup.preview(); 254 SourceMapGenerator.initInstance(this.rollup); 255 const modeMock = new ModuleModeMock(this.rollup); 256 const mockFileList: object = this.rollup.getModuleIds(); 257 this.moduleInfos = new Map<String, ModuleInfo>(); 258 for (const moduleId of mockFileList) { 259 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 260 const code: string = fs.readFileSync(moduleId, 'utf-8'); 261 const moduleSource = new ModuleSourceFile(moduleId, code); 262 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 263 const metaInfo: object = moduleInfo[META]; 264 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 265 moduleInfo.setImportedIdMaps(); 266 moduleInfo.setNodeImportDeclaration(); 267 const importMap: object = moduleInfo.importedIdMaps; 268 const moduleNodeMap: Map<string, any> = 269 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 270 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 271 let hasDynamicImport: boolean = false; 272 for (const nodeSet of moduleNodeMap.values()) { 273 nodeSet.forEach(node => { 274 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 275 hasDynamicImport = true; 276 } 277 if (node.source) { 278 if (node.source.type === ROLLUP_LITERAL_NODE) { 279 const ohmUrl: string | undefined = 280 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap[node.source.value]); 281 expect(ohmUrl === OH_UIABILITY || ohmUrl === OH_HILOG).to.be.true; 282 } else { 283 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 284 + `DynamicImport only accept stringLiteral as argument currently.\n`; 285 console.log(errorMsg); 286 } 287 } 288 }); 289 } 290 } 291 } 292 SourceMapGenerator.cleanSourceMapObject(); 293 }); 294 295 mocha.it('1-4: test getOhmUrl under hot reload debug', function () { 296 this.rollup.hotReload(); 297 SourceMapGenerator.initInstance(this.rollup); 298 const modeMock = new ModuleModeMock(this.rollup); 299 const mockFileList: object = this.rollup.getModuleIds(); 300 this.moduleInfos = new Map<String, ModuleInfo>(); 301 for (const moduleId of mockFileList) { 302 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS) || moduleId.endsWith(EXTNAME_JS)) { 303 const code: string = fs.readFileSync(moduleId, 'utf-8'); 304 const moduleSource = new ModuleSourceFile(moduleId, code); 305 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 306 const metaInfo: object = moduleInfo[META]; 307 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 308 moduleInfo.setImportedIdMaps(); 309 moduleInfo.setNodeImportDeclaration(); 310 const importMap: object = moduleInfo.importedIdMaps; 311 const moduleNodeMap: Map<string, any> = 312 moduleInfo.getNodeByType(ROLLUP_IMPORT_NODE, ROLLUP_EXPORTNAME_NODE, 313 ROLLUP_EXPORTALL_NODE, ROLLUP_DYNAMICIMPORT_NODE); 314 let hasDynamicImport: boolean = false; 315 for (const nodeSet of moduleNodeMap.values()) { 316 nodeSet.forEach(node => { 317 if (!hasDynamicImport && node.type === ROLLUP_DYNAMICIMPORT_NODE) { 318 hasDynamicImport = true; 319 } 320 if (node.source) { 321 if (node.source.type === ROLLUP_LITERAL_NODE) { 322 const ohmUrl: string | undefined = 323 moduleSource.getOhmUrl(this.rollup, node.source.value, importMap[node.source.value]); 324 expect(ohmUrl === OH_UIABILITY || ohmUrl === OH_HILOG).to.be.true; 325 } else { 326 const errorMsg: string = `ArkTS:ERROR ArkTS:ERROR File: ${this.moduleId}\n` 327 + `DynamicImport only accept stringLiteral as argument currently.\n`; 328 console.log(errorMsg); 329 } 330 } 331 }); 332 } 333 } 334 } 335 SourceMapGenerator.cleanSourceMapObject(); 336 }); 337 338 mocha.it('2-1: test processJsModuleRequest under build debug', function () { 339 this.rollup.build(); 340 SourceMapGenerator.initInstance(this.rollup); 341 const modeMock = new ModuleModeMock(this.rollup); 342 const mockFileList: object = this.rollup.getModuleIds(); 343 this.moduleInfos = new Map<String, ModuleInfo>(); 344 for (const moduleId of mockFileList) { 345 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 346 const code: string = fs.readFileSync(moduleId, 'utf-8'); 347 const moduleSource = new ModuleSourceFile(moduleId, code); 348 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 349 const metaInfo: object = moduleInfo[META]; 350 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 351 moduleInfo.setImportedIdMaps(); 352 moduleSource.processJsModuleRequest(this.rollup); 353 const EntryAbility_ts = fs.readFileSync(EXPECT_ENTRY_TS).toString(); 354 const Index_ets = fs.readFileSync(EXPECT_INDEX_ETS).toString(); 355 expect(moduleSource.source === EntryAbility_ts || moduleSource.source === Index_ets).to.be.true; 356 } 357 } 358 SourceMapGenerator.cleanSourceMapObject(); 359 }); 360 361 mocha.it('2-2: test processJsModuleRequest under build release', function () { 362 this.rollup.build(RELEASE); 363 SourceMapGenerator.initInstance(this.rollup); 364 const modeMock = new ModuleModeMock(this.rollup); 365 const mockFileList: object = this.rollup.getModuleIds(); 366 this.moduleInfos = new Map<String, ModuleInfo>(); 367 for (const moduleId of mockFileList) { 368 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 369 const code: string = fs.readFileSync(moduleId, 'utf-8'); 370 const moduleSource = new ModuleSourceFile(moduleId, code); 371 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 372 const metaInfo: object = moduleInfo[META]; 373 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 374 moduleInfo.setImportedIdMaps(); 375 moduleSource.processJsModuleRequest(this.rollup); 376 const EntryAbility_ts = fs.readFileSync(EXPECT_ENTRY_TS).toString(); 377 const Index_ets = fs.readFileSync(EXPECT_INDEX_ETS).toString(); 378 expect(moduleSource.source === EntryAbility_ts || moduleSource.source === Index_ets).to.be.true; 379 } 380 } 381 SourceMapGenerator.cleanSourceMapObject(); 382 }); 383 384 mocha.it('2-3: test processJsModuleRequest under preview debug', function () { 385 this.rollup.preview(); 386 SourceMapGenerator.initInstance(this.rollup); 387 const modeMock = new ModuleModeMock(this.rollup); 388 const mockFileList: object = this.rollup.getModuleIds(); 389 this.moduleInfos = new Map<String, ModuleInfo>(); 390 for (const moduleId of mockFileList) { 391 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 392 const code: string = fs.readFileSync(moduleId, 'utf-8'); 393 const moduleSource = new ModuleSourceFile(moduleId, code); 394 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 395 const metaInfo: object = moduleInfo[META]; 396 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 397 moduleInfo.setImportedIdMaps(); 398 moduleSource.processJsModuleRequest(this.rollup); 399 const EntryAbility_ts = fs.readFileSync(EXPECT_ENTRY_TS).toString(); 400 const Index_ets = fs.readFileSync(EXPECT_INDEX_ETS).toString(); 401 expect(moduleSource.source === EntryAbility_ts || moduleSource.source === Index_ets).to.be.true; 402 } 403 } 404 SourceMapGenerator.cleanSourceMapObject(); 405 }); 406 407 mocha.it('2-4: test processJsModuleRequest under hot reload debug', function () { 408 this.rollup.hotReload(); 409 SourceMapGenerator.initInstance(this.rollup); 410 const modeMock = new ModuleModeMock(this.rollup); 411 const mockFileList: object = this.rollup.getModuleIds(); 412 this.moduleInfos = new Map<String, ModuleInfo>(); 413 for (const moduleId of mockFileList) { 414 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 415 const code: string = fs.readFileSync(moduleId, 'utf-8'); 416 const moduleSource = new ModuleSourceFile(moduleId, code); 417 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 418 const metaInfo: object = moduleInfo[META]; 419 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 420 moduleInfo.setImportedIdMaps(); 421 moduleSource.processJsModuleRequest(this.rollup); 422 const EntryAbility_ts = fs.readFileSync(EXPECT_ENTRY_TS).toString(); 423 const Index_ets = fs.readFileSync(EXPECT_INDEX_ETS).toString(); 424 expect(moduleSource.source === EntryAbility_ts || moduleSource.source === Index_ets).to.be.true; 425 } 426 } 427 SourceMapGenerator.cleanSourceMapObject(); 428 }); 429 430 mocha.it('3-1-1: test processTransformedJsModuleRequest under build debug: hasDynamicImport is false', function () { 431 this.rollup.build(); 432 SourceMapGenerator.initInstance(this.rollup); 433 const modeMock = new ModuleModeMock(this.rollup); 434 const mockFileList: object = this.rollup.getModuleIds(); 435 this.moduleInfos = new Map<String, ModuleInfo>(); 436 for (const moduleId of mockFileList) { 437 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 438 const code: string = JSON.stringify(fs.readFileSync(moduleId, 'utf-8')); 439 const moduleSource = new ModuleSourceFile(moduleId, code); 440 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 441 const metaInfo: object = moduleInfo[META]; 442 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 443 moduleInfo.setImportedIdMaps(); 444 moduleInfo.setNodeImportDeclaration(); 445 moduleSource.processTransformedJsModuleRequest(this.rollup); 446 const json = fs.readFileSync(EXPECT_TO_JS, 'utf-8'); 447 const etsToJs = JSON.parse(json).expect_index_ets_to_js; 448 const tsToJs = JSON.parse(json).expect_entryability_ts_to_js; 449 expect(moduleSource.source === etsToJs || moduleSource.source === tsToJs).to.be.true; 450 } 451 } 452 SourceMapGenerator.cleanSourceMapObject(); 453 }); 454 455 mocha.it('3-1-2: test processTransformedJsModuleRequest under build debug: hasDynamicImport is true', async function () { 456 this.rollup.build(); 457 const sourceMapGenerator: SourceMapGenerator = SourceMapGenerator.initInstance(this.rollup); 458 let newSourceMaps = sourceMapGenerator.getSourceMaps(); 459 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 = JSON.stringify(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 moduleInfo.setNodeImportExpression(); 472 ModuleSourceFile.projectConfig = modeMock.projectConfig; 473 await moduleSource.processTransformedJsModuleRequest(this.rollup); 474 for (const key in newSourceMaps) { 475 expect(newSourceMaps[key].mappings.length > 0).to.be.true; 476 expect(newSourceMaps[key].file.includes(ENTRYABILITY_TS) !== -1 477 || newSourceMaps[key].file.includes(INDEX_ETS) !== -1).to.be.true; 478 expect(newSourceMaps[key].sources.includes(ENTRYABILITY_TS_PATH_DEFAULT) !== -1 479 || newSourceMaps[key].sources.includes(INDEX_ETS_PATH_DEFAULT) !== -1).to.be.true; 480 } 481 } 482 } 483 484 for (const key of Object.keys(newSourceMaps)) { 485 delete newSourceMaps[key]; 486 } 487 SourceMapGenerator.cleanSourceMapObject(); 488 }); 489 490 mocha.it('3-2: test processTransformedJsModuleRequest under build release', function () { 491 this.rollup.build(RELEASE); 492 SourceMapGenerator.initInstance(this.rollup); 493 const modeMock = new ModuleModeMock(this.rollup); 494 const mockFileList: object = this.rollup.getModuleIds(); 495 this.moduleInfos = new Map<String, ModuleInfo>(); 496 for (const moduleId of mockFileList) { 497 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 498 const code: string = JSON.stringify(fs.readFileSync(moduleId, 'utf-8')); 499 const moduleSource = new ModuleSourceFile(moduleId, code); 500 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 501 const metaInfo: object = moduleInfo[META]; 502 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 503 moduleInfo.setImportedIdMaps(); 504 moduleInfo.setNodeImportDeclaration(); 505 moduleSource.processTransformedJsModuleRequest(this.rollup); 506 const json = fs.readFileSync(EXPECT_TO_JS, 'utf-8'); 507 const etsToJs = JSON.parse(json).expect_index_ets_to_js; 508 const tsToJs = JSON.parse(json).expect_entryability_ts_to_js; 509 expect(moduleSource.source === etsToJs || moduleSource.source === tsToJs).to.be.true; 510 } 511 } 512 SourceMapGenerator.cleanSourceMapObject(); 513 }); 514 515 mocha.it('3-3: test processTransformedJsModuleRequest under preview debug', function () { 516 this.rollup.preview(); 517 SourceMapGenerator.initInstance(this.rollup); 518 const modeMock = new ModuleModeMock(this.rollup); 519 const mockFileList: object = this.rollup.getModuleIds(); 520 this.moduleInfos = new Map<String, ModuleInfo>(); 521 for (const moduleId of mockFileList) { 522 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 523 const code: string = JSON.stringify(fs.readFileSync(moduleId, 'utf-8')); 524 const moduleSource = new ModuleSourceFile(moduleId, code); 525 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 526 const metaInfo: object = moduleInfo[META]; 527 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 528 moduleInfo.setImportedIdMaps(); 529 moduleInfo.setNodeImportDeclaration(); 530 moduleSource.processTransformedJsModuleRequest(this.rollup); 531 const json = fs.readFileSync(EXPECT_TO_JS, 'utf-8'); 532 const etsToJs = JSON.parse(json).expect_index_ets_to_js; 533 const tsToJs = JSON.parse(json).expect_entryability_ts_to_js; 534 expect(moduleSource.source === etsToJs || moduleSource.source === tsToJs).to.be.true; 535 } 536 } 537 SourceMapGenerator.cleanSourceMapObject(); 538 }); 539 540 mocha.it('3-4: test processTransformedJsModuleRequest under hot reload debug', function () { 541 this.rollup.hotReload(); 542 SourceMapGenerator.initInstance(this.rollup); 543 const modeMock = new ModuleModeMock(this.rollup); 544 const mockFileList: object = this.rollup.getModuleIds(); 545 this.moduleInfos = new Map<String, ModuleInfo>(); 546 for (const moduleId of mockFileList) { 547 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 548 const code: string = JSON.stringify(fs.readFileSync(moduleId, 'utf-8')); 549 const moduleSource = new ModuleSourceFile(moduleId, code); 550 const moduleInfo: object = this.rollup.getModuleInfo(moduleId); 551 const metaInfo: object = moduleInfo[META]; 552 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 553 moduleInfo.setImportedIdMaps(); 554 moduleInfo.setNodeImportDeclaration(); 555 moduleSource.processTransformedJsModuleRequest(this.rollup); 556 const json = fs.readFileSync(EXPECT_TO_JS, 'utf-8'); 557 const etsToJs = JSON.parse(json).expect_index_ets_to_js; 558 const tsToJs = JSON.parse(json).expect_entryability_ts_to_js; 559 expect(moduleSource.source === etsToJs || moduleSource.source === tsToJs).to.be.true; 560 } 561 } 562 SourceMapGenerator.cleanSourceMapObject(); 563 }); 564 565 mocha.it('4-1: test processTransformedTsModuleRequest under build debug', function () { 566 this.rollup.build(); 567 const modeMock = new ModuleModeMock(this.rollup); 568 const allFiles = new Set<string>(); 569 this.moduleInfos = new Map<String, ModuleInfo>(); 570 scanFiles(MODULE_TEST_PATH, allFiles); 571 for (const moduleId of allFiles.values()) { 572 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 573 const code: string = fs.readFileSync(moduleId, 'utf-8'); 574 const moduleInfo = new ModuleInfoMock(moduleId, 575 this.rollup.share.projectConfig.entryModuleName, 576 this.rollup.share.projectConfig.modulePath); 577 moduleInfo.setImportedIdMaps(); 578 this.rollup.moduleInfos.push(moduleInfo); 579 const metaInfo: object = moduleInfo[META]; 580 SourceMapGenerator.initInstance(this.rollup); 581 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 582 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 583 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 584 ModuleSourceFile.processModuleSourceFiles(this.rollup); 585 moduleSource.processTransformedTsModuleRequest(this.rollup); 586 expect(moduleSource.source.fileName === moduleId).to.be.true; 587 expect(moduleSource.source.text === code).to.be.true; 588 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 589 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 590 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 591 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 592 SourceMapGenerator.cleanSourceMapObject(); 593 } 594 } 595 }); 596 597 mocha.it('4-2: test processTransformedTsModuleRequest under build release', function () { 598 this.rollup.build(RELEASE); 599 const modeMock = new ModuleModeMock(this.rollup); 600 const allFiles = new Set<string>(); 601 scanFiles(MODULE_TEST_PATH, allFiles); 602 for (const moduleId of allFiles.values()) { 603 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 604 const code: string = fs.readFileSync(moduleId, 'utf-8'); 605 const moduleInfo = new ModuleInfoMock(moduleId, 606 this.rollup.share.projectConfig.entryModuleName, 607 this.rollup.share.projectConfig.modulePath); 608 moduleInfo.setImportedIdMaps(); 609 this.rollup.moduleInfos.push(moduleInfo); 610 const metaInfo: object = moduleInfo[META]; 611 SourceMapGenerator.initInstance(this.rollup); 612 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 613 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 614 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 615 ModuleSourceFile.processModuleSourceFiles(this.rollup); 616 moduleSource.processTransformedTsModuleRequest(this.rollup); 617 expect(moduleSource.source.fileName === moduleId).to.be.true; 618 expect(moduleSource.source.text === code).to.be.true; 619 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 620 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 621 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 622 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 623 SourceMapGenerator.cleanSourceMapObject(); 624 } 625 } 626 }); 627 628 mocha.it('4-3: test processTransformedTsModuleRequest under preview debug', function () { 629 this.rollup.preview(); 630 const modeMock = new ModuleModeMock(this.rollup); 631 const allFiles = new Set<string>(); 632 scanFiles(MODULE_TEST_PATH, allFiles); 633 for (const moduleId of allFiles.values()) { 634 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 635 const code: string = fs.readFileSync(moduleId, 'utf-8'); 636 const moduleInfo = new ModuleInfoMock(moduleId, 637 this.rollup.share.projectConfig.entryModuleName, 638 this.rollup.share.projectConfig.modulePath); 639 moduleInfo.setImportedIdMaps(); 640 this.rollup.moduleInfos.push(moduleInfo); 641 const metaInfo: object = moduleInfo[META]; 642 SourceMapGenerator.initInstance(this.rollup); 643 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 644 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 645 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 646 ModuleSourceFile.processModuleSourceFiles(this.rollup); 647 moduleSource.processTransformedTsModuleRequest(this.rollup); 648 expect(moduleSource.source.fileName === moduleId).to.be.true; 649 expect(moduleSource.source.text === code).to.be.true; 650 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 651 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 652 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 653 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 654 SourceMapGenerator.cleanSourceMapObject(); 655 } 656 } 657 }); 658 659 mocha.it('4-4: test processTransformedTsModuleRequest under reload debug', function () { 660 this.rollup.hotReload(); 661 const modeMock = new ModuleModeMock(this.rollup); 662 const allFiles = new Set<string>(); 663 scanFiles(MODULE_TEST_PATH, allFiles); 664 for (const moduleId of allFiles.values()) { 665 if (moduleId.endsWith(EXTNAME_TS) || moduleId.endsWith(EXTNAME_ETS)) { 666 const code: string = fs.readFileSync(moduleId, 'utf-8'); 667 const moduleInfo = new ModuleInfoMock(moduleId, 668 this.rollup.share.projectConfig.entryModuleName, 669 this.rollup.share.projectConfig.modulePath); 670 moduleInfo.setImportedIdMaps(); 671 this.rollup.moduleInfos.push(moduleInfo); 672 const metaInfo: object = moduleInfo[META]; 673 SourceMapGenerator.initInstance(this.rollup); 674 modeMock.addModuleInfoItem(moduleId, false, '', metaInfo, this.moduleInfos); 675 const sourceFile = ts.createSourceFile(moduleId, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS); 676 const moduleSource = new ModuleSourceFile(moduleId, sourceFile); 677 ModuleSourceFile.processModuleSourceFiles(this.rollup); 678 moduleSource.processTransformedTsModuleRequest(this.rollup); 679 expect(moduleSource.source.fileName === moduleId).to.be.true; 680 expect(moduleSource.source.text === code).to.be.true; 681 expect(moduleSource.source.languageVariant === ts.LanguageVariant.Standard).to.be.true; 682 expect(moduleSource.source.isDeclarationFile === false).to.be.true; 683 expect(moduleSource.source.hasNoDefaultLib === false).to.be.true; 684 expect(moduleSource.source.languageVersion === ts.ScriptTarget.Latest).to.be.true; 685 SourceMapGenerator.cleanSourceMapObject(); 686 } 687 } 688 }); 689 690 mocha.it('5-1: test setProcessMock under LocalTest mode', function () { 691 this.rollup.share.projectConfig.isPreview = true; 692 this.rollup.share.projectConfig.isOhosTest = true; 693 this.rollup.share.projectConfig.isLocalTest = true; 694 this.rollup.share.projectConfig.mockParams = { 695 decorator: "@MockSetup", 696 packageName: "@ohos/hamock", 697 etsSourceRootPath: "src/main", 698 mockConfigPath: this.rollup.share.projectConfig.aceModuleRoot + '/mock/mock-config.json5', 699 } 700 ModuleSourceFile.setProcessMock(this.rollup); 701 expect(ModuleSourceFile.needProcessMock).to.be.true; 702 }); 703 704 mocha.it('5-2: test collectMockConfigInfo under LocalTest mode', function () { 705 this.rollup.share.projectConfig.isLocalTest = true; 706 this.rollup.share.projectConfig.mockParams = { 707 decorator: "@MockSetup", 708 packageName: "@ohos/hamock", 709 etsSourceRootPath: "src/main", 710 mockConfigPath: this.rollup.share.projectConfig.aceModuleRoot + '/mock/mock-config.json5', 711 } 712 ModuleSourceFile.collectMockConfigInfo(this.rollup); 713 let EXPECT_MOCKFILES = [ 714 "src/mock/ohos/I18nMock.ts", 715 "src/mock/ohos/bluetooth.mock.ts", 716 "src/mock/module/calc.mock.ts", 717 "src/mock/module/bigInt.mock.ts", 718 "src/mock/native/libentry.mock.ts" 719 ]; 720 expect(ModuleSourceFile.mockFiles).to.deep.equal(EXPECT_MOCKFILES); 721 }); 722 723 mocha.it('5-3: test addMockConfig under LocalTest mode', function () { 724 ModuleSourceFile.newMockConfigInfo = { 725 "@ohos:i18n": { 726 "source": "@bundle:com.example.demo/entry/src/mock/ohos/I18nMock" 727 }, 728 "@ohos:bluetooth": { 729 "source": "@bundle:com.example.demo/entry/src/mock/ohos/bluetooth.mock" 730 }, 731 "@bundle:com.example.demo/entry/ets/calc": { 732 "source": "@bundle:com.example.demo/entry/src/mock/module/calc.mock" 733 }, 734 "@bundle:/testProjectRootPath/oh_modules/lib/dist/index.js": { 735 "source": "@bundle:com.example.demo/entry/src/mock/module/bigInt.mock" 736 }, 737 "@app:UtTestApplication/entry/entry": { 738 "source": "@bundle:com.example.demo/entry/src/mock/native/libentry.mock" 739 } 740 }; 741 742 ModuleSourceFile.addMockConfig(ModuleSourceFile.newMockConfigInfo, "@ohos:i18n", "@bundle:com.example.demo/entry/src/mock/I18nMock"); 743 expect(ModuleSourceFile.newMockConfigInfo).to.deep.equal(ModuleSourceFile.newMockConfigInfo); 744 }); 745 746 mocha.it('5-4: test generateNewMockInfo under LocalTest mode', function () { 747 this.rollup.share.projectConfig.isLocalTest = true; 748 ModuleSourceFile.mockConfigInfo = { 749 "@ohos:i18n": { 750 "source": "src/mock/ohos/I18nMock.ts" 751 }, 752 } 753 let originKey = "@ohos.i18n"; 754 let transKey = "@ohos:i18n"; 755 let importerFile = this.rollup.share.projectConfig.aceModuleRoot + '/mock/ohos/I18nMock.ts'; 756 ModuleSourceFile.generateNewMockInfo(originKey, transKey, this.rollup, importerFile); 757 let EXPECT_NEW_MOCK_INFO = { 758 "@ohos:i18n": { 759 "source": "@bundle:com.example.demo/entry/src/mock/ohos/I18nMock" 760 }, 761 "@ohos:bluetooth": { 762 "source": "@bundle:com.example.demo/entry/src/mock/ohos/bluetooth.mock" 763 }, 764 "@bundle:com.example.demo/entry/ets/calc": { 765 "source": "@bundle:com.example.demo/entry/src/mock/module/calc.mock" 766 }, 767 "@bundle:/testProjectRootPath/oh_modules/lib/dist/index.js": { 768 "source": "@bundle:com.example.demo/entry/src/mock/module/bigInt.mock" 769 }, 770 "@app:UtTestApplication/entry/entry": { 771 "source": "@bundle:com.example.demo/entry/src/mock/native/libentry.mock" 772 } 773 }; 774 expect(ModuleSourceFile.newMockConfigInfo).to.deep.equal(EXPECT_NEW_MOCK_INFO); 775 }); 776 777 778 mocha.it('5-5: test isMockFile under LocalTest mode', function () { 779 ModuleSourceFile.needProcessMock = true; 780 ModuleSourceFile.mockFiles = ["src/mock/ohos/I18nMock.ts"]; 781 let file = this.rollup.share.projectConfig.aceModuleRoot +'/mock/ohos/I18nMock.ts'; 782 expect(ModuleSourceFile.isMockFile(file, this.rollup)).to.be.true; 783 ModuleSourceFile.needProcessMock = false; 784 }); 785 786 mocha.it('5-6: test generateMockConfigFile under LocalTest mode', function () { 787 this.rollup.share.projectConfig.isLocalTest = true; 788 ModuleSourceFile.newMockConfigInfo = { 789 "@ohos:i18n": { 790 "source": "@bundle:com.example.demo/entry/src/mock/I18nMock" 791 }, 792 "@ohos:bluetooth": { 793 "source": "@bundle:com.example.demo/entry/src/mock/ohos/bluetooth.mock" 794 }, 795 "@bundle:com.example.demo/entry/ets/calc": { 796 "source": "@bundle:com.example.demo/entry/src/mock/module/calc.mock" 797 }, 798 "@bundle:/testProjectRootPath/oh_modules/lib/dist/index.js": { 799 "source": "@bundle:com.example.demo/entry/src/mock/module/bigInt.mock" 800 }, 801 "@app:UtTestApplication/entry/entry": { 802 "source": "@bundle:com.example.demo/entry/src/mock/native/libentry.mock" 803 } 804 } 805 this.rollup.share.projectConfig.mockParams = { 806 decorator: "@MockSetup", 807 packageName: "@ohos/hamock", 808 etsSourceRootPath: "src/main", 809 mockConfigPath: this.rollup.share.projectConfig.aceModuleRoot + '/mock/mock-config.json5', 810 } 811 ModuleSourceFile.generateMockConfigFile(this.rollup); 812 let EXPECT_MOCK_CONFIG_FILE = path.resolve(this.rollup.share.projectConfig.aceModuleJsonPath, `../mock-config.json`); 813 expect(fs.existsSync(EXPECT_MOCK_CONFIG_FILE)).to.be.true; 814 let EXPECT_MOCK_CONFIG_CONTENT = JSON.stringify(ModuleSourceFile.newMockConfigInfo); 815 let ACTUAL_MOCK_CONFIG_CONTENT = JSON.stringify(require(EXPECT_MOCK_CONFIG_FILE)); 816 expect(EXPECT_MOCK_CONFIG_CONTENT).to.equal(ACTUAL_MOCK_CONFIG_CONTENT); 817 fs.unlinkSync(this.rollup.share.projectConfig.cachePath + '/mock-config.json'); 818 fs.unlinkSync(this.rollup.share.projectConfig.cachePath + '/mock-config.json5'); 819 }); 820 821 mocha.it('6-1: test removePotentialMockConfigCache delete mock-config', function () { 822 const transformedMockConfigCache: string = 823 path.resolve(this.rollup.share.projectConfig.cachePath, `./${TRANSFORMED_MOCK_CONFIG}`); 824 const userDefinedMockConfigCache: string = 825 path.resolve(this.rollup.share.projectConfig.cachePath, `./${USER_DEFINE_MOCK_CONFIG}`); 826 fs.writeFileSync(transformedMockConfigCache, '{}'); 827 fs.writeFileSync(userDefinedMockConfigCache, '{}'); 828 ModuleSourceFile.removePotentialMockConfigCache(this.rollup); 829 expect(!fs.existsSync(transformedMockConfigCache)).to.be.true; 830 expect(!fs.existsSync(userDefinedMockConfigCache)).to.be.true; 831 }); 832});