FunctionObfuscator tests

test/mocks/NodeMocks.ts

@@ -1,8 +1,10 @@
 import * as escodegen from 'escodegen';
 
+import { TExpression } from "../../src/types/nodes/TExpression";
 import { TStatement } from "../../src/types/nodes/TStatement";
 
 import { IBlockStatementNode } from "../../src/interfaces/nodes/IBlockStatementNode";
+import { ICallExpressionNode } from "../../src/interfaces/nodes/ICallExpressionNode";
 import { ICatchClauseNode } from "../../src/interfaces/nodes/ICatchClauseNode";
 import { IExpressionStatementNode } from "../../src/interfaces/nodes/IExpressionStatementNode";
 import { IFunctionDeclarationNode } from "../../src/interfaces/nodes/IFunctionDeclarationNode";
@@ -10,6 +12,7 @@ import { IIdentifierNode } from "../../src/interfaces/nodes/IIdentifierNode";
 import { IIfStatementNode } from "../../src/interfaces/nodes/IIfStatementNode";
 import { ILiteralNode } from "../../src/interfaces/nodes/ILiteralNode";
 import { IProgramNode } from "../../src/interfaces/nodes/IProgramNode";
+import { ISpreadElementNode } from "../../src/interfaces/nodes/ISpreadElementNode";
 
 import { NodeType } from "../../src/enums/NodeType";
 
@@ -49,25 +52,49 @@ export class NodeMocks {
     }
 
     /**
+     * @param callee
+     * @param args
+     * @returns {ICallExpressionNode}
+     */
+    public static getCallExpressionNode (
+        callee: TExpression,
+        args: TExpression[] | ISpreadElementNode[] = []
+    ): ICallExpressionNode {
+        return {
+            type: NodeType.CallExpression,
+            callee: callee,
+            arguments: args
+        };
+    }
+
+    /**
+     * @param expression
      * @returns {IExpressionStatementNode}
      */
