admin/javascript-obfuscator-javascript-obfuscator
1
0
Fork 0
mirror of https://github.com/javascript-obfuscator/javascript-obfuscator synced 2026-08-09 12:42:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

custom nodes structure rework

Browse Source
This commit is contained in:
sanex3339
2016-11-04 14:26:24 +03:00
parent 12378f2304
commit d184298208
35 changed files with 1437 additions and 997 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/dev/dev.ts
+2 -1
View File
@@ -70,7 +70,8 @@ if (!(<any>global)._babelPolyfill) {
`,
{
disableConsoleOutput: false,
unicodeArrayEncoding: 'rc4'
unicodeArrayEncoding: 'rc4',
domainLock: ['google.ru']
}
).getObfuscatedCode();
test/functional-tests/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.spec.ts
+2 -2
View File
@@ -7,7 +7,7 @@ import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
const assert: Chai.AssertStatic = require('chai').assert;
describe('ConsoleOutputDisableExpressionNode', () => {
it('should correctly appendNode `ConsoleOutputDisableExpressionNode` custom node into the obfuscated code if `disableConsoleOutput` option is set', () => {
it('should correctly appendNodeToOptimalBlockScope `ConsoleOutputDisableExpressionNode` custom node into the obfuscated code if `disableConsoleOutput` option is set', () => {
let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
`var test = 'test';`,
Object.assign({}, NO_CUSTOM_NODES_PRESET, {
@@ -19,7 +19,7 @@ describe('ConsoleOutputDisableExpressionNode', () => {
assert.match(obfuscationResult.getObfuscatedCode(), /for *\(_0x([a-z0-9]){4,6} in _0x([a-z0-9]){4,6} *= *'(\\x[a-f0-9]*)*'\)/);
});
it('should\'t appendNode `ConsoleOutputDisableExpressionNode` custom node into the obfuscated code if `disableConsoleOutput` option is not set', () => {
it('should\'t appendNodeToOptimalBlockScope `ConsoleOutputDisableExpressionNode` custom node into the obfuscated code if `disableConsoleOutput` option is not set', () => {
let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
`var test = 'test';`,
Object.assign({}, NO_CUSTOM_NODES_PRESET, {
test/functional-tests/custom-nodes/domain-lock-nodes/DomainLockNode.spec.ts
+2 -2
View File
@@ -7,7 +7,7 @@ import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
const assert: Chai.AssertStatic = require('chai').assert;
describe('DomainLockNode', () => {
it('should correctly appendNode `DomainLockNode` custom node into the obfuscated code if `domainLock` option is set', () => {
it('should correctly appendNodeToOptimalBlockScope `DomainLockNode` custom node into the obfuscated code if `domainLock` option is set', () => {
let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
`var test = 'test';`,
Object.assign({}, NO_CUSTOM_NODES_PRESET, {
@@ -18,7 +18,7 @@ describe('DomainLockNode', () => {
assert.match(obfuscationResult.getObfuscatedCode(), /var _0x([a-z0-9]){4,6} *= *new RegExp/);
});
it('should\'t appendNode `DomainLockNode` custom node into the obfuscated code if `domainLock` option is not set', () => {
it('should\'t appendNodeToOptimalBlockScope `DomainLockNode` custom node into the obfuscated code if `domainLock` option is not set', () => {
let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
`var test = 'test';`,
Object.assign({}, NO_CUSTOM_NODES_PRESET, {
test/functional-tests/custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper.spec.ts
+1 -1
View File
@@ -7,7 +7,7 @@ import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
const assert: Chai.AssertStatic = require('chai').assert;
describe('UnicodeArrayCallsWrapper', () => {
it('should correctly appendNode `UnicodeArrayCallsWrapper` custom node into the obfuscated code', () => {
it('should correctly appendNodeToOptimalBlockScope `UnicodeArrayCallsWrapper` custom node into the obfuscated code', () => {
let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
`var test = 'test';`,
Object.assign({}, NO_CUSTOM_NODES_PRESET, {
test/functional-tests/custom-nodes/unicode-array-nodes/UnicodeArrayNode.spec.ts
+2 -2
View File
@@ -7,7 +7,7 @@ import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
const assert: Chai.AssertStatic = require('chai').assert;
describe('UnicodeArrayNode', () => {
it('should correctly appendNode `UnicodeArrayNode` custom node into the obfuscated code if `unicodeArray` option is set', () => {
it('should correctly appendNodeToOptimalBlockScope `UnicodeArrayNode` custom node into the obfuscated code if `unicodeArray` option is set', () => {
let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
`var test = 'test';`,
Object.assign({}, NO_CUSTOM_NODES_PRESET, {
@@ -19,7 +19,7 @@ describe('UnicodeArrayNode', () => {
assert.match(obfuscationResult.getObfuscatedCode(), /^var _0x([a-z0-9]){4} *= *\[/);
});
it('should\'t appendNode `UnicodeArrayNode` custom node into the obfuscated code if `unicodeArray` option is not set', () => {
it('should\'t appendNodeToOptimalBlockScope `UnicodeArrayNode` custom node into the obfuscated code if `unicodeArray` option is not set', () => {
let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
`var test = 'test';`,
Object.assign({}, NO_CUSTOM_NODES_PRESET, {
test/functional-tests/custom-nodes/unicode-array-nodes/UnicodeArrayRotateFunctionNode.spec.ts
+2 -2
View File
@@ -7,7 +7,7 @@ import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
const assert: Chai.AssertStatic = require('chai').assert;
describe('UnicodeArrayRotateFunctionNode', () => {
it('should correctly appendNode `UnicodeArrayRotateFunctionNode` custom node into the obfuscated code if `rotateUnicodeArray` option is set', () => {
it('should correctly appendNodeToOptimalBlockScope `UnicodeArrayRotateFunctionNode` custom node into the obfuscated code if `rotateUnicodeArray` option is set', () => {
let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
`var test = 'test';`,
Object.assign({}, NO_CUSTOM_NODES_PRESET, {
@@ -20,7 +20,7 @@ describe('UnicodeArrayRotateFunctionNode', () => {
assert.match(obfuscationResult.getObfuscatedCode(), /while *\(-- *_0x([a-z0-9]){4,6}\) *\{/);
});
it('should\'t appendNode `UnicodeArrayRotateFunctionNode` custom node into the obfuscated code if `rotateUnicodeArray` option is not set', () => {
it('should\'t appendNodeToOptimalBlockScope `UnicodeArrayRotateFunctionNode` custom node into the obfuscated code if `rotateUnicodeArray` option is not set', () => {
let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
`var test = 'test';`,
Object.assign({}, NO_CUSTOM_NODES_PRESET, {
test/functional-tests/templates/custom-nodes/domain-lock-nodes/DomainLockNodeTemplate.spec.ts
+25 -12
View File
@@ -9,17 +9,26 @@ const assert: Chai.AssertStatic = require('chai').assert;
/**
* @param templateData
* @param callsControllerFunctionName
* @param currentDomain
* @returns {Function}
*/
function getFunctionFromTemplate (templateData: any, currentDomain: string) {
function getFunctionFromTemplate (templateData: any, callsControllerFunctionName: string, currentDomain: string) {
let domainLockTemplate: string = DomainLockNodeTemplate().formatUnicorn(templateData);
return Function(`
document = {
domain: '${currentDomain}'
};
var ${callsControllerFunctionName} = (function(){
return function (context, fn){
return function () {
return fn.apply(context, arguments);
};
}
})();
${domainLockTemplate}
`)();
}
@@ -28,7 +37,8 @@ describe('DomainLockNodeTemplate (): string', () => {
let domainsString: string,
currentDomain: string,
hiddenDomainsString: string,
diff: string;
diff: string,
singleNodeCallControllerFunctionName: string = 'callsController';
it('should correctly runs code inside template if current domain matches with `domainsString`', () => {
domainsString = ['www.example.com'].join(';');
@@ -39,10 +49,11 @@ describe('DomainLockNodeTemplate (): string', () => {
] = Utils.hideString(domainsString, domainsString.length * 3);
assert.doesNotThrow(() => getFunctionFromTemplate({
domainLockFunctionName: 'func',
domainLockFunctionName: 'domainLockFunction',
diff: diff,
domains: hiddenDomainsString
}, currentDomain));
domains: hiddenDomainsString,
singleNodeCallControllerFunctionName
}, singleNodeCallControllerFunctionName, currentDomain));
});
it('should correctly runs code inside template if current domain matches with base domain of `domainsString` item', () => {
@@ -54,10 +65,11 @@ describe('DomainLockNodeTemplate (): string', () => {
] = Utils.hideString(domainsString, domainsString.length * 3);
assert.doesNotThrow(() => getFunctionFromTemplate({
domainLockFunctionName: 'func',
domainLockFunctionName: 'domainLockFunction',
diff: diff,
domains: hiddenDomainsString
}, currentDomain));
domains: hiddenDomainsString,
singleNodeCallControllerFunctionName
}, singleNodeCallControllerFunctionName, currentDomain));
});
it('should throw an error if current domain doesn\'t match with `domainsString`', () => {
@@ -69,10 +81,11 @@ describe('DomainLockNodeTemplate (): string', () => {
] = Utils.hideString(domainsString, domainsString.length * 3);
assert.throws(() => getFunctionFromTemplate({
domainLockFunctionName: 'func',
domainLockFunctionName: 'domainLockFunction',
diff: diff,
domains: hiddenDomainsString
}, currentDomain));
domains: hiddenDomainsString,
singleNodeCallControllerFunctionName
}, singleNodeCallControllerFunctionName, currentDomain));
});
afterEach(() => {
test/index.spec.ts
+1 -1
View File
@@ -13,7 +13,7 @@ import './unit-tests/OptionsNormalizer.spec';
import './unit-tests/SourceMapCorrector.spec';
import './unit-tests/Utils.spec';
import './unit-tests/cli/CLIUtils.spec';
import './unit-tests/custom-nodes/CustomNodeAppender.spec';
import './unit-tests/custom-nodes/NodeAppender.spec';
import './unit-tests/node-obfuscators/CatchClauseObfuscator.spec';
import './unit-tests/node-obfuscators/FunctionDeclarationObfuscator.spec';
import './unit-tests/node-obfuscators/FunctionObfuscator.spec';
test/unit-tests/NodeUtils.spec.ts
-132
View File
@@ -1,8 +1,6 @@
import * as chai from 'chai';
import * as ESTree from 'estree';
import { TStatement } from '../../src/types/TStatement';
import { NodeMocks } from '../mocks/NodeMocks';
import { NodeUtils } from '../../src/NodeUtils';
@@ -27,43 +25,6 @@ describe('NodeUtils', () => {
});
});
describe('appendNode (blockScopeNode: TNodeWithBlockStatement[], nodeBodyStatements: TStatement[]): void', () => {
let blockStatementNode: ESTree.BlockStatement,
expectedBlockStatementNode: ESTree.BlockStatement,
expectedExpressionStatementNode: ESTree.ExpressionStatement,
expressionStatementNode: ESTree.ExpressionStatement;
beforeEach(() => {
expressionStatementNode = NodeMocks.getExpressionStatementNode();
expectedExpressionStatementNode = NodeMocks.getExpressionStatementNode();
blockStatementNode = NodeMocks.getBlockStatementNode();
expectedExpressionStatementNode['parentNode'] = blockStatementNode;
expectedBlockStatementNode = NodeMocks.getBlockStatementNode([
expectedExpressionStatementNode
]);
NodeUtils.appendNode(
blockStatementNode,
[expressionStatementNode]
);
NodeUtils.appendNode(
blockStatementNode,
<TStatement[]>[{}]
);
});
it('should appendNode given node to a `BlockStatement` node body', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
it('should does not change `BlockStatement` node body if given node is not a valid Node', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
});
describe('convertCodeToStructure (code: string): ESTree.Node[]', () => {
let code: string,
identifierNode: ESTree.Identifier,
@@ -198,56 +159,6 @@ describe('NodeUtils', () => {
});
});
describe('insertNodeAtIndex (blockScopeNode: TNodeWithBlockStatement[], nodeBodyStatements: TStatement[], index: number): void', () => {
let blockStatementNode: ESTree.BlockStatement,
expectedBlockStatementNode: ESTree.BlockStatement,
expressionStatementNode1: ESTree.ExpressionStatement,
expressionStatementNode2: ESTree.ExpressionStatement,
expressionStatementNode3: ESTree.ExpressionStatement,
expressionStatementNode4: ESTree.ExpressionStatement;
beforeEach(() => {
expressionStatementNode1 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(1));
expressionStatementNode2 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(2));
expressionStatementNode3 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(3));
expressionStatementNode4 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(2));
blockStatementNode = NodeMocks.getBlockStatementNode([
expressionStatementNode1,
expressionStatementNode3
]);
expressionStatementNode1['parentNode'] = blockStatementNode;
expressionStatementNode2['parentNode'] = blockStatementNode;
expressionStatementNode3['parentNode'] = blockStatementNode;
expectedBlockStatementNode = NodeMocks.getBlockStatementNode([
expressionStatementNode1,
expressionStatementNode2,
expressionStatementNode3
]);
NodeUtils.insertNodeAtIndex(
blockStatementNode,
[expressionStatementNode4],
1
);
NodeUtils.insertNodeAtIndex(
blockStatementNode,
<TStatement[]>[{}],
1
);
});
it('should insert given node in `BlockStatement` node body at index', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
it('should does not change `BlockStatement` node body if given node is not a valid Node', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
});
describe('parentize (node: ESTree.Node): void', () => {
let ifStatementNode: ESTree.IfStatement,
ifStatementBlockStatementNode: ESTree.BlockStatement,
@@ -295,47 +206,4 @@ describe('NodeUtils', () => {
assert.deepEqual(expressionStatementNode2['parentNode'], ifStatementBlockStatementNode);
});
});
describe('prependNode (blockScopeNode: TNodeWithBlockStatement[], nodeBodyStatements: TStatement[]): void', () => {
let blockStatementNode: ESTree.BlockStatement,
expectedBlockStatementNode: ESTree.BlockStatement,
expressionStatementNode1: ESTree.ExpressionStatement,
expressionStatementNode2: ESTree.ExpressionStatement,
expressionStatementNode3: ESTree.ExpressionStatement;
beforeEach(() => {
expressionStatementNode1 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(1));
expressionStatementNode2 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(2));
expressionStatementNode3 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(2));
blockStatementNode = NodeMocks.getBlockStatementNode([
expressionStatementNode1
]);
expressionStatementNode1['parentNode'] = blockStatementNode;
expressionStatementNode2['parentNode'] = blockStatementNode;
expectedBlockStatementNode = NodeMocks.getBlockStatementNode([
expressionStatementNode2,
expressionStatementNode1
]);
NodeUtils.prependNode(
blockStatementNode,
[Object.assign({}, expressionStatementNode3)]
);
NodeUtils.prependNode(
blockStatementNode,
<TStatement[]>[{}]
)
});
it('should prepend given node to a `BlockStatement` node body', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
it('should does not change `BlockStatement` node body if given node is not a valid Node', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
});
});
test/unit-tests/custom-nodes/CustomNodeAppender.spec.ts → test/unit-tests/custom-nodes/NodeAppender.spec.ts
+140 -10
View File
@@ -5,15 +5,52 @@ import { TStatement } from '../../../src/types/TStatement';
import { IStackTraceData } from '../../../src/interfaces/stack-trace-analyzer/IStackTraceData';
import { CustomNodeAppender } from '../../../src/custom-nodes/CustomNodeAppender';
import { NodeAppender } from '../../../src/NodeAppender';
import { NodeMocks } from '../../mocks/NodeMocks';
import { NodeUtils } from '../../../src/NodeUtils';
import { StackTraceAnalyzer } from '../../../src/stack-trace-analyzer/StackTraceAnalyzer';
const assert: any = chai.assert;
describe('CustomNodeAppender', () => {
describe('appendNode (blockScopeStackTraceData: IStackTraceData[], blockScopeNode: TNodeWithBlockStatement, nodeBodyStatements: TStatement[], index: number = 0): void', () => {
describe('NodeAppender', () => {
describe('appendNode (blockScopeNode: TNodeWithBlockStatement[], nodeBodyStatements: TStatement[]): void', () => {
let blockStatementNode: ESTree.BlockStatement,
expectedBlockStatementNode: ESTree.BlockStatement,
expectedExpressionStatementNode: ESTree.ExpressionStatement,
expressionStatementNode: ESTree.ExpressionStatement;
beforeEach(() => {
expressionStatementNode = NodeMocks.getExpressionStatementNode();
expectedExpressionStatementNode = NodeMocks.getExpressionStatementNode();
blockStatementNode = NodeMocks.getBlockStatementNode();
expectedExpressionStatementNode['parentNode'] = blockStatementNode;
expectedBlockStatementNode = NodeMocks.getBlockStatementNode([
expectedExpressionStatementNode
]);
NodeAppender.appendNode(
blockStatementNode,
[expressionStatementNode]
);
NodeAppender.appendNode(
blockStatementNode,
<TStatement[]>[{}]
);
});
it('should append given node to a `BlockStatement` node body', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
it('should does not change `BlockStatement` node body if given node is not a valid Node', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
});
describe('appendNodeToOptimalBlockScope (blockScopeStackTraceData: IStackTraceData[], blockScopeNode: TNodeWithBlockStatement, nodeBodyStatements: TStatement[], index: number = 0): void', () => {
let astTree: ESTree.Program,
expectedAstTree: ESTree.Program,
node: TStatement[],
@@ -92,7 +129,7 @@ describe('CustomNodeAppender', () => {
);
stackTraceData = new StackTraceAnalyzer(astTree.body).analyze();
CustomNodeAppender.appendNode(stackTraceData, astTree, node);
NodeAppender.appendNodeToOptimalBlockScope(stackTraceData, astTree, node);
assert.deepEqual(astTree, expectedAstTree);
});
@@ -165,7 +202,7 @@ describe('CustomNodeAppender', () => {
);
stackTraceData = new StackTraceAnalyzer(astTree.body).analyze();
CustomNodeAppender.appendNode(stackTraceData, astTree, node);
NodeAppender.appendNodeToOptimalBlockScope(stackTraceData, astTree, node);
assert.deepEqual(astTree, expectedAstTree);
});
@@ -243,7 +280,7 @@ describe('CustomNodeAppender', () => {
);
stackTraceData = new StackTraceAnalyzer(astTree.body).analyze();
CustomNodeAppender.appendNode(stackTraceData, astTree, node, 2);
NodeAppender.appendNodeToOptimalBlockScope(stackTraceData, astTree, node, 2);
assert.deepEqual(astTree, expectedAstTree);
});
@@ -283,7 +320,7 @@ describe('CustomNodeAppender', () => {
);
stackTraceData = new StackTraceAnalyzer(astTree.body).analyze();
CustomNodeAppender.appendNode(stackTraceData, astTree, node, 1);
NodeAppender.appendNodeToOptimalBlockScope(stackTraceData, astTree, node, 1);
assert.deepEqual(astTree, expectedAstTree);
});
@@ -353,11 +390,11 @@ describe('CustomNodeAppender', () => {
);
stackTraceData = new StackTraceAnalyzer(astTree.body).analyze();
CustomNodeAppender.appendNode(
NodeAppender.appendNodeToOptimalBlockScope(
stackTraceData,
astTree,
node,
CustomNodeAppender.getRandomStackTraceIndex(stackTraceData.length)
NodeAppender.getRandomStackTraceIndex(stackTraceData.length)
);
assert.deepEqual(astTree, expectedAstTree);
@@ -370,11 +407,104 @@ describe('CustomNodeAppender', () => {
let index: number;
for (let i: number = 0; i < 100; i++) {
index = CustomNodeAppender.getRandomStackTraceIndex(100);
index = NodeAppender.getRandomStackTraceIndex(100);
assert.isAtLeast(index, 0);
assert.isAtMost(index, 100);
}
});
});
describe('insertNodeAtIndex (blockScopeNode: TNodeWithBlockStatement[], nodeBodyStatements: TStatement[], index: number): void', () => {
let blockStatementNode: ESTree.BlockStatement,
expectedBlockStatementNode: ESTree.BlockStatement,
expressionStatementNode1: ESTree.ExpressionStatement,
expressionStatementNode2: ESTree.ExpressionStatement,
expressionStatementNode3: ESTree.ExpressionStatement,
expressionStatementNode4: ESTree.ExpressionStatement;
beforeEach(() => {
expressionStatementNode1 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(1));
expressionStatementNode2 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(2));
expressionStatementNode3 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(3));
expressionStatementNode4 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(2));
blockStatementNode = NodeMocks.getBlockStatementNode([
expressionStatementNode1,
expressionStatementNode3
]);
expressionStatementNode1['parentNode'] = blockStatementNode;
expressionStatementNode2['parentNode'] = blockStatementNode;
expressionStatementNode3['parentNode'] = blockStatementNode;
expectedBlockStatementNode = NodeMocks.getBlockStatementNode([
expressionStatementNode1,
expressionStatementNode2,
expressionStatementNode3
]);
NodeAppender.insertNodeAtIndex(
blockStatementNode,
[expressionStatementNode4],
1
);
NodeAppender.insertNodeAtIndex(
blockStatementNode,
<TStatement[]>[{}],
1
);
});
it('should insert given node in `BlockStatement` node body at index', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
it('should does not change `BlockStatement` node body if given node is not a valid Node', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
});
describe('prependNode (blockScopeNode: TNodeWithBlockStatement[], nodeBodyStatements: TStatement[]): void', () => {
let blockStatementNode: ESTree.BlockStatement,
expectedBlockStatementNode: ESTree.BlockStatement,
expressionStatementNode1: ESTree.ExpressionStatement,
expressionStatementNode2: ESTree.ExpressionStatement,
expressionStatementNode3: ESTree.ExpressionStatement;
beforeEach(() => {
expressionStatementNode1 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(1));
expressionStatementNode2 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(2));
expressionStatementNode3 = NodeMocks.getExpressionStatementNode(NodeMocks.getLiteralNode(2));
blockStatementNode = NodeMocks.getBlockStatementNode([
expressionStatementNode1
]);
expressionStatementNode1['parentNode'] = blockStatementNode;
expressionStatementNode2['parentNode'] = blockStatementNode;
expectedBlockStatementNode = NodeMocks.getBlockStatementNode([
expressionStatementNode2,
expressionStatementNode1
]);
NodeAppender.prependNode(
blockStatementNode,
[Object.assign({}, expressionStatementNode3)]
);
NodeAppender.prependNode(
blockStatementNode,
<TStatement[]>[{}]
)
});
it('should prepend given node to a `BlockStatement` node body', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
it('should does not change `BlockStatement` node body if given node is not a valid Node', () => {
assert.deepEqual(blockStatementNode, expectedBlockStatementNode);
});
});
});