The type of the result of the operation.
Provides access to operations that can be performed on the assertion scope, based on the IIsOp interface.
Asserts that executing the target function changes the monitored value. Can monitor either a getter function's return value or an object property.
import { expect } from "@nevware21/tripwire";
// With getter function
let value = 1;
const getValue = () => value;
const changeValue = () => { value = 2; };
expect(changeValue).to.change(getValue);
expect(changeValue).to.change(getValue).by(1);
// With object property
const obj = { value: 1 };
const updateValue = () => { obj.value = 3; };
expect(updateValue).to.change(obj, 'value');
expect(updateValue).to.change(obj, 'value').by(2);
Asserts that executing the target function changes the monitored value by a specific delta. The sign of the delta is ignored - only the absolute value is compared. This is a direct method that doesn't require chaining with .by().
import { expect } from "@nevware21/tripwire";
// With getter function
let value = 0;
const getValue = () => value;
const addFive = () => { value += 5; };
expect(addFive).to.changeBy(getValue, 5); // Passes (delta of 5)
expect(addFive).to.changeBy(getValue, -5); // Also passes (absolute value of 5)
// With object property
const obj = { count: 10 };
const addFive = () => { obj.count += 5; };
expect(addFive).to.changeBy(obj, 'count', 5); // Passes (delta of 5)
expect(addFive).to.changeBy(obj, 'count', -5); // Also passes (absolute value of 5)
Alias for change.
Asserts that the value DOES change but NOT by the specified delta after executing the target function. The value MUST change (cannot remain the same), but the change amount must not equal the specified delta. This differs from notChangesBy which allows the value to remain unchanged.
import { expect } from "@nevware21/tripwire";
let value = 0;
const getValue = () => value;
const addTwo = () => { value += 2; };
const noOp = () => {};
expect(addTwo).to.changesButNotBy(getValue, 5); // Passes - changed by 2, not by 5
expect(addTwo).to.changesButNotBy(getValue, 2); // Fails - changed by exactly 2
expect(noOp).to.changesButNotBy(getValue, 5); // Fails - no change occurred
Asserts that executing the target function changes the monitored value by a specific delta. The sign of the delta is ignored - only the absolute value is compared. This is a direct method that doesn't require chaining with .by().
Provides operations for containment checks.
This operation allows you to assert that the target value contains the specified value(s). It is useful for verifying that an array, string, or object contains certain elements or properties.
import { assert } from "@nevware21/tripwire";
const arr = [1, 2, 3];
const str = "hello darkness welcome back again";
const obj = { a: 1, b: 2, c: 3 };
assert(arr).contain(2); // Passes
assert(str).contain("darkness"); // Passes
assert(obj).contain.all.keys('a', 'b'); // Passes
assert(arr).contain(4); // Fails
assert(str).contain("planet"); // Fails
assert(obj).contain.all.keys('a', 'd'); // Fails
Provides operations for containment checks.
This operation allows you to assert that the target value contains the specified value(s). It is useful for verifying that an array, string, or object contains certain elements or properties.
import { assert } from "@nevware21/tripwire";
const arr = [1, 2, 3];
const str = "hello darkness welcome back again";
const obj = { a: 1, b: 2, c: 3 };
assert(arr).contains(2); // Passes
assert(str).contains("darkness"); // Passes
assert(obj).contains.all.keys('a', 'b'); // Passes
assert(arr).contains(4); // Fails
assert(str).contains("planet"); // Fails
assert(obj).contains.all.keys('a', 'd'); // Fails
Asserts that executing the target function decreases the monitored numeric value. Can monitor either a getter function's return value or an object property.
import { expect } from "@nevware21/tripwire";
// With getter function
let count = 10;
const getCount = () => count;
const decrement = () => { count--; };
expect(decrement).to.decrease(getCount);
expect(decrement).to.decrease(getCount).by(1); // delta of 1 (positive) for a decrease
// With object property
const obj = { count: 10 };
const subtractThree = () => { obj.count -= 3; };
expect(subtractThree).to.decrease(obj, 'count');
expect(subtractThree).to.decrease(obj, 'count').by(3); // delta of 3 (positive) for a decrease
Asserts that executing the target function decreases the monitored value by a specific delta. This is a direct method that doesn't require chaining with .by().
import { expect } from "@nevware21/tripwire";
// With getter function
let value = 10;
const getValue = () => value;
const subtractFive = () => { value -= 5; };
expect(subtractFive).to.decreaseBy(getValue, 5);
// With object property
const obj = { count: 10 };
const subtractFive = () => { obj.count -= 5; };
expect(subtractFive).to.decreaseBy(obj, 'count', 5);
Alias for decrease.
Asserts that the value DOES decrease but NOT by the specified delta after executing the target function. The value MUST decrease (must go down), but the decrease amount must not equal the specified delta. The delta value should be a positive number as a decrease is expected.
import { expect } from "@nevware21/tripwire";
let count = 10;
const getCount = () => count;
const subtractTwo = () => { count -= 2; };
expect(subtractTwo).to.decreasesButNotBy(getCount, 5); // Passes - decreased by 2, not by 5
expect(subtractTwo).to.decreasesButNotBy(getCount, 2); // Fails - decreased by exactly 2
Asserts that executing the target function decreases the monitored value by a specific delta. This is a direct method that doesn't require chaining with .by().
This operation provides access to operations that will deeplyallows you to assert that the target value deeply equals the expected value. It is useful for comparing objects, arrays, and other complex structures.
Asserts that the target exists (is not null and not undefined).
expect(0).to.exist(); // Passes - 0 is not null or undefined
expect("").to.exist(); // Passes - empty string exists
expect(false).to.exist(); // Passes - false exists
expect(null).to.not.exist(); // Passes - null does not exist
expect(undefined).to.not.exist(); // Passes - undefined does not exist
Provides access to operations that can be performed on the assertion scope, based on the IHasOp interface.
Asserts that the target is falsy or throws the error if it is an Error instance. This is commonly used in Node.js-style callback error handling.
Provides operations for inclusion checks.
This operation allows you to assert that the target value includes the specified value(s). It is useful for verifying that an array, string, or object contains certain elements or properties.
import { assert } from "@nevware21/tripwire";
const arr = [1, 2, 3];
const str = "hello darkness welcome back again";
const obj = { a: 1, b: 2, c: 3 };
assert(arr).include(2); // Passes
assert(str).include("darkness"); // Passes
assert(obj).include.all.keys('a', 'b'); // Passes
assert(arr).include(4); // Fails
assert(str).include("planet"); // Fails
assert(obj).include.all.keys('a', 'd'); // Fails
Provides operations for inclusion checks.
This operation allows you to assert that the target value includes the specified value(s). It is useful for verifying that an array, string, or object contains certain elements or properties.
import { assert } from "@nevware21/tripwire";
const arr = [1, 2, 3];
const str = "hello darkness welcome back again";
const obj = { a: 1, b: 2, c: 3 };
assert(arr).includes(2); // Passes
assert(str).includes("darkness"); // Passes
assert(obj).includes.all.keys('a', 'b'); // Passes
assert(arr).includes(4); // Fails
assert(str).includes("planet"); // Fails
assert(obj).includes.all.keys('a', 'd'); // Fails
Asserts that executing the target function increases the monitored numeric value. Can monitor either a getter function's return value or an object property.
import { expect } from "@nevware21/tripwire";
// With getter function
let count = 0;
const getCount = () => count;
const increment = () => { count++; };
expect(increment).to.increase(getCount);
expect(increment).to.increase(getCount).by(1);
// With object property
const obj = { count: 5 };
const addFive = () => { obj.count += 5; };
expect(addFive).to.increase(obj, 'count');
expect(addFive).to.increase(obj, 'count').by(5);
Asserts that executing the target function increases the monitored value by a specific delta. This is a direct method that doesn't require chaining with .by().
import { expect } from "@nevware21/tripwire";
// With getter function
let value = 0;
const getValue = () => value;
const addFive = () => { value += 5; };
expect(addFive).to.increaseBy(getValue, 5);
// With object property
const obj = { count: 10 };
const addFive = () => { obj.count += 5; };
expect(addFive).to.increaseBy(obj, 'count', 5);
Alias for increase.
Asserts that the value DOES increase but NOT by the specified delta after executing the target function. The value MUST increase (must go up), but the increase amount must not equal the specified delta.
import { expect } from "@nevware21/tripwire";
let count = 5;
const getCount = () => count;
const addTwo = () => { count += 2; };
expect(addTwo).to.increasesButNotBy(getCount, 5); // Passes - increased by 2, not by 5
expect(addTwo).to.increasesButNotBy(getCount, 2); // Fails - increased by exactly 2
Asserts that executing the target function increases the monitored value by a specific delta. This is a direct method that doesn't require chaining with .by().
Negates any performed evaluations that are performed in the assertion chain.
This operation applies a stateful change to the evaluation chain, meaning
that subsequent operations that would normally fail will pass without the need
for them to "implement" any knowledge about the not operation. You may call
not multiple times to negate the negation.
Provides operations for strict equality checks.
This operation allows you to assert that the target value is strictly equal to the expected value. It is useful for comparing values without any type coercion.
An assertion function that will validate that the actual value is a function
that when executed will throw an error.
An AssertionFailure if the function does not throw an error.
Asserts that the current IScopeContext.value matches the specified regular expression.
The regular expression to match against.
OptionalevalMsg: MsgSourceOptional. The message to display if the assertion fails.
Represents an interface for operations that can be performed on an assertion scope. This represents a logical grouping of assertion operations, which is used to provide a descriptive API for assertion operations.