@atlaskit/eslint-plugin-platform 0.0.5 → 0.0.7

package/report.api.md

@@ -23,6 +23,8 @@ export const configs: {
     plugins: string[];
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': string;
+      '@atlaskit/platform/ensure-test-runner-arguments': string;
+      '@atlaskit/platform/ensure-test-runner-nested-count': string;
       '@atlaskit/platform/no-invalid-feature-flag-usage': string;
     };
   };
@@ -31,6 +33,8 @@ export const configs: {
 // @public (undocumented)
 export const rules: {
   'ensure-feature-flag-registration': Rule.RuleModule;
+  'ensure-test-runner-arguments': Rule.RuleModule;
+  'ensure-test-runner-nested-count': Rule.RuleModule;
   'no-invalid-feature-flag-usage': Rule.RuleModule;
 };
 

package/src/index.tsx

@@ -1,8 +1,12 @@
 import ensureFeatureFlagRegistration from './rules/ensure-feature-flag-registration';
+import ensureTestRunnerArguments from './rules/ensure-test-runner-arguments';
+import ensureTestRunnerNestedCount from './rules/ensure-test-runner-nested-count';
 import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 
 export const rules = {
   'ensure-feature-flag-registration': ensureFeatureFlagRegistration,
+  'ensure-test-runner-arguments': ensureTestRunnerArguments,
+  'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
 };
 
@@ -11,6 +15,8 @@ export const configs = {
     plugins: ['@atlaskit/platform'],
     rules: {
       '@atlaskit/platform/ensure-feature-flag-registration': 'error',
+      '@atlaskit/platform/ensure-test-runner-arguments': 'error',
+      '@atlaskit/platform/ensure-test-runner-nested-count': 'warn',
       '@atlaskit/platform/no-invalid-feature-flag-usage': 'error',
     },
   },

package/src/rules/ensure-test-runner-arguments/__tests__/unit/rule.test.tsx

@@ -0,0 +1,298 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+describe('Feature Flag can only be passed into ffTest as Literal', () => {
+  tester.run('ensure-test-runner-arguments', rule, {
+    valid: [
+      {
+        code: `ffTest('sample.feature.flag', () => {
+          const { getByText } = render(<SampleComponent />);
+          expect(getByText('SampleComponent')).toBeDefined();
+        });`,
+      },
+    ],
+    invalid: [
+      {
+        code: `ffTest(myFeatureFlag, () => {
+          const { getByText } = render(<SampleComponent />);
+          expect(getByText('SampleComponent')).toBeDefined();
+        });`,
+        errors: [
+          {
+            messageId: 'onlyInlineFeatureFlag',
+            data: { identifierName: 'myFeatureFlag' },
+          },
+        ],
+      },
+    ],
+  });
+});
+
+describe('Test functions can only be passed in directly, instead of as variables', () => {
+  tester.run('ensure-test-runner-arguments', rule, {
+    valid: [
+      {
+        code: `ffTest('sample.feature.flag', () => {
+          const { getByText } = render(<SampleComponent />);
+          expect(getByText('SampleComponent')).toBeDefined();
+        });`,
+      },
+      {
+        code: `ffTest('sample.feature.flag', () => {
+          const { getByText } = render(<SampleComponent />);
+          expect(getByText('SampleComponent')).toBeDefined();
+        }, () => {
+          const { getByText } = render(<SampleComponent />);
+          expect(getByText('AnotherSampleComponent')).toBeDefined();
+        });`,
+      },
+    ],
+    invalid: [
+      {
+        code: `ffTest('sample.feature.flag', fnToPassIn);`,
+        errors: [
+          {
+            messageId: 'onlyInlineTestFunction',
+            data: { identifierName: 'fnToPassIn' },
+          },
+        ],
+      },
+      {
+        code: `ffTest('sample.feature.flag', () => {
+          const { getByText } = render(<SampleComponent />);
+          expect(getByText('SampleComponent')).toBeDefined();
+        }, fnToPassInWhenFlagIsDisabled);`,
+        errors: [
+          {
+            messageId: 'onlyInlineTestFunction',
+            data: { identifierName: 'fnToPassInWhenFlagIsDisabled' },
+          },
+        ],
+      },
+      {
+        code: `ffTest('sample.feature.flag', fnToPassInWhenFlagIsEnabled, () => {
+          const { getByText } = render(<SampleComponent />);
+          expect(getByText('SampleComponent')).toBeDefined();
+        },);`,
+        errors: [
+          {
+            messageId: 'onlyInlineTestFunction',
+            data: { identifierName: 'fnToPassInWhenFlagIsEnabled' },
+          },
+        ],
+      },
+    ],
+  });
+});
+
+describe('Verify existing ff overrides are passed down if test runner is nested', () => {
+  tester.run('ensure-test-runner-arguments', rule, {
+    valid: [
+      {
+        code: `ffTest(
+          'uip.sample.color',
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              ff,
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ff,
+            ),
+        );
+        `,
+      },
+    ],
+    invalid: [
+      {
+        code: `ffTest(
+          'uip.sample.color',
+          () =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              ff,
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ff,
+            ),
+        );
+        `,
+        output: `ffTest(
+          'uip.sample.color',
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              ff,
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ff,
+            ),
+        );
+        `,
+        errors: [
+          {
+            messageId: 'passDownExistingFeatureFlagParam',
+          },
+        ],
+      },
+      {
+        code: `ffTest(
+          'uip.sample.color',
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ff,
+            ),
+        );
+        `,
+        output: `ffTest(
+          'uip.sample.color',
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              }, ff,
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ff,
+            ),
+        );
+        `,
+        errors: [
+          {
+            messageId: 'passDownExistingFeatureFlagArgument',
+          },
+        ],
+      },
+      {
+        code: `ffTest(
+          'uip.sample.color',
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              ff,
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ffExisting,
+            ),
+        );
+        `,
+        output: `ffTest(
+          'uip.sample.color',
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: red');
+              },
+              ff,
+            ),
+          ff =>
+            ffTest(
+              'uip.sample.backgroundColor',
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              () => {
+                expect(getByText('SampleComponent')).toHaveStyle('color: blue');
+              },
+              ff,
+            ),
+        );
+        `,
+        errors: [
+          {
+            messageId: 'passDownExistingFeatureFlagNamesMatch',
+          },
+        ],
+      },
+    ],
+  });
+});

package/src/rules/ensure-test-runner-arguments/index.tsx

@@ -0,0 +1,134 @@
+import type { Rule } from 'eslint';
+
+const TEST_RUNNER_IDENTIFIER = 'ffTest' as const;
+
+const rule: Rule.RuleModule = {
+  meta: {
+    docs: {
+      recommended: false,
+    },
+    type: 'problem',
+    fixable: 'code',
+    messages: {
+      onlyInlineFeatureFlag:
+        'Only pass in feature flag as string literal, please replace {{identifierName}} with its value.',
+      onlyInlineTestFunction:
+        'Only pass in test functions/cases in an inline manner. Test functions/cases should be passed in directly, instead of as variables. Please replace {{identifierName}} with its own definition.',
+      passDownExistingFeatureFlagParam:
+        'An argument symbolising existing FFs needs to be passed down as param when calling nested test runner. See examples in the package which declares this function.',
+      passDownExistingFeatureFlagArgument:
+        'An argument symbolising existing FFs needs to be passed in as argument when calling nested test runner. See examples in the package which declares this function.',
+      passDownExistingFeatureFlagNamesMatch:
+        'Argument names not matching when passing down existing feature flags. See examples in the package which declares this function.',
+    },
+  },
+  create(context) {
+    return {
+      [`CallExpression[callee.name=/${TEST_RUNNER_IDENTIFIER}/]`]: (
+        node: Rule.Node,
+      ) => {
+        if (node.type === 'CallExpression') {
+          const args = node.arguments;
+
+          // Verify FF is passed inline
+          if (args[0] && args[0].type !== 'Literal') {
+            return context.report({
+              node,
+              messageId: 'onlyInlineFeatureFlag',
+              data: {
+                identifierName:
+                  args[0].type === 'Identifier' ? args[0].name : '',
+              },
+            });
+          }
+
+          // Verify test functions/cases are passed inline
+          if (args[1] && args[1].type !== 'ArrowFunctionExpression') {
+            return context.report({
+              node,
+              messageId: 'onlyInlineTestFunction',
+              data: {
+                identifierName:
+                  args[1].type === 'Identifier' ? args[1].name : '',
+              },
+            });
+          }
+
+          if (args[2] && args[2].type !== 'ArrowFunctionExpression') {
+            return context.report({
+              node,
+              messageId: 'onlyInlineTestFunction',
+              data: {
+                identifierName:
+                  args[2].type === 'Identifier' ? args[2].name : '',
+              },
+            });
+          }
+
+          // Verify existing ff overrides are passed down if test runner is nested
+          let upperTestRunner = node.parent?.parent;
+          if (
+            upperTestRunner?.type === 'CallExpression' &&
+            upperTestRunner?.callee.type === 'Identifier' &&
+            upperTestRunner?.callee.name === TEST_RUNNER_IDENTIFIER &&
+            node.parent?.type === 'ArrowFunctionExpression'
+          ) {
+            // Not pass in ff to the function that calls test runner
+            if (
+              !node.parent.params[0] ||
+              node.parent.params[0].type !== 'Identifier'
+            ) {
+              return context.report({
+                node: node.parent,
+                messageId: 'passDownExistingFeatureFlagParam',
+                fix: function (fixer) {
+                  const parentNodeRange = node.parent.range as [number, number];
+                  return [
+                    fixer.replaceTextRange(
+                      [parentNodeRange[0], parentNodeRange[0] + 2],
+                      'ff',
+                    ),
+                    node.arguments[3]
+                      ? fixer.replaceText(node.arguments[3], 'ff')
+                      : fixer.insertTextAfter(node.arguments[2], ', ff'),
+                  ];
+                },
+              });
+            }
+
+            // Not pass in ff to test runner as 4th argument
+            const paramName = node.parent.params[0].name;
+            if (!node.arguments[3] || node.arguments[3].type !== 'Identifier') {
+              return context.report({
+                node,
+                messageId: 'passDownExistingFeatureFlagArgument',
+                fix: function (fixer) {
+                  return node.arguments[3]
+                    ? fixer.replaceText(node.arguments[3], paramName)
+                    : fixer.insertTextAfter(
+                        node.arguments[2],
+                        `, ${paramName}`,
+                      );
+                },
+              });
+            }
+            // Pass in the above two, but names don't match
+            const arguName = node.arguments[3].name;
+            if (paramName !== arguName) {
+              return context.report({
+                node: node.parent,
+                messageId: 'passDownExistingFeatureFlagNamesMatch',
+                fix: function (fixer) {
+                  return fixer.replaceText(node.arguments[3], paramName);
+                },
+              });
+            }
+          }
+        }
+        return {};
+      },
+    };
+  },
+};
+
+export default rule;