Non-Retrying Assertions on Grafana Labs

toBe()

Mon, 21 Sep 2026 15:16:28 +0000

toBe()

The toBe() method asserts that the actual value is exactly equal to the expected value using Object.is() comparison.

Syntax

expect(actual).toBe(expected);
expect(actual).not.toBe(expected);

Parameters

Parameter	Type	Description
expected	any	The expected value

Returns

Type	Description
void	No return value

Description

The toBe() method performs exact equality comparison using Object.is(). This means it checks for strict equality and handles special cases like NaN and -0 correctly.

Use toBe() when you want to assert that two values are the same reference or primitive value. For object comparison, use toEqual() instead.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  expect(42).toBe(42);
  expect('hello').toBe('hello');
  expect(true).toBe(true);
  expect(null).toBe(null);
  expect(undefined).toBe(undefined);
}

toEqual()

Mon, 21 Sep 2026 15:16:28 +0000

toEqual()

The toEqual() method asserts that the actual value is deeply equal to the expected value, performing recursive comparison of objects and arrays.

Syntax

expect(actual).toEqual(expected);
expect(actual).not.toEqual(expected);

Parameters

Parameter	Type	Description
expected	any	The expected value

Returns

Type	Description
void	No return value

Description

The toEqual() method performs deep equality comparison, recursively checking all properties of objects and elements of arrays. Unlike toBe(), it compares the content of objects rather than their references.

Use toEqual() when you want to assert that two values have the same structure and content, even if they are different objects in memory.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  const user1 = { name: 'John', age: 30 };
  const user2 = { name: 'John', age: 30 };

  expect(user1).toEqual(user2);
  expect(user1).not.toBe(user2); // Different references
}

toContain()

Mon, 21 Sep 2026 15:16:28 +0000

toContain()

The toContain() method asserts that an array contains a specific item or a string contains a substring.

Syntax

expect(actual).toContain(expected);
expect(actual).not.toContain(expected);

Parameters

Parameter	Type	Description
expected	any	The value to search for

Returns

Type	Description
void	No return value

Description

The toContain() method checks if:

An array contains a specific element (using includes())
A string contains a substring (using includes())

For arrays, it uses strict equality (===) to match elements. For more complex object matching in arrays, use toContainEqual().

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  const numbers = [1, 2, 3, 4, 5];
  expect(numbers).toContain(3);
  expect(numbers).not.toContain(6);

  const fruits = ['apple', 'banana', 'orange'];
  expect(fruits).toContain('banana');
  expect(fruits).not.toContain('grape');
}

toBeTruthy()

Mon, 21 Sep 2026 15:16:28 +0000

toBeTruthy()

The toBeTruthy() method asserts that a value is truthy in JavaScript. A value is truthy if it converts to true when evaluated in a boolean context.

Syntax

expect(actual).toBeTruthy();
expect(actual).not.toBeTruthy();

Returns

Type	Description
void	No return value

Description

The toBeTruthy() method checks if a value is truthy. In JavaScript, all values are truthy except for the following falsy values:

false
0
-0
0n (BigInt)
"" (empty string)
null
undefined
NaN

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  expect(true).toBeTruthy();
  expect(1).toBeTruthy();
  expect(-1).toBeTruthy();
  expect('hello').toBeTruthy();
  expect(' ').toBeTruthy(); // Non-empty string
  expect(42).toBeTruthy();
  expect(3.14).toBeTruthy();
  expect(Infinity).toBeTruthy();
  expect(-Infinity).toBeTruthy();
}

toBeFalsy()

Mon, 21 Sep 2026 15:16:28 +0000

toBeFalsy()

The toBeFalsy() method asserts that a value is falsy in JavaScript. A value is falsy if it converts to false when evaluated in a boolean context.

Syntax

expect(actual).toBeFalsy();
expect(actual).not.toBeFalsy();

Returns

Type	Description
void	No return value

Description

The toBeFalsy() method checks if a value is falsy. In JavaScript, the following values are falsy:

false
0
-0
0n (BigInt)
"" (empty string)
null
undefined
NaN

All other values are truthy.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  expect(false).toBeFalsy();
  expect(0).toBeFalsy();
  expect(-0).toBeFalsy();
  expect(0n).toBeFalsy();
  expect('').toBeFalsy();
  expect(null).toBeFalsy();
  expect(undefined).toBeFalsy();
  expect(NaN).toBeFalsy();
}

toBeDefined()

Mon, 21 Sep 2026 15:16:28 +0000

toBeDefined()

The toBeDefined() method asserts that a value is defined, meaning it is not undefined.

