• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this 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
16import { describe, it } from 'mocha';
17import { TransformerManager } from '../../../src/transformers/TransformerManager';
18import { assert, expect } from 'chai';
19import { FileUtils } from '../../../src/utils/FileUtils';
20import path from 'path';
21import { IOptions } from '../../../src/configs/IOptions';
22import fs from 'fs';
23import ts, {
24  TransformationResult,
25  factory,
26  transform,
27  SourceFile,
28  Node,
29  IndexedAccessTypeNode,
30  LiteralTypeNode,
31  setParentRecursive,
32  UnionTypeNode
33} from 'typescript';
34import secharmony from '../../../src/transformers/rename/RenamePropertiesTransformer';
35import { ArkObfuscator } from '../../../src/ArkObfuscator';
36
37
38describe('Tester Cases for <RenamePropertiesTransformer>.', function () {
39  describe('Tester Cases for <renameIndexedAccessProperty>.', function () {
40    let options: IOptions;
41    beforeEach(() => {
42      options = {
43        mNameObfuscation: {
44          mEnable: true,
45          mNameGeneratorType: 1,
46          mRenameProperties: true,
47          mKeepStringProperty: false,
48          mReservedProperties: []
49        },
50      }
51    });
52
53    it('should rename string property in indexedAccessType when using prop+strProp', function () {
54      ArkObfuscator.isKeptCurrentFile = false;
55      const renamePropertiesFactory = secharmony.transformerPlugin.createTransformerFactory(options as IOptions);
56      let sourcefile = factory.createIndexedAccessTypeNode(
57        factory.createTypeReferenceNode(
58          factory.createIdentifier("T"),
59          undefined
60        ),
61        factory.createLiteralTypeNode(factory.createStringLiteral("X"))
62      )
63      let parentNodes = setParentRecursive(sourcefile, true);
64      let transfomedResult: TransformationResult<Node> = transform(parentNodes, [renamePropertiesFactory], {});
65      let node = transfomedResult.transformed[0] as IndexedAccessTypeNode;
66      expect((node.indexType as LiteralTypeNode).literal).not.to.be.equal((parentNodes.indexType as LiteralTypeNode).literal);
67    });
68
69    it('should not rename string property in indexedAccessType when using prop', function () {
70      ArkObfuscator.isKeptCurrentFile = false;
71      options = {
72        mNameObfuscation: {
73          mEnable: true,
74          mNameGeneratorType: 1,
75          mRenameProperties: true,
76          mKeepStringProperty: true,
77          mReservedProperties: []
78        },
79      };
80      const renamePropertiesFactory = secharmony.transformerPlugin.createTransformerFactory(options as IOptions);
81      let sourcefile = factory.createIndexedAccessTypeNode(
82        factory.createTypeReferenceNode(
83          factory.createIdentifier("T"),
84          undefined
85        ),
86        factory.createLiteralTypeNode(factory.createStringLiteral("X"))
87      )
88      let parentNodes = setParentRecursive(sourcefile, true);
89      let transfomedResult: TransformationResult<Node> = transform(parentNodes, [renamePropertiesFactory], {});
90      let node = transfomedResult.transformed[0] as IndexedAccessTypeNode;
91      expect((node.indexType as LiteralTypeNode).literal).to.be.equal((parentNodes.indexType as LiteralTypeNode).literal);
92    });
93
94    it('should not rename numeric property in indexedAccessType when using prop+strProp', function () {
95      ArkObfuscator.isKeptCurrentFile = false;
96      options = {
97        mNameObfuscation: {
98          mEnable: true,
99          mNameGeneratorType: 1,
100          mRenameProperties: true,
101          mKeepStringProperty: false,
102          mReservedProperties: []
103        },
104      };
105      const renamePropertiesFactory = secharmony.transformerPlugin.createTransformerFactory(options as IOptions);
106      let sourcefile = factory.createIndexedAccessTypeNode(
107        factory.createTypeReferenceNode(
108          factory.createIdentifier("T"),
109          undefined
110        ),
111        factory.createLiteralTypeNode(factory.createNumericLiteral(1))
112      )
113      let parentNodes = setParentRecursive(sourcefile, true);
114      let transfomedResult: TransformationResult<Node> = transform(parentNodes, [renamePropertiesFactory], {});
115      let node = transfomedResult.transformed[0] as IndexedAccessTypeNode;
116      expect((node.indexType as LiteralTypeNode).literal).to.be.equal((parentNodes.indexType as LiteralTypeNode).literal);
117    });
118
119    it('should rename string property in unionType of indexedAccessType when using prop+strProp', function () {
120      ArkObfuscator.isKeptCurrentFile = false;
121      options = {
122        mNameObfuscation: {
123          mEnable: true,
124          mNameGeneratorType: 1,
125          mRenameProperties: true,
126          mKeepStringProperty: false,
127          mReservedProperties: []
128        },
129      };
130      const renamePropertiesFactory = secharmony.transformerPlugin.createTransformerFactory(options as IOptions);
131      let sourcefile = factory.createIndexedAccessTypeNode(
132        factory.createTypeReferenceNode(
133          factory.createIdentifier("T"),
134          undefined
135        ),
136        factory.createUnionTypeNode([
137          factory.createLiteralTypeNode(factory.createStringLiteral("U")),
138          factory.createLiteralTypeNode(factory.createStringLiteral("V"))
139        ])
140      )
141      let parentNodes = setParentRecursive(sourcefile, true);
142      let transfomedResult: TransformationResult<Node> = transform(parentNodes, [renamePropertiesFactory], {});
143      let node = transfomedResult.transformed[0] as IndexedAccessTypeNode;
144      expect(((node.indexType as UnionTypeNode).types[0] as LiteralTypeNode).literal).not.to.be.equal(((parentNodes.indexType as UnionTypeNode).types[0] as LiteralTypeNode).literal);
145      expect(((node.indexType as UnionTypeNode).types[1] as LiteralTypeNode).literal).not.to.be.equal(((parentNodes.indexType as UnionTypeNode).types[1] as LiteralTypeNode).literal);
146    });
147
148    it('should not rename string property in unionType of indexedAccessType when using prop', function () {
149      ArkObfuscator.isKeptCurrentFile = false;
150      options = {
151        mNameObfuscation: {
152          mEnable: true,
153          mNameGeneratorType: 1,
154          mRenameProperties: true,
155          mKeepStringProperty: true,
156          mReservedProperties: []
157        },
158      };
159      const renamePropertiesFactory = secharmony.transformerPlugin.createTransformerFactory(options as IOptions);
160      let sourcefile = factory.createIndexedAccessTypeNode(
161        factory.createTypeReferenceNode(
162          factory.createIdentifier("T"),
163          undefined
164        ),
165        factory.createUnionTypeNode([
166          factory.createLiteralTypeNode(factory.createStringLiteral("U")),
167          factory.createLiteralTypeNode(factory.createStringLiteral("V"))
168        ])
169      )
170      let parentNodes = setParentRecursive(sourcefile, true);
171      let transfomedResult: TransformationResult<Node> = transform(parentNodes, [renamePropertiesFactory], {});
172      let node = transfomedResult.transformed[0] as IndexedAccessTypeNode;
173      expect(((node.indexType as UnionTypeNode).types[0] as LiteralTypeNode).literal).to.be.equal(((parentNodes.indexType as UnionTypeNode).types[0] as LiteralTypeNode).literal);
174      expect(((node.indexType as UnionTypeNode).types[1] as LiteralTypeNode).literal).to.be.equal(((parentNodes.indexType as UnionTypeNode).types[1] as LiteralTypeNode).literal);
175    });
176
177    it('should not rename numeric property in unionType of indexedAccessType when using prop+strProp', function () {
178      ArkObfuscator.isKeptCurrentFile = false;
179      options = {
180        mNameObfuscation: {
181          mEnable: true,
182          mNameGeneratorType: 1,
183          mRenameProperties: true,
184          mKeepStringProperty: false,
185          mReservedProperties: []
186        },
187      };
188      const renamePropertiesFactory = secharmony.transformerPlugin.createTransformerFactory(options as IOptions);
189      let sourcefile = factory.createIndexedAccessTypeNode(
190        factory.createTypeReferenceNode(
191          factory.createIdentifier("T"),
192          undefined
193        ),
194        factory.createUnionTypeNode([
195          factory.createLiteralTypeNode(factory.createNumericLiteral(1)),
196          factory.createLiteralTypeNode(factory.createNumericLiteral(2))
197        ])
198      )
199      let parentNodes = setParentRecursive(sourcefile, true);
200      let transfomedResult: TransformationResult<Node> = transform(parentNodes, [renamePropertiesFactory], {});
201      let node = transfomedResult.transformed[0] as IndexedAccessTypeNode;
202      expect(((node.indexType as UnionTypeNode).types[0] as LiteralTypeNode).literal).to.be.equal(((parentNodes.indexType as UnionTypeNode).types[0] as LiteralTypeNode).literal);
203      expect(((node.indexType as UnionTypeNode).types[1] as LiteralTypeNode).literal).to.be.equal(((parentNodes.indexType as UnionTypeNode).types[1] as LiteralTypeNode).literal);
204    });
205  });
206});
207