@vitest/expect 2.1.9: ObjectContaining

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify @vitest/expect.ObjectContaining in pkg:npm/%40vitest/expect@2.1.9
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/%40vitest/expect@2.1.9
Demonstrate these symbols/APIs:
  - @vitest/expect.ObjectContaining

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:8ac7290cf61955ec05bad3c1a50ae6f4b0d213834971c2db84c82d3e9aa6200e","contract":["assert ObjectContaining constructor creates an asymmetric matcher instance with sample and inverse properties","assert ObjectContaining matches objects containing all expected properties regardless of extra properties","assert ObjectContaining rejects objects missing expected properties or having mismatched property values","assert ObjectContaining rejects non-object values including primitives, null, and undefined","assert ObjectContaining with inverse flag inverts match results via ObjectNotContaining","assert ObjectContaining supports nested asymmetric matchers and integrates with equals"],"goal":"verify @vitest/expect.ObjectContaining in pkg:npm/%40vitest/expect@2.1.9","kind":"HOW","packages":["pkg:npm/%40vitest/expect@2.1.9"],"schemaVersion":1,"symbols":["@vitest/expect.ObjectContaining"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/%40vitest/expect@2.1.9"],"schemaVersion":1,"subject":"pkg:npm/%40vitest/expect@2.1.9","symbols":["@vitest/expect.ObjectContaining"],"verifierAdapter":"node-typescript@1"}

import { ObjectContaining, equals } from '@vitest/expect';

/**
 * Creates an ObjectContaining asymmetric matcher instance.
 *
 * @param {Record<string, unknown>} sample - Expected properties and values.
 * @param {boolean} [inverse=false] - Whether to invert the matching logic.
 * @returns {ObjectContaining} The asymmetric matcher instance.
 */
export function createObjectContaining(sample, inverse = false) {
  return new ObjectContaining(sample, inverse);
}

/**
 * Evaluates whether a received value satisfies the ObjectContaining condition.
 *
 * @param {unknown} received - The value under test.
 * @param {Record<string, unknown>} sample - Expected subset of properties.
 * @param {boolean} [inverse=false] - Whether to invert the matching logic.
 * @returns {boolean} True if the matching condition passes.
 */
export function matchesObjectContaining(received, sample, inverse = false) {
  const matcher = new ObjectContaining(sample, inverse);
  return matcher.asymmetricMatch(received);
}

/**
 * Evaluates structural equality using asymmetric matchers with @vitest/expect equals.
 *
 * @param {unknown} actual - The actual data structure.
 * @param {unknown} expected - The expected data structure containing asymmetric matchers.
 * @returns {boolean} True if values match structurally.
 */
export function matchStructure(actual, expected) {
  return equals(actual, expected);
}

export { ObjectContaining, equals };

{
  "name": "sample-vitest-expect-object-containing",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-vitest-expect-object-containing",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "@vitest/expect": "2.1.9"
      }
    },
    "node_modules/@vitest/expect": {
      "version": "2.1.9",
      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.9.tgz",
      "integrity": "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==",
      "license": "MIT",
      "dependencies": {
        "@vitest/spy": "2.1.9",
        "@vitest/utils": "2.1.9",
        "chai": "^5.1.2",
        "tinyrainbow": "^1.2.0"
      },
      "funding": {
        "url": "https://opencollective.com/vitest"
      }
    },
    "node_modules/@vitest/pretty-format": {
      "version": "2.1.9",
      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",
      "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",
      "license": "MIT",
      "dependencies": {
        "tinyrainbow": "^1.2.0"
      },
      "funding": {
        "url": "https://opencollective.com/vitest"
      }
    },
    "node_modules/@vitest/spy": {
      "version": "2.1.9",
      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.9.tgz",
      "integrity": "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==",
      "license": "MIT",
      "dependencies": {
        "tinyspy": "^3.0.2"
      },
      "funding": {
        "url": "https://opencollective.com/vitest"
      }
    },
    "node_modules/@vitest/utils": {
      "version": "2.1.9",
      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.9.tgz",
      "integrity": "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==",
      "license": "MIT",
      "dependencies": {
        "@vitest/pretty-format": "2.1.9",
        "loupe": "^3.1.2",
        "tinyrainbow": "^1.2.0"
      },
      "funding": {
        "url": "https://opencollective.com/vitest"
      }
    },
    "node_modules/assertion-error": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
      "license": "MIT",
      "engines": {
        "node": ">=12"
      }
    },
    "node_modules/chai": {
      "version": "5.3.3",
      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
      "license": "MIT",
      "dependencies": {
        "assertion-error": "^2.0.1",
        "check-error": "^2.1.1",
        "deep-eql": "^5.0.1",
        "loupe": "^3.1.0",
        "pathval": "^2.0.0"
      },
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/check-error": {
      "version": "2.1.3",
      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",
      "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",
      "license": "MIT",
      "engines": {
        "node": ">= 16"
      }
    },
    "node_modules/deep-eql": {
      "version": "5.0.2",
      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/loupe": {
      "version": "3.2.1",
      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
      "license": "MIT"
    },
    "node_modules/pathval": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
      "license": "MIT",
      "engines": {
        "node": ">= 14.16"
      }
    },
    "node_modules/tinyrainbow": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",
      "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",
      "license": "MIT",
      "engines": {
        "node": ">=14.0.0"
      }
    },
    "node_modules/tinyspy": {
      "version": "3.0.2",
      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",
      "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",
      "license": "MIT",
      "engines": {
        "node": ">=14.0.0"
      }
    }
  }
}

