add allowFunctions as an allow-list for require-expect function calls

docs/rules/require-expect.md

@@ -11,6 +11,18 @@ test. This rule checks for `expect` at linting time.
 
 ## Options
 
+This rule is configurable by  the `Check Type` and the `Config Options`
+
+### Check Type
+
+Example:
+
+```js
+rules: {
+  'qunit/require-expect': ['error', 'except-simple'],
+},
+```
+
 The "always" option requires that `expect` is called in each test.
 
 The "except-simple" (**default**) option only requires an `expect` call when an assertion is
@@ -28,6 +40,28 @@ The "never-except-zero" option disallows `except` calls, except when used to
 explicitly assert that a test performs no assertions, which would otherwise
 be considered an error.
 
+### Config Options
+
+This rule allows exactly one config option: `allowFunctions`
+
+#### allowFunctions
+
+If you are using the Check Type `except-simple` whenever you pass `assert` into
+another function you will cause an error. If you have some functions that you
+are passing `assert` to that don't add to the number of asserts (and maybe just
+extract the test name from the assert context) then you can mark those functions
+to be ok with the `allowFunctions` config option.
+
+Here is an example:
+
+```js
+rules: {
+  'qunit/require-expect': ['error', 'except-simple', {
+    allowFunctions: [ 'percySnapshot' ]
+  }],
+},
+```
+
 ## Rule Details
 
 ### always

lib/rules/require-expect.js

@@ -28,6 +28,15 @@ module.exports = {
         schema: [
             {
                 "enum": ["always", "except-simple", "never", "never-except-zero"]
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "allowFunctions": {
+                        "type": "array"
+                    }
+                },
+                "additionalProperties": false
             }
         ]
     },
@@ -67,10 +76,16 @@ module.exports = {
         }
 
         function isPassingAssertAsArgument(node) {
+            const allowedFunctions = context.options[1] && context.options[1].allowFunctions || [];
+
             if (!currentTest.assertName) {
                 return false;
             }
 
+            if (allowedFunctions.includes(node.callee.name)) {
+                return false;
+            }
+
             for (let i = 0; i < node.arguments.length; i++) {
                 if (node.arguments[i].name === currentTest.assertName) {
                     return true;

tests/lib/rules/require-expect.js

@@ -141,6 +141,16 @@ ruleTester.run("require-expect", rule, {
         {
             code: "test('name', function(assert) { assert.expect(0) });",
             options: ["never-except-zero"]
+        },
+
+        // Sending assert to a function with a valid allowFunctions
+        {
+            code: [
+                "function myAssertion(a, assert, c) { assert.ok(true); }",
+                "test('name', function(assert) { myAssertion(null, assert, null); });"
+            ].join(returnAndIndent),
+            options: ["except-simple", { allowFunctions: ["myAssertion"] }],
+            errors: [exceptSimpleErrorMessage("assert.expect")]
         }
     ],