Viewing github.com/facebook/react/scripts/eslint-rules/__tests_

```
/**
```

 * Copyright (c) Meta Platforms, Inc. and affiliates.

```
 *
```

 * This source code is licensed under the MIT license found in the

 * LICENSE file in the root directory of this source tree.

```
 *
```
```
 * @emails react-core
```
```
 */
```
```
'use strict';
```

const rule = require('../safe-string-coercion');

const {RuleTester} = require('eslint');

```
RuleTester.setDefaultConfig({
```

  parser: require.resolve('babel-eslint'),

```
  parserOptions: {
```
```
    ecmaVersion: 6,
```
```
    sourceType: 'module',
```
```
  },
```
```
});
```
```
const ruleTester = new RuleTester();
```
```
const missingDevCheckMessage =
```

  'Missing DEV check before this string coercion.' +

  ' Check should be in this format:\n' +

```
  '  if (__DEV__) {\n' +
```

  '    checkXxxxxStringCoercion(value);\n' +

```
  '  }';
```

const prevStatementNotDevCheckMessage =

  'The statement before this coercion must be a DEV check in this format:\n' +

```
  '  if (__DEV__) {\n' +
```

  '    checkXxxxxStringCoercion(value);\n' +

```
  '  }';
```
```
const message =
```

  "Using `'' + value` or `value + ''` is fast to coerce strings, but may throw." +

  ' For prod code, add a DEV check from shared/CheckStringCoercion immediately' +

```
  ' before this coercion.' +
```

  ' For non-prod code and prod error handling, use `String(value)` instead.';

ruleTester.run('eslint-rules/safe-string-coercion', rule, {

```
  valid: [
```
```
    {
```
```
      code: 'String(obj)',
```

      options: [{isProductionUserAppCode: false}],

```
    },
```
```
    'String(obj)',
```
```
    "'a' + obj",
```
```
    `
```
```
      function getValueForAttribute(
```
```
        node,
```
```
        name,
```
```
        expected
```
```
      ) {
```
```
        if (__DEV__) {
```

          var value = node.getAttribute(name);

```
          if (__DEV__) {
```

            checkAttributeStringCoercion(expected, name);

```
          }
```

          if (value === '' + expected) {

```
            return expected;
```
```
          }
```
```
          return value;
```
```
        }
```
```
      }
```
```
    `,
```
```
    `
```

      if (__DEV__) { checkFormFieldValueStringCoercion (obj) }

```
      '' + obj;
```
```
    `,
```
```
    `
```
```
      function f(a, index) {
```

        if (typeof a === 'object' && a !== null && a.key != null) {

```
          if (__DEV__) {
```

            checkKeyStringCoercion(a.key);

```
          }
```
```
          return f('' + a.key);
```
```
        }
```
```
        return a;
```
```
      }
```
```
    `,
```
```
    "'' + i++",
```
```
    "'' + +i",
```
```
    "'' + +i",
```
```
    "+i + ''",
```

    "if (typeof obj === 'string') { '' + obj }",

    "if (typeof obj === 'string' || typeof obj === 'number') { '' + obj }",

    "if (typeof obj === 'string' && somethingElse) { '' + obj }",

    "if (typeof obj === 'number' && somethingElse) { '' + obj }",

    "if (typeof obj === 'bigint' && somethingElse) { '' + obj }",

    "if (typeof obj === 'undefined' && somethingElse) { '' + obj }",

    "if (typeof nextProp === 'number') { setTextContent(domElement, '' + nextProp); }",

    // These twe below are sneaky. The inner `if` is unsafe, but the outer `if`

    // ensures that the unsafe code will never be run. It's bad code, but

```
    // doesn't violate this rule.
```

    "if (typeof obj === 'string') { if (typeof obj === 'string' && obj.length) {} else {'' + obj} }",

    "if (typeof obj === 'string') if (typeof obj === 'string' && obj.length) {} else {'' + obj}",

```
    "'' + ''",
```
```
    "'' + '' + ''",
```
```
    "`test${foo}` + ''",
```
```
  ],
```
```
  invalid: [
```
```
    {
```
```
      code: "'' + obj",
```
```
      errors: [
```
```
        {
```

          message: missingDevCheckMessage + '\n' + message,

```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: "obj + ''",
```
```
      errors: [
```
```
        {
```

          message: missingDevCheckMessage + '\n' + message,

```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: 'String(obj)',
```

      options: [{isProductionUserAppCode: true}],