Syntax

expect(actual).toBeDefined();
expect(actual).not.toBeDefined();

Returns

Type	Description
void	No return value

Description

The toBeDefined() method checks if a value is defined (not undefined). It passes for all values except undefined, including null, false, 0, empty strings, and empty objects/arrays.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  expect(null).toBeDefined();
  expect(false).toBeDefined();
  expect(0).toBeDefined();
  expect('').toBeDefined();
  expect([]).toBeDefined();
  expect({}).toBeDefined();
  expect(NaN).toBeDefined();
}

toBeGreaterThan()

Mon, 21 Sep 2026 15:16:28 +0000

toBeGreaterThan()

The toBeGreaterThan() method asserts that a numeric value is greater than another value.

Syntax

expect(actual).toBeGreaterThan(expected);
expect(actual).not.toBeGreaterThan(expected);

Parameters

Parameter	Type	Description
expected	number	The value to compare against

Returns

Type	Description
void	No return value

Description

The toBeGreaterThan() method performs a numeric comparison using the > operator. Both values must be numbers, or the assertion will fail.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  expect(5).toBeGreaterThan(3);
  expect(10.5).toBeGreaterThan(10);
  expect(-1).toBeGreaterThan(-5);
  expect(0).toBeGreaterThan(-1);
}

toBeCloseTo()

Mon, 21 Sep 2026 15:16:28 +0000

toBeCloseTo()

The toBeCloseTo() method asserts that a number is close to another number within a specified precision. This is useful for comparing floating-point numbers where exact equality might fail due to precision issues.

Syntax

expect(actual).toBeCloseTo(expected);
expect(actual).toBeCloseTo(expected, precision);
expect(actual).not.toBeCloseTo(expected);
expect(actual).not.toBeCloseTo(expected, precision);

Parameters

Parameter	Type	Default	Description
expected	number		The expected number
precision	number	`2`	Number of decimal digits to check

Returns

Type	Description
void	No return value

Description

The toBeCloseTo() method checks if two numbers are approximately equal within a specified precision. It uses the formula Math.abs(actual - expected) < Math.pow(10, -precision) / 2 to determine if the numbers are close enough.

This is particularly useful when working with floating-point arithmetic where exact equality comparisons might fail due to precision limitations.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  // Floating-point arithmetic precision issues
  expect(0.1 + 0.2).toBeCloseTo(0.3);
  expect(0.1 + 0.2).toBeCloseTo(0.3, 2);

  // These would fail with toBe()
  // expect(0.1 + 0.2).toBe(0.3); // This fails!

  // More examples
  expect(1.005).toBeCloseTo(1, 0);
  expect(1.005).toBeCloseTo(1.01, 1);
  expect(1.005).not.toBeCloseTo(1.01, 2);
}

toHaveLength()

Mon, 21 Sep 2026 15:16:28 +0000

toHaveLength()

The toHaveLength() method asserts that an object has a specific length property value. This is commonly used with arrays, strings, and other objects that have a length property.

Syntax

expect(actual).toHaveLength(expected);
expect(actual).not.toHaveLength(expected);

Parameters

Parameter	Type	Description
expected	number	The expected length value

Returns

Type	Description
void	No return value

Description

The toHaveLength() method checks if an object has a length property that equals the expected value. It works with arrays, strings, and any object that has a numeric length property.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  const fruit = 'mango';

  expect(fruit).toHaveLength(5);
  expect(fruit).not.toHaveLength(2);
}

toHaveProperty()

Mon, 21 Sep 2026 15:16:28 +0000

toHaveProperty()

The toHaveProperty() method asserts that an object has a specific property, optionally with a specific value. It supports both simple property names and nested property paths.

Syntax

expect(actual).toHaveProperty(keyPath);
expect(actual).toHaveProperty(keyPath, value);
expect(actual).not.toHaveProperty(keyPath);
expect(actual).not.toHaveProperty(keyPath, value);

Parameters

Parameter	Type	Description
keyPath	string \| Array	The property path to check
value	any	Optional expected value for the property

Returns

Type	Description
void	No return value

Description

The toHaveProperty() method checks if an object has a specific property. The property path can be:

A simple property name (e.g., 'name')
A nested property path using dot notation (e.g., 'user.address.city')
An array of property keys (e.g., ['user', 'address', 'city'])

If a value is provided, it also checks that the property has that exact value.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  const user = {
    id: 123,
    name: 'John Doe',
    email: 'john@example.com',
    active: true,
  };

  // Check property existence
  expect(user).toHaveProperty('id');
  expect(user).toHaveProperty('name');
  expect(user).toHaveProperty('email');
  expect(user).toHaveProperty('active');

  // Check missing property
  expect(user).not.toHaveProperty('phone');
  expect(user).not.toHaveProperty('address');
}

