@nevware21/tripwire - v0.1.2
    Preparing search index...

    Interface IIsOp<R>

    Represents an interface for operations on an assertion scope confirming the type of a value.

    interface IIsOp<R> {
        a: IIsOp<R>;
        an: IIsOp<R>;
        array: AssertFn<R>;
        boolean: AssertFn<R>;
        empty: AssertFn<R>;
        eq: EqualFn<R>;
        equal: EqualFn<R>;
        equals: EqualFn<R>;
        error: ErrorLikeFn<R>;
        extensible: AssertFn<R>;
        false: AssertFn<R>;
        frozen: AssertFn<R>;
        function: AssertFn<R>;
        iterable: AssertFn<R>;
        not: IIsOp;
        null: AssertFn<R>;
        number: AssertFn<R>;
        object: AssertFn<R>;
        ok: AssertFn<R>;
        plainObject: AssertFn<R>;
        sealed: AssertFn<R>;
        strictly: IStrictlyOp<R>;
        string: AssertFn<R>;
        true: AssertFn<R>;
        truthy: AssertFn<R>;
        undefined: AssertFn<R>;
    }

    Type Parameters

    • R

      The type of the result of the operation.

    Hierarchy (View Summary)

    Index

    Properties

    a an array boolean empty eq equal equals error extensible false frozen function iterable not null number object ok plainObject sealed strictly string true truthy undefined

    Properties

    a: IIsOp<R>

    A decorative / alias operation which returns the current instance, useful for chaining operations to provide a more descriptive description of the operations being performed within your tests.

    • The current instance.
    expect(1).is.a.number();
    expect(1).to.be.a.number();

    // This is equivalent to not using this decorator operation
    expect(1).is.number()
    expect(1).to.be.number();
    an: IIsOp<R>

    A decorative / alias operation which returns the current instance, useful for chaining operations to provide a more descriptive description of the operations being performed within your tests.

    • The current instance.
    expect(1).is.an.object();
    expect(1).to.be.an.array();

    // This is equivalent to not using this decorator operation
    expect(1).is.object()
    expect(1).to.be.array();
    array: AssertFn<R>

    Asserts that the value is an array.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    boolean: AssertFn<R>

    Asserts that the value is a boolean.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    empty: AssertFn<R>

    Asserts that the value is empty.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    eq: EqualFn<R>

    Performs an equality check between the actual and expected values, throwing an AssertionFailure with the given message when the actual value is not equal to the expected value. The default equality check is a loose (==) equality check, to perform a strict equality check (===), use the IStrictlyOp.equal (strictly.equal) operations and when comparing complex objects, use the deep equality operations provided by the IDeepOp.equal (deep.equal) operations or (deep.strictly.equal) for deep strict equality checks. IStrictlyOp.eq (strictly.eq) operations.

    The type of the expected value.

    The expected value.

    The message to display if the values are strictly equal.

    AssertionFailure - If the expected and actual values are strictly equal.

    assert.eq(1, 1); // Passes
    assert.eq("a", "a"); // Passes
    assert.eq(true, true); // Passes
    assert.eq(false, false); // Passes
    assert.eq(null, null); // Passes
    assert.eq(undefined, undefined); // Passes
    assert.eq(0, 0); // Passes
    assert.eq(-0, -0); // Passes
    assert.eq(+0, +0); // Passes
    assert.eq(0n, 0n); // Passes
    assert.eq("", ""); // Passes
    assert.eq(Symbol(), Symbol()); // Passes
    assert.eq([], []); // Throws AssertionError
    assert.eq([1, 2], [1, 2]); // Throws AssertionError
    equal: EqualFn<R>

    Performs an equality check between the actual and expected values, throwing an AssertionFailure with the given message when the actual value is not equal to the expected value. The default equality check is a loose (==) equality check, to perform a strict equality check (===), use the IStrictlyOp.equal (strictly.equal) operations and when comparing complex objects, use the deep equality operations provided by the IDeepOp.equal (deep.equal) operations or (deep.strictly.equal) for deep strict equality checks.

    The type of the expected value.

    The expected value.

    The message to display if the values are not strictly equal.

    AssertionFailure - If the expected and actual values are not strictly equal.

    assert.equal(1, 1); // Passes
    assert.equal("a", "a"); // Passes
    assert.equal(true, true); // Passes
    assert.equal(false, false); // Passes
    assert.equal(null, null); // Passes
    assert.equal(undefined, undefined); // Passes
    assert.equal(0, 0); // Passes
    assert.equal(-0, -0); // Passes
    assert.equal(+0, +0); // Passes
    assert.equal(0n, 0n); // Passes
    assert.equal("", ""); // Passes
    assert.equal(Symbol(), Symbol()); // Passes
    assert.equal([], []); // Throws AssertionError
    assert.equal([1, 2], [1, 2]); // Throws AssertionError
    equals: EqualFn<R>

    Performs an equality check between the actual and expected values, throwing an AssertionFailure with the given message when the actual value is not equal to the expected value. The default equality check is a loose (==) equality check, to perform a strict equality check (===), use the IStrictlyOp.equal (strictly.equal) operations and when comparing complex objects, use the deep equality operations provided by the IDeepOp.equal (deep.equal) operations or (deep.strictly.equal) for deep strict equality checks.

    The type of the expected value.

    The expected value.

    The message to display if the values are strictly equal.

    AssertionFailure - If the expected and actual values are strictly equal.

    assert.equals(1, 1); // Passes
    assert.equals("a", "a"); // Passes
    assert.equals(true, true); // Passes
    assert.equals(false, false); // Passes
    assert.equals(null, null); // Passes
    assert.equals(undefined, undefined); // Passes
    assert.equals(0, 0); // Passes
    assert.equals(-0, -0); // Passes
    assert.equals(+0, +0); // Passes
    assert.equals(0n, 0n); // Passes
    assert.equals("", ""); // Passes
    assert.equals(Symbol(), Symbol()); // Passes
    assert.equals([], []); // Throws AssertionError
    assert.equals([1, 2], [1, 2]); // Throws AssertionError
    error: ErrorLikeFn<R>

    Asserts that the value is an error or matches the provided error constructor.

    The error or error constructor to match.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    extensible: AssertFn<R>

    Asserts that the value is extensible.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    false: AssertFn<R>

    Asserts that the value is false.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    frozen: AssertFn<R>

    Asserts that the value is frozen.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    function: AssertFn<R>

    Asserts that the value is a function.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    iterable: AssertFn<R>

    Asserts that the value is iterable.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    not: IIsOp

    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.

    import { assert } from "@nevware21/tripwire";

    expect(true).not.ok(); // Fails
    expect(false).not.ok(); // Passes
    expect(true).not.not.ok(); // Passes
    expect(false).not.not.ok(); // Fails
    null: AssertFn<R>

    Asserts that the value is null.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    number: AssertFn<R>

    Asserts that the value is a number.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    object: AssertFn<R>

    Asserts that the value is an object.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    ok: AssertFn<R>

    Asserts that the value is truthy.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    plainObject: AssertFn<R>

    Asserts that the value is a plain object.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    sealed: AssertFn<R>

    Asserts that the value is sealed.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    strictly: IStrictlyOp<R>

    Provides access to operations to confirm that the value strictly matches the type based on the used assertion operator.

    The custom message to display on evaluation.

    An object that provides operations to assert the value is strictly of the specified operation.

    string: AssertFn<R>

    Asserts that the value is a string.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    true: AssertFn<R>

    Asserts that the value is true.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    truthy: AssertFn<R>

    Asserts that the value is truthy.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    undefined: AssertFn<R>

    Asserts that the value is undefined.

    The custom message to display on evaluation.

    The current IAssertScope.that object.

    AssertionFailure - If the assertion fails.

    Settings

    Member Visibility

    On This Page

    Properties