KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use toContainAllKeys method in jest-extended

Best JavaScript code snippet using jest-extended

chain.test.js

Source:chain.test.js

...22      toBe: noop,23      toEqual: noop,24    }));25    const actual = chain(expectMock)("hello");26    expect(actual).toContainAllKeys(["toBe", "toEqual"]);27  });28  it("returns an object with identical nested keys as given expect when proxy expect is invoked", () => {29    const expectMock = jest.fn(() => ({30      toBe: noop,31      toEqual: noop,32      not: {33        toBe: noop,34        toEqual: noop,35      },36    }));37    const actual = chain(expectMock)("hello");38    expect(actual.not).toContainAllKeys(["toBe", "toEqual"]);39  });40  it("calls original matcher when invoked", () => {41    const matcherMock = jest.fn();42    const expectMock = jest.fn(() => ({43      toBe: matcherMock,44    }));45    chain(expectMock)("hello").toBe("world");46    expect(matcherMock).toHaveBeenCalledTimes(1);47    expect(matcherMock).toHaveBeenCalledWith("world");48  });49  it("returns matchers when matcher is invoked", () => {50    const expectMock = jest.fn(() => ({51      toBe: noop,52      toEqual: noop,53    }));54    const actual = chain(expectMock)("hello").toBe("world");55    expect(actual).toContainAllKeys(["toBe", "toEqual"]);56  });57  it("calls original matcher functions when matchers are chained", () => {58    const toBe = jest.fn();59    const toEqual = jest.fn();60    const expectMock = jest.fn(() => ({61      toBe,62      toEqual,63    }));64    chain(expectMock)("hello").toBe("foo").toEqual("bar").toBe("baz");65    expect(toBe).toHaveBeenCalledTimes(2);66    expect(toBe).toHaveBeenCalledWith("foo");67    expect(toBe).toHaveBeenCalledWith("baz");68    expect(toEqual).toHaveBeenCalledTimes(1);69    expect(toEqual).toHaveBeenCalledWith("bar");70  });71  it("calls original nested matcher when invoked", () => {72    const matcherMock = jest.fn();73    const expectMock = jest.fn(() => ({74      toBe: noop,75      not: {76        toBe: matcherMock,77      },78    }));79    chain(expectMock)("hello").not.toBe("world");80    expect(matcherMock).toHaveBeenCalledTimes(1);81    expect(matcherMock).toHaveBeenCalledWith("world");82  });83  it("returns matchers when nested matcher is invoked", () => {84    const expectMock = jest.fn(() => ({85      toBe: noop,86      not: {87        toBe: noop,88      },89    }));90    const actual = chain(expectMock)("hello").not.toBe("world");91    expect(actual).toContainAllKeys(["toBe", "not"]);92    expect(actual.not).toContainAllKeys(["toBe"]);93  });94  it("calls original matcher functions when nested matchers are chained", () => {95    const toBe = jest.fn();96    const toEqual = jest.fn();97    const notToBe = jest.fn();98    const notToEqual = jest.fn();99    const expectMock = jest.fn(() => ({100      toBe,101      toEqual,102      not: {103        toBe: notToBe,104        toEqual: notToEqual,105      },106    }));107    chain(expectMock)("hello")108      .not.toBe("not foo")109      .toBe("foo")110      .not.toEqual("not bar")111      .toEqual("bar")112      .toBe("baz")113      .not.toBe("not baz");114    expect(toBe).toHaveBeenCalledTimes(2);115    expect(toBe).toHaveBeenCalledWith("foo");116    expect(toBe).toHaveBeenCalledWith("baz");117    expect(toEqual).toHaveBeenCalledTimes(1);118    expect(toEqual).toHaveBeenCalledWith("bar");119    expect(notToBe).toHaveBeenCalledTimes(2);120    expect(notToBe).toHaveBeenCalledWith("not foo");121    expect(notToBe).toHaveBeenCalledWith("not baz");122    expect(notToEqual).toHaveBeenCalledTimes(1);123    expect(notToEqual).toHaveBeenCalledWith("not bar");124  });125  it("calls original expect.extend when custom matcher is registered", () => {126    const extendMock = jest.fn();127    const expectMock = jest.fn();128    expectMock.extend = extendMock;129    const newMatcher = { newMatcher: "woo" };130    chain(expectMock).extend(newMatcher);131    expect(extendMock).toHaveBeenCalledTimes(1);132    expect(extendMock).toHaveBeenCalledWith(newMatcher);133  });134  it("sets new asymmetric matchers when custom matcher is registered with expect.extend", () => {135    const expectMock = () => {};136    const extendMock = jest.fn((o) => Object.assign(expectMock, o));137    expectMock.a = "a";138    expectMock.extend = extendMock;139    const newMatcher = { newMatcher: "woo" };140    const actual = chain(expectMock);141    expect(actual).toContainAllKeys(["a", "extend"]);142    actual.extend(newMatcher);143    expect(extendMock).toHaveBeenCalledTimes(1);144    expect(extendMock).toHaveBeenCalledWith(newMatcher);145    expect(actual).toContainAllKeys(["a", "extend", "newMatcher"]);146  });147  it("throws error when matcher fails", () => {148    expect.assertions(1);149    const expectMock = jest.fn(() => ({150      toBe: () => {151        const error = new Error("");152        error.matcherResult = { message: "blah", pass: false };153        throw error;154      },155    }));156    expect(() => chain(expectMock)("hello").toBe("hi")).toThrowErrorMatchingInlineSnapshot('"blah"');157  });158  it("throws `matcherResult` message when it is a function", () => {159    expect.assertions(1);...

auth.test.js

Source:auth.test.js

...19      .end((err, res) => {20        if (err) throw err21        const { status, body } = res;22        expect(status).toBe(201)23        expect(body).toContainAllKeys(RESPONSE_PROPERTIES)24        expect(body.payload.user).toContainAllKeys(["id", "username", "points", "email"])25        expect(body.payload.user.username).toBe(newUser.username)26        expect(body.payload.user.email).toBe(newUser.email)27        expect(body.payload.user.points).toBe(0)28        expect(body.error).toBe(false)29        done();30      })31  })32  it('Should not allow the registration/sign-up of a user with a username already taken', (done) => {33    expect.assertions(4)34    const newUser = {35      username: 'JonDoe',36      password: 'abc123',37      email: 'jon@email.com'38    }39    reqAgent40      .post('/api/auth/signup')41      .send(newUser)42      .end((err, res) => {43        if (err) throw err44        const { status, body } = res;45        expect(status).toBe(409)46        expect(body).toContainAllKeys(RESPONSE_PROPERTIES)47        expect(body.payload).toBe(null)48        expect(body.error).toBe(true)49        done();50      })51  })52  it('Should allow a registered user to login', (done) => {53    expect.assertions(5)54    const newUser = {55      username: 'JonDoe',56      password: 'abc123'57    }58    reqAgent59      .post('/api/auth/login')60      .send(newUser)61      .end((err, res) => {62        if (err) throw err63        const { status, body } = res;64        expect(status).toBe(200)65        expect(body).toContainAllKeys(RESPONSE_PROPERTIES)66        expect(body.payload.user).toContainAllKeys(["id", "username", "points", "email"])67        expect(body.payload.user.username).toBe(newUser.username)68        expect(body.error).toBe(false)69        done();70      })71  })72  it('Should successfully logout a logged-in user', (done) => {73    expect.assertions(5)74    reqAgent75      .get('/api/auth/logout')76      .end((err, res) => {77        if (err) throw err78        const { status, body } = res;79        expect(status).toBe(200)80        expect(body).toContainAllKeys(RESPONSE_PROPERTIES)81        expect(body.payload).toBe(null)82        expect(body.message).toMatch(/success/)83        expect(body.error).toBe(false)84        done();85      })86  })87  it('Should prevent the login of an unregistered user', (done) => {88    expect.assertions(5)89    const newUser = {90      username: 'DonDoe',91      password: 'abc123'92    }93    reqAgent94      .post('/api/auth/login')95      .send(newUser)96      .end((err, res) => {97        if (err) throw err98        const { status, body } = res;99        expect(status).toBe(401)100        expect(body).toContainAllKeys(RESPONSE_PROPERTIES)101        expect(body.payload).toBe(null)102        expect(body.message).toBe("Wrong username or password")103        expect(body.error).toBe(true)104        done();105      })106  })107  it('Should prevent the login of a user with the wrong password', (done) => {108    expect.assertions(5)109    const newUser = {110      username: 'JonDoe',111      password: 'xyz123'112    }113    reqAgent114      .post('/api/auth/login')115      .send(newUser)116      .end((err, res) => {117        if (err) throw err118        const { status, body } = res;119        expect(status).toBe(401)120        expect(body).toContainAllKeys(RESPONSE_PROPERTIES)121        expect(body.payload).toBe(null)122        expect(body.message).toBe("Wrong username or password")123        expect(body.error).toBe(true)124        done();125      })126  })127  it('Should return the currently logged in user', async (done) => {128    expect.assertions(5)129    const newUser = {130      username: 'JaneDoe',131      password: 'abc123',132      email: 'jane@email.com'133    }134    await reqAgent.post('/api/auth/signup').send(newUser)135    reqAgent136      .get('/api/auth/user')137      .end((err, res) => {138        if (err) throw err139        const { status, body } = res;140        expect(status).toBe(200)141        expect(body).toContainAllKeys(RESPONSE_PROPERTIES)142        expect(body.payload.user).toContainAllKeys(["id", "username", "points", "email"])143        expect(body.payload.user.username).toBe(newUser.username)144        expect(body.error).toBe(false)145        done();146      })147  })148  it('Should prevent a user to log in if either username or password is missing', async (done) => {149    expect.assertions(15)150    const missingCredentials = {151      missingPassword: {152        username: 'userABC',153      },154      missingUsername: {155        password: '123',156      },157      missingBoth: {}158    }159    for (let missing in missingCredentials) {160      const creds = missingCredentials[missing]161      const { status, body } = await reqAgent.post('/api/auth/login').send(creds)162      expect(status).toBe(422)163      expect(body).toContainAllKeys(RESPONSE_PROPERTIES)164      expect(body.message).toMatch(/validation error/i)165      expect(body.error).toBe(true)166      expect(body.payload.errors).toBeArray()167    }168    done();169  })170  it('Should prevent a user to sign up if either username, email or password are not valid', async (done) => {171    expect.assertions(20)172    const credentials = {173      missingPassword: {174        username: 'userABC',175        email: 'user@email.com'176      },177      missingUsername: {178        password: '123',179        email: 'user@email.com'180      },181      missingEmail: {182        username: 'userABC',183        password: '123'184      },185      missingAll: {}186    }187    for (let invalidCred in credentials) {188      const creds = credentials[invalidCred]189      const { status, body } = await reqAgent.post('/api/auth/signup').send(creds)190      expect(status).toBe(422)191      expect(body).toContainAllKeys(RESPONSE_PROPERTIES)192      expect(body.message).toMatch(/validation error/i)193      expect(body.error).toBe(true)194      expect(body.payload.errors).toBeArray()195    }196    done();197  })...

