This is documentation for the next version of K6. For the latest stable release, go to the latest version.
Functional testing
Most basic integration test
import http from 'k6/http';
import { describe, expect } from 'https://jslib.k6.io/k6chaijs/4.3.4.3/index.js';
export const options = {
thresholds: {
checks: ['rate == 1.00'],
},
};
export default function () {
describe('Hello world!', () => {
const response = http.get('https://test-api.k6.io/public/crocodiles/');
expect(response.status, 'response status').to.equal(200);
expect(response).to.have.validJsonBody();
expect(response.json(), 'croc list').to.be.an('array');
});
}
Sample integration test
This test goes through several steps. It creates a new user account, authenticates, and interacts with protected resources.
import chai, { describe, expect } from 'https://jslib.k6.io/k6chaijs/4.3.4.3/index.js';
import { Httpx, Get } from 'https://jslib.k6.io/httpx/0.0.6/index.js';
import { randomString } from 'https://jslib.k6.io/k6-utils/1.0.0/index.js';
chai.config.logFailures = true;
export let options = {
thresholds: {
// fail the test if any checks fail or any requests fail
checks: ['rate == 1.00'],
http_req_failed: ['rate == 0.00'],
},
vus: 1,
iterations: 1,
};
let session = new Httpx({ baseURL: 'https://test-api.k6.io' });
function retrieveIndividualCrocodilesInABatch() {
describe('[Crocs service] Fetch public crocs one by one', () => {
let responses = session.batch([
new Get('/public/crocodiles/1/'),
new Get('/public/crocodiles/2/'),
new Get('/public/crocodiles/3/'),
]);
expect(responses, 'responses').to.be.an('array');
responses.forEach((response) => {
expect(response.status, 'response status').to.equal(200);
expect(response).to.have.validJsonBody();
expect(response.json(), 'crocodile').to.be.an('object');
expect(response.json(), 'crocodile').to.include.keys('age', 'name', 'id', 'sex');
expect(response.json(), 'crocodile').to.not.have.a.property('outfit');
});
});
}
function retrieveAllPublicCrocodiles() {
describe('[Crocs service] Fetch a list of crocs', () => {
let response = session.get('/public/crocodiles');
expect(response.status, 'response status').to.equal(200);
expect(response).to.have.validJsonBody();
expect(response.json(), 'croc list').to.be.an('array').lengthOf.above(5);
});
}
function validateAuthService() {
const USERNAME = `${randomString(10)}@example.com`;
const PASSWORD = 'superCroc2021';
describe('[Registration service] user registration', () => {
let sampleUser = {
username: USERNAME,
password: PASSWORD,
email: USERNAME,
first_name: 'John',
last_name: 'Smith',
};
let response = session.post(`/user/register/`, sampleUser);
expect(response.status, 'registration status').to.equal(201);
expect(response).to.have.validJsonBody();
});
describe('[Auth service] user authentication', () => {
let authData = {
username: USERNAME,
password: PASSWORD,
};
let resp = session.post(`/auth/token/login/`, authData);
expect(resp.status, 'Auth status').to.be.within(200, 204);
expect(resp).to.have.validJsonBody();
expect(resp.json()).to.have.a.property('access');
expect(resp.json('access'), 'auth token').to.be.a('string');
let authToken = resp.json('access');
// set the authorization header on the session for the subsequent requests.
session.addHeader('Authorization', `Bearer ${authToken}`);
});
}
function validateCrocodileCreation() {
// authentication happened before this call.
describe('[Croc service] Create a new crocodile', () => {
let payload = {
name: `Croc Name`,
sex: 'M',
date_of_birth: '2019-01-01',
};
let resp = session.post(`/my/crocodiles/`, payload);
expect(resp.status, 'Croc creation status').to.equal(201);
expect(resp).to.have.validJsonBody();
session.newCrocId = resp.json('id'); // caching croc ID for the future.
});
describe('[Croc service] Fetch private crocs', () => {
let response = session.get('/my/crocodiles/');
expect(response.status, 'response status').to.equal(200);
expect(response, 'private crocs').to.have.validJsonBody();
expect(response.json(), 'private crocs').to.not.be.empty;
});
}
export default function testSuite() {
retrieveIndividualCrocodilesInABatch();
retrieveAllPublicCrocodiles();
validateAuthService();
validateCrocodileCreation();
}
Full example showcasing all functionality
Here’s an auto-generated k6 test script showcasing all examples from the Chaijs API documentation.
import { describe, expect, chai } from 'https://jslib.k6.io/k6chaijs/4.3.4.3/index.js';
chai.config.aggregateChecks = false;
chai.config.logFailures = true;
export default function testSuite() {
describe('docs example 0', () => {
expect(function () {}).to.not.throw();
expect({ a: 1 }).to.not.have.property('b');
expect([1, 2]).to.be.an('array').that.does.not.include(3);
});
describe('docs example 1', () => {
expect(2).to.equal(2); // Recommended
expect(2).to.not.equal(1); // Not recommended
});
describe('docs example 2', () => {
// Target object deeply (but not strictly) equals `{a: 1}`
expect({ a: 1 }).to.deep.equal({ a: 1 });
expect({ a: 1 }).to.not.equal({ a: 1 });
// Target array deeply (but not strictly) includes `{a: 1}`
expect([{ a: 1 }]).to.deep.include({ a: 1 });
expect([{ a: 1 }]).to.not.include({ a: 1 });
// Target object deeply (but not strictly) includes `x: {a: 1}`
expect({ x: { a: 1 } }).to.deep.include({ x: { a: 1 } });
expect({ x: { a: 1 } }).to.not.include({ x: { a: 1 } });
// Target array deeply (but not strictly) has member `{a: 1}`
expect([{ a: 1 }]).to.have.deep.members([{ a: 1 }]);
expect([{ a: 1 }]).to.not.have.members([{ a: 1 }]);
// Target set deeply (but not strictly) has key `{a: 1}`
expect(new Set([{ a: 1 }])).to.have.deep.keys([{ a: 1 }]);
expect(new Set([{ a: 1 }])).to.not.have.keys([{ a: 1 }]);
// Target object deeply (but not strictly) has property `x: {a: 1}`
expect({ x: { a: 1 } }).to.have.deep.property('x', { a: 1 });
expect({ x: { a: 1 } }).to.not.have.property('x', { a: 1 });
});
describe('docs example 3', () => {
expect({ a: { b: ['x', 'y'] } }).to.have.nested.property('a.b[1]');
expect({ a: { b: ['x', 'y'] } }).to.nested.include({ 'a.b[1]': 'y' });
});
describe('docs example 4', () => {
expect({ '.a': { '[b]': 'x' } }).to.have.nested.property('\\.a.\\[b\\]');
expect({ '.a': { '[b]': 'x' } }).to.nested.include({ '\\.a.\\[b\\]': 'x' });
});
describe('docs example 5', () => {
Object.prototype.b = 2;
expect({ a: 1 }).to.have.own.property('a');
expect({ a: 1 }).to.have.property('b');
expect({ a: 1 }).to.not.have.own.property('b');
expect({ a: 1 }).to.own.include({ a: 1 });
expect({ a: 1 }).to.include({ b: 2 }).but.not.own.include({ b: 2 });
});
describe('docs example 6', () => {
expect([1, 2]).to.have.ordered.members([1, 2]).but.not.have.ordered.members([2, 1]);
});
describe('docs example 7', () => {
expect([1, 2, 3]).to.include.ordered.members([1, 2]).but.not.include.ordered.members([2, 3]);
});
describe('docs example 8', () => {
expect({ a: 1, b: 2 }).to.not.have.any.keys('c', 'd');
});
describe('docs example 9', () => {
expect({ a: 1, b: 2 }).to.have.all.keys('a', 'b');
});
describe('docs example 10', () => {
expect('foo').to.be.a('string');
expect({ a: 1 }).to.be.an('object');
expect(null).to.be.a('null');
expect(undefined).to.be.an('undefined');
expect(new Error()).to.be.an('error');
expect(Promise.resolve()).to.be.a('promise');
expect(new Float32Array()).to.be.a('float32array');
expect(Symbol()).to.be.a('symbol');
});
describe('docs example 11', () => {
var myObj = {
[Symbol.toStringTag]: 'myCustomType',
};
expect(myObj).to.be.a('myCustomType').but.not.an('object');
});
describe('docs example 12', () => {
expect([1, 2, 3]).to.be.an('array').that.includes(2);
expect([]).to.be.an('array').that.is.empty;
});
describe('docs example 13', () => {
expect('foo').to.be.a('string'); // Recommended
expect('foo').to.not.be.an('array'); // Not recommended
});
describe('docs example 14', () => {
expect(1).to.be.a('string', 'nooo why fail??');
expect(1, 'nooo why fail??').to.be.a('string');
});
describe('docs example 15', () => {
expect({ b: 2 }).to.have.a.property('b');
});
describe('docs example 16', () => {
expect('foobar').to.include('foo');
});
describe('docs example 17', () => {
expect([1, 2, 3]).to.include(2);
});
describe('docs example 18', () => {
expect({ a: 1, b: 2, c: 3 }).to.include({ a: 1, b: 2 });
});
describe('docs example 19', () => {
expect(new Set([1, 2])).to.include(2);
});
describe('docs example 20', () => {
expect(
new Map([
['a', 1],
['b', 2],
])
).to.include(2);
});
describe('docs example 21', () => {
expect([1, 2, 3]).to.be.an('array').that.includes(2);
});
describe('docs example 22', () => {
// Target array deeply (but not strictly) includes `{a: 1}`
expect([{ a: 1 }]).to.deep.include({ a: 1 });
expect([{ a: 1 }]).to.not.include({ a: 1 });
// Target object deeply (but not strictly) includes `x: {a: 1}`
expect({ x: { a: 1 } }).to.deep.include({ x: { a: 1 } });
expect({ x: { a: 1 } }).to.not.include({ x: { a: 1 } });
});
describe('docs example 23', () => {
Object.prototype.b = 2;
expect({ a: 1 }).to.own.include({ a: 1 });
expect({ a: 1 }).to.include({ b: 2 }).but.not.own.include({ b: 2 });
});
describe('docs example 24', () => {
expect({ a: { b: 2 } }).to.deep.own.include({ a: { b: 2 } });
});
describe('docs example 25', () => {
expect({ a: { b: ['x', 'y'] } }).to.nested.include({ 'a.b[1]': 'y' });
});
describe('docs example 26', () => {
expect({ '.a': { '[b]': 2 } }).to.nested.include({ '\\.a.\\[b\\]': 2 });
});
describe('docs example 27', () => {
expect({ a: { b: [{ c: 3 }] } }).to.deep.nested.include({ 'a.b[0]': { c: 3 } });
});
describe('docs example 28', () => {
expect('foobar').to.not.include('taco');
expect([1, 2, 3]).to.not.include(4);
});
describe('docs example 29', () => {
expect({ c: 3 }).to.not.have.any.keys('a', 'b'); // Recommended
expect({ c: 3 }).to.not.include({ a: 1, b: 2 }); // Not recommended
});
describe('docs example 30', () => {
expect({ a: 3, b: 4 }).to.include({ a: 3, b: 4 }); // Recommended
expect({ a: 3, b: 4 }).to.not.include({ a: 1, b: 2 }); // Not recommended
});
describe('docs example 31', () => {
expect([1, 2, 3]).to.include(4, 'nooo why fail??');
expect([1, 2, 3], 'nooo why fail??').to.include(4);
});
describe('docs example 32', () => {
// Target object's keys are a superset of ['a', 'b'] but not identical
expect({ a: 1, b: 2, c: 3 }).to.include.all.keys('a', 'b');
expect({ a: 1, b: 2, c: 3 }).to.not.have.all.keys('a', 'b');
// Target array is a superset of [1, 2] but not identical
expect([1, 2, 3]).to.include.members([1, 2]);
expect([1, 2, 3]).to.not.have.members([1, 2]);
// Duplicates in the subset are ignored
expect([1, 2, 3]).to.include.members([1, 2, 2, 2]);
});
describe('docs example 33', () => {
// Both assertions are identical
expect({ a: 1 }).to.include.any.keys('a', 'b');
expect({ a: 1 }).to.have.any.keys('a', 'b');
});
describe('docs example 34', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.be.ok; // Not recommended
expect(true).to.be.true; // Recommended
expect(true).to.be.ok; // Not recommended
});
describe('docs example 35', () => {
expect(0).to.equal(0); // Recommended
expect(0).to.not.be.ok; // Not recommended
expect(false).to.be.false; // Recommended
expect(false).to.not.be.ok; // Not recommended
expect(null).to.be.null; // Recommended
expect(null).to.not.be.ok; // Not recommended
expect(undefined).to.be.undefined; // Recommended
expect(undefined).to.not.be.ok; // Not recommended
});
describe('docs example 36', () => {
expect(false, 'nooo why fail??').to.be.ok;
});
describe('docs example 37', () => {
expect(true).to.be.true;
});
describe('docs example 38', () => {
expect(false).to.be.false; // Recommended
expect(false).to.not.be.true; // Not recommended
expect(1).to.equal(1); // Recommended
expect(1).to.not.be.true; // Not recommended
});
describe('docs example 39', () => {
expect(false, 'nooo why fail??').to.be.true;
});
describe('docs example 40', () => {
expect(false).to.be.false;
});
describe('docs example 41', () => {
expect(true).to.be.true; // Recommended
expect(true).to.not.be.false; // Not recommended
expect(1).to.equal(1); // Recommended
expect(1).to.not.be.false; // Not recommended
});
describe('docs example 42', () => {
expect(true, 'nooo why fail??').to.be.false;
});
describe('docs example 43', () => {
expect(null).to.be.null;
});
describe('docs example 44', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.not.be.null; // Not recommended
});
describe('docs example 45', () => {
expect(42, 'nooo why fail??').to.be.null;
});
describe('docs example 46', () => {
expect(undefined).to.be.undefined;
});
describe('docs example 47', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.not.be.undefined; // Not recommended
});
describe('docs example 48', () => {
expect(42, 'nooo why fail??').to.be.undefined;
});
describe('docs example 49', () => {
expect(NaN).to.be.NaN;
});
describe('docs example 50', () => {
expect('foo').to.equal('foo'); // Recommended
expect('foo').to.not.be.NaN; // Not recommended
});
describe('docs example 51', () => {
expect(42, 'nooo why fail??').to.be.NaN;
});
describe('docs example 52', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.exist; // Not recommended
expect(0).to.equal(0); // Recommended
expect(0).to.exist; // Not recommended
});
describe('docs example 53', () => {
expect(null).to.be.null; // Recommended
expect(null).to.not.exist; // Not recommended
expect(undefined).to.be.undefined; // Recommended
expect(undefined).to.not.exist; // Not recommended
});
describe('docs example 54', () => {
expect(null, 'nooo why fail??').to.exist;
});
describe('docs example 55', () => {
expect([]).to.be.empty;
expect('').to.be.empty;
});
describe('docs example 56', () => {
expect(new Set()).to.be.empty;
expect(new Map()).to.be.empty;
});
describe('docs example 57', () => {
expect({}).to.be.empty;
});
describe('docs example 58', () => {
expect([]).to.be.an('array').that.is.empty;
});
describe('docs example 59', () => {
expect([1, 2, 3]).to.have.lengthOf(3); // Recommended
expect([1, 2, 3]).to.not.be.empty; // Not recommended
expect(new Set([1, 2, 3])).to.have.property('size', 3); // Recommended
expect(new Set([1, 2, 3])).to.not.be.empty; // Not recommended
expect(Object.keys({ a: 1 })).to.have.lengthOf(1); // Recommended
expect({ a: 1 }).to.not.be.empty; // Not recommended
});
describe('docs example 60', () => {
expect([1, 2, 3], 'nooo why fail??').to.be.empty;
});
describe('docs example 61', () => {
function test() {
expect(arguments).to.be.arguments;
}
test();
});
describe('docs example 62', () => {
expect('foo').to.be.a('string'); // Recommended
expect('foo').to.not.be.arguments; // Not recommended
});
describe('docs example 63', () => {
expect({}, 'nooo why fail??').to.be.arguments;
});
describe('docs example 64', () => {
expect(1).to.equal(1);
expect('foo').to.equal('foo');
});
describe('docs example 65', () => {
// Target object deeply (but not strictly) equals `{a: 1}`
expect({ a: 1 }).to.deep.equal({ a: 1 });
expect({ a: 1 }).to.not.equal({ a: 1 });
// Target array deeply (but not strictly) equals `[1, 2]`
expect([1, 2]).to.deep.equal([1, 2]);
expect([1, 2]).to.not.equal([1, 2]);
});
describe('docs example 66', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.not.equal(2); // Not recommended
});
describe('docs example 67', () => {
expect(1).to.equal(2, 'nooo why fail??');
expect(1, 'nooo why fail??').to.equal(2);
});
describe('docs example 68', () => {
// Target object is deeply (but not strictly) equal to {a: 1}
expect({ a: 1 }).to.eql({ a: 1 }).but.not.equal({ a: 1 });
// Target array is deeply (but not strictly) equal to [1, 2]
expect([1, 2]).to.eql([1, 2]).but.not.equal([1, 2]);
});
describe('docs example 69', () => {
expect({ a: 1 }).to.eql({ a: 1 }); // Recommended
expect({ a: 1 }).to.not.eql({ b: 2 }); // Not recommended
});
describe('docs example 70', () => {
expect({ a: 1 }).to.eql({ b: 2 }, 'nooo why fail??');
expect({ a: 1 }, 'nooo why fail??').to.eql({ b: 2 });
});
describe('docs example 71', () => {
expect(2).to.equal(2); // Recommended
expect(2).to.be.above(1); // Not recommended
});
describe('docs example 72', () => {
expect('foo').to.have.lengthOf(3); // Recommended
expect('foo').to.have.lengthOf.above(2); // Not recommended
expect([1, 2, 3]).to.have.lengthOf(3); // Recommended
expect([1, 2, 3]).to.have.lengthOf.above(2); // Not recommended
});
describe('docs example 73', () => {
expect(2).to.equal(2); // Recommended
expect(1).to.not.be.above(2); // Not recommended
});
describe('docs example 74', () => {
expect(1).to.be.above(2, 'nooo why fail??');
expect(1, 'nooo why fail??').to.be.above(2);
});
describe('docs example 75', () => {
expect(2).to.equal(2); // Recommended
expect(2).to.be.at.least(1); // Not recommended
expect(2).to.be.at.least(2); // Not recommended
});
describe('docs example 76', () => {
expect('foo').to.have.lengthOf(3); // Recommended
expect('foo').to.have.lengthOf.at.least(2); // Not recommended
expect([1, 2, 3]).to.have.lengthOf(3); // Recommended
expect([1, 2, 3]).to.have.lengthOf.at.least(2); // Not recommended
});
describe('docs example 77', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.not.be.at.least(2); // Not recommended
});
describe('docs example 78', () => {
expect(1).to.be.at.least(2, 'nooo why fail??');
expect(1, 'nooo why fail??').to.be.at.least(2);
});
describe('docs example 79', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.be.below(2); // Not recommended
});
describe('docs example 80', () => {
expect('foo').to.have.lengthOf(3); // Recommended
expect('foo').to.have.lengthOf.below(4); // Not recommended
expect([1, 2, 3]).to.have.length(3); // Recommended
expect([1, 2, 3]).to.have.lengthOf.below(4); // Not recommended
});
describe('docs example 81', () => {
expect(2).to.equal(2); // Recommended
expect(2).to.not.be.below(1); // Not recommended
});
describe('docs example 82', () => {
expect(2).to.be.below(1, 'nooo why fail??');
expect(2, 'nooo why fail??').to.be.below(1);
});
describe('docs example 83', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.be.at.most(2); // Not recommended
expect(1).to.be.at.most(1); // Not recommended
});
describe('docs example 84', () => {
expect('foo').to.have.lengthOf(3); // Recommended
expect('foo').to.have.lengthOf.at.most(4); // Not recommended
expect([1, 2, 3]).to.have.lengthOf(3); // Recommended
expect([1, 2, 3]).to.have.lengthOf.at.most(4); // Not recommended
});
describe('docs example 85', () => {
expect(2).to.equal(2); // Recommended
expect(2).to.not.be.at.most(1); // Not recommended
});
describe('docs example 86', () => {
expect(2).to.be.at.most(1, 'nooo why fail??');
expect(2, 'nooo why fail??').to.be.at.most(1);
});
describe('docs example 87', () => {
expect(2).to.equal(2); // Recommended
expect(2).to.be.within(1, 3); // Not recommended
expect(2).to.be.within(2, 3); // Not recommended
expect(2).to.be.within(1, 2); // Not recommended
});
describe('docs example 88', () => {
expect('foo').to.have.lengthOf.within(2, 4); // Not recommended
expect([1, 2, 3]).to.have.lengthOf(3); // Recommended
expect([1, 2, 3]).to.have.lengthOf.within(2, 4); // Not recommended
});
describe('docs example 89', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.not.be.within(2, 4); // Not recommended
});
describe('docs example 90', () => {
expect(4).to.be.within(1, 3, 'nooo why fail??');
expect(4, 'nooo why fail??').to.be.within(1, 3);
});
describe('docs example 91', () => {
function Cat() {}
expect(new Cat()).to.be.an.instanceof(Cat);
expect([1, 2]).to.be.an.instanceof(Array);
});
describe('docs example 92', () => {
expect({ a: 1 }).to.not.be.an.instanceof(Array);
});
describe('docs example 93', () => {
expect(1).to.be.an.instanceof(Array, 'nooo why fail??');
expect(1, 'nooo why fail??').to.be.an.instanceof(Array);
});
describe('docs example 94', () => {
expect({ a: 1 }).to.have.property('a');
});
describe('docs example 95', () => {
expect({ a: 1 }).to.have.property('a', 1);
});
describe('docs example 96', () => {
// Target object deeply (but not strictly) has property `x: {a: 1}`
expect({ x: { a: 1 } }).to.have.deep.property('x', { a: 1 });
expect({ x: { a: 1 } }).to.not.have.property('x', { a: 1 });
});
describe('docs example 97', () => {
Object.prototype.b = 2;
expect({ a: 1 }).to.have.own.property('a');
expect({ a: 1 }).to.have.own.property('a', 1);
expect({ a: 1 }).to.have.property('b');
expect({ a: 1 }).to.not.have.own.property('b');
});
describe('docs example 98', () => {
expect({ x: { a: 1 } }).to.have.deep.own.property('x', { a: 1 });
});
describe('docs example 99', () => {
expect({ a: { b: ['x', 'y'] } }).to.have.nested.property('a.b[1]');
expect({ a: { b: ['x', 'y'] } }).to.have.nested.property('a.b[1]', 'y');
});
describe('docs example 100', () => {
expect({ '.a': { '[b]': 'x' } }).to.have.nested.property('\\.a.\\[b\\]');
});
describe('docs example 101', () => {
expect({ a: { b: [{ c: 3 }] } }).to.have.deep.nested.property('a.b[0]', { c: 3 });
});
describe('docs example 102', () => {
expect({ a: 1 }).to.not.have.property('b');
});
describe('docs example 103', () => {
expect({ b: 2 }).to.not.have.property('a'); // Recommended
expect({ b: 2 }).to.not.have.property('a', 1); // Not recommended
});
describe('docs example 104', () => {
expect({ a: 3 }).to.have.property('a', 3); // Recommended
expect({ a: 3 }).to.not.have.property('a', 1); // Not recommended
});
describe('docs example 105', () => {
expect({ a: 1 }).to.have.property('a').that.is.a('number');
});
describe('docs example 106', () => {
// Recommended
expect({ a: 1 }).to.have.property('a', 2, 'nooo why fail??');
expect({ a: 1 }, 'nooo why fail??').to.have.property('a', 2);
expect({ a: 1 }, 'nooo why fail??').to.have.property('b');
// Not recommended
expect({ a: 1 }).to.have.property('b', undefined, 'nooo why fail??');
});
describe('docs example 107', () => {
expect({ a: 1 }).to.have.ownPropertyDescriptor('a');
});
describe('docs example 108', () => {
expect({ a: 1 }).to.have.ownPropertyDescriptor('a', {
configurable: true,
enumerable: true,
writable: true,
value: 1,
});
});
describe('docs example 109', () => {
expect({ a: 1 }).to.not.have.ownPropertyDescriptor('b');
});
describe('docs example 110', () => {
// Recommended
expect({ b: 2 }).to.not.have.ownPropertyDescriptor('a');
// Not recommended
expect({ b: 2 }).to.not.have.ownPropertyDescriptor('a', {
configurable: true,
enumerable: true,
writable: true,
value: 1,
});
});
describe('docs example 111', () => {
// Recommended
expect({ a: 3 }).to.have.ownPropertyDescriptor('a', {
configurable: true,
enumerable: true,
writable: true,
value: 3,
});
// Not recommended
expect({ a: 3 }).to.not.have.ownPropertyDescriptor('a', {
configurable: true,
enumerable: true,
writable: true,
value: 1,
});
});
describe('docs example 112', () => {
expect({ a: 1 }).to.have.ownPropertyDescriptor('a').that.has.property('enumerable', true);
});
describe('docs example 113', () => {
// Recommended
expect({ a: 1 }).to.have.ownPropertyDescriptor(
'a',
{
configurable: true,
enumerable: true,
writable: true,
value: 2,
},
'nooo why fail??'
);
// Recommended
expect({ a: 1 }, 'nooo why fail??').to.have.ownPropertyDescriptor('a', {
configurable: true,
enumerable: true,
writable: true,
value: 2,
});
// Recommended
expect({ a: 1 }, 'nooo why fail??').to.have.ownPropertyDescriptor('b');
// Not recommended
expect({ a: 1 }).to.have.ownPropertyDescriptor('b', undefined, 'nooo why fail??');
});
describe('docs example 114', () => {
expect([1, 2, 3]).to.have.lengthOf(3);
expect('foo').to.have.lengthOf(3);
expect(new Set([1, 2, 3])).to.have.lengthOf(3);
expect(
new Map([
['a', 1],
['b', 2],
['c', 3],
])
).to.have.lengthOf(3);
});
describe('docs example 115', () => {
expect('foo').to.have.lengthOf(3); // Recommended
expect('foo').to.not.have.lengthOf(4); // Not recommended
});
describe('docs example 116', () => {
expect([1, 2, 3]).to.have.lengthOf(2, 'nooo why fail??');
expect([1, 2, 3], 'nooo why fail??').to.have.lengthOf(2);
});
describe('docs example 117', () => {
// Recommended
expect([1, 2, 3]).to.have.lengthOf(3);
// Not recommended
expect([1, 2, 3]).to.have.lengthOf.above(2);
expect([1, 2, 3]).to.have.lengthOf.below(4);
expect([1, 2, 3]).to.have.lengthOf.at.least(3);
expect([1, 2, 3]).to.have.lengthOf.at.most(3);
expect([1, 2, 3]).to.have.lengthOf.within(2, 4);
});
describe('docs example 118', () => {
expect([1, 2, 3]).to.have.a.length(3); // incompatible; throws error
expect([1, 2, 3]).to.have.a.lengthOf(3); // passes as expected
});
describe('docs example 119', () => {
expect('foobar').to.match(/^foo/);
});
describe('docs example 120', () => {
expect('foobar').to.not.match(/taco/);
});
describe('docs example 121', () => {
expect('foobar').to.match(/taco/, 'nooo why fail??');
expect('foobar', 'nooo why fail??').to.match(/taco/);
});
describe('docs example 122', () => {
expect('foobar').to.have.string('bar');
});
describe('docs example 123', () => {
expect('foobar').to.not.have.string('taco');
});
describe('docs example 124', () => {
expect('foobar').to.have.string('taco', 'nooo why fail??');
expect('foobar', 'nooo why fail??').to.have.string('taco');
});
describe('docs example 125', () => {
expect({ a: 1, b: 2 }).to.have.all.keys('a', 'b');
expect(['x', 'y']).to.have.all.keys(0, 1);
expect({ a: 1, b: 2 }).to.have.all.keys(['a', 'b']);
expect(['x', 'y']).to.have.all.keys([0, 1]);
expect({ a: 1, b: 2 }).to.have.all.keys({ a: 4, b: 5 }); // ignore 4 and 5
expect(['x', 'y']).to.have.all.keys({ 0: 4, 1: 5 }); // ignore 4 and 5
});
describe('docs example 126', () => {
expect(
new Map([
['a', 1],
['b', 2],
])
).to.have.all.keys('a', 'b');
expect(new Set(['a', 'b'])).to.have.all.keys('a', 'b');
});
describe('docs example 127', () => {
expect({ a: 1, b: 2 }).to.be.an('object').that.has.all.keys('a', 'b');
});
describe('docs example 128', () => {
// Target set deeply (but not strictly) has key `{a: 1}`
expect(new Set([{ a: 1 }])).to.have.all.deep.keys([{ a: 1 }]);
expect(new Set([{ a: 1 }])).to.not.have.all.keys([{ a: 1 }]);
});
describe('docs example 129', () => {
// Recommended; asserts that target doesn't have any of the given keys
expect({ a: 1, b: 2 }).to.not.have.any.keys('c', 'd');
// Not recommended; asserts that target doesn't have all of the given
// keys but may or may not have some of them
expect({ a: 1, b: 2 }).to.not.have.all.keys('c', 'd');
});
describe('docs example 130', () => {
// Recommended; asserts that target has all the given keys
expect({ a: 1, b: 2 }).to.have.all.keys('a', 'b');
// Not recommended; asserts that target has at least one of the given
// keys but may or may not have more of them
expect({ a: 1, b: 2 }).to.have.any.keys('a', 'b');
});
describe('docs example 131', () => {
// Both assertions are identical
expect({ a: 1, b: 2 }).to.have.all.keys('a', 'b'); // Recommended
expect({ a: 1, b: 2 }).to.have.keys('a', 'b'); // Not recommended
});
describe('docs example 132', () => {
// Target object's keys are a superset of ['a', 'b'] but not identical
expect({ a: 1, b: 2, c: 3 }).to.include.all.keys('a', 'b');
expect({ a: 1, b: 2, c: 3 }).to.not.have.all.keys('a', 'b');
});
describe('docs example 133', () => {
// Both assertions are identical
expect({ a: 1 }).to.have.any.keys('a', 'b');
expect({ a: 1 }).to.include.any.keys('a', 'b');
});
describe('docs example 134', () => {
expect({ a: 1 }, 'nooo why fail??').to.have.key('b');
});
describe('docs example 135', () => {
var badFn = function () {
throw new TypeError('Illegal salmon!');
};
expect(badFn).to.throw();
});
describe('docs example 136', () => {
var badFn = function () {
throw new TypeError('Illegal salmon!');
};
expect(badFn).to.throw(TypeError);
});
describe('docs example 137', () => {
var err = new TypeError('Illegal salmon!');
var badFn = function () {
throw err;
};
expect(badFn).to.throw(err);
});
describe('docs example 138', () => {
var badFn = function () {
throw new TypeError('Illegal salmon!');
};
expect(badFn).to.throw('salmon');
});
describe('docs example 139', () => {
var badFn = function () {
throw new TypeError('Illegal salmon!');
};
expect(badFn).to.throw(/salmon/);
});
describe('docs example 140', () => {
var err = new TypeError('Illegal salmon!');
var badFn = function () {
throw err;
};
expect(badFn).to.throw(TypeError, 'salmon');
expect(badFn).to.throw(TypeError, /salmon/);
expect(badFn).to.throw(err, 'salmon');
expect(badFn).to.throw(err, /salmon/);
});
describe('docs example 141', () => {
var goodFn = function () {};
expect(goodFn).to.not.throw();
});
describe('docs example 142', () => {
var goodFn = function () {};
expect(goodFn).to.not.throw(); // Recommended
expect(goodFn).to.not.throw(ReferenceError, 'x'); // Not recommended
});
describe('docs example 143', () => {
var badFn = function () {
throw new TypeError('Illegal salmon!');
};
expect(badFn).to.throw(TypeError, 'salmon'); // Recommended
expect(badFn).to.not.throw(ReferenceError, 'x'); // Not recommended
});
describe('docs example 144', () => {
var err = new TypeError('Illegal salmon!');
err.code = 42;
var badFn = function () {
throw err;
};
expect(badFn).to.throw(TypeError).with.property('code', 42);
});
describe('docs example 145', () => {
var goodFn = function () {};
expect(goodFn).to.throw(TypeError, 'x', 'nooo why fail??');
expect(goodFn, 'nooo why fail??').to.throw();
});
describe('docs example 146', () => {
var fn = function () {
throw new TypeError('Illegal salmon!');
};
expect(fn).to.throw(); // Good! Tests `fn` as desired
expect(fn()).to.throw(); // Bad! Tests result of `fn()`, not `fn`
});
describe('docs example 147', () => {
expect(function () {
fn(42);
}).to.throw(); // Function expression
expect(() => fn(42)).to.throw(); // ES6 arrow function
});
describe('docs example 148', () => {
expect(function () {
cat.meow();
}).to.throw(); // Function expression
expect(() => cat.meow()).to.throw(); // ES6 arrow function
expect(cat.meow.bind(cat)).to.throw(); // Bind
});
describe('docs example 149', () => {
function Cat() {}
Cat.prototype.meow = function () {};
expect(new Cat()).to.respondTo('meow');
});
describe('docs example 150', () => {
function Cat() {}
Cat.prototype.meow = function () {};
expect(Cat).to.respondTo('meow');
});
describe('docs example 151', () => {
function Cat() {}
Cat.prototype.meow = function () {};
Cat.hiss = function () {};
expect(Cat).itself.to.respondTo('hiss').but.not.respondTo('meow');
});
describe('docs example 152', () => {
function Cat() {}
Cat.prototype.meow = function () {};
expect(new Cat()).to.be.an('object').that.respondsTo('meow');
});
describe('docs example 153', () => {
function Dog() {}
Dog.prototype.bark = function () {};
expect(new Dog()).to.not.respondTo('meow');
});
describe('docs example 154', () => {
expect({}).to.respondTo('meow', 'nooo why fail??');
expect({}, 'nooo why fail??').to.respondTo('meow');
});
describe('docs example 155', () => {
function Cat() {}
Cat.prototype.meow = function () {};
Cat.hiss = function () {};
expect(Cat).itself.to.respondTo('hiss').but.not.respondTo('meow');
});
describe('docs example 156', () => {
expect(1).to.satisfy(function (num) {
return num > 0;
});
});
describe('docs example 157', () => {
expect(1).to.not.satisfy(function (num) {
return num > 2;
});
});
describe('docs example 158', () => {
expect(1).to.satisfy(function (num) {
return num > 2;
}, 'nooo why fail??');
expect(1, 'nooo why fail??').to.satisfy(function (num) {
return num > 2;
});
});
describe('docs example 159', () => {
// Recommended
expect(1.5).to.equal(1.5);
// Not recommended
expect(1.5).to.be.closeTo(1, 0.5);
expect(1.5).to.be.closeTo(2, 0.5);
expect(1.5).to.be.closeTo(1, 1);
});
describe('docs example 160', () => {
expect(1.5).to.equal(1.5); // Recommended
expect(1.5).to.not.be.closeTo(3, 1); // Not recommended
});
describe('docs example 161', () => {
expect(1.5).to.be.closeTo(3, 1, 'nooo why fail??');
expect(1.5, 'nooo why fail??').to.be.closeTo(3, 1);
});
describe('docs example 162', () => {
expect([1, 2, 3]).to.have.members([2, 1, 3]);
expect([1, 2, 2]).to.have.members([2, 1, 2]);
});
describe('docs example 163', () => {
// Target array deeply (but not strictly) has member `{a: 1}`
expect([{ a: 1 }]).to.have.deep.members([{ a: 1 }]);
expect([{ a: 1 }]).to.not.have.members([{ a: 1 }]);
});
describe('docs example 164', () => {
expect([1, 2, 3]).to.have.ordered.members([1, 2, 3]);
expect([1, 2, 3]).to.have.members([2, 1, 3]).but.not.ordered.members([2, 1, 3]);
});
describe('docs example 165', () => {
// Target array is a superset of [1, 2] but not identical
expect([1, 2, 3]).to.include.members([1, 2]);
expect([1, 2, 3]).to.not.have.members([1, 2]);
// Duplicates in the subset are ignored
expect([1, 2, 3]).to.include.members([1, 2, 2, 2]);
});
describe('docs example 166', () => {
expect([{ a: 1 }, { b: 2 }, { c: 3 }])
.to.include.deep.ordered.members([{ a: 1 }, { b: 2 }])
.but.not.include.deep.ordered.members([{ b: 2 }, { c: 3 }]);
});
describe('docs example 167', () => {
expect([1, 2]).to.not.include(3).and.not.include(4); // Recommended
expect([1, 2]).to.not.have.members([3, 4]); // Not recommended
});
describe('docs example 168', () => {
expect([1, 2]).to.have.members([1, 2, 3], 'nooo why fail??');
expect([1, 2], 'nooo why fail??').to.have.members([1, 2, 3]);
});
describe('docs example 169', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.be.oneOf([1, 2, 3]); // Not recommended
});
describe('docs example 170', () => {
expect(1).to.equal(1); // Recommended
expect(1).to.not.be.oneOf([2, 3, 4]); // Not recommended
});
describe('docs example 171', () => {
expect('Today is sunny').to.contain.oneOf(['sunny', 'cloudy']);
expect('Today is rainy').to.not.contain.oneOf(['sunny', 'cloudy']);
expect([1, 2, 3]).to.contain.oneOf([3, 4, 5]);
expect([1, 2, 3]).to.not.contain.oneOf([4, 5, 6]);
});
describe('docs example 172', () => {
expect(1).to.be.oneOf([2, 3, 4], 'nooo why fail??');
expect(1, 'nooo why fail??').to.be.oneOf([2, 3, 4]);
});
describe('docs example 173', () => {
var dots = '',
addDot = function () {
dots += '.';
},
getDots = function () {
return dots;
};
// Recommended
expect(getDots()).to.equal('');
addDot();
expect(getDots()).to.equal('.');
// Not recommended
expect(addDot).to.change(getDots);
});
describe('docs example 174', () => {
var myObj = { dots: '' },
addDot = function () {
myObj.dots += '.';
};
// Recommended
expect(myObj).to.have.property('dots', '');
addDot();
expect(myObj).to.have.property('dots', '.');
// Not recommended
expect(addDot).to.change(myObj, 'dots');
});
describe('docs example 175', () => {
var dots = '',
noop = function () {},
getDots = function () {
return dots;
};
expect(noop).to.not.change(getDots);
var myObj = { dots: '' },
noop = function () {};
expect(noop).to.not.change(myObj, 'dots');
});
describe('docs example 176', () => {
var myObj = { dots: '' },
addDot = function () {
myObj.dots += '.';
};
expect(addDot).to.not.change(myObj, 'dots', 'nooo why fail??');
var dots = '',
addDot = function () {
dots += '.';
},
getDots = function () {
return dots;
};
expect(addDot, 'nooo why fail??').to.not.change(getDots);
});
describe('docs example 177', () => {
var myObj = { val: 1 },
addTwo = function () {
myObj.val += 2;
},
subtractTwo = function () {
myObj.val -= 2;
};
expect(addTwo).to.increase(myObj, 'val').by(2); // Recommended
expect(addTwo).to.change(myObj, 'val').by(2); // Not recommended
expect(subtractTwo).to.decrease(myObj, 'val').by(2); // Recommended
expect(subtractTwo).to.change(myObj, 'val').by(2); // Not recommended
});
describe('docs example 178', () => {
var val = 1,
addTwo = function () {
val += 2;
},
getVal = function () {
return val;
};
expect(addTwo).to.increase(getVal).by(2); // Recommended
expect(addTwo).to.increase(getVal); // Not recommended
});
describe('docs example 179', () => {
var myObj = { val: 1 },
addTwo = function () {
myObj.val += 2;
};
expect(addTwo).to.increase(myObj, 'val').by(2); // Recommended
expect(addTwo).to.increase(myObj, 'val'); // Not recommended
});
describe('docs example 180', () => {
var myObj = { val: 1 },
subtractTwo = function () {
myObj.val -= 2;
};
expect(subtractTwo).to.decrease(myObj, 'val').by(2); // Recommended
expect(subtractTwo).to.not.increase(myObj, 'val'); // Not recommended
});
describe('docs example 181', () => {
var myObj = { val: 1 },
noop = function () {};
expect(noop).to.not.change(myObj, 'val'); // Recommended
expect(noop).to.not.increase(myObj, 'val'); // Not recommended
});
describe('docs example 182', () => {
var myObj = { val: 1 },
noop = function () {};
expect(noop).to.increase(myObj, 'val', 'nooo why fail??');
var val = 1,
noop = function () {},
getVal = function () {
return val;
};
expect(noop, 'nooo why fail??').to.increase(getVal);
});
describe('docs example 183', () => {
var val = 1,
subtractTwo = function () {
val -= 2;
},
getVal = function () {
return val;
};
expect(subtractTwo).to.decrease(getVal).by(2); // Recommended
expect(subtractTwo).to.decrease(getVal); // Not recommended
});
describe('docs example 184', () => {
var myObj = { val: 1 },
subtractTwo = function () {
myObj.val -= 2;
};
expect(subtractTwo).to.decrease(myObj, 'val').by(2); // Recommended
expect(subtractTwo).to.decrease(myObj, 'val'); // Not recommended
});
describe('docs example 185', () => {
var myObj = { val: 1 },
addTwo = function () {
myObj.val += 2;
};
expect(addTwo).to.increase(myObj, 'val').by(2); // Recommended
expect(addTwo).to.not.decrease(myObj, 'val'); // Not recommended
});
describe('docs example 186', () => {
var myObj = { val: 1 },
noop = function () {};
expect(noop).to.not.change(myObj, 'val'); // Recommended
expect(noop).to.not.decrease(myObj, 'val'); // Not recommended
});
describe('docs example 187', () => {
var myObj = { val: 1 },
noop = function () {};
expect(noop).to.decrease(myObj, 'val', 'nooo why fail??');
var val = 1,
noop = function () {},
getVal = function () {
return val;
};
expect(noop, 'nooo why fail??').to.decrease(getVal);
});
describe('docs example 188', () => {
var myObj = { val: 1 },
addTwo = function () {
myObj.val += 2;
};
expect(addTwo).to.increase(myObj, 'val').by(2);
});
describe('docs example 189', () => {
var myObj = { val: 1 },
subtractTwo = function () {
myObj.val -= 2;
};
expect(subtractTwo).to.decrease(myObj, 'val').by(2);
});
describe('docs example 190', () => {
var myObj = { val: 1 },
addTwo = function () {
myObj.val += 2;
},
subtractTwo = function () {
myObj.val -= 2;
};
expect(addTwo).to.increase(myObj, 'val').by(2); // Recommended
expect(addTwo).to.change(myObj, 'val').by(2); // Not recommended
expect(subtractTwo).to.decrease(myObj, 'val').by(2); // Recommended
expect(subtractTwo).to.change(myObj, 'val').by(2); // Not recommended
});
describe('docs example 191', () => {
var myObj = { val: 1 },
addTwo = function () {
myObj.val += 2;
};
// Recommended
expect(addTwo).to.increase(myObj, 'val').by(2);
// Not recommended
expect(addTwo).to.increase(myObj, 'val').but.not.by(3);
});
describe('docs example 192', () => {
var myObj = { val: 1 },
addTwo = function () {
myObj.val += 2;
};
expect(addTwo).to.increase(myObj, 'val').by(3, 'nooo why fail??');
expect(addTwo, 'nooo why fail??').to.increase(myObj, 'val').by(3);
});
describe('docs example 193', () => {
expect({ a: 1 }).to.be.extensible;
});
describe('docs example 194', () => {
var nonExtensibleObject = Object.preventExtensions({}),
sealedObject = Object.seal({}),
frozenObject = Object.freeze({});
expect(nonExtensibleObject).to.not.be.extensible;
expect(sealedObject).to.not.be.extensible;
expect(frozenObject).to.not.be.extensible;
expect(1).to.not.be.extensible;
});
describe('docs example 195', () => {
expect(1, 'nooo why fail??').to.be.extensible;
});
describe('docs example 196', () => {
var sealedObject = Object.seal({});
var frozenObject = Object.freeze({});
expect(sealedObject).to.be.sealed;
expect(frozenObject).to.be.sealed;
expect(1).to.be.sealed;
});
describe('docs example 197', () => {
expect({ a: 1 }).to.not.be.sealed;
});
describe('docs example 198', () => {
expect({ a: 1 }, 'nooo why fail??').to.be.sealed;
});
describe('docs example 199', () => {
var frozenObject = Object.freeze({});
expect(frozenObject).to.be.frozen;
expect(1).to.be.frozen;
});
describe('docs example 200', () => {
expect({ a: 1 }).to.not.be.frozen;
});
describe('docs example 201', () => {
expect({ a: 1 }, 'nooo why fail??').to.be.frozen;
});
describe('docs example 202', () => {
expect(1).to.be.finite;
});
describe('docs example 203', () => {
expect('foo').to.be.a('string'); // Recommended
expect('foo').to.not.be.finite; // Not recommended
});
describe('docs example 204', () => {
expect(NaN).to.be.NaN; // Recommended
expect(NaN).to.not.be.finite; // Not recommended
});
describe('docs example 205', () => {
expect(Infinity).to.equal(Infinity); // Recommended
expect(Infinity).to.not.be.finite; // Not recommended
});
describe('docs example 206', () => {
expect(-Infinity).to.equal(-Infinity); // Recommended
expect(-Infinity).to.not.be.finite; // Not recommended
});
describe('docs example 207', () => {
expect('foo', 'nooo why fail??').to.be.finite;
});
describe('docs example 208', () => {
expect.fail();
expect.fail('custom error message');
expect.fail(1, 2);
expect.fail(1, 2, 'custom error message');
expect.fail(1, 2, 'custom error message', '>');
expect.fail(1, 2, undefined, '>');
});
// describe('docs example 209', () => {
// should.fail();
// should.fail("custom error message");
// should.fail(1, 2);
// should.fail(1, 2, "custom error message");
// should.fail(1, 2, "custom error message", ">");
// should.fail(1, 2, undefined, ">");
// });
}