Preparing transformers tests

scripts/test-compile

@@ -1,5 +1,5 @@
 #!/bin/bash
 
-$(yarn bin)/tsc -p tsconfig-test.json &&
+$(yarn bin)/tsc -p tsconfig.test.json &&
 $(yarn bin)/babel test-tmp --out-dir test-tmp --source-maps inline --presets es2015 &&
 rsync -a --prune-empty-dirs --include '*/' --include '*.js' --exclude '*' test/ test-tmp/test/

test/dev/dev-compile-performance.ts

@@ -3,7 +3,7 @@
 import * as fs from 'fs';
 
 (function () {
-    const JavaScriptObfuscator: any = require("../../index");
+    const JavaScriptObfuscator: any = require('../../index');
 
     let start: any = new Date();
 

test/dev/dev-runtime-performance.ts

@@ -1,7 +1,7 @@
 'use strict';
 
 (function () {
-    const JavaScriptObfuscator: any = require("../../index");
+    const JavaScriptObfuscator: any = require('../../index');
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(`
         var start = new Date();

test/dev/dev.ts

@@ -2,7 +2,7 @@
 import { NO_CUSTOM_NODES_PRESET } from '../../src/options/presets/NoCustomNodes';
 
 (function () {
-    const JavaScriptObfuscator: any = require("../../index");
+    const JavaScriptObfuscator: any = require('../../index');
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `

test/index.spec.ts

@@ -16,6 +16,8 @@ import './unit-tests/javascript-obfuscator/JavaScriptObfuscator.spec';
 import './unit-tests/logger/Logger.spec';
 import './unit-tests/node/node-appender/NodeAppender.spec';
 import './unit-tests/node/node-utils/NodeUtils.spec';
+import './unit-tests/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.spec';
+import './unit-tests/node-transformers/preparing-transformers/ParentificationTransformer.spec';
 import './unit-tests/obfuscation-result/ObfuscationResult.spec';
 import './unit-tests/options/OptionsNormalizer.spec';
 import './unit-tests/options/ValidationErrorsFormatter.spec';

test/unit-tests/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.spec.ts

@@ -0,0 +1,77 @@
+import 'reflect-metadata';
+
+import { assert } from 'chai';
+
+import * as ESTree from 'estree';
+
+import { ServiceIdentifiers } from '../../../../src/container/ServiceIdentifiers';
+import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
+
+import { IInversifyContainerFacade } from '../../../../src/interfaces/container/IInversifyContainerFacade';
+import { INodeTransformer } from '../../../../src/interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../../src/enums/node-transformers/NodeTransformer';
+import { Nodes } from '../../../../src/node/Nodes';
+import { NodeUtils } from '../../../../src/node/NodeUtils';
+
+describe('ObfuscatingGuardsTransformer', () => {
+    describe('transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node', () => {
+        let inversifyContainerFacade: IInversifyContainerFacade,
+            obfuscatingGuardsTransformer: INodeTransformer;
+
+        before(() => {
+            inversifyContainerFacade = new InversifyContainerFacade();
+            inversifyContainerFacade.load('', {});
+
+            obfuscatingGuardsTransformer = inversifyContainerFacade
+                .getNamed(ServiceIdentifiers.INodeTransformer, NodeTransformer.ObfuscatingGuardsTransformer);
+        });
+
+        describe('variant #1: valid node', () => {
+            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
+
+            const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
+
+            let result: ESTree.Identifier;
+
+            before(() => {
+                identifier.parentNode = identifier;
+
+                expectedResult.ignoredNode = false;
+
+                result = <ESTree.Identifier>obfuscatingGuardsTransformer.transformNode(identifier, identifier);
+            });
+
+            it('should add `ignoredNode` property with `false` value to given node', () => {
+                assert.deepEqual(result, expectedResult);
+            });
+        });
+
+        describe('variant #2: invalid node', () => {
+            const expressionStatement: ESTree.ExpressionStatement = Nodes.getExpressionStatementNode(
+                Nodes.getIdentifierNode('foo')
+            );
+
+            const expectedResult: ESTree.ExpressionStatement = NodeUtils.clone(expressionStatement);
+
+            let result: ESTree.ExpressionStatement;
+
+            before(() => {
+                expressionStatement.directive = 'use strict';
+                expressionStatement.parentNode = expressionStatement;
+                expressionStatement.expression.parentNode = expressionStatement;
+
+                expectedResult.directive = 'use strict';
+                expectedResult.parentNode = expectedResult;
+                expectedResult.ignoredNode = true;
+
+                result = <ESTree.ExpressionStatement>obfuscatingGuardsTransformer
+                    .transformNode(expressionStatement, expressionStatement);
+            });
+
+            it('should add `ignoredNode` property with `true` value to given node', () => {
+                assert.deepEqual(result, expectedResult);
+            });
+        });
+    });
+});

test/unit-tests/node-transformers/preparing-transformers/ParentificationTransformer.spec.ts

@@ -0,0 +1,66 @@
+import 'reflect-metadata';
+
+import { assert } from 'chai';
+
+import * as ESTree from 'estree';
+
+import { ServiceIdentifiers } from '../../../../src/container/ServiceIdentifiers';
+import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
+
+import { IInversifyContainerFacade } from '../../../../src/interfaces/container/IInversifyContainerFacade';
+import { INodeTransformer } from '../../../../src/interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../../src/enums/node-transformers/NodeTransformer';
+import { Nodes } from '../../../../src/node/Nodes';
+import { NodeUtils } from '../../../../src/node/NodeUtils';
+
+describe('ParentificationTransformer', () => {
+    describe('transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node', () => {
+        let inversifyContainerFacade: IInversifyContainerFacade,
+            parentificationTransformer: INodeTransformer;
+
+        before(() => {
+            inversifyContainerFacade = new InversifyContainerFacade();
+            inversifyContainerFacade.load('', {});
+
+            parentificationTransformer = inversifyContainerFacade
+                .getNamed(ServiceIdentifiers.INodeTransformer, NodeTransformer.ParentificationTransformer);
+        });
+
+        describe('variant #1: node with parent node', () => {
+            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
+            const breakStatement: ESTree.BreakStatement = Nodes.getBreakStatement(identifier);
+
+            const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
+
+            let result: ESTree.Identifier;
+
+            before(() => {
+                expectedResult.parentNode = breakStatement;
+
+                result = <ESTree.Identifier>parentificationTransformer.transformNode(identifier, breakStatement);
+            });
+
+            it('should parentize given node', () => {
+                assert.deepEqual(result, expectedResult);
+            });
+        });
+
+        describe('variant #2: node without parent node', () => {
+            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('Foo');
+            const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
+
+            let result: ESTree.Identifier;
+
+            before(() => {
+                expectedResult.parentNode = expectedResult;
+
+                result = <ESTree.Identifier>parentificationTransformer.transformNode(identifier, <any>null);
+            });
+
+            it('should parentize given node', () => {
+                assert.deepEqual(result, expectedResult);
+            });
+        });
+    });
+});