toBeGreaterThanOrEqual()

Mon, 21 Sep 2026 15:16:28 +0000

toBeGreaterThanOrEqual()

The toBeGreaterThanOrEqual() method asserts that a numeric value is greater than or equal to another value.

Syntax

expect(actual).toBeGreaterThanOrEqual(expected);
expect(actual).not.toBeGreaterThanOrEqual(expected);

Parameters

Parameter	Type	Description
expected	number	The value to compare against

Returns

Type	Description
void	No return value

Description

The toBeGreaterThanOrEqual() method performs a numeric comparison using the >= operator. Both values must be numbers, or the assertion will fail.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  expect(5).toBeGreaterThanOrEqual(3);
  expect(5).toBeGreaterThanOrEqual(5); // Equal values pass
  expect(10.5).toBeGreaterThanOrEqual(10);
  expect(0).toBeGreaterThanOrEqual(-1);
  expect(-1).toBeGreaterThanOrEqual(-5);
}

toBeLessThan()

Mon, 21 Sep 2026 15:16:28 +0000

toBeLessThan()

The toBeLessThan() method asserts that a numeric value is less than another value.

Syntax

expect(actual).toBeLessThan(expected);
expect(actual).not.toBeLessThan(expected);

Parameters

Parameter	Type	Description
expected	number	The value to compare against

Returns

Type	Description
void	No return value

Description

The toBeLessThan() method performs a numeric comparison using the < operator. Both values must be numbers, or the assertion will fail.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  expect(3).toBeLessThan(5);
  expect(10).toBeLessThan(10.5);
  expect(-5).toBeLessThan(-1);
  expect(-1).toBeLessThan(0);
  expect(0).toBeLessThan(1);
}

toBeNull()

Mon, 21 Sep 2026 15:16:28 +0000

toBeNull()

The toBeNull() method asserts that a value is exactly null.

Syntax

expect(actual).toBeNull();
expect(actual).not.toBeNull();

Returns

Type	Description
void	No return value

Description

The toBeNull() method checks if a value is exactly null. It only passes for the null value and fails for all other values, including undefined, false, 0, and empty strings.

Usage

import http from 'k6/http';
import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  const response = http.get('https://quickpizza.grafana.com/');

  // Check for null values in response
  const maybeNull = null;
  if (maybeNull === null) {
    expect(maybeNull).toBeNull();
  }

  // Check that required fields are not null
  expect(response.body).not.toBeNull();
  expect(response.status).not.toBeNull();

  // Basic null checks
  expect(null).toBeNull();
  expect(undefined).not.toBeNull();
  expect(false).not.toBeNull();
  expect(0).not.toBeNull();
}

toBeUndefined()

Mon, 21 Sep 2026 15:16:28 +0000

toBeUndefined()

The toBeUndefined() method asserts that a value is exactly undefined.

Syntax

expect(actual).toBeUndefined();
expect(actual).not.toBeUndefined();

Returns

Type	Description
void	No return value

Description

The toBeUndefined() method checks if a value is exactly undefined. It only passes for the undefined value and fails for all other values, including null, false, 0, and empty strings.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  const user = {
    id: 123,
    name: 'John Doe',
    email: 'john@example.com',
  };

  // Check existing properties
  expect(user.id).not.toBeUndefined();
  expect(user.name).not.toBeUndefined();
  expect(user.email).not.toBeUndefined();

  // Check missing properties
  expect(user.phone).toBeUndefined();
  expect(user.address).toBeUndefined();

  // Basic undefined checks
  expect(undefined).toBeUndefined();
  expect(null).not.toBeUndefined();
  expect(false).not.toBeUndefined();
  expect(0).not.toBeUndefined();
}

toContainEqual()

Mon, 21 Sep 2026 15:16:28 +0000

toContainEqual()

The toContainEqual() method asserts that an array or set contains an element that is deeply equal to the expected value, using the same equality logic as toEqual().

Syntax

expect(actual).toContainEqual(expected);
expect(actual).not.toContainEqual(expected);

Parameters

Parameter	Type	Description
expected	any	The value to search for using deep equality

Returns

Type	Description
void	No return value

Description

The toContainEqual() method checks if an array or set contains an element that is deeply equal to the expected value. Unlike toContain(), which uses strict equality (===), toContainEqual() performs deep equality comparison, making it suitable for finding objects with matching content even if they are different instances.

Usage