```
      errors: [
```
```
        {
```
```
          message:
```

            "For perf-sensitive coercion, avoid `String(value)`. Instead, use `'' + value`." +

            ' Precede it with a DEV check from shared/CheckStringCoercion' +

            ' unless Symbol and Temporal.* values are impossible.' +

            ' For non-prod code and prod error handling, use `String(value)` and disable this rule.',

```
        },
```
```
      ],
```
```
    },
```
```
    {
```

      code: "if (typeof obj === 'object') { '' + obj }",

```
      errors: [
```
```
        {
```

          message: missingDevCheckMessage + '\n' + message,

```
        },
```
```
      ],
```
```
    },
```
```
    {
```

      code: "if (typeof obj === 'string') { } else if (typeof obj === 'object') {'' + obj}",

```
      errors: [
```
```
        {
```

          message: missingDevCheckMessage + '\n' + message,

```
        },
```
```
      ],
```
```
    },
```
```
    {
```

      code: "if (typeof obj === 'string' && obj.length) {} else {'' + obj}",

```
      errors: [
```
```
        {
```

          message: missingDevCheckMessage + '\n' + message,

```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: `
```

          if (__D__) { checkFormFieldValueStringCoercion (obj) }

```
          '' + obj;
```
```
        `,
```
```
      errors: [
```
```
        {
```

          message: prevStatementNotDevCheckMessage + '\n' + message,

```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: `
```

          if (__DEV__) { checkFormFieldValueStringCoercion (obj) }

```
          '' + notobjj;
```
```
        `,
```
```
      errors: [
```
```
        {
```
```
          message:
```

            'Value passed to the check function before this coercion must match the value being coerced.' +

```
            '\n' +
```
```
            message,
```
```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: `
```

          if (__DEV__) { checkFormFieldValueStringCoercion (obj) }

          // must be right before the check call

```
          someOtherCode();
```
```
          '' + objj;
```
```
        `,
```
```
      errors: [
```
```
        {
```

          message: prevStatementNotDevCheckMessage + '\n' + message,

```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: `
```

          if (__DEV__) { chexxxxBadNameCoercion (obj) }

```
          '' + objj;
```
```
        `,
```
```
      errors: [
```
```
        {
```
```
          message:
```

            'Missing or invalid check function call before this coercion.' +

            ' Expected: call of a function like checkXXXStringCoercion. ' +

            prevStatementNotDevCheckMessage +

```
            '\n' +
```
```
            message,
```
```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: `
```
```
          if (__DEV__) {  }
```
```
          '' + objj;
```
```
        `,
```
```
      errors: [
```
```
        {
```

          message: prevStatementNotDevCheckMessage + '\n' + message,

```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: `
```
```
          if (__DEV__) { if (x) {} }
```
```
          '' + objj;
```
```
        `,
```
```
      errors: [
```
```
        {
```
```
          message:
```

            'The DEV block before this coercion must only contain an expression. ' +

            prevStatementNotDevCheckMessage +

```
            '\n' +
```
```
            message,
```
```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: `
```
```
        if (a) {
```
```
          if (__DEV__) {
```

            // can't have additional code before the check call

```
            if (b) {
```

              checkKeyStringCoercion(obj);

```
            }
```
```
          }
```

          g = f( c, d + (b ? '' + obj : '') + e);

```
        }
```
```
      `,
```
```
      errors: [
```
```
        {
```
```
          message:
```

            'The DEV block before this coercion must only contain an expression. ' +

            prevStatementNotDevCheckMessage +

```
            '\n' +
```
```
            message,
```
```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: `
```
```
        if (__DEV__) {
```

          checkAttributeStringCoercion(expected, name);

```
        }
```

        // DEV check should be inside the if block

```
        if (a && b) {
```
```
          f('' + expected);
```
```
        }
```
```
      `,
```
```
      errors: [
```
```
        {
```

          message: missingDevCheckMessage + '\n' + message,

```
        },
```
```
      ],
```
```
    },
```
```
    {
```
```
      code: `'' + obj + ''`,
```
```
      errors: [
```

        {message: missingDevCheckMessage + '\n' + message},

        {message: missingDevCheckMessage + '\n' + message},

```
      ],
```
```
    },
```
```
    {
```
```
      code: `foo\`text\` + ""`,
```

      errors: [{message: missingDevCheckMessage + '\n' + message}],

```
    },
```
```
  ],
```
```
});
```