Tests for NodeMetadata class

src/declarations/ESTree.d.ts

@@ -12,7 +12,7 @@ declare module 'estree' {
         renamedIdentifier?: boolean;
     }
 
-    export interface SimpleLiteralNodeMetadata extends BaseNodeMetadata {
+    export interface LiteralNodeMetadata extends BaseNodeMetadata {
         replacedLiteral?: boolean;
     }
 
@@ -26,7 +26,11 @@ declare module 'estree' {
     }
 
     interface SimpleLiteral extends BaseNode {
-        metadata?: SimpleLiteralNodeMetadata;
+        metadata?: LiteralNodeMetadata;
+    }
+
+    interface RegExpLiteral extends BaseNode {
+        metadata?: LiteralNodeMetadata;
     }
 
     interface ExpressionStatement extends BaseNode {

src/node/NodeMetadata.ts

@@ -2,8 +2,8 @@ import * as ESTree from 'estree';
 
 export class NodeMetadata {
     /**
-     * @param {Node} node
-     * @param {BaseNodeMetadata} metadata
+     * @param {T} node
+     * @param {Partial<T["metadata"]>} metadata
      */
     public static set <T extends ESTree.Node = ESTree.Node> (node: T, metadata: Partial<T['metadata']>): void {
         node.metadata = Object.assign(node.metadata || {}, metadata);
@@ -11,15 +11,12 @@ export class NodeMetadata {
 
     /**
      * @param {Node} node
-     * @param {BaseNodeMetadata} metadataKey
-     * @returns {T | undefined}
+     * @param {keyof T} metadataKey
+     * @returns {T[keyof T] | undefined}
      */
-    public static get <T extends U[keyof U], U extends ESTree.BaseNodeMetadata> (
-        node: ESTree.Node,
-        metadataKey: keyof U
-    ): T | undefined {
+    public static get <T extends ESTree.BaseNodeMetadata> (node: ESTree.Node, metadataKey: keyof T): T[keyof T] | undefined {
         return node.metadata !== undefined
-            ? <T>(<U>node.metadata)[metadataKey]
+            ? (<T>node.metadata)[metadataKey]
             : undefined;
     }
 
@@ -36,7 +33,7 @@ export class NodeMetadata {
      * @returns {boolean}
      */
     public static isRenamedIdentifier (identifierNode: ESTree.Identifier): boolean {
-        return NodeMetadata.get<boolean, ESTree.IdentifierNodeMetadata>(identifierNode, 'renamedIdentifier') === true;
+        return NodeMetadata.get<ESTree.IdentifierNodeMetadata>(identifierNode, 'renamedIdentifier') === true;
     }
 
     /**
@@ -44,6 +41,6 @@ export class NodeMetadata {
      * @returns {boolean}
      */
     public static isReplacedLiteral (literalNode: ESTree.Literal): boolean {
-        return NodeMetadata.get<boolean, ESTree.SimpleLiteralNodeMetadata>(literalNode, 'replacedLiteral') === true;
+        return NodeMetadata.get<ESTree.LiteralNodeMetadata>(literalNode, 'replacedLiteral') === true;
     }
 }

test/index.spec.ts

@@ -22,6 +22,7 @@ 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-guards/NodeGuards.spec';
+import './unit-tests/node/node-metadata/NodeMetadata.spec';
 import './unit-tests/node/node-utils/NodeUtils.spec';
 import './unit-tests/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.spec';
 import './unit-tests/obfuscation-result/ObfuscationResult.spec';

test/unit-tests/node/node-metadata/NodeMetadata.spec.ts

@@ -0,0 +1,103 @@
+import 'reflect-metadata';
+
+import * as ESTree from 'estree';
+
+import { assert } from 'chai';
+
+import { NodeMetadata } from '../../../../src/node/NodeMetadata';
+import { NodeFactory } from '../../../../src/node/NodeFactory';
+
+describe('NodeMetadata', () => {
+    describe('set', () => {
+        const expectedMetadata: ESTree.IdentifierNodeMetadata = {
+            ignoredNode: true,
+            renamedIdentifier: true
+        };
+
+        let node: ESTree.Identifier;
+
+        before(() => {
+            node = NodeFactory.identifierNode('foo');
+            NodeMetadata.set(node, {
+                ignoredNode: true,
+                renamedIdentifier: true
+            })
+        });
+
+        it('should set metadata to the node', () => {
+            assert.deepPropertyVal(node, 'metadata', expectedMetadata);
+        });
+    });
+
+    describe('get', () => {
+        const expectedValue: boolean = true;
+
+        let node: ESTree.Identifier,
+            value: boolean | undefined;
+
+        before(() => {
+            node = NodeFactory.identifierNode('foo');
+            node.metadata = {};
+            node.metadata.renamedIdentifier = true;
+            value = NodeMetadata.get<ESTree.IdentifierNodeMetadata>(node, 'renamedIdentifier');
+        });
+
+        it('should get metadata value of the node', () => {
+            assert.equal(value, expectedValue);
+        });
+    });
+
+    describe('isIgnoredNode (node: ESTree.Node): boolean', () => {
+        const expectedValue: boolean = true;
+
+        let node: ESTree.Identifier,
+            value: boolean | undefined;
+
+        before(() => {
+            node = NodeFactory.identifierNode('foo');
+            node.metadata = {};
+            node.metadata.ignoredNode = true;
+            value = NodeMetadata.isIgnoredNode(node);
+        });
+
+        it('should return metadata value', () => {
+            assert.equal(value, expectedValue);
+        });
+    });
+
+    describe('isRenamedIdentifier (identifierNode: ESTree.Identifier): boolean', () => {
+        const expectedValue: boolean = true;
+
+        let node: ESTree.Identifier,
+            value: boolean | undefined;
+
+        before(() => {
+            node = NodeFactory.identifierNode('foo');
+            node.metadata = {};
+            node.metadata.renamedIdentifier = true;
+            value = NodeMetadata.isRenamedIdentifier(node);
+        });
+
+        it('should return metadata value', () => {
+            assert.equal(value, expectedValue);
+        });
+    });
+
+    describe('isReplacedLiteral (literalNode: ESTree.Literal): boolean', () => {
+        const expectedValue: boolean = true;
+
+        let node: ESTree.Literal,
+            value: boolean | undefined;
+
+        before(() => {
+            node = NodeFactory.literalNode('foo');
+            node.metadata = {};
+            node.metadata.replacedLiteral = true;
+            value = NodeMetadata.isReplacedLiteral(node);
+        });
+
+        it('should return metadata value', () => {
+            assert.equal(value, expectedValue);
+        });
+    });
+});