{
  "name": "sample-vitest-expect-object-containing",
  "version": "1.0.0",
  "description": "Clean-room verification sample for @vitest/expect ObjectContaining asymmetric matcher",
  "type": "module",
  "main": "index.mjs",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "license": "MIT-0",
  "dependencies": {
    "@vitest/expect": "2.1.9"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify @vitest/expect.ObjectContaining in pkg:npm/%40vitest/expect@2.1.9",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40vitest/expect@2.1.9"
  ],
  "symbols": [
    "@vitest/expect.ObjectContaining"
  ]
}

import assert from 'node:assert/strict';
import {
  ObjectContaining,
  equals,
  createObjectContaining,
  matchesObjectContaining,
  matchStructure,
} from '../index.mjs';
import { Any, ArrayContaining, StringMatching } from '@vitest/expect';

async function runContract() {
  // 1. assert ObjectContaining constructor creates an asymmetric matcher instance with sample and inverse properties
  const matcher = createObjectContaining({ id: 1, name: 'item' });
  assert.strictEqual(matcher instanceof ObjectContaining, true);
  assert.strictEqual(matcher.toString(), 'ObjectContaining');
  assert.strictEqual(matcher.getExpectedType(), 'object');
  assert.deepStrictEqual(matcher.sample, { id: 1, name: 'item' });
  assert.strictEqual(matcher.inverse, false);

  const invMatcher = createObjectContaining({ id: 1 }, true);
  assert.strictEqual(invMatcher instanceof ObjectContaining, true);
  assert.strictEqual(invMatcher.toString(), 'ObjectNotContaining');
  assert.strictEqual(invMatcher.inverse, true);

  // 2. assert ObjectContaining matches objects containing all expected properties regardless of extra properties
  assert.strictEqual(matcher.asymmetricMatch({ id: 1, name: 'item' }), true);
  assert.strictEqual(matcher.asymmetricMatch({ id: 1, name: 'item', extra: 'ignored', count: 5 }), true);
  assert.strictEqual(matchesObjectContaining({ id: 1, name: 'item', extra: true }, { id: 1, name: 'item' }), true);

  // Empty expected object matches any object
  const emptyMatcher = new ObjectContaining({});
  assert.strictEqual(emptyMatcher.asymmetricMatch({}), true);
  assert.strictEqual(emptyMatcher.asymmetricMatch({ anything: 'goes' }), true);

  // 3. assert ObjectContaining rejects objects missing expected properties or having mismatched property values
  assert.strictEqual(matcher.asymmetricMatch({ id: 1 }), false);
  assert.strictEqual(matcher.asymmetricMatch({ id: 1, name: 'mismatch' }), false);
  assert.strictEqual(matcher.asymmetricMatch({ name: 'item' }), false);
  assert.strictEqual(matcher.asymmetricMatch({}), false);
  assert.strictEqual(matchesObjectContaining({ id: 2 }, { id: 1 }), false);

  // 4. assert ObjectContaining rejects non-object values including primitives, null, and undefined
  assert.strictEqual(matcher.asymmetricMatch(null), false);
  assert.strictEqual(matcher.asymmetricMatch(undefined), false);
  assert.strictEqual(matcher.asymmetricMatch(123), false);
  assert.strictEqual(matcher.asymmetricMatch('id: 1, name: item'), false);
  assert.strictEqual(matcher.asymmetricMatch(true), false);
  assert.strictEqual(matcher.asymmetricMatch(Symbol('sample')), false);

  // 5. assert ObjectContaining with inverse flag inverts match results via ObjectNotContaining
  assert.strictEqual(invMatcher.toString(), 'ObjectNotContaining');
  assert.strictEqual(invMatcher.asymmetricMatch({ id: 1, name: 'item' }), false);
  assert.strictEqual(invMatcher.asymmetricMatch({ id: 2, name: 'item' }), true);
  assert.strictEqual(invMatcher.asymmetricMatch({ name: 'item' }), true);
  assert.strictEqual(invMatcher.asymmetricMatch(null), true);
  assert.strictEqual(invMatcher.asymmetricMatch('not-an-object'), true);
  assert.strictEqual(matchesObjectContaining({ id: 2 }, { id: 1 }, true), true);
  assert.strictEqual(matchesObjectContaining({ id: 1, extra: 2 }, { id: 1 }, true), false);

  // 6. assert ObjectContaining supports nested asymmetric matchers and integrates with equals
  const nestedMatcher = new ObjectContaining({
    id: new Any(Number),
    tags: new ArrayContaining(['alpha']),
    label: new StringMatching(/^prod-/),
  });
  assert.strictEqual(
    nestedMatcher.asymmetricMatch({
      id: 999,
      tags: ['beta', 'alpha'],
      label: 'prod-api-server',
      version: 2,
    }),
    true
  );
  assert.strictEqual(
    nestedMatcher.asymmetricMatch({
      id: '999',
      tags: ['alpha'],
      label: 'prod-api-server',
    }),
    false
  );
  assert.strictEqual(
    nestedMatcher.asymmetricMatch({
      id: 999,
      tags: ['beta'],
      label: 'prod-api-server',
    }),
    false
  );

  const payload = {
    status: 200,
    data: {
      userId: 42,
      profile: { role: 'admin', team: 'infra' },
    },
  };
  const expectedStructure = {
    status: 200,
    data: new ObjectContaining({
      userId: 42,
      profile: new ObjectContaining({ role: 'admin' }),
    }),
  };
  assert.strictEqual(matchStructure(payload, expectedStructure), true);
  assert.strictEqual(equals(payload, expectedStructure), true);

  const mismatchedPayload = {
    status: 200,
    data: {
      userId: 42,
      profile: { role: 'viewer', team: 'infra' },
    },
  };
  assert.strictEqual(equals(mismatchedPayload, expectedStructure), false);

  console.log('Contract assertions passed successfully.');
}

runContract().catch((err) => {
  console.error('Contract test failed:', err);
  process.exit(1);
});