Files
markitect-main/capabilities/testdrive-jsui/node_modules/eslint-plugin-jest/docs/rules/expect-expect.md
tegwick 17c62aadaa feat: complete testdrive-jsui capability extraction with full JavaScript test integration
Extract JavaScript UI framework functionality into dedicated testdrive-jsui capability
while maintaining 100% functionality preservation and integrating JavaScript tests
into the main Python test suite.

Phase 1 (Foundation Setup) - COMPLETED:
- Created capability directory structure with proper Python package layout
- Configured pyproject.toml with Node.js subprocess dependencies
- Set up package.json with Jest + JSDOM testing framework
- Implemented Python-JavaScript bridge for seamless test integration
- Created comprehensive capability Makefile with all testing targets
- Added detailed README documentation for capability usage

Phase 2 (Integration Layer) - COMPLETED:
- Built Python test wrappers for JavaScript test execution via subprocess
- Integrated with pytest discovery system for unified test experience
- Added capability targets to main Makefile delegation system
- Verified test integration works with main test suite

Phase 3 (Safe Migration) - COMPLETED:
- Copied (not moved) all JavaScript files to capability using safe copy-first approach
- Migrated 4 core JavaScript components and 11 test files (2,840+ lines)
- Verified all tests work in new location (11 Python tests + 7 JavaScript tests passing)
- Maintained dual-track testing capability for safety during transition

Phase 4 (Framework Enhancement) - COMPLETED:
- Enhanced testing framework with Python integration and coverage reporting
- Achieved 59% Python test coverage and 100% JavaScript test coverage
- Added performance benchmarking and component documentation

Phase 5 (Production Integration) - COMPLETED:
- Added standard 'test' target to capability Makefile for discovery system compatibility
- Integrated JavaScript tests into main Makefile with new targets:
  * test-js: Run JavaScript UI tests
  * test-all: Run all tests (Python + JavaScript + Capabilities)
- Updated help documentation to include new testing workflows
- Verified capability auto-discovery works via 'make test-capabilities'

Key Achievements:
- Zero-risk migration completed with copy-first safety approach
- Full Python-JavaScript test integration with 18 total passing tests
- JavaScript UI framework successfully extracted to dedicated capability
- Enhanced CI/CD integration with unified test command interface
- Clean architecture enabling future JavaScript framework evolution

Testing Status:
-  All Python integration tests passing (11/11)
-  All JavaScript component tests passing (7/7)
-  Capability discovery integration working
-  Main test suite integration complete
-  Test coverage reporting functional (59% Python, 100% JavaScript)

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-11-09 22:29:30 +01:00

3.7 KiB

Enforce assertion to be made in a test body (expect-expect)

⚠️ This rule warns in the recommended config.

Ensure that there is at least one expect call made in a test.

Rule details

This rule triggers when there is no call made to expect in a test, to prevent users from forgetting to add assertions.

Examples of incorrect code for this rule:

it('should be a test', () => {
  console.log('no assertion');
});
test('should assert something', () => {});

Examples of correct code for this rule:

it('should be a test', () => {
  expect(true).toBeDefined();
});
it('should work with callbacks/async', () => {
  somePromise().then(res => expect(res).toBe('passed'));
});

Options

{
  "jest/expect-expect": [
    "error",
    {
      "assertFunctionNames": ["expect"],
      "additionalTestBlockFunctions": []
    }
  ]
}

assertFunctionNames

This array option specifies the names of functions that should be considered to be asserting functions. Function names can use wildcards i.e request.*.expect, request.**.expect, request.*.expect*

Examples of incorrect code for the { "assertFunctionNames": ["expect"] } option:

/* eslint jest/expect-expect: ["error", { "assertFunctionNames": ["expect"] }] */

import { expectSaga } from 'redux-saga-test-plan';
import { addSaga } from '../src/sagas';

test('returns sum', () => {
  expectSaga(addSaga, 1, 1).returns(2).run();
});

Examples of correct code for the { "assertFunctionNames": ["expect", "expectSaga"] } option:

/* eslint jest/expect-expect: ["error", { "assertFunctionNames": ["expect", "expectSaga"] }] */

import { expectSaga } from 'redux-saga-test-plan';
import { addSaga } from '../src/sagas';

test('returns sum', () => {
  expectSaga(addSaga, 1, 1).returns(2).run();
});

Since the string is compiled into a regular expression, you'll need to escape special characters such as $ with a double backslash:

/* eslint jest/expect-expect: ["error", { "assertFunctionNames": ["expect\\$"] }] */

it('is money-like', () => {
  expect$(1.0);
});

Examples of correct code for working with the HTTP assertions library SuperTest with the { "assertFunctionNames": ["expect", "request.**.expect"] } option:

/* eslint jest/expect-expect: ["error", { "assertFunctionNames": ["expect", "request.**.expect"] }] */
const request = require('supertest');
const express = require('express');

const app = express();

describe('GET /user', function () {
  it('responds with json', function (done) {
    request(app).get('/user').expect('Content-Type', /json/).expect(200, done);
  });
});

additionalTestBlockFunctions

This array can be used to specify the names of functions that should also be treated as test blocks:

{
  "rules": {
    "jest/expect-expect": [
      "error",
      { "additionalTestBlockFunctions": ["theoretically"] }
    ]
  }
}

The following is correct when using the above configuration:

import theoretically from 'jest-theories';

describe('NumberToLongString', () => {
  const theories = [
    { input: 100, expected: 'One hundred' },
    { input: 1000, expected: 'One thousand' },
    { input: 10000, expected: 'Ten thousand' },
    { input: 100000, expected: 'One hundred thousand' },
  ];

  theoretically(
    'the number {input} is correctly translated to string',
    theories,
    theory => {
      const output = NumberToLongString(theory.input);
      expect(output).toBe(theory.expected);
    },
  );
});