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