axe-reporter-earl.js

Source:axe-reporter-earl.js

...9  describe(`axeReporterEarl fn`, () => {10    test(`get report with empty "@graph"`, () => {11      const args = { raw: [] };12      const actual = axeReporterEarl(args);13      expect(actual).toContainAllKeys(["@context", "@graph"]);14      expect(actual["@context"]).toBeObject();15      expect(16        JSON.stringify(actual["@context"]) === JSON.stringify(context)17      ).toBe(true);18      expect(actual["@graph"].length).toBe(0);19    });20    test.each(rawResults)(21      `assert "@graph" EARL results for  given rule raw results, %p`,22      rawResult => {23        const args = {24          raw: [rawResult],25          env: {26            version: "100.200.999"27          }28        };29        const actual = axeReporterEarl(args);30        expect(actual).toContainAllKeys(["@context", "@graph"]);31        expect(actual["@context"]).toBeObject();32        expect(JSON.stringify(actual["@context"])).toEqual(33          JSON.stringify(context)34        );35        expect(actual["@graph"].length).toBe(1);36        const assertion = actual["@graph"][0];37        expect(assertion).toContainAllKeys([38          "@type",39          "mode",40          "subject",41          "assertedBy",42          "result",43          "test"44        ]);45        expect(assertion["@type"]).toBe("Assertion");46        expect(assertion["mode"]).toBeOneOf([47          "earl:automatic" // note: can be extended later48        ]);49        expect(assertion.assertedBy).toEndWith(`${args.env.version}`);50        expect(assertion.result.outcome).toBe(`earl:${rawResult.result}`);51      }52    );53  });54  describe(`earlUntested fn`, () => {55    test(`get assertion of untested testcase`, () => {56      const args = { url: "http://idonot.exist", version: "100.200.999" };57      const actual = earlUntested(args);58      expect(actual).toContainAllKeys(["@context", "@graph"]);59      expect(actual["@context"]).toBeObject();60      expect(JSON.stringify(actual["@context"])).toEqual(61        JSON.stringify(context)62      );63      expect(actual["@graph"].length).toBe(1);64      const assertion = actual["@graph"][0];65      expect(assertion).toContainAllKeys([66        "@type",67        "mode",68        "subject",69        "assertedBy",70        "result"71      ]);72      expect(assertion["@type"]).toBe("Assertion");73      expect(assertion["mode"]).toBeOneOf([74        "earl:automatic" // note: can be extended later75      ]);76      expect(assertion.assertedBy).toEndWith(`${args.version}`);77      expect(assertion.result.outcome).toBe(`earl:untested`);78    });79  });...

Using AI Code Generation

1const { toContainAllKeys } = require('jest-extended');2expect.extend({ toContainAllKeys });3test('object contains all keys', () => {4  expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'b']);5});6const { toContainAnyKeys } = require('jest-extended');7expect.extend({ toContainAnyKeys });8test('object contains any keys', () => {9  expect({ a: 1, b: 2 }).toContainAnyKeys(['a', 'b']);10});11const { toContainAllValues } = require('jest-extended');12expect.extend({ toContainAllValues });13test('object contains all values', () => {14  expect({ a: 1, b: 2 }).toContainAllValues([1, 2]);15});16const { toContainAnyValues } = require('jest-extended');17expect.extend({ toContainAnyValues });18test('object contains any values', () => {19  expect({ a: 1, b: 2 }).toContainAnyValues([1, 2]);20});21const { toContainAllEntries } = require('jest-extended');22expect.extend({ toContainAllEntries });23test('object contains all entries', () => {24  expect({ a: 1, b: 2 }).toContainAllEntries([['a', 1], ['b', 2]]);25});26const { toContainAnyEntries } = require('jest-extended');27expect.extend({ toContainAnyEntries });28test('object contains any entries', () => {29  expect({ a: 1, b: 2 }).toContainAnyEntries([['a', 1], ['b', 2]]);30});31const { toContainAllEntriesOf } = require('jest-extended');32expect.extend({ toContainAllEntriesOf });33test('object contains all entries of', () =>

Using AI Code Generation

1const obj = {2};3expect(obj).toContainAllKeys(['a', 'b', 'c', 'd', 'e']);4const obj = {5};6expect(obj).toContainAnyKeys(['a', 'b', 'c', 'd', 'e']);7const obj = {8};9expect(obj).toContainAllValues([1, 2, 3, 4, 5]);10const obj = {11};12expect(obj).toContainAnyValues([1, 2, 3, 4, 5]);13const obj = {14};15expect(obj).toContainAllEntries([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]]);16const obj = {17};18expect(obj).toContainAnyEntries([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]]);19const obj = {

Using AI Code Generation

1const { toContainAllKeys } = require('jest-extended');2expect.extend({ toContainAllKeys });3test('passes when given object contains all the keys', () => {4  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b']);5});6test('fails when given object does not contain all the keys', () => {7  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'd']);8});9test('fails when given object does not contain all the keys', () => {10  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'd']);11});12const { toContainAllKeys } = require('jest-extended');13expect.extend({ toContainAllKeys });14test('passes when given object contains all the keys', () => {15  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b']);16});17test('fails when given object does not contain all the keys', () => {18  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'd']);19});20test('fails when given object does not contain all the keys', () => {21  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'd']);22});23const { toContainAllKeys } = require('jest-extended');24expect.extend({ toContainAllKeys });25test('passes when given object contains all the keys', () => {26  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b']);27});28test('fails when given object does not contain all the keys', () => {29  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'd']);30});31test('fails when given object does not contain all the keys', () => {32  expect({ a: 1,

Using AI Code Generation

1const { toContainAllKeys } = require('jest-extended');2expect.extend({ toContainAllKeys });3test('passes when all keys are contained', () => {4  expect({ a: 1, b: 2 }).toContainAllKeys(['a']);5});6test('fails when not all keys are contained', () => {7  expect(() => {8    expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'c']);9  }).toThrowErrorMatchingSnapshot();10});11test('fails when not all keys are contained', () => {12  expect(() => {13    expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'c']);14  }).toThrowErrorMatchingSnapshot();15});16test('fails when not all keys are contained', () => {17  expect(() => {18    expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'c']);19  }).toThrowErrorMatchingSnapshot();20});21test('fails when not all keys are contained', () => {22  expect(() => {23    expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'c']);24  }).toThrowErrorMatchingSnapshot();25});26test('fails when not all keys are contained', () => {27  expect(() => {28    expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'c']);29  }).toThrowErrorMatchingSnapshot();30});31test('fails when not all keys are contained', () => {32  expect(() => {33    expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'c']);34  }).toThrowErrorMatchingSnapshot();35});36test('fails when not all keys are contained', () => {37  expect(() => {38    expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'c']);39  }).toThrowErrorMatchingSnapshot();40});41test('fails when not all keys are contained', () => {42  expect(() => {43    expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'c']);44  }).toThrowErrorMatchingSnapshot();45});46test('fails when not all keys are contained', () => {47  expect(() => {48    expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'c']);49  }).toThrowErrorMatchingSnapshot();50});51test('fails when not all keys are contained', () => {

Using AI Code Generation

1const { toContainAllKeys } = require('jest-extended');2const { toContainAllKeys } = require('jest');3expect.extend({ toContainAllKeys });4expect.extend({ toContainAllKeys });5expect.extend({ toContainAllKeys });6expect.extend({ toContainAllKeys });7expect.extend({ toContainAllKeys });8expect.extend({ toContainAllKeys });9expect.extend({ toContainAllKeys });10expect.extend({ toContainAllKeys });11expect.extend({ toContainAllKeys });12expect.extend({ toContainAllKeys });13expect.extend({ toContainAllKeys });14expect.extend({ toContainAllKeys });15expect.extend({ toContainAllKeys });16expect.extend({ toContainAllKeys });17expect.extend({ toContainAllKeys });18expect.extend({ toContainAllKeys });19expect.extend({ toContainAllKeys });20expect.extend({ toContainAllKeys });21expect.extend({ toContainAllKeys });22expect.extend({ toContainAllKeys });23expect.extend({ toContainAllKeys });24expect.extend({ toContainAllKeys

Using AI Code Generation

1const { toContainAllKeys } = require('jest-extended');2expect.extend({ toContainAllKeys });3test('validates that an object contains all the keys', () => {4  expect({ a: 1, b: 2 }).toContainAllKeys(['a', 'b']);5  expect({ a: 1, b: 2 }).not.toContainAllKeys(['a', 'b', 'c']);6});7const { toContainAnyKeys } = require('jest-extended');8expect.extend({ toContainAnyKeys });9test('validates that an object contains any of the keys', () => {10  expect({ a: 1, b: 2 }).toContainAnyKeys(['a', 'c']);11  expect({ a: 1, b: 2 }).not.toContainAnyKeys(['c', 'd']);12});13const { toContainAllValues } = require('jest-extended');14expect.extend({ toContainAllValues });15test('validates that an object contains all the values', () => {16  expect({ a: 1, b: 2 }).toContainAllValues([1, 2]);17  expect({ a: 1, b: 2 }).not.toContainAllValues([1, 2, 3]);18});19const { toContainAnyValues } = require('jest-extended');20expect.extend({ toContainAnyValues });21test('validates that an object contains any of the values', () => {22  expect({ a: 1, b: 2 }).toContainAnyValues([1, 3]);23  expect({ a: 1, b: 2 }).not.toContainAnyValues([3, 4]);24});25const { toContainAllEntries } = require('jest-extended');26expect.extend({ toContainAllEntries });27test('validates that an object contains all the entries', () => {28  expect({ a: 1, b: 2 }).toContainAllEntries([['a', 1], ['b', 2]]);29  expect({ a: 1, b

Using AI Code Generation

1const { toContainAllKeys } = require('jest-extended');2expect.extend({ toContainAllKeys });3describe('test', () => {4  it('should pass', () => {5    expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'c']);6  });7});8test('test', () => {9  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'c']);10});11test('test', () => {12  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'c']);13});14test('test', () => {15  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'c']);16});17test('test', () => {18  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'c']);19});20test('test', () => {21  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'c']);22});23test('test', () => {24  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'c']);25});26test('test', () => {27  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'c']);28});29test('test', () => {30  expect({ a: 1, b: 2, c: 3 }).toContainAllKeys(['a', 'b', 'c

Using AI Code Generation

1test('object contains all keys', () => {2  const object = { foo: 'bar', baz: 42 };3  expect(object).toContainAllKeys(['foo', 'baz']);4});5test('object contains any keys', () => {6  const object = { foo: 'bar', baz: 42 };7  expect(object).toContainAnyKeys(['foo', 'bam']);8});9test('object contains all values', () => {10  const object = { foo: 'bar', baz: 42 };11  expect(object).toContainAllValues(['bar', 42]);12});13test('object contains any values', () => {14  const object = { foo: 'bar', baz: 42 };15  expect(object).toContainAnyValues(['bar', 'bam']);16});17test('object contains all entries', () => {18  const object = { foo: 'bar', baz: 42 };19  expect(object).toContainAllEntries([['foo', 'bar'], ['baz', 42]]);20});21test('object contains any entries', () => {22  const object = { foo: 'bar', baz: 42 };23  expect(object).toContainAnyEntries([['foo', 'bar'], ['bam', 'baz']]);24});

Using AI Code Generation

1test("toContainAllKeys", () => {2  const obj = {3  };4  expect(obj).toContainAllKeys(["name", "age"]);5});6test("toContainAllKeys", () => {7  const obj = {8  };9  expect(obj).toContainAllKeys(["name", "age"]);10});11test("toContainAllKeys", () => {12  const obj = {13  };14  expect(obj).toContainAllKeys(["name", "age"]);15});16test("toContainAllKeys", () => {17  const obj = {18  };19  expect(obj).toContainAllKeys(["name", "age"]);20});21test("toContainAllKeys", () => {22  const obj = {23  };24  expect(obj).toContainAllKeys(["name", "age"]);25});26test("toContainAllKeys", () => {27  const obj = {28  };29  expect(obj).toContainAllKeys(["name", "age"]);30});31test("toContainAllKeys", () => {32  const obj = {33  };34  expect(obj).toContainAllKeys(["name", "age"]);35});36test("toContainAllKeys", () => {37  const obj = {38  };39  expect(obj).toContainAllKeys(["name", "age"]);40});41test("toContainAllKeys", () => {42  const obj = {43  };44  expect(obj).toContainAllKeys(["name", "age"]);45});

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.