FunctionDeclarationNode tests + tests source maps fix

scripts/test-compile

@@ -1,4 +1,4 @@
 #!/bin/bash
 
 $(npm bin)/tsc -p tsconfig-test.json
-$(npm bin)/babel test-tmp --out-dir test-tmp --source-maps --presets es2015
+$(npm bin)/babel test-tmp --out-dir test-tmp --source-maps inline --presets es2015

test/NodeUtils.spec.ts

@@ -131,7 +131,7 @@ describe('NodeUtils', () => {
                 ifStatementNode1
             ]);
 
-            functionDeclarationNode = NodeMocks.getFunctionDeclarationNode(functionDeclarationBlockStatementNode);
+            functionDeclarationNode = NodeMocks.getFunctionDeclarationNode('test', functionDeclarationBlockStatementNode);
 
             programNode = NodeMocks.getProgramNode([
                 functionDeclarationNode

test/config/config.spec.ts

@@ -1,5 +1,7 @@
 import { BabelPolyfill } from '../polyfills/BabelPolyfill';
 
+require('source-map-support').install();
+
 before(() => {
     BabelPolyfill.append();
 });

test/mocks/NodeMocks.ts

@@ -45,13 +45,14 @@ export class NodeMocks {
     }
 
     /**
+     * @param functionName
      * @param blockStatementNode
      * @returns {IFunctionDeclarationNode}
      */
-    public static getFunctionDeclarationNode (blockStatementNode: IBlockStatementNode): IFunctionDeclarationNode {
+    public static getFunctionDeclarationNode (functionName: string, blockStatementNode: IBlockStatementNode): IFunctionDeclarationNode {
         return {
             type: NodeType.FunctionDeclaration,
-            id: NodeMocks.getIdentifierNode('test'),
+            id: NodeMocks.getIdentifierNode(functionName),
             params: [],
             body: blockStatementNode,
             generator: false,

test/node-obfuscators/FunctionDeclarationObfuscator.spec.ts

@@ -0,0 +1,110 @@
+import { IBlockStatementNode } from "../../src/interfaces/nodes/IBlockStatementNode";
+import { ICustomNode } from "../../src/interfaces/ICustomNode";
+import { IFunctionDeclarationNode } from "../../src/interfaces/nodes/IFunctionDeclarationNode";
+import { INode } from "../../src/interfaces/nodes/INode";
+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';
+import { NodeMocks } from "../mocks/NodeMocks";
+import { Options } from "../../src/Options";
+
+const assert: Chai.AssertStatic = require('chai').assert;
+
+describe('FunctionDeclarationObfuscator', () => {
+    describe('obfuscateNode (functionDeclarationNode: IFunctionDeclarationNode, parentNode: INode): void', () => {
+        let expressionStatementNode: INode,
+            functionDeclarationObfuscator: FunctionDeclarationObfuscator,
+            functionDeclarationNode: IFunctionDeclarationNode,
+            functionName: string = 'functionDeclaration',
+            programNode: IProgramNode;
+
+        beforeEach(() => {
+            expressionStatementNode = <INode>{
+                type: NodeType.ExpressionStatement,
+                expression: {
+                    type: NodeType.CallExpression,
+                    callee: NodeMocks.getIdentifierNode(functionName),
+                    arguments: []
+                }
+            };
+
+            functionDeclarationObfuscator = new FunctionDeclarationObfuscator(
+                new Map<string, ICustomNode>(),
+                new Options(DEFAULT_PRESET)
+            );
+
+            functionDeclarationNode = NodeMocks.getFunctionDeclarationNode(
+                functionName,
+                NodeMocks.getBlockStatementNode()
+            );
+        });
+
+        describe('if `functionDeclaration` node parent node is not a Program node', () => {
+            let blockStatementNode: IBlockStatementNode,
+                functionDeclarationParentNode: IFunctionDeclarationNode;
+
+            beforeEach(() => {
+                blockStatementNode = NodeMocks.getBlockStatementNode([
+                    functionDeclarationNode,
+                    expressionStatementNode
+                ]);
+
+                functionDeclarationParentNode = NodeMocks.getFunctionDeclarationNode(
+                    'functionDeclarationParentNode',
+                    blockStatementNode
+                );
+
+                programNode = NodeMocks.getProgramNode([
+                    functionDeclarationParentNode
+                ]);
+
+                programNode['parentNode'] = programNode;
+                functionDeclarationParentNode['parentNode'] = programNode;
+                blockStatementNode['parentNode'] = functionDeclarationParentNode;
+                functionDeclarationNode['parentNode'] = blockStatementNode;
+                expressionStatementNode['parentNode'] = blockStatementNode;
+
+                functionDeclarationObfuscator.obfuscateNode(
+                    functionDeclarationNode,
+                    functionDeclarationNode['parentNode']
+                );
+            });
+
+            it('should obfuscate function name inside `functionDeclaration` parent scope', () => {
+                assert.match(functionDeclarationNode.id.name, /^_0x\w+$/);
+            });
+
+            it('should obfuscate function name in `functionDeclaration` calls inside `functionDeclaration` parent scope', () => {
+                assert.match((<any>expressionStatementNode).expression.callee.name, /^_0x\w+$/);
+            });
+        });
+
+        describe('if `functionDeclaration` node parent node is a Program node', () => {
+            beforeEach(() => {
+                programNode = NodeMocks.getProgramNode([
+                    functionDeclarationNode
+                ]);
+
+                functionDeclarationNode['parentNode'] = programNode;
+                expressionStatementNode['parentNode'] = programNode;
+
+                functionDeclarationObfuscator.obfuscateNode(
+                    functionDeclarationNode,
+                    functionDeclarationNode['parentNode']
+                );
+            });
+
+            it('shouldn\'t obfuscate function name inside `programNode` scope', () => {
+                assert.equal(functionDeclarationNode.id.name, functionName);
+            });
+
+            it('should\'t obfuscate function name in `functionDeclaration` calls inside `programNode`', () => {
+                assert.equal((<any>expressionStatementNode).expression.callee.name, functionName);
+            });
+        });
+    });
+});

tsconfig-test.json

@@ -3,7 +3,8 @@
     "outDir": "test-tmp",
     "target": "ES6",
     "module": "commonjs",
-    "sourceMap": true,
+    "inlineSourceMap": true,
+    "inlineSources": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
     "removeComments": true,