@hs-web-team/eslint-config-node 5.1.1 → 5.2.0

package/README.md

@@ -180,6 +180,17 @@ This package includes a shared accessibility testing setup using [cypress-axe](h
 
 `cy.checkAccessibility()` adds the `high-contrast` class to `body`, runs WCAG 2.2 Level AA rules only, and logs each violation with its id, help text, impact, element targets, and help URL. TypeScript types are included — no `tsconfig.json` changes required.
 
+## Cloudflare 429 handling (optional, Cucumber suites)
+
+For Cypress + Cucumber suites hitting Cloudflare-fronted endpoints, opt in to shared handling of Cloudflare `429` rate-limit responses: stop retrying a 429'd test, skip the rest of a Scenario Outline whose example 429'd, and tag the failure with a `[RATE-LIMIT-429]` marker. Add one import inside your `stepDefinitions` glob (not `support/e2e.js`):
+
+```js
+// cypress/support/step_definitions/rate-limit-429.js  (or .ts)
+import '@hs-web-team/eslint-config-node/cypress/rate-limit-429';
+```
+
+For how it works and how to verify it with a mocked 429, see [examples/cypress-usage.md](./examples/cypress-usage.md#cloudflare-429-handling-cucumber-suites).
+
 ## Custom Rules
 
 This package ships a `hs-web-team` ESLint plugin with custom rules that are active automatically when you use `wtConfig` or `wtBrowserConfig` — no extra setup needed.
@@ -200,6 +211,7 @@ This package provides multiple configurations:
 - **Stylelint configuration** (`.stylelintrc.json` export): For SCSS/CSS linting
 - **Cypress configuration** (`cypress.config` export): For E2E testing with Cypress
 - **Accessibility testing** (`/cypress` export): Opt-in cypress-axe setup with WCAG 2.2 AA checks
+- **Cloudflare 429 handling** (`/cypress/rate-limit-429` export): Opt-in Cucumber handling of rate-limit 429s
 - **Prettier configuration** (`.prettierrc.json` export): For code formatting
 
 Choose the appropriate configurations based on your project needs.

package/cypress/rate-limit-429.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="cypress" />
+
+// Side-effect-only module: importing it registers the Cloudflare-429 Cypress/Cucumber hooks.
+// There are no exported bindings — this declaration just makes the bare import resolvable in
+// TypeScript consumers:
+//
+//   import '@hs-web-team/eslint-config-node/cypress/rate-limit-429';
+
+export {};

package/cypress/rate-limit-429.js

@@ -0,0 +1,99 @@
+import { Before } from '@badeball/cypress-cucumber-preprocessor';
+
+// All Cloudflare-429 handling lives in one file so the three hooks share plain module state.
+// Usage & setup: see examples/cypress-usage.md. In short: import this (side-effect only) from a
+// file in your `stepDefinitions` glob, NOT the support file — the cucumber Before() hook
+// (outline-skip) only registers against the step-def bundle's global registry, so importing from
+// support/e2e.js throws "Expected to find a global registry ...".
+//
+// Using Mocha's afterEach (NOT cucumber After()) is deliberate: the preprocessor's After() does
+// NOT run when a scenario fails, and a 429 fails the scenario, so After() could never react to it.
+// https://github.com/badeball/cypress-cucumber-preprocessor/blob/master/docs/cucumber-basics.md#hooks
+
+/** @typedef {{ url: string, ray: string | string[], at: string }} RateLimit429Hit */
+
+// Shared across a feature's scenarios; resets between spec files (so nothing leaks between features).
+/** @type {RateLimit429Hit | null} */
+let rateLimit429Hit = null;
+/** @type {string | null} */
+let currentOutline = null;
+/** @type {string | null} */
+let rateLimited429Outline = null;
+
+// cy.state('runnable') is an internal API
+const currentRunnable = () => cy.state('runnable');
+
+// Cypress decides whether to requeue a failed test before afterEach runs, so a 429'd test's
+// retries must be cancelled here, during the test.
+const disableRetriesForCurrentTest = () => {
+  const runnable = currentRunnable();
+  if (!runnable) {
+    return;
+  }
+  /* eslint-disable no-underscore-dangle */
+  const attempt = runnable._currentRetry ?? 0;
+  // Pin both; Cypress re-expands _retries from _maxRetries otherwise.
+  runnable._retries = attempt;
+  runnable._maxRetries = attempt;
+  /* eslint-enable no-underscore-dangle */
+};
+
+beforeEach(() => {
+  rateLimit429Hit = null; // to ensure each scenario starts clean, in case a previous afterEach was skipped
+
+  // Observe every response (middleware:true never modifies). Genuine Cloudflare 429s
+  // carry a cf-ray header; third-party 429s (Google c2dm, pixels, etc.) don't, so ignore
+  // those — otherwise we'd wrongly disable retries / skip an outline. Gate on the header,
+  // not the host, since the suite may hit several Cloudflare-fronted hosts.
+  cy.intercept({ url: '**/*', middleware: true }, req => {
+    req.on('response', res => {
+      const ray = res.headers['cf-ray'];
+      if (res.statusCode === 429 && ray) {
+        rateLimit429Hit = { url: req.url, ray, at: new Date().toISOString() };
+        disableRetriesForCurrentTest();
+      }
+    });
+  });
+});
+
+afterEach(function () {
+  const hit = rateLimit429Hit;
+  rateLimit429Hit = null;
+  if (!hit) {
+    return;
+  }
+
+  const test = this.currentTest;
+
+  // If this example failed on the 429, record its outline so the Before hook below skips the
+  // outline's remaining examples — they hit the same blocked endpoint and would 429 too.
+  if (test?.state === 'failed') {
+    rateLimited429Outline = currentOutline;
+  }
+
+  // Don't throw here — an afterEach throw skips the rest of the spec.
+  const marker =
+    `[RATE-LIMIT-429] Cloudflare 429 rate limit (IP blocked ~10 min). ` +
+    `Retries disabled for this test. at=${hit.at} url=${hit.url} cf-ray=${hit.ray}`;
+
+  if (test?.err) {
+    test.err.message = `${marker}\n\n${test.err.message}`;
+  } else {
+    Cypress.log({ name: '429', message: marker });
+  }
+});
+
+// A 429 blocks the IP ~10 min, so every later example of the same Scenario Outline would 429
+// too. Identify the outline by pickle.astNodeIds[0] (the outline node, identical across its
+// rows — the title can't be used, it interpolates the example values). Record the 429'd
+// example's outline, skip the rest; any other scenario clears it.
+Before(({ pickle }) => {
+  currentOutline = pickle.astNodeIds?.[0] ?? null;
+  if (rateLimited429Outline) {
+    if (currentOutline === rateLimited429Outline) {
+      return 'skipped';
+    }
+    rateLimited429Outline = null;
+  }
+  return undefined;
+});

package/cypress.config.cjs

@@ -38,6 +38,9 @@ const getRootDir = currDir => {
  *   or `null` if this is not the dev environment or no such property exists.
  */
 const getDevBaseUrl = () => {
+  // Skip the DEV portal lookup in CI; Jenkins runs as `jenkins_lt`.
+  if (process.env.LT_USERNAME === 'jenkins_lt') return null;
+
   try {
     const root = getRootDir(__dirname);
     if (!root) return null;

package/examples/cypress-usage.md

@@ -115,6 +115,59 @@ regression:
       url: https://prod.example.com
 ```
 
+## Cloudflare 429 handling (Cucumber suites)
+
+For Cypress + Cucumber suites that hit Cloudflare-fronted endpoints, this package ships an
+opt-in handler for Cloudflare `429` rate-limit responses. A Cloudflare 429 is a ~10-minute
+IP block, so a retry can't pass — it just burns the limited request budget. The handler:
+
+- **Stops retrying** a test that fails on a Cloudflare 429 (it still fails once; every other
+  failure retries per your `retries` config, and sibling tests are unaffected).
+- **Skips the remaining examples of a Scenario Outline** once one example hits a 429 — the
+  other rows target the same blocked endpoint, so they're marked pending instead of run.
+- **Tags the failure** with a searchable `[RATE-LIMIT-429]` marker (timestamp, URL, `cf-ray`)
+  on the test error, without ever throwing from the hook.
+
+Detection is gated on Cloudflare's `cf-ray` response header, so unrelated third-party 429s
+(pixels, analytics, etc.) don't trigger it.
+
+### Enabling it
+
+Add **one file inside your `stepDefinitions` glob** (commonly
+`cypress/support/step_definitions/`). JavaScript projects name it `.js`, TypeScript projects
+name it `.ts` — the contents are identical:
+
+```js
+// cypress/support/step_definitions/rate-limit-429.js  (or .ts)
+import '@hs-web-team/eslint-config-node/cypress/rate-limit-429';
+```
+
+That single side-effect import registers everything. No config, `setupNodeEvents`, or
+dependency changes are needed — `@badeball/cypress-cucumber-preprocessor` is already a peer
+dependency your suite satisfies.
+
+> **It must live in a step-definitions file, not `cypress/support/e2e.js`.** The handler
+> registers a Cucumber `Before` hook (for the outline-skip), and the preprocessor only exposes
+> its hook registry while bundling step-definition files. Importing from the support file
+> throws `Expected to find a global registry ...`.
+
+### Verifying it with a mocked 429
+
+Real Cloudflare 429s are intermittent, so to confirm the handler fires, force one in a
+throwaway/smoke spec with a **dynamic-reply** intercept — point it at a request the page
+actually makes (a browser `fetch`/XHR, not `cy.request`):
+
+```js
+cy.intercept('GET', '**/your-endpoint', req =>
+  req.reply({ statusCode: 429, headers: { 'cf-ray': 'mock-cf-ray-123' } }),
+);
+```
+
+The handler's `**/*` middleware intercept runs first and observes the response, so the test
+fails once (no retry), carries the `[RATE-LIMIT-429]` marker, and — in a Scenario Outline —
+the remaining examples are skipped. Use a dynamic `req.reply(...)`, not a static stub object:
+a static stub doesn't reliably drive the response lifecycle the middleware observes.
+
 ## Customizing Configuration
 
 ### Add Custom setupNodeEvents

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hs-web-team/eslint-config-node",
-  "version": "5.1.1",
+  "version": "5.2.0",
   "description": "HubSpot Marketing WebTeam shared configurations for ESLint, Prettier, Stylelint, and Cypress",
   "files": [
     ".prettierrc.json",
@@ -33,6 +33,10 @@
       "types": "./cypress/index.d.ts",
       "default": "./cypress/index.js"
     },
+    "./cypress/rate-limit-429": {
+      "types": "./cypress/rate-limit-429.d.ts",
+      "default": "./cypress/rate-limit-429.js"
+    },
     "./plugin": "./plugins/hs-web-team/index.js",
     "./gherkin/.gplintrc": "./gherkin/.gplintrc",
     "./gherkin/coverage-config": "./gherkin/coverage-config.js"
@@ -44,6 +48,9 @@
       ],
       "cypress": [
         "./cypress/index.d.ts"
+      ],
+      "cypress/rate-limit-429": [
+        "./cypress/rate-limit-429.d.ts"
       ]
     }
   },

package/plugins/hs-web-team/rules/no-abbreviations.js

@@ -1,5 +1,17 @@
 const DEFAULT_EXCEPTIONS = new Set(['e', '_']);
 const DEFAULT_MIN_LENGTH = 2;
+const DEFAULT_DISALLOWED_NAMES = new Set([
+  'cfg',
+  'btn',
+  'msg',
+  'tmp',
+  'idx',
+  'val',
+  'str',
+  'obj',
+  'arr',
+  'evt',
+]);
 
 const SORT_METHODS = new Set(['sort', 'toSorted']);
 const ARRAY_ITERATION_METHODS = new Set([
@@ -66,6 +78,7 @@ export const noAbbreviations = {
     messages: {
       tooShort:
         'Identifier "{{name}}" is too short ({{length}} < {{min}}). Use a descriptive name.',
+      disallowed: 'Identifier "{{name}}" is a known abbreviation. Use a descriptive name.',
     },
     schema: [
       {
@@ -73,6 +86,7 @@ export const noAbbreviations = {
         properties: {
           exceptions: { type: 'array', items: { type: 'string' }, uniqueItems: true },
           minLength: { type: 'integer', minimum: 1 },
+          disallowedNames: { type: 'array', items: { type: 'string' }, uniqueItems: true },
         },
         additionalProperties: false,
       },
@@ -83,13 +97,17 @@ export const noAbbreviations = {
     const options = context.options[0] ?? {};
     const exceptions = new Set([...DEFAULT_EXCEPTIONS, ...(options.exceptions ?? [])]);
     const minLength = options.minLength ?? DEFAULT_MIN_LENGTH;
+    const disallowedNames = new Set([
+      ...DEFAULT_DISALLOWED_NAMES,
+      ...(options.disallowedNames ?? []),
+    ]);
 
     return {
       Identifier(node) {
         const { name, parent } = node;
 
-        if (name.length >= minLength) return;
         if (exceptions.has(name)) return;
+        if ((name.length >= minLength) && !disallowedNames.has(name)) return;
 
         // Only flag declaration sites — not usage sites.
         //
@@ -124,11 +142,16 @@ export const noAbbreviations = {
           isCallbackToMethod(parent, ARRAY_ITERATION_METHODS)
         ) return;
 
-        context.report({
-          node,
-          messageId: 'tooShort',
-          data: { name, length: name.length, min: minLength },
-        });
+        if (name.length < minLength) {
+          context.report({
+            node,
+            messageId: 'tooShort',
+            data: { name, length: name.length, min: minLength },
+          });
+          return;
+        }
+
+        context.report({ node, messageId: 'disallowed', data: { name } });
       },
     };
   },