-    public static getExpressionStatementNode (): IExpressionStatementNode {
+    public static getExpressionStatementNode (
+        expression: TExpression = NodeMocks.getIdentifierNode()
+    ): IExpressionStatementNode {
         return {
             type: NodeType.ExpressionStatement,
-            expression: NodeMocks.getIdentifierNode()
+            expression: expression
         };
     }
 
     /**
      * @param functionName
      * @param blockStatementNode
+     * @param params
      * @returns {IFunctionDeclarationNode}
      */
-    public static getFunctionDeclarationNode (functionName: string, blockStatementNode: IBlockStatementNode): IFunctionDeclarationNode {
+    public static getFunctionDeclarationNode (
+        functionName: string,
+        blockStatementNode: IBlockStatementNode,
+        params: IIdentifierNode[] = []
+    ): IFunctionDeclarationNode {
         return {
             type: NodeType.FunctionDeclaration,
             id: NodeMocks.getIdentifierNode(functionName),
-            params: [],
+            params: params,
             body: blockStatementNode,
             generator: false,
             expression: false

test/node-obfuscators/FunctionDeclarationObfuscator.spec.ts

@@ -4,8 +4,6 @@ import { IExpressionStatementNode } from "../../src/interfaces/nodes/IExpression
 import { IFunctionDeclarationNode } from "../../src/interfaces/nodes/IFunctionDeclarationNode";
 import { IProgramNode } from "../../src/interfaces/nodes/IProgramNode";
 
-import { NodeType } from "../../src/enums/NodeType";
-
 import { DEFAULT_PRESET } from "../../src/preset-options/DefaultPreset";
 
 import { FunctionDeclarationObfuscator } from '../../src/node-obfuscators/FunctionDeclarationObfuscator';
@@ -23,14 +21,9 @@ describe('FunctionDeclarationObfuscator', () => {
             programNode: IProgramNode;
 
         beforeEach(() => {
-            expressionStatementNode = {
-                type: NodeType.ExpressionStatement,
-                expression: {
-                    type: NodeType.CallExpression,
-                    callee: NodeMocks.getIdentifierNode(functionName),
-                    arguments: []
-                }
-            };
+            expressionStatementNode = NodeMocks.getExpressionStatementNode(
+                NodeMocks.getCallExpressionNode(NodeMocks.getIdentifierNode(functionName))
+            );
 
             functionDeclarationObfuscator = new FunctionDeclarationObfuscator(
                 new Map<string, ICustomNode>(),

test/node-obfuscators/FunctionObfuscator.spec.ts

@@ -0,0 +1,88 @@
+import { IBlockStatementNode } from "../../src/interfaces/nodes/IBlockStatementNode";
+import { ICustomNode } from "../../src/interfaces/ICustomNode";
+import { IExpressionStatementNode } from "../../src/interfaces/nodes/IExpressionStatementNode";
+import { IFunctionDeclarationNode } from "../../src/interfaces/nodes/IFunctionDeclarationNode";
+import { IIdentifierNode } from "../../src/interfaces/nodes/IIdentifierNode";
+import { IProgramNode } from "../../src/interfaces/nodes/IProgramNode";
+
+import { DEFAULT_PRESET } from "../../src/preset-options/DefaultPreset";
+
+import { FunctionObfuscator } from "../../src/node-obfuscators/FunctionObfuscator";
+import { NodeMocks } from "../mocks/NodeMocks";
+import { Options } from "../../src/Options";
+
+
+const assert: Chai.AssertStatic = require('chai').assert;
+
+describe('FunctionObfuscator', () => {
+    describe('obfuscateNode (functionNode: IFunctionNode): void', () => {
+        let blockStatementNode: IBlockStatementNode,
+            expressionStatementNode1: IExpressionStatementNode,
+            expressionStatementNode2: IExpressionStatementNode,
+            functionObfuscator: FunctionObfuscator,
+            functionDeclarationNode: IFunctionDeclarationNode,
+            functionName: string = 'functionDeclaration',
+            identifierName: string = 'identifierName',
+            identifierNode1: IIdentifierNode,
+            identifierNode2: IIdentifierNode,
+            identifierNode3: IIdentifierNode,
+            paramName: string = 'param1',
+            programNode: IProgramNode;
+
+        before(() => {
+            identifierNode1 = NodeMocks.getIdentifierNode(paramName);
+            identifierNode2 = NodeMocks.getIdentifierNode(paramName);
+            identifierNode3 = NodeMocks.getIdentifierNode(identifierName);
+
+            expressionStatementNode1 = NodeMocks.getExpressionStatementNode(
+                NodeMocks.getCallExpressionNode(identifierNode2)
+            );
+
+            expressionStatementNode2 = NodeMocks.getExpressionStatementNode(
+                NodeMocks.getCallExpressionNode(identifierNode3)
+            );
+
+            blockStatementNode = NodeMocks.getBlockStatementNode([
+                expressionStatementNode1
+            ]);
+
+            functionDeclarationNode = NodeMocks.getFunctionDeclarationNode(
+                functionName,
+                blockStatementNode,
+                [
+                    identifierNode1
+                ]
+            );
+
+            programNode = NodeMocks.getProgramNode([
+                functionDeclarationNode
+            ]);
+
+            programNode['parentNode'] = programNode;
+            functionDeclarationNode['parentNode'] = programNode;
+            blockStatementNode['parentNode'] = functionDeclarationNode;
+            identifierNode1['parentNode'] = functionDeclarationNode;
+            expressionStatementNode1['parentNode'] = blockStatementNode;
+
+            functionObfuscator = new FunctionObfuscator(
+                new Map<string, ICustomNode>(),
+                new Options(DEFAULT_PRESET)
+            );
+
+            functionObfuscator.obfuscateNode(functionDeclarationNode);
+        });
+
+        it('should obfuscate function parameter', () => {
+            assert.match(identifierNode1.name, /^_0x\w+$/);
+        });
+
+        it('should obfuscate function parameter in function body', () => {
+            assert.match(identifierNode2.name, /^_0x\w+$/);
+            assert.equal(identifierNode2.name, identifierNode1.name);
+        });
+
+        it('shouldn\'t obfuscate other identifiers in function body', () => {
+            assert.equal(identifierNode3.name, identifierName);
+        });
+    });
+});