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

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 { NodeFactory } from '../../../../src/node/NodeFactory';
import { NodeMetadata } from '../../../../src/node/NodeMetadata';
import { NodeUtils } from '../../../../src/node/NodeUtils';

describe('ObfuscatingGuardsTransformer', () => {
    describe('transformNode', () => {
        const forceObfuscatedString: string = 'important string';
        const ignoredAndForceObfuscatedString: string = 'important ignored string';

        let inversifyContainerFacade: IInversifyContainerFacade,
            obfuscatingGuardsTransformer: INodeTransformer;

        before(() => {
            inversifyContainerFacade = new InversifyContainerFacade();
            inversifyContainerFacade.load('', '', {
                forceTransformedStrings: [
                    forceObfuscatedString,
                    ignoredAndForceObfuscatedString
                ],
                reservedStrings: [
                    ignoredAndForceObfuscatedString
                ]
            });

            obfuscatingGuardsTransformer = inversifyContainerFacade
                .getNamed(ServiceIdentifiers.INodeTransformer, NodeTransformer.ObfuscatingGuardsTransformer);
        });

        describe('Variant #1: allowed node', () => {
            const identifier: ESTree.Identifier = NodeFactory.identifierNode('foo');

            const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);

            let result: ESTree.Identifier;

            before(() => {
                identifier.parentNode = identifier;

                NodeMetadata.set(expectedResult, {
                    forceObfuscatedNode: false,
                    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: ignored node', () => {
            const expressionStatement: ESTree.ExpressionStatement = NodeFactory.directiveNode(
                NodeFactory.literalNode('use strict'),
                'use strict'
            );

            const expectedResult: ESTree.ExpressionStatement = NodeUtils.clone(expressionStatement);

            let result: ESTree.ExpressionStatement;

            before(() => {
                expressionStatement.parentNode = expressionStatement;
                expressionStatement.expression.parentNode = expressionStatement;

                expectedResult.parentNode = expectedResult;
                NodeMetadata.set(expectedResult, {
                    forceObfuscatedNode: false,
                    ignoredNode: true
                });

                result = <ESTree.ExpressionStatement>obfuscatingGuardsTransformer
                    .transformNode(expressionStatement, expressionStatement);
            });

            it('should add `ignoredNode` property with `true` value to given node', () => {
                assert.deepEqual(result, expectedResult);
            });
        });

        describe('Variant #3: force obfuscated node', () => {
            const literalNode: ESTree.Literal =  NodeFactory.literalNode(forceObfuscatedString);

            const expectedResult: ESTree.Literal = NodeUtils.clone(literalNode);

            let result: ESTree.Literal;

            before(() => {
                literalNode.parentNode = literalNode;

                expectedResult.parentNode = expectedResult;
                NodeMetadata.set(expectedResult, {
                    forceObfuscatedNode: true,
                    ignoredNode: false
                });

                result = <ESTree.Literal>obfuscatingGuardsTransformer
                    .transformNode(literalNode, literalNode);
            });

            it('should add `forceObfuscatedNode` property with `true` value to given node', () => {
                assert.deepEqual(result, expectedResult);
            });
        });

        describe('Variant #4: ignored node and force obfuscated node', () => {
            const literalNode: ESTree.Literal = NodeFactory.literalNode(ignoredAndForceObfuscatedString);

            const expectedResult: ESTree.Literal = NodeUtils.clone(literalNode);

            let result: ESTree.Literal;

            before(() => {
                literalNode.parentNode = literalNode;

                expectedResult.parentNode = expectedResult;
                NodeMetadata.set(expectedResult, {
                    forceObfuscatedNode: false,
                    ignoredNode: true
                });

                result = <ESTree.Literal>obfuscatingGuardsTransformer
                    .transformNode(literalNode, literalNode);
            });

            it('should add `ignoredNode` property with `true` value to given node', () => {
                assert.deepEqual(result, expectedResult);
            });
        });
    });
});