add unit tests

Author: bmish

lib/rules/require-meta-docs-description.js

@@ -45,6 +45,7 @@ module.exports = {
     return {
       Program() {
         const sourceCode = context.getSourceCode();
+        const { scopeManager } = sourceCode;
         const info = utils.getRuleInfo(sourceCode);
 
         if (info === null) {
@@ -57,17 +58,13 @@ module.exports = {
             : DEFAULT_PATTERN;
 
         const metaNode = info.meta;
-        const docsNode =
-          metaNode &&
-          metaNode.properties &&
-          metaNode.properties.find(
-            (p) => p.type === 'Property' && utils.getKeyName(p) === 'docs'
-          );
+        const docsNode = utils
+          .evaluateObjectProperties(metaNode, scopeManager)
+          .find((p) => p.type === 'Property' && utils.getKeyName(p) === 'docs');
 
-        const descriptionNode =
-          docsNode &&
-          docsNode.value.properties &&
-          docsNode.value.properties.find(
+        const descriptionNode = utils
+          .evaluateObjectProperties(docsNode && docsNode.value, scopeManager)
+          .find(
             (p) =>
               p.type === 'Property' && utils.getKeyName(p) === 'description'
           );

lib/rules/require-meta-docs-url.js

@@ -50,7 +50,6 @@ module.exports = {
    */
   create(context) {
     const options = context.options[0] || {};
-    const sourceCode = context.getSourceCode();
     const filename = context.getFilename();
     const ruleName =
       filename === '<input>'
@@ -75,24 +74,24 @@ module.exports = {
 
     return {
       Program() {
+        const sourceCode = context.getSourceCode();
+        const { scopeManager } = sourceCode;
+
         const info = util.getRuleInfo(sourceCode);
         if (info === null) {
           return;
         }
 
         const metaNode = info.meta;
-        const docsPropNode =
-          metaNode &&
-          metaNode.properties &&
-          metaNode.properties.find(
-            (p) => p.type === 'Property' && util.getKeyName(p) === 'docs'
-          );
-        const urlPropNode =
-          docsPropNode &&
-          docsPropNode.value.properties &&
-          docsPropNode.value.properties.find(
-            (p) => p.type === 'Property' && util.getKeyName(p) === 'url'
-          );
+        const docsPropNode = util
+          .evaluateObjectProperties(metaNode, scopeManager)
+          .find((p) => p.type === 'Property' && util.getKeyName(p) === 'docs');
+        const urlPropNode = util
+          .evaluateObjectProperties(
+            docsPropNode && docsPropNode.value,
+            scopeManager
+          )
+          .find((p) => p.type === 'Property' && util.getKeyName(p) === 'url');
 
         const staticValue = urlPropNode
           ? getStaticValue(urlPropNode.value, context.getScope())

lib/utils.js

@@ -747,23 +747,19 @@ module.exports = {
    * @returns {Node[]} the list of all properties that could be found
    */
   evaluateObjectProperties(objectNode, scopeManager) {
-    if (!objectNode) {
+    if (!objectNode || objectNode.type !== 'ObjectExpression') {
       return [];
     }
 
-    const spreadElements = objectNode.properties.filter(
-      (prop) => prop.type === 'SpreadElement'
-    );
-    const spreadElementNodes = spreadElements.map((spreadElement) =>
-      findVariableValue(spreadElement.argument, scopeManager)
-    );
-    const spreadElementObjectNodes = spreadElementNodes.filter(
-      (node) => node && node.type === 'ObjectExpression'
-    );
-    const spreadElementObjectNodeProperties = spreadElementObjectNodes.flatMap(
-      (node) => node.properties
-    );
-
-    return [...objectNode.properties, ...spreadElementObjectNodeProperties];
+    return objectNode.properties.flatMap((property) => {
+      if (property.type === 'SpreadElement') {
+        const value = findVariableValue(property.argument, scopeManager);
+        if (value && value.type === 'ObjectExpression') {
+          return value.properties;
+        }
+        return [];
+      }
+      return [property];
+    });
   },
 };

tests/lib/rules/require-meta-docs-description.js

@@ -11,7 +11,7 @@ const RuleTester = require('eslint').RuleTester;
 // Tests
 // ------------------------------------------------------------------------------
 
-const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
+const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 9 } });
 ruleTester.run('require-meta-docs-description', rule, {
   valid: [
     'foo()',
@@ -107,6 +107,14 @@ ruleTester.run('require-meta-docs-description', rule, {
         create(context) {}
       };
     `,
+    `
+      const extraDocs = { description: 'enforce foo' };
+      const extraMeta = { docs: { ...extraDocs } };
+      module.exports = {
+        meta: { ...extraMeta },
+        create(context) {}
+      };
+    `,
   ],
 
   invalid: [

tests/lib/rules/require-meta-docs-url.js

@@ -155,6 +155,22 @@ tester.run('require-meta-docs-url', rule, {
         },
       ],
     },
+    {
+      filename: 'test-rule',
+      code: `
+        const extraDocs = { url: "path/to/test-rule.md" };
+        const extraMeta = { docs: { ...extraDocs } };
+        module.exports = {
+          meta: { ...extraMeta },
+          create() {}
+        }
+      `,
+      options: [
+        {
+          pattern: 'path/to/{{name}}.md',
+        },
+      ],
+    },
   ],
 
   invalid: [

tests/lib/utils.js

@@ -1274,4 +1274,81 @@ describe('utils', () => {
       });
     });
   });
+
+  describe('evaluateObjectProperties', function () {
+    it('behaves correctly with simple object expression', function () {
+      const ast = espree.parse('const obj = { a: 123, b: foo() };', {
+        ecmaVersion: 9,
+        range: true,
+      });
+      const scopeManager = eslintScope.analyze(ast);
+      const result = utils.evaluateObjectProperties(
+        ast.body[0].declarations[0].init,
+        scopeManager
+      );
+      assert.deepEqual(result, ast.body[0].declarations[0].init.properties);
+    });
+
+    it('behaves correctly with spreads of objects', function () {
+      const ast = espree.parse(
+        `
+        const extra1 = { a: 123 };
+        const extra2 = { b: 456 };
+        const obj = { ...extra1, c: 789, ...extra2 };
+        `,
+        {
+          ecmaVersion: 9,
+          range: true,
+        }
+      );
+      const scopeManager = eslintScope.analyze(ast);
+      const result = utils.evaluateObjectProperties(
+        ast.body[2].declarations[0].init,
+        scopeManager
+      );
+      assert.deepEqual(result, [
+        ...ast.body[0].declarations[0].init.properties, // First spread properties
+        ...ast.body[2].declarations[0].init.properties.filter(
+          (property) => property.type !== 'SpreadElement'
+        ), // Non-spread properties
+        ...ast.body[1].declarations[0].init.properties, // Second spread properties
+      ]);
+    });
+
+    it('behaves correctly with non-variable spreads', function () {
+      const ast = espree.parse(`function foo() {} const obj = { ...foo() };`, {
+        ecmaVersion: 9,
+        range: true,
+      });
+      const scopeManager = eslintScope.analyze(ast);
+      const result = utils.evaluateObjectProperties(
+        ast.body[1].declarations[0].init,
+        scopeManager
+      );
+      assert.deepEqual(result, []);
+    });
+
+    it('behaves correctly with spread with variable that cannot be found', function () {
+      const ast = espree.parse(`const obj = { ...foo };`, {
+        ecmaVersion: 9,
+        range: true,
+      });
+      const scopeManager = eslintScope.analyze(ast);
+      const result = utils.evaluateObjectProperties(
+        ast.body[0].declarations[0].init,
+        scopeManager
+      );
+      assert.deepEqual(result, []);
+    });
+
+    it('behaves correctly when passed wrong node type', function () {
+      const ast = espree.parse(`foo();`, {
+        ecmaVersion: 9,
+        range: true,
+      });
+      const scopeManager = eslintScope.analyze(ast);
+      const result = utils.evaluateObjectProperties(ast.body[0], scopeManager);
+      assert.deepEqual(result, []);
+    });
+  });
 });