import http from 'k6/http';
import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  const response = http.get('https://quickpizza.grafana.com/');

  // Create test data to demonstrate toContainEqual
  const pizzaOptions = [
    { name: 'Margherita', toppings: ['tomato', 'mozzarella'] },
    { name: 'Pepperoni', toppings: ['tomato', 'mozzarella', 'pepperoni'] },
    { name: 'Veggie', toppings: ['tomato', 'mozzarella', 'peppers'] },
  ];

  // Check if array contains specific pizza objects
  expect(pizzaOptions).toContainEqual({
    name: 'Margherita',
    toppings: ['tomato', 'mozzarella'],
  });

  // Works with various data types
  const mixedArray = ['string', 123, { key: 'value' }, [1, 2, 3]];
  expect(mixedArray).toContainEqual({ key: 'value' });
  expect(mixedArray).toContainEqual([1, 2, 3]);
  expect(mixedArray).not.toContainEqual({ key: 'different' });
}

toBeLessThanOrEqual()

Mon, 21 Sep 2026 15:16:28 +0000

toBeLessThanOrEqual()

The toBeLessThanOrEqual() method asserts that a numeric value is less than or equal to another value.

Syntax

expect(actual).toBeLessThanOrEqual(expected);
expect(actual).not.toBeLessThanOrEqual(expected);

Parameters

Parameter	Type	Description
expected	number	The value to compare against

Returns

Type	Description
void	No return value

Description

The toBeLessThanOrEqual() method performs a numeric comparison using the <= operator. Both values must be numbers, or the assertion will fail.

Usage

import http from 'k6/http';
import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  const response = http.get('https://quickpizza.grafana.com/');

  // Check response timing constraints
  expect(response.timings.duration).toBeLessThanOrEqual(2000); // Max 2 seconds
  expect(response.timings.waiting).toBeLessThanOrEqual(1500); // Max 1.5 seconds

  // Basic numeric comparisons
  expect(3).toBeLessThanOrEqual(5);
  expect(5).toBeLessThanOrEqual(5); // Equal values pass
  expect(10).not.toBeLessThanOrEqual(5);
}

toBeInstanceOf()

Mon, 21 Sep 2026 15:16:28 +0000

toBeInstanceOf()

The toBeInstanceOf() method asserts that a value is an instance of a specific class or constructor function.

Syntax

expect(actual).toBeInstanceOf(expected);
expect(actual).not.toBeInstanceOf(expected);

Parameters

Parameter	Type	Description
expected	Function	The constructor function or class to check against

Returns

Type	Description
void	No return value

Description

The toBeInstanceOf() method uses the instanceof operator to check if the actual value is an instance of the expected constructor or class. It checks the prototype chain to determine if the constructor function appears anywhere in the object’s prototype chain.

Usage

import http from 'k6/http';
import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

class User {
  constructor(name) {
    this.name = name;
  }
}

export default function () {
  const response = http.get('https://quickpizza.grafana.com/');

  // Check response object types
  expect(response).toBeInstanceOf(Object);
  expect(response.headers).toBeInstanceOf(Object);

  // Check built-in types
  expect([1, 2, 3]).toBeInstanceOf(Array);
  expect(new Date()).toBeInstanceOf(Date);

  // Check custom classes
  const user = new User('John');
  expect(user).toBeInstanceOf(User);
  expect(user).not.toBeInstanceOf(Array);
}

toBeNaN()

Mon, 21 Sep 2026 15:16:28 +0000

toBeNaN()

The toBeNaN() method asserts that a value is NaN (Not a Number).

Syntax

expect(actual).toBeNaN();
expect(actual).not.toBeNaN();

Returns

Type	Description
void	No return value

Description

The toBeNaN() method checks if a value is exactly NaN using Number.isNaN(). It only passes for the NaN value and fails for all other values, including numbers, strings, and other falsy values.

Usage

import { expect } from 'https://jslib.k6.io/k6-testing/0.6.1/index.js';

export default function () {
  const formData = {
    age: '25',
    invalidNumber: 'not-a-number',
  };

  // Validate numeric conversions
  expect(Number(formData.age)).not.toBeNaN();
  expect(Number(formData.invalidNumber)).toBeNaN();

  // Mathematical operations that result in NaN
  expect(0 / 0).toBeNaN();
  expect(Math.sqrt(-1)).toBeNaN();
  expect(Infinity - Infinity).toBeNaN();

  // Valid numbers are not NaN
  expect(123).not.toBeNaN();
  expect(Infinity).not.toBeNaN();
  expect(1 / 0).not.toBeNaN(); // Infinity
}