alsatian-fluent-assertions/dist/matchers/i-simple-matcher.d.ts

Fluent assertions extension to Alsatian xUnit framework.

import { EqType, At } from "../types";
import { IFluentCore } from "./i-fluent-core";
import { INarrowableFluentCore } from "./i-narrowable-fluent-core";
/** Fluent API for simple (as opposed to property) assertions. */
export interface ISimpleMatcher<T, TNext, TPrev> {
    /**
     * Looks for the expected substring within the string.
     * For array contains, see hasElements.
     * @param expected substring to match
     * @param location where to look for the substring (default: At.anywhere)
     */
    contains(expected: T, location?: At): IFluentCore<T, TNext, TPrev>;
    /**
     * Strictly (===) compares the contextual value with the expected value.
     * Helper method for equal(...). See https://git.io/vptAT.
     * @param expected The expected value.
     */
    strictlyEquals(expected: T): IFluentCore<T, TNext, TPrev>;
    /**
     * Loosely (==) compares the contextual value with the expected value.
     * See https://git.io/vptAT.
     * @param expected The expected value.
     */
    looselyEquals(expected: T): IFluentCore<T, TNext, TPrev>;
    /**
     * Recursively compares the contextual value with the expected value.
     * See https://git.io/vptAT.
     * @param expected The expected value.
     * @param eqType The comparison type, either EqType.strictly or EqType.loosely (default: strictly).
     */
    deeplyEquals(expected: T, eqType?: EqType.strictly | EqType.loosely): IFluentCore<T, TNext, TPrev>;
    /**
     * Performs a loose, recursive comparison of the contextual value with the expected value.
     * See https://git.io/vptAT.
     * @param expected The expected value.
     */
    deepLooselyEquals(expected: T): IFluentCore<T, TNext, TPrev>;
    /**
     * Performs a strict, recursive comparison of the contextual value with the expected value.
     * See https://git.io/vptAT.
     * @param expected The expected value.
     */
    deepStrictlyEquals(expected: T): IFluentCore<T, TNext, TPrev>;
    /**
     * Checks whether the value is defined.
     * See https://git.io/vptAD.
     */
    isDefined(): IFluentCore<T, TNext, TPrev>;
    /**
     * Checks whether the value is null.
     * See
     */
    isNull(): IFluentCore<T, TNext, TPrev>;
    /**
     * Validates the contextual, string value with a regular expression. Preserves context.
     * See https://git.io/vptxm.
     * @param matcher The regular expression to validate the contextual value.
     */
    matches(matcher: RegExp): IFluentCore<string, TNext, TPrev>;
    /**
     * Same as matches, except that it narrows the context to the matches themselves.
     * See https://git.io/vptxm.
     * @param matcher The regular expression to match the contextual value.
     */
    hasMatch(matcher: RegExp): INarrowableFluentCore<T, Array<string>, TPrev>;
    /**
     * Validates whether the contextual value (a lambda function) throws an Error.
     * Narrows the fluent context to the error object.
     * See https://git.io/vptxL.
     */
    throws(): INarrowableFluentCore<T, Error, TPrev>;
    /**
     * Validates whether the contextual value (a lambda function) throws an Error of the given type.
     * Narrows the fluent context to the error object.
     * See https://git.io/vptxL.
     *
     * @param errorType The type of the Error.
     * @returns A fluent context for the error object.
     */
    throws<TError extends Error>(errorType?: {
        new (...args: Array<any>): TError;
    }): INarrowableFluentCore<T, TError, TPrev>;
    /** Same as throws, but for asynchronous methods. */
    throwsAsync(): Promise<INarrowableFluentCore<T, Error, TPrev>>;
    /** Same as throws, but for asynchronous methods. */
    throwsAsync<TError extends Error>(errorType?: {
        new (...args: Array<any>): TError;
    }): Promise<INarrowableFluentCore<T, TError, TPrev>>;
    /**
     * Checks whether the contextual value satisfies the given predicate function.
     * See https://git.io/vptxf.
     * @param predicate A function returning a boolean value.
     */
    satisfies(predicate: (t: T) => boolean): IFluentCore<T, TNext, TPrev>;
    /**
     * Checks whether the contextual value is an instance of the given type.
     * See https://git.io/vptAr.
     * @param expectedType The expected type.
     */
    is(expectedType: {
        new (...args: Array<any>): any;
    }): IFluentCore<T, TNext, TPrev>;
    /**
     * Ensures the expected object contains the given property.
     * See https://git.io/vptAY.
     * @param expected Either a key or a property selector method.
     */
    hasProperty<R>(expected: ((o: T) => R) | keyof T): INarrowableFluentCore<T, R, TPrev>;
    /**
     * Asserts that the list contains one element. Throws if not a list.
     * See https://git.io/vptAR.
     */
    hasSingle(): T extends Array<any> ? INarrowableFluentCore<T, T[0], TPrev> : void;
    /**
     * Checks whether the given array, object, or string is empty.
     * See https://git.io/vptAb.
     */
    isEmpty(): IFluentCore<T, TNext, TPrev>;
    /**
     * Asserts that the value can be coerced to false (e.g., !value === true). Ex: empty strings,
     * zero, null, undefined, false, etc.
     * See https://git.io/vptAx.
     */
    isFalsy(): IFluentCore<T, TNext, TPrev>;
    /**
     * Asserts that the value can be coerced to true. Ex: non-empty strings, numbers not equal
     * to zero, objects, true, etc.
     * See https://git.io/vptAh.
     */
    isTruthy(): IFluentCore<T, TNext, TPrev>;
    /**
     * Performs the specified transformation and returns the result in the fluent context.
     * Shorthand for `hasProperty(o => transform(o)).that.` (obviates `that`).
     * Included for clarity.
     * See https://git.io/vptNj.
     */
    converted<R>(lambda: (v: T) => R): IFluentCore<R, TNext, TPrev>;
}