@atlaskit/eslint-plugin-platform 0.6.1 → 0.7.0

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

@@ -2,94 +2,94 @@ 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', () => {
+	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, () => {
+			},
+		],
+		invalid: [
+			{
+				code: `ffTest(myFeatureFlag, () => {
           const { getByText } = render(<SampleComponent />);
           expect(getByText('SampleComponent')).toBeDefined();
         });`,
-        errors: [
-          {
-            messageId: 'onlyInlineFeatureFlag',
-            data: { identifierName: 'myFeatureFlag' },
-          },
-        ],
-      },
-    ],
-  });
+				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', () => {
+	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', () => {
+			},
+			{
+				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', () => {
+			},
+		],
+		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, () => {
+				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' },
-          },
-        ],
-      },
-    ],
-  });
+				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(
+	tester.run('ensure-test-runner-arguments', rule, {
+		valid: [
+			{
+				code: `ffTest(
           'uip.sample.color',
           ff =>
             ffTest(
@@ -115,11 +115,11 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
-      },
-    ],
-    invalid: [
-      {
-        code: `ffTest(
+			},
+		],
+		invalid: [
+			{
+				code: `ffTest(
           'uip.sample.color',
           () =>
             ffTest(
@@ -145,7 +145,7 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
-        output: `ffTest(
+				output: `ffTest(
           'uip.sample.color',
           ff =>
             ffTest(
@@ -171,14 +171,14 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
-        errors: [
-          {
-            messageId: 'passDownExistingFeatureFlagParam',
-          },
-        ],
-      },
-      {
-        code: `ffTest(
+				errors: [
+					{
+						messageId: 'passDownExistingFeatureFlagParam',
+					},
+				],
+			},
+			{
+				code: `ffTest(
           'uip.sample.color',
           ff =>
             ffTest(
@@ -203,7 +203,7 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
-        output: `ffTest(
+				output: `ffTest(
           'uip.sample.color',
           ff =>
             ffTest(
@@ -228,14 +228,14 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
-        errors: [
-          {
-            messageId: 'passDownExistingFeatureFlagArgument',
-          },
-        ],
-      },
-      {
-        code: `ffTest(
+				errors: [
+					{
+						messageId: 'passDownExistingFeatureFlagArgument',
+					},
+				],
+			},
+			{
+				code: `ffTest(
           'uip.sample.color',
           ff =>
             ffTest(
@@ -261,7 +261,7 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
-        output: `ffTest(
+				output: `ffTest(
           'uip.sample.color',
           ff =>
             ffTest(
@@ -287,12 +287,12 @@ describe('Verify existing ff overrides are passed down if test runner is nested'
             ),
         );
         `,
-        errors: [
-          {
-            messageId: 'passDownExistingFeatureFlagNamesMatch',
-          },
-        ],
-      },
-    ],
-  });
+				errors: [
+					{
+						messageId: 'passDownExistingFeatureFlagNamesMatch',
+					},
+				],
+			},
+		],
+	});
 });

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

@@ -4,132 +4,118 @@ 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;
+	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 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 : '',
-              },
-            });
-          }
+					// 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 : '',
-              },
-            });
-          }
+					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'),
-                  ];
-                },
-              });
-            }
+					// 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 {};
-      },
-    };
-  },
+						// 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;

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

@@ -2,18 +2,18 @@ import { tester } from '../../../../__tests__/utils/_tester';
 import rule from '../../index';
 
 describe('Warning about too many nested test runners', () => {
-  tester.run('ensure-test-runner-nested-count', rule, {
-    valid: [
-      {
-        code: `describe('1 FF', () => {
+	tester.run('ensure-test-runner-nested-count', rule, {
+		valid: [
+			{
+				code: `describe('1 FF', () => {
           ffTest('uip.sample.color', () => {
             const { getByText } = render(<SampleComponent />);
             expect(getByText('SampleComponent')).toBeDefined();
           });
         });`,
-      },
-      {
-        code: `describe('2 FFs', () => {
+			},
+			{
+				code: `describe('2 FFs', () => {
           ffTest(
             'uip.sample.color',
             ff =>
@@ -40,9 +40,9 @@ describe('Warning about too many nested test runners', () => {
               ),
           );
         });`,
-      },
-      {
-        code: `ffTest(
+			},
+			{
+				code: `ffTest(
           'uip.sample.color',
           (ff) =>
             ffTest(
@@ -59,9 +59,9 @@ describe('Warning about too many nested test runners', () => {
               ff,
             ),
         );`,
-      },
-      {
-        code: `ffTest(
+			},
+			{
+				code: `ffTest(
           'uip.sample.color',
           (ff) =>
             ffTest(
@@ -96,9 +96,9 @@ describe('Warning about too many nested test runners', () => {
               ff,
             ),
         );`,
-      },
-      {
-        code: `
+			},
+			{
+				code: `
         ffTest(
           'uip.sample.color',
           (ff) =>
@@ -152,11 +152,11 @@ describe('Warning about too many nested test runners', () => {
               ff,
             ),
         );`,
-      },
-    ],
-    invalid: [
-      {
-        code: `
+			},
+		],
+		invalid: [
+			{
+				code: `
         describe('5 FFs', () => {
           ffTest(
             'uip.sample.color',
@@ -218,17 +218,17 @@ describe('Warning about too many nested test runners', () => {
               ),
           );
         });`,
-        errors: [
-          {
-            messageId: 'tooManyNestedTestRunner',
-            data: {
-              nestedTestRunner: 5,
-            },
-          },
-        ],
-      },
-      {
-        code: `
+				errors: [
+					{
+						messageId: 'tooManyNestedTestRunner',
+						data: {
+							nestedTestRunner: 5,
+						},
+					},
+				],
+			},
+			{
+				code: `
         ffTest(
           'uip.sample.color',
           (ff) =>
@@ -294,15 +294,15 @@ describe('Warning about too many nested test runners', () => {
               ff,
             ),
         );`,
-        errors: [
-          {
-            messageId: 'tooManyNestedTestRunner',
-            data: {
-              nestedTestRunner: 6,
-            },
-          },
-        ],
-      },
-    ],
-  });
+				errors: [
+					{
+						messageId: 'tooManyNestedTestRunner',
+						data: {
+							nestedTestRunner: 6,
+						},
+					},
+				],
+			},
+		],
+	});
 });