Tests for identifierPrefix option

src/generators/identifier-names-generators/AbstractIdentifierNamesGenerator.ts

@@ -47,4 +47,11 @@ export abstract class AbstractIdentifierNamesGenerator implements IIdentifierNam
      * @returns {string}
      */
     public abstract generateWithPrefix (): string;
+
+    /**
+     * @returns {string}
+     */
+    public getPrefix (): string {
+        return this.identifiersPrefix;
+    }
 }

src/interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator.d.ts

@@ -8,4 +8,9 @@ export interface IIdentifierNamesGenerator {
      * @returns {string}
      */
     generateWithPrefix (): string;
+
+    /**
+     * @returns {string}
+     */
+    getPrefix (): string;
 }

src/storages/string-array/StringArrayStorage.ts

@@ -50,10 +50,15 @@ export class StringArrayStorage extends ArrayStorage <string> {
     public initialize (): void {
         super.initialize();
 
-        const stringArrayName: string = this.identifierNamesGenerator
-            .generateWithPrefix().slice(0, StringArrayStorage.stringArrayNameLength);
-        const stringArrayCallsWrapperName: string = this.identifierNamesGenerator
-            .generateWithPrefix().slice(0, StringArrayStorage.stringArrayNameLength);
+        const namePrefix: string = this.identifierNamesGenerator.getPrefix();
+        const baseStringArrayName: string = this.identifierNamesGenerator
+            .generate()
+            .slice(0, StringArrayStorage.stringArrayNameLength);
+        const baseStringArrayCallsWrapperName: string = this.identifierNamesGenerator
+            .generate()
+            .slice(0, StringArrayStorage.stringArrayNameLength);
+        const stringArrayName: string = `${namePrefix}${baseStringArrayName}`;
+        const stringArrayCallsWrapperName: string = `${namePrefix}${baseStringArrayCallsWrapperName}`;
 
         this.storageId = `${stringArrayName}|${stringArrayCallsWrapperName}`;
     }

test/functional-tests/javascript-obfuscator/JavaScriptObfuscator.spec.ts

@@ -186,28 +186,108 @@ describe('JavaScriptObfuscator', () => {
         });
 
         describe('variable inside global scope', () => {
-            const regExp: RegExp = /^var *test *= *0x\d+;$/;
+            describe('variant #1: without `renameGlobals` option', () => {
+                const regExp: RegExp = /^var *test *= *0x\d+;$/;
 
-            let obfuscatedCode: string;
+                let obfuscatedCode: string;
 
-            beforeEach(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET
-                    }
-                );
+                beforeEach(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
+                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET
+                        }
+                    );
 
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                });
+
+                it('should return correct obfuscated code', () => {
+                    assert.match(obfuscatedCode, regExp);
+                });
             });
 
-            it('should return correct obfuscated code', () => {
-                assert.match(obfuscatedCode, regExp);
+            describe('variant #2: with `renameGlobals` option', () => {
+                const regExp: RegExp = /^var *_0x(\w){4,6} *= *0x\d+;$/;
+
+                let obfuscatedCode: string;
+
+                beforeEach(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
+                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            renameGlobals: true
+                        }
+                    );
+
+                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                });
+
+                it('should return correct obfuscated code', () => {
+                    assert.match(obfuscatedCode, regExp);
+                });
+            });
+
+            describe('variant #3: with `renameGlobals` and `identifiersPrefix` options', () => {
+                const regExp: RegExp = /^var *foo_0x(\w){4,6} *= *0x\d+;$/;
+
+                let obfuscatedCode: string;
+
+                beforeEach(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
+                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            renameGlobals: true,
+                            identifiersPrefix: 'foo'
+                        }
+                    );
+
+                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                });
+
+                it('should return correct obfuscated code', () => {
+                    assert.match(obfuscatedCode, regExp);
+                });
+            });
+
+            describe('variant #4: with `stringArray`, `renameGlobals` and `identifiersPrefix` options', () => {
+                const stringArrayRegExp: RegExp = /^var foo_0x(\w){4} *= *\['abc'\];/;
+                const stringArrayCallRegExp: RegExp = /var *foo_0x(\w){4,6} *= *foo_0x(\w){4}\('0x0'\);$/;
+
+                let obfuscatedCode: string;
+
+                beforeEach(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/simple-input-2.js');
+                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            renameGlobals: true,
+                            identifiersPrefix: 'foo',
+                            stringArray: true,
+                            stringArrayThreshold: 1
+                        }
+                    );
+
+                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                });
+
+                it('match #1: should return correct obfuscated code', () => {
+                    assert.match(obfuscatedCode, stringArrayRegExp);
+                });
+
+                it('match #2: should return correct obfuscated code', () => {
+                    assert.match(obfuscatedCode, stringArrayCallRegExp);
+                });
             });
         });
 
-        describe('variable inside global scope', () => {
+        describe('variable inside block scope', () => {
             const regExp: RegExp = /^\(function *\(\) *\{ *var *_0x[\w]+ *= *0x\d+; *\}(\(\)\)|\)\(\));?$/;
 
             let obfuscatedCode: string;
@@ -229,6 +309,47 @@ describe('JavaScriptObfuscator', () => {
             });
         });
 
+        describe('variables inside global and block scopes', () => {
+            describe('variant #1: with `renameGlobals` and `identifiersPrefix` options', () => {
+                const variableDeclaration1: RegExp = /var foo_0x(\w){4,6} *= *0x1;/;
+                const variableDeclaration2: RegExp = /var foo_0x(\w){4,6} *= *0x2;/;
+                const variableDeclaration3: RegExp = /var _0x(\w){4,6} *= *foo_0x(\w){4,6} *\+ *foo_0x(\w){4,6}/;
+                const functionDeclaration: RegExp = /var foo_0x(\w){4,6} *= *function/;
+
+                let obfuscatedCode: string;
+
+                beforeEach(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/identifiers-prefix.js');
+                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            renameGlobals: true,
+                            identifiersPrefix: 'foo'
+                        }
+                    );
+
+                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                });
+
+                it('match #1: should return correct obfuscated code', () => {
+                    assert.match(obfuscatedCode, variableDeclaration1);
+                });
+
+                it('match #2: should return correct obfuscated code', () => {
+                    assert.match(obfuscatedCode, variableDeclaration2);
+                });
+
+                it('match #3: should return correct obfuscated code', () => {
+                    assert.match(obfuscatedCode, variableDeclaration3);
+                });
+
+                it('match #4: should return correct obfuscated code', () => {
+                    assert.match(obfuscatedCode, functionDeclaration);
+                });
+            });
+        });
+
         describe('latin literal variable value', () => {
             const stringArrayLatinRegExp: RegExp = /^var _0x(\w){4} *= *\['abc'\];/;
             const stringArrayCallRegExp: RegExp = /var *test *= *_0x(\w){4}\('0x0'\);$/;

test/functional-tests/javascript-obfuscator/fixtures/identifiers-prefix.js

@@ -0,0 +1,7 @@
+var foo = 1;
+var bar = 2;
+var baz = function () {
+    var bark = foo + bar;
+
+    return bark;
+};

test/unit-tests/generators/identifier-names-generators/HexadecimalIdentifierNamesGenerator.spec.ts

@@ -12,30 +12,30 @@ import { IdentifierNamesGenerator } from '../../../../src/enums/generators/ident
 import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
 
 describe('HexadecimalIdentifierNamesGenerator', () => {
-    describe('generate (length: number, attachPrefix: boolean): string', () => {
-        describe('Hexadecimal name without prefix', () => {
-            let identifierNamesGenerator: IIdentifierNamesGenerator,
-                hexadecimalIdentifierName: string,
-                regExp: RegExp;
-
-            before(() => {
-                const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
-
-                inversifyContainerFacade.load('', {});
-                identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
-                    ServiceIdentifiers.IIdentifierNamesGenerator,
-                    IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator
-                );
-
-                hexadecimalIdentifierName = identifierNamesGenerator.generate();
-                regExp = /^_0x(\w){4,6}$/;
-            });
-
-            it('should return hexadecimal name', () => {
-                assert.match(hexadecimalIdentifierName, regExp);
-            })
+    describe('generate (): string', () => {
+        let identifierNamesGenerator: IIdentifierNamesGenerator,
+            hexadecimalIdentifierName: string,
+            regExp: RegExp;
+
+        before(() => {
+            const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
+
+            inversifyContainerFacade.load('', {});
+            identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
+                ServiceIdentifiers.IIdentifierNamesGenerator,
+                IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator
+            );
+
+            hexadecimalIdentifierName = identifierNamesGenerator.generate();
+            regExp = /^_0x(\w){4,6}$/;
         });
 
+        it('should return hexadecimal name', () => {
+            assert.match(hexadecimalIdentifierName, regExp);
+        })
+    });
+
+    describe('generateWithPrefix (): string', () => {
         describe('Hexadecimal name with prefix', () => {
             const regExp: RegExp = /^foo_0x(\w){4,6}$/;
 
@@ -86,4 +86,29 @@ describe('HexadecimalIdentifierNamesGenerator', () => {
             })
         });
     });
+
+    describe('getPrefix (): string', () => {
+        const expectedIdentifierPrefix: string = 'foo';
+
+        let identifierNamesGenerator: IIdentifierNamesGenerator,
+            identifierPrefix: string;
+
+        before(() => {
+            const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
+
+            inversifyContainerFacade.load('', {
+                identifiersPrefix: 'foo'
+            });
+            identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
+                ServiceIdentifiers.IIdentifierNamesGenerator,
+                IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator
+            );
+
+            identifierPrefix = identifierNamesGenerator.getPrefix();
+        });
+
+        it('should return prefix', () => {
+            assert.equal(identifierPrefix, expectedIdentifierPrefix);
+        })
+    });
 });

test/unit-tests/generators/identifier-names-generators/MangledlIdentifierNamesGenerator.spec.ts

@@ -12,124 +12,124 @@ import { IdentifierNamesGenerator } from '../../../../src/enums/generators/ident
 import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
 
 describe('MangledIdentifierNamesGenerator', () => {
-    describe('generate (length: number): string', () => {
-        describe('Mangled name without prefix', () => {
-            let identifierNamesGenerator: IIdentifierNamesGenerator,
-                mangledIdentifierName: string;
+    describe('generate (): string', () => {
+        let identifierNamesGenerator: IIdentifierNamesGenerator,
+            mangledIdentifierName: string;
+
+        beforeEach(() => {
+            const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
+
+            inversifyContainerFacade.load('', {});
+            identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
+                ServiceIdentifiers.IIdentifierNamesGenerator,
+                IdentifierNamesGenerator.MangledIdentifierNamesGenerator
+            );
+        });
+
+        describe('variant #1: initial mangled name', () => {
+            const expectedMangledIdentifierName: string = 'a';
 
             beforeEach(() => {
-                const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
+                mangledIdentifierName = identifierNamesGenerator.generate();
+            });
 
-                inversifyContainerFacade.load('', {});
-                identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
-                    ServiceIdentifiers.IIdentifierNamesGenerator,
-                    IdentifierNamesGenerator.MangledIdentifierNamesGenerator
-                );
+            it('should return mangled name', () => {
+                assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
             });
+        });
 
-            describe('variant #1: initial mangled name', () => {
-                const expectedMangledIdentifierName: string = 'a';
+        describe('variant #2: second mangled name', () => {
+            const expectedMangledIdentifierName: string = 'b';
+            const expectedMangledIdentifierPosition: number = 1;
 
-                beforeEach(() => {
+            beforeEach(() => {
+                for (let i: number = 0; i <= expectedMangledIdentifierPosition; i++) {
                     mangledIdentifierName = identifierNamesGenerator.generate();
-                });
-
-                it('should return mangled name', () => {
-                    assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
-                });
+                }
             });
 
-            describe('variant #2: second mangled name', () => {
-                const expectedMangledIdentifierName: string = 'b';
-                const expectedMangledIdentifierPosition: number = 1;
-
-                beforeEach(() => {
-                    for (let i: number = 0; i <= expectedMangledIdentifierPosition; i++) {
-                        mangledIdentifierName = identifierNamesGenerator.generate();
-                    }
-                });
-
-                it('should return mangled name', () => {
-                    assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
-                });
+            it('should return mangled name', () => {
+                assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
             });
+        });
 
-            describe('variant #3: last mangled name with single character', () => {
-                const expectedMangledIdentifierName: string = 'Z';
-                const expectedMangledIdentifierPosition: number = 51;
+        describe('variant #3: last mangled name with single character', () => {
+            const expectedMangledIdentifierName: string = 'Z';
+            const expectedMangledIdentifierPosition: number = 51;
 
-                beforeEach(() => {
-                    for (let i: number = 0; i <= expectedMangledIdentifierPosition; i++) {
-                        mangledIdentifierName = identifierNamesGenerator.generate();
-                    }
-                });
+            beforeEach(() => {
+                for (let i: number = 0; i <= expectedMangledIdentifierPosition; i++) {
+                    mangledIdentifierName = identifierNamesGenerator.generate();
+                }
+            });
 
-                it('should return mangled name', () => {
-                    assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
-                });
+            it('should return mangled name', () => {
+                assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
             });
+        });
 
-            describe('variant #4: correct increase of mangled name length', () => {
-                const expectedMangledIdentifierName: string = 'a0';
-                const expectedMangledIdentifierPosition: number = 52;
+        describe('variant #4: correct increase of mangled name length', () => {
+            const expectedMangledIdentifierName: string = 'a0';
+            const expectedMangledIdentifierPosition: number = 52;
 
-                beforeEach(() => {
-                    for (let i: number = 0; i <= expectedMangledIdentifierPosition; i++) {
-                        mangledIdentifierName = identifierNamesGenerator.generate();
-                    }
-                });
+            beforeEach(() => {
+                for (let i: number = 0; i <= expectedMangledIdentifierPosition; i++) {
+                    mangledIdentifierName = identifierNamesGenerator.generate();
+                }
+            });
 
-                it('should return mangled name', () => {
-                    assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
-                });
+            it('should return mangled name', () => {
+                assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
             });
+        });
 
-            describe('variant #5: correct increase of mangled name length #2', () => {
-                const expectedMangledIdentifierName: string = 'aa';
-                const expectedMangledIdentifierPosition: number = 62;
+        describe('variant #5: correct increase of mangled name length #2', () => {
+            const expectedMangledIdentifierName: string = 'aa';
+            const expectedMangledIdentifierPosition: number = 62;
 
-                beforeEach(() => {
-                    for (let i: number = 0; i <= expectedMangledIdentifierPosition; i++) {
-                        mangledIdentifierName = identifierNamesGenerator.generate();
-                    }
-                });
+            beforeEach(() => {
+                for (let i: number = 0; i <= expectedMangledIdentifierPosition; i++) {
+                    mangledIdentifierName = identifierNamesGenerator.generate();
+                }
+            });
 
-                it('should return mangled name', () => {
-                    assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
-                });
+            it('should return mangled name', () => {
+                assert.equal(mangledIdentifierName, expectedMangledIdentifierName);
             });
+        });
 
-            describe('variant #6: reserved names', () => {
-                const expectedMangledIdentifierName1: string = 'dn';
-                const expectedMangledIdentifierName2: string = 'dp';
-                const expectedMangledIdentifierPosition1: number = 261;
-                const expectedMangledIdentifierPosition2: number = 262;
+        describe('variant #6: reserved names', () => {
+            const expectedMangledIdentifierName1: string = 'dn';
+            const expectedMangledIdentifierName2: string = 'dp';
+            const expectedMangledIdentifierPosition1: number = 261;
+            const expectedMangledIdentifierPosition2: number = 262;
 
-                let mangledIdentifierName1: string,
-                    mangledIdentifierName2: string;
+            let mangledIdentifierName1: string,
+                mangledIdentifierName2: string;
 
-                beforeEach(() => {
-                    for (let i: number = 0; i <= expectedMangledIdentifierPosition2; i++) {
-                        mangledIdentifierName = identifierNamesGenerator.generate();
-
-                        if (i === expectedMangledIdentifierPosition1) {
-                            mangledIdentifierName1 = mangledIdentifierName;
-                        } else if (i === expectedMangledIdentifierPosition2) {
-                            mangledIdentifierName2 = mangledIdentifierName;
-                        }
+            beforeEach(() => {
+                for (let i: number = 0; i <= expectedMangledIdentifierPosition2; i++) {
+                    mangledIdentifierName = identifierNamesGenerator.generate();
+
+                    if (i === expectedMangledIdentifierPosition1) {
+                        mangledIdentifierName1 = mangledIdentifierName;
+                    } else if (i === expectedMangledIdentifierPosition2) {
+                        mangledIdentifierName2 = mangledIdentifierName;
                     }
-                });
+                }
+            });
 
-                it('should return mangled name', () => {
-                    assert.equal(mangledIdentifierName1, expectedMangledIdentifierName1);
-                });
+            it('should return mangled name', () => {
+                assert.equal(mangledIdentifierName1, expectedMangledIdentifierName1);
+            });
 
-                it('shouldn\'t return reserved mangled name', () => {
-                    assert.equal(mangledIdentifierName2, expectedMangledIdentifierName2);
-                });
+            it('shouldn\'t return reserved mangled name', () => {
+                assert.equal(mangledIdentifierName2, expectedMangledIdentifierName2);
             });
         });
+    });
 
+    describe('generateWithPrefix (): string', () => {
         describe('Mangled name with prefix', () => {
             let identifierNamesGenerator: IIdentifierNamesGenerator,
                 mangledIdentifierName: string;
@@ -212,4 +212,29 @@ describe('MangledIdentifierNamesGenerator', () => {
             });
         });
     });
+
+    describe('getPrefix (): string', () => {
+        const expectedIdentifierPrefix: string = 'foo';
+
+        let identifierNamesGenerator: IIdentifierNamesGenerator,
+            identifierPrefix: string;
+
+        before(() => {
+            const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
+
+            inversifyContainerFacade.load('', {
+                identifiersPrefix: 'foo'
+            });
+            identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
+                ServiceIdentifiers.IIdentifierNamesGenerator,
+                IdentifierNamesGenerator.MangledIdentifierNamesGenerator
+            );
+
+            identifierPrefix = identifierNamesGenerator.getPrefix();
+        });
+
+        it('should return prefix', () => {
+            assert.equal(identifierPrefix, expectedIdentifierPrefix);
+        })
+    });
 });