Added `getOptions` method to `IObfuscationResult`

src/interfaces/source-code/IObfuscationResult.ts

@@ -1,5 +1,7 @@
 import { TIdentifierNamesCache } from '../../types/TIdentifierNamesCache';
+
 import { IInitializable } from '../IInitializable';
+import { IOptions } from '../options/IOptions';
 
 export interface IObfuscationResult extends IInitializable <[string, string]> {
     /**
@@ -12,6 +14,11 @@ export interface IObfuscationResult extends IInitializable <[string, string]> {
      */
     getObfuscatedCode (): string;
 
+    /**
+     * @return {IOptions}
+     */
+    getOptions (): IOptions;
+
     /**
      * @return {string}
      */

src/source-code/ObfuscationResult.ts

@@ -96,6 +96,13 @@ export class ObfuscationResult implements IObfuscationResult {
         return this.correctObfuscatedCode();
     }
 
+    /**
+     * @returns {IOptions}
+     */
+    public getOptions (): IOptions {
+        return this.options;
+    }
+
     /**
      * @returns {string}
      */

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

@@ -1141,13 +1141,13 @@ describe('JavaScriptObfuscator', () => {
             const samplesCount: number = 30;
 
             let collisionError: string | null = null;
-            let obfuscateFunc: (identifierNamesGenerator: TTypeFromEnum<typeof IdentifierNamesGenerator>) => string;
+            let obfuscateFunc: (identifierNamesGenerator: TTypeFromEnum<typeof IdentifierNamesGenerator>) => IObfuscationResult;
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/custom-nodes-identifier-names-collision.js');
 
                 obfuscateFunc = (identifierNamesGenerator: TTypeFromEnum<typeof IdentifierNamesGenerator>) => {
-                    const obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    return JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             identifierNamesGenerator,
@@ -1156,9 +1156,7 @@ describe('JavaScriptObfuscator', () => {
                             identifiersDictionary: ['foo', 'bar', 'baz', 'bark', 'hawk', 'foozmos', 'cow', 'chikago'],
                             stringArray: true
                         }
-                    ).getObfuscatedCode();
-
-                    return obfuscatedCode;
+                    );
                 };
 
 
@@ -1167,10 +1165,14 @@ describe('JavaScriptObfuscator', () => {
                     IdentifierNamesGenerator.MangledIdentifierNamesGenerator
                 ].forEach((identifierNamesGenerator: TTypeFromEnum<typeof IdentifierNamesGenerator>) => {
                     for (let i = 0; i < samplesCount; i++) {
+                        const obfuscationResult = obfuscateFunc(identifierNamesGenerator);
+                        const obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                        const seed = obfuscationResult.getOptions().seed;
+
                         try {
-                            eval(obfuscateFunc(identifierNamesGenerator));
+                            eval(obfuscatedCode);
                         } catch (error) {
-                            collisionError = error.message;
+                            collisionError = `Seed: ${seed}. Error: ${error.message}`;
                             break;
                         }
                     }

test/unit-tests/source-code/ObfuscationResult.spec.ts

@@ -4,15 +4,47 @@ import { ServiceIdentifiers } from '../../../src/container/ServiceIdentifiers';
 
 import { assert } from 'chai';
 
+import { TInputOptions } from '../../../src/types/options/TInputOptions';
 import { TTypeFromEnum } from '../../../src/types/utils/TTypeFromEnum';
 
 import { IInversifyContainerFacade } from '../../../src/interfaces/container/IInversifyContainerFacade';
 import { IObfuscationResult } from '../../../src/interfaces/source-code/IObfuscationResult';
+import { IOptions } from '../../../src/interfaces/options/IOptions';
 
 import { SourceMapMode } from '../../../src/enums/source-map/SourceMapMode';
 
+import { DEFAULT_PRESET } from '../../../src/options/presets/Default';
+
 import { InversifyContainerFacade } from '../../../src/container/InversifyContainerFacade';
 
+/**
+ * @param {string} rawObfuscatedCode
+ * @param {TInputOptions} options
+ * @returns {IObfuscationResult}
+ */
+function getObfuscationResult (
+    rawObfuscatedCode: string,
+    options: TInputOptions
+): IObfuscationResult {
+    const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
+
+    inversifyContainerFacade.load(
+        '',
+        '',
+        {
+            ...DEFAULT_PRESET,
+            ...options
+        }
+    );
+
+    const obfuscationResult: IObfuscationResult = inversifyContainerFacade
+        .get<IObfuscationResult>(ServiceIdentifiers.IObfuscationResult);
+
+    obfuscationResult.initialize(rawObfuscatedCode, '');
+
+    return obfuscationResult;
+}
+
 /**
  * @param rawObfuscatedCode
  * @param sourceMap
@@ -20,7 +52,7 @@ import { InversifyContainerFacade } from '../../../src/container/InversifyContai
  * @param sourceMapFileName
  * @param sourceMapMode
  */
-function getObfuscationResult (
+function getSourceMapObfuscationResult (
     rawObfuscatedCode: string,
     sourceMap: string,
     sourceMapBaseUrl: string,
@@ -33,10 +65,11 @@ function getObfuscationResult (
         '',
         '',
         {
+            ...DEFAULT_PRESET,
             sourceMap: true,
-            sourceMapBaseUrl: sourceMapBaseUrl,
-            sourceMapFileName: sourceMapFileName,
-            sourceMapMode: sourceMapMode
+            sourceMapBaseUrl,
+            sourceMapFileName,
+            sourceMapMode
         }
     );
 
@@ -56,7 +89,7 @@ describe('ObfuscatedCode', () => {
         let obfuscationResult: IObfuscationResult;
 
         before(() => {
-            obfuscationResult = getObfuscationResult(
+            obfuscationResult = getSourceMapObfuscationResult(
                 expectedObfuscatedCode,
                 sourceMap,
                 '',
@@ -75,7 +108,7 @@ describe('ObfuscatedCode', () => {
 
         describe('source map doest\'t exist', () => {
             before(() => {
-                obfuscatedCode = getObfuscationResult(
+                obfuscatedCode = getSourceMapObfuscationResult(
                     expectedObfuscatedCode,
                     '',
                     '',
@@ -93,7 +126,7 @@ describe('ObfuscatedCode', () => {
             const regExp: RegExp = /data:application\/json;base64,dGVzdA==/;
 
             before(() => {
-                obfuscatedCode = getObfuscationResult(
+                obfuscatedCode = getSourceMapObfuscationResult(
                     expectedObfuscatedCode,
                     sourceMap,
                     '',
@@ -111,7 +144,7 @@ describe('ObfuscatedCode', () => {
             const regExp: RegExp = /sourceMappingURL=http:\/\/example\.com\/output\.js\.map/;
 
             before(() => {
-                obfuscatedCode = getObfuscationResult(
+                obfuscatedCode = getSourceMapObfuscationResult(
                     expectedObfuscatedCode,
                     sourceMap,
                     'http://example.com',
@@ -127,7 +160,7 @@ describe('ObfuscatedCode', () => {
 
         describe('source map mode is `separate`, `sourceMapUrl` is not set', () => {
             before(() => {
-                obfuscatedCode = getObfuscationResult(
+                obfuscatedCode = getSourceMapObfuscationResult(
                     expectedObfuscatedCode,
                     sourceMap,
                     '',
@@ -141,4 +174,26 @@ describe('ObfuscatedCode', () => {
             });
         });
     });
+
+    describe('getOptions', () => {
+        const seed: number = 1234;
+        const expectedOptions: IOptions = {
+            ...DEFAULT_PRESET,
+            seed
+        } as IOptions;
+        let options: IOptions;
+
+        before(() => {
+            options = getObfuscationResult(
+                expectedObfuscatedCode,
+                {
+                    seed
+                }
+            ).getOptions();
+        });
+
+        it('should return options object', () => {
+            assert.deepEqual(options, expectedOptions);
+        });
+    });
 });