@types/sinon

method usingAccessor

usingAccessor: <T, TKey extends keyof T, R extends T[TKey] = T[TKey]>(
    obj: T,
    prop: TKey,
    replacement: R
) => R;

• Assigns a value to a property on object with replacement argument. replacement can be any value, including spies, stubs and fakes. This method only works on accessor properties.

call signature

<T, TKey extends keyof T, R extends T[TKey] = T[TKey]>(
    obj: T,
    prop: TKey,
    replacement: R
): R;

• Replaces property on object with replacement argument. Attempts to replace an already replaced value cause an exception. replacement can be any value, including spies, stubs and fakes. This method only works on non-accessor properties, for replacing accessors, use sandbox.replaceGetter() and sandbox.replaceSetter().

method get

get: (key: any) => any;

method has

has: (el: any) => boolean;

property addBehavior

addBehavior: (
    name: string,
    fn: (fake: SinonStub, ...userArgs: any[]) => void
) => void;

• Add a custom behavior. The name will be available as a function on stubs, and the chaining mechanism will be set up for you (e.g. no need to return anything from your function, its return value will be ignored). The fn will be passed the fake instance as its first argument, and then the user's arguments.

property clock

clock: {
    create(now: number | Date): FakeTimers.Clock;
};

property defaultConfig

defaultConfig: Partial<SinonSandboxConfig>;

property expectation

expectation: SinonExpectationStatic;

property fakeServer

fakeServer: SinonFakeServerStatic;

property fakeServerWithClock

fakeServerWithClock: SinonFakeServerStatic;

property FakeXMLHttpRequest

FakeXMLHttpRequest: SinonFakeXMLHttpRequestStatic;

property setFormatter

setFormatter: (customFormatter: (...args: any[]) => string) => void;

• Replace the default formatter used when formatting ECMAScript object An example converts a basic object, such as {id: 42 }, to a string on a format of your choosing, such as "{ id: 42 }"

method createSandbox

createSandbox: (config?: Partial<SinonSandboxConfig>) => SinonSandbox;

• Creates a new sandbox object with spies, stubs, and mocks.

  Parameter config

method promise

promise: <T = unknown>(
    executor?: (
        resolve: (value: T) => void,
        reject: (reason?: unknown) => void
    ) => void
) => SinonPromise<T>;

method contains

contains: (expected: any[]) => SinonMatcher;

• Requires an Array to contain each one of the values the given array has.

method deepEquals

deepEquals: (expected: any[]) => SinonMatcher;

• Requires an Array to be deep equal another one.

method endsWith

endsWith: (expected: any[]) => SinonMatcher;

• Requires an Array to end with the same values as another one.

method startsWith

startsWith: (expected: any[]) => SinonMatcher;

• Requires an Array to start with the same values as another one.

property failException

failException: string;

• Defaults to AssertError.

method alwaysCalledOn

alwaysCalledOn: (spy: SinonSpy<any>, obj: any) => void;

• Passes if spy was always called with obj as its this value.

method alwaysCalledWith

alwaysCalledWith: <TArgs extends any[]>(
    spy: SinonSpy<TArgs>,
    ...args: MatchPartialArguments<TArgs>
) => void;

• Passes if spy was always called with the provided arguments.

  Parameter spy

  Parameter args

method alwaysCalledWithExactly

alwaysCalledWithExactly: <TArgs extends any[]>(
    spy: SinonSpy<TArgs>,
    ...args: MatchExactArguments<TArgs>
) => void;

• Passes if spy was always called with the provided arguments and no others.

method alwaysCalledWithMatch

alwaysCalledWithMatch: <TArgs extends any[]>(
    spy: SinonSpy<TArgs>,
    ...args: MatchPartialArguments<TArgs>
) => void;

• Passes if spy was always called with matching arguments. This behaves the same way as sinon.assert.alwaysCalledWith(spy, sinon.match(arg1), sinon.match(arg2), ...).

method alwaysThrew

alwaysThrew: {
    (spy: SinonSpy<any>): void;
    (spy: SinonSpy<any, any>, exception: string): void;
    (spy: SinonSpy<any, any>, exception: any): void;
};

• Like threw, only required for all calls to the spy.

method callCount

callCount: (spy: SinonSpy<any>, count: number) => void;

• Passes if spy was called exactly num times.

method called

called: (spy: SinonSpy<any>) => void;

• Passes if spy was called at least once.

method calledOn

calledOn: (spyOrSpyCall: SinonSpy<any> | SinonSpyCall<any>, obj: any) => void;

• Passes if spy was ever called with obj as its this value. It’s possible to assert on a dedicated spy call: sinon.assert.calledOn(spy.firstCall, arg1, arg2, ...);.

method calledOnce

calledOnce: (spy: SinonSpy<any>) => void;

• Passes if spy was called once and only once.

method calledOnceWithExactly

calledOnceWithExactly: <TArgs extends any[]>(
    spyOrSpyCall: SinonSpy<TArgs> | SinonSpyCall<TArgs>,
    ...args: MatchExactArguments<TArgs>
) => void;

• Passes if spy was called at exactly once with the provided arguments and no others.

  Parameter spyOrSpyCall

  Parameter args

method calledOnceWithMatch

calledOnceWithMatch: <TArgs extends any[]>(
    spyOrSpyCall: SinonSpy<TArgs> | SinonSpyCall<TArgs>,
    ...args: MatchPartialArguments<TArgs>
) => void;

• Passes if spy was called once with matching arguments. This behaves the same way as calling both sinon.assert.calledOnce(spy) and sinon.assert.calledWithMatch(spy, ...).

method calledThrice

calledThrice: (spy: SinonSpy<any>) => void;

• Passes if spy was called exactly three times.

method calledTwice

calledTwice: (spy: SinonSpy<any>) => void;

• Passes if spy was called exactly twice.

method calledWith

calledWith: <TArgs extends any[]>(
    spyOrSpyCall: SinonSpy<TArgs> | SinonSpyCall<TArgs>,
    ...args: MatchPartialArguments<TArgs>
) => void;

• Passes if spy was called with the provided arguments. It’s possible to assert on a dedicated spy call: sinon.assert.calledWith(spy.firstCall, arg1, arg2, ...);.

  Parameter spyOrSpyCall

  Parameter args

method calledWithExactly

calledWithExactly: <TArgs extends any[]>(
    spyOrSpyCall: SinonSpy<TArgs> | SinonSpyCall<TArgs>,
    ...args: MatchExactArguments<TArgs>
) => void;

• Passes if spy was called with the provided arguments and no others. It’s possible to assert on a dedicated spy call: sinon.assert.calledWithExactly(spy.getCall(1), arg1, arg2, ...);.

  Parameter spyOrSpyCall

  Parameter args

method calledWithMatch

calledWithMatch: <TArgs extends any[]>(
    spyOrSpyCall: SinonSpy<TArgs> | SinonSpyCall<TArgs>,
    ...args: MatchPartialArguments<TArgs>
) => void;

• Passes if spy was called with matching arguments. This behaves the same way as sinon.assert.calledWith(spy, sinon.match(arg1), sinon.match(arg2), ...). It's possible to assert on a dedicated spy call: sinon.assert.calledWithMatch(spy.secondCall, arg1, arg2, ...);.

method calledWithNew

calledWithNew: (spyOrSpyCall: SinonSpy<any> | SinonSpyCall<any>) => void;

• Passes if spy was called with the new operator. It’s possible to assert on a dedicated spy call: sinon.assert.calledWithNew(spy.secondCall, arg1, arg2, ...);.

  Parameter spyOrSpyCall

method callOrder

callOrder: (...spies: Array<SinonSpy<any>>) => void;

• Passes if provided spies were called in the specified order.

  Parameter spies

method expose

expose: (obj: any, options?: Partial<SinonExposeOptions>) => void;

• Exposes assertions into another object, to better integrate with the test framework. For instance, JsTestDriver uses global assertions, and to make Sinon.JS assertions appear alongside them, you can do.

  Example 1

  sinon.assert.expose(this); This will give you assertCalled(spy),assertCallOrder(spy1, spy2, ...) and so on. The method accepts an optional options object with two options.

method fail

fail: (message?: string) => void;

• Every assertion fails by calling this method. By default it throws an error of type sinon.assert.failException. If the test framework looks for assertion errors by checking for a specific exception, you can simply override the kind of exception thrown. If that does not fit with your testing framework of choice, override the fail method to do the right thing.

method match

match: (actual: any, expected: any) => void;

• Uses sinon.match to test if the arguments can be considered a match.

method neverCalledWith

neverCalledWith: <TArgs extends any[]>(
    spy: SinonSpy<TArgs>,
    ...args: MatchPartialArguments<TArgs>
) => void;

• Passes if spy was never called with the provided arguments.

  Parameter spy

  Parameter args

method neverCalledWithMatch

neverCalledWithMatch: <TArgs extends any[]>(
    spy: SinonSpy<TArgs>,
    ...args: MatchPartialArguments<TArgs>
) => void;

• Passes if spy was never called with matching arguments. This behaves the same way as sinon.assert.neverCalledWith(spy, sinon.match(arg1), sinon.match(arg2), ...).

  Parameter spy

  Parameter args

method notCalled

notCalled: (spy: SinonSpy<any>) => void;

• Passes if spy was never called

  Parameter spy

method pass

pass: (assertion: any) => void;

• Called every time assertion passes. Default implementation does nothing.

method threw

threw: {
    (spyOrSpyCall: SinonSpy<any> | SinonSpyCall<any>): void;
    (
        spyOrSpyCall: SinonSpyCall<any, any> | SinonSpy<any, any>,
        exception: string
    ): void;
    (
        spyOrSpyCall: SinonSpyCall<any, any> | SinonSpy<any, any>,
        exception: any
    ): void;
};

• Passes if spy threw any exception.

• Passes if spy threw the given exception. The exception is an actual object. It’s possible to assert on a dedicated spy call: sinon.assert.threw(spy.thirdCall, exception);.

• Passes if spy threw the given exception. The exception is a String denoting its type. It’s possible to assert on a dedicated spy call: sinon.assert.threw(spy.thirdCall, exception);.

method atLeast

atLeast: (n: number) => SinonExpectation;

• Specify the minimum amount of calls expected.

method atMost

atMost: (n: number) => SinonExpectation;

• Specify the maximum amount of calls expected.

  Parameter n

method exactly

exactly: (n: number) => SinonExpectation;

• Expect the method to be called exactly

  Parameter n

  times.

method never

never: () => SinonExpectation;

• Expect the method to never be called.

method on

on: (obj: any) => SinonExpectation;

method once

once: () => SinonExpectation;

• Expect the method to be called exactly once.

method restore

restore: () => void;

• Restores all mocked methods.

method thrice

thrice: () => SinonExpectation;

• Expect the method to be called exactly thrice.

method twice

twice: () => SinonExpectation;

• Expect the method to be called exactly twice.

method verify

verify: () => SinonExpectation;

• Verifies all expectations on the mock. If any expectation is not satisfied, an exception is thrown. Also restores the mocked methods.

method withArgs

withArgs: (...args: any[]) => SinonExpectation;

• Expect the method to be called with the provided arguments and possibly others. An expectation instance only holds onto a single set of arguments specified with withArgs. Subsequent calls will overwrite the previously-specified set of arguments (even if they are different), so it is generally not intended that this method be invoked more than once per test case.

  Parameter args

method withExactArgs

withExactArgs: (...args: any[]) => SinonExpectation;

• Expect the method to be called with the provided arguments and no others. An expectation instance only holds onto a single set of arguments specified with withExactArgs. Subsequent calls will overwrite the previously-specified set of arguments (even if they are different), so it is generally not intended that this method be invoked more than once per test case.

  Parameter args

method create

create: (methodName?: string) => SinonExpectation;

• Creates an expectation without a mock object, basically an anonymous mock function. Method name is optional and is used in exception messages to make them more readable.

  Parameter methodName

property includeFail

includeFail: boolean;

property prefix

prefix: string;

method rejects

rejects: <TArgs extends readonly any[] = any[], TReturnValue = any>(
    val: any
) => SinonSpy<TArgs, TReturnValue>;

• Creates a fake that returns a rejected Promise for the passed value. If an Error is passed as the value argument, then that will be the value of the promise. If any other value is passed, then that will be used for the message property of the Error returned by the promise.

  Parameter val

  Rejected promise

method resolves

resolves: <TArgs extends readonly any[] = any[], TReturnValue = any>(
    val: TReturnValue extends PromiseLike<infer TResolveValue>
        ? TResolveValue
        : any
) => SinonSpy<TArgs, TReturnValue>;

• Creates a fake that returns a resolved Promise for the passed value.

  Parameter val

  Resolved promise

method returns

returns: <TArgs extends readonly any[] = any[], TReturnValue = any>(
    val: TReturnValue
) => SinonSpy<TArgs, TReturnValue>;

• Creates a fake that returns the val argument

  Parameter val

  Returned value

method throws

throws: <TArgs extends readonly any[] = any[], TReturnValue = any>(
    val: Error | string
) => SinonSpy<TArgs, TReturnValue>;

• Creates a fake that throws an Error with the provided value as the message property. If an Error is passed as the val argument, then that will be the thrown value. If any other value is passed, then that will be used for the message property of the thrown Error.

  Parameter val

  Returned value or throw value if an Error

method yields

yields: <TArgs extends readonly any[] = any[], TReturnValue = any>(
    ...args: any[]
) => SinonSpy<TArgs, TReturnValue>;

• fake expects the last argument to be a callback and will invoke it with the given arguments.

method yieldsAsync

yieldsAsync: <TArgs extends readonly any[] = any[], TReturnValue = any>(
    ...args: any[]
) => SinonSpy<TArgs, TReturnValue>;

• fake expects the last argument to be a callback and will invoke it asynchronously with the given arguments.

call signature

<TArgs extends readonly any[] = any[], TReturnValue = any>(): SinonSpy<
    TArgs,
    TReturnValue
>;

• Creates a basic fake, with no behavior

call signature

<TArgs extends readonly any[] = any[], TReturnValue = any>(
    fn: (...args: TArgs) => TReturnValue
): SinonSpy<TArgs, TReturnValue>;

• Wraps an existing Function to record all interactions, while leaving it up to the func to provide the behavior. This is useful when complex behavior not covered by the sinon.fake.* methods is required or when wrapping an existing function or method.

property requests

requests: SinonFakeXMLHttpRequest[];

• You can inspect the server.requests to verify request ordering, find unmatched requests or check that no requests has been done. server.requests is an array of all the FakeXMLHttpRequest objects that have been created.

method getHTTPMethod

getHTTPMethod: (request: SinonFakeXMLHttpRequest) => string;

• Used internally to determine the HTTP method used with the provided request. By default this method simply returns request.method. When server.fakeHTTPMethods is true, the method will return the value of the _method parameter if the method is “POST”. This method can be overridden to provide custom behavior.

  Parameter request

method respond

respond: () => void;

• Causes all queued asynchronous requests to receive a response. If none of the responses added through respondWith match, the default response is [404, {}, ""]. Synchronous requests are responded to immediately, so make sure to call respondWith upfront. If called with arguments, respondWith will be called with those arguments before responding to requests.

method respondWith

respondWith: {
    (body: string): void;
    (response: any[]): void;
    (fn: (xhr: SinonFakeXMLHttpRequest) => void): void;
    (url: string, body: string): void;
    (url: string, response: any[]): void;
    (url: string, fn: (xhr: SinonFakeXMLHttpRequest) => void): void;
    (method: string, url: string, body: string): void;
    (method: string, url: string, response: any[]): void;
    (
        method: string,
        url: string,
        fn: (xhr: SinonFakeXMLHttpRequest) => void
    ): void;
    (url: RegExp, body: string): void;
    (url: RegExp, response: any[]): void;
    (url: RegExp, fn: (xhr: SinonFakeXMLHttpRequest) => void): void;
    (method: string, url: RegExp, body: string): void;
    (method: string, url: RegExp, response: any[]): void;
    (
        method: string,
        url: RegExp,
        fn: (xhr: SinonFakeXMLHttpRequest) => void
    ): void;
};

• Causes the server to respond to any request not matched by another response with the provided data. The default catch-all response is [404, {}, ""]. A String representing the response body An Array with status, headers and response body, e.g. [200, { "Content-Type": "text/html", "Content-Length": 2 }, "OK"] A Function. Default status is 200 and default headers are none. When the response is a Function, it will be passed the request object. You must manually call respond on it to complete the request.

  Parameter body

  A String representing the response body

• Causes the server to respond to any request not matched by another response with the provided data. The default catch-all response is [404, {}, ""]. Default status is 200 and default headers are none. When the response is a Function, it will be passed the request object. You must manually call respond on it to complete the request.

  Parameter response

  An Array with status, headers and response body, e.g. [200, { "Content-Type": "text/html", "Content-Length": 2 }, "OK"]

• Causes the server to respond to any request not matched by another response with the provided data. The default catch-all response is [404, {}, ""]. Default status is 200 and default headers are none. When the response is a Function, it will be passed the request object. You must manually call respond on it to complete the request.

  Parameter fn

  A Function.

• Responds to all requests to given URL, e.g. /posts/1.

• Responds to all method requests to the given URL with the given response. method is an HTTP verb.

• URL may be a regular expression, e.g. /\/post\//\d+ If the response is a Function, it will be passed any capture groups from the regular expression along with the XMLHttpRequest object:

• Responds to all method requests to URLs matching the regular expression.

method restore

restore: () => void;

property autoRespond

autoRespond: boolean;

• When set to true, causes the server to automatically respond to incoming requests after a timeout. The default timeout is 10ms but you can control it through the autoRespondAfter property. Note that this feature is intended to help during mockup development, and is not suitable for use in tests.

property autoRespondAfter

autoRespondAfter: number;

• When autoRespond is true, respond to requests after this number of milliseconds. Default is 10.

property fakeHTTPMethods

fakeHTTPMethods: boolean;

• If set to true, server will find _method parameter in POST body and recognize that as the actual method. Supports a pattern common to Ruby on Rails applications. For custom HTTP method faking, override server.getHTTPMethod(request).

property respondImmediately

respondImmediately: boolean;

• If set, the server will respond to every request immediately and synchronously. This is ideal for faking the server from within a test without having to call server.respond() after each request made in that test. As this is synchronous and immediate, this is not suitable for simulating actual network latency in tests or mockups. To simulate network latency with automatic responses, see server.autoRespond and server.autoRespondAfter.

method create

create: (options?: Partial<SinonFakeServerOptions>) => SinonFakeServer;

property eventListeners

eventListeners: {
    progress: any[];
    load: any[];
    abort: any[];
    error: any[];
};

method addEventListener

addEventListener: (event: string, listener: (e: Event) => any) => void;

method dispatchEvent

dispatchEvent: (event: Event) => void;

method removeEventListener

removeEventListener: (event: string, listener: (e: Event) => any) => void;

property async

async: boolean;

• Whether or not the request is asynchronous.

property method

method: string;

• The request method as a string.

property password

password: string;

• Password, if any.

property requestBody

requestBody: string;

• The request body

property requestHeaders

requestHeaders: any;

• An object of all request headers, i.e.:

property responseXML

responseXML: Document;

• When using respond, this property is populated with a parsed document if response headers indicate as much (see the spec)

property status

status: number;

• The request’s status code. undefined if the request has not been handled (see respond below)

property statusText

statusText: string;

• Only populated if the respond method is called (see below).

property upload

upload: SinonFakeUploadProgress;

property url

url: string;

• The URL set on the request object.

property username

username: string;

• Username, if any.

property withCredentials

withCredentials: boolean;

method autoRespond

autoRespond: (ms: number) => void;

method error

error: () => void;

• Simulates a network error on the request. The onerror handler will be called and the status will be 0.

method getAllResponseHeaders

getAllResponseHeaders: () => any;

• All response headers as an object.

method getResponseHeader

getResponseHeader: (header: string) => string;

• The value of the given response header, if the request has been responded to (see respond).

  Parameter header

method onerror

onerror: () => void;

method respond

respond: (status: number, headers: any, body: string) => void;

• Calls the above three methods.

method setResponseBody

setResponseBody: (body: string) => void;

• Sets the respond body, updates the readyState property and fires onreadystatechange. Additionally, populates responseXML with a parsed document if response headers indicate as much.

method setResponseHeaders

setResponseHeaders: (headers: any) => void;

• Sets response headers (e.g. { "Content-Type": "text/html", ... }, updates the readyState property and fires onreadystatechange.

  Parameter headers

property useFilters

useFilters: boolean;

• Default false. When set to true, Sinon will check added filters if certain requests should be “unfaked”

method addFilter

addFilter: (
    filter: (
        method: string,
        url: string,
        async: boolean,
        username: string,
        password: string
    ) => boolean
) => void;

• Add a filter that will decide whether or not to fake a request. The filter will be called when xhr.open is called, with the exact same arguments (method, url, async, username, password). If the filter returns true, the request will not be faked.

  Parameter filter

method onCreate

onCreate: (xhr: SinonFakeXMLHttpRequest) => void;

• By assigning a function to the onCreate property of the returned object from useFakeXMLHttpRequest() you can subscribe to newly created FakeXMLHttpRequest objects. See below for the fake xhr object API. Using this observer means you can still reach objects created by e.g. jQuery.ajax (or other abstractions/frameworks).

  Parameter xhr

method restore

restore: () => void;

• Restore original function(s).

construct signature

new (): SinonFakeXMLHttpRequest;

method contains

contains: (expected: SimplifiedMap) => SinonMatcher;

• Requires a Map to contain each one of the items the given map has.

method deepEquals

deepEquals: (expected: SimplifiedMap) => SinonMatcher;

• Requires a Map to be deep equal another one.

property any

any: SinonMatcher;

• Matches anything.

property array

array: SinonArrayMatcher;

• Requires the value to be an Array.

property bool

bool: SinonMatcher;

• Requires the value to be a Boolean

property date

date: SinonMatcher;

• Requires the value to be a Date object.

property defined

defined: SinonMatcher;

• Requires the value to be defined.

property falsy

falsy: SinonMatcher;

• Requires the value to be falsy.

property func

func: SinonMatcher;

• Requires the value to be a Function.

property map

map: SinonMapMatcher;

• Requires the value to be a Map.

property number

number: SinonMatcher;

• Requires the value to be a Number.

property object

object: SinonMatcher;

• Requires the value to be an Object.

property regexp

regexp: SinonMatcher;

• Requires the value to be a regular expression.

property set

set: SinonSetMatcher;

• Requires the value to be a Set.

property string

string: SinonMatcher;

• Requires the value to be a String.

property symbol

symbol: SinonMatcher;

• Requires the value to be a Symbol.

property truthy

truthy: SinonMatcher;

• Requires the value to be truthy.

method every

every: (matcher: SinonMatcher) => SinonMatcher;

• Requires every element of an Array, Set or Map, or alternatively every value of an Object to match the given matcher.

method has

has: (property: string, expect?: any) => SinonMatcher;

• Requires the value to define the given property. The property might be inherited via the prototype chain. If the optional expectation is given, the value of the property is deeply compared with the expectation. The expectation can be another matcher.

  Parameter property

  Parameter expect

method hasNested

hasNested: (path: string, expect?: any) => SinonMatcher;

• Requires the value to define the given propertyPath. Dot (prop.prop) and bracket (prop[0]) notations are supported as in Lodash.get. The propertyPath might be inherited via the prototype chain. If the optional expectation is given, the value at the propertyPath is deeply compared with the expectation. The expectation can be another matcher.

method hasOwn

hasOwn: (property: string, expect?: any) => SinonMatcher;

• Same as sinon.match.has but the property must be defined by the value itself. Inherited properties are ignored.

  Parameter property

  Parameter expect

method in

in: (allowed: any[]) => SinonMatcher;

• Requires the value to be in the specified array.

method instanceOf

instanceOf: (type: any) => SinonMatcher;

• Requires the value to be an instance of the given type.

method same

same: (obj: any) => SinonMatcher;

• Requires the value to strictly equal ref.

method some

some: (matcher: SinonMatcher) => SinonMatcher;

• Requires any element of an Array, Set or Map, or alternatively any value of an Object to match the given matcher.

method typeOf

typeOf: (type: string) => SinonMatcher;

• Requires the value to be of the given type, where type can be one of "undefined", "null", "boolean", "number", "string", "object", "function", "array", "regexp", "date" or "symbol".

call signature

(value: number): SinonMatcher;

• Requires the value to be == to the given number.

call signature

(value: string): SinonMatcher;

• Requires the value to be a string and have the expectation as a substring.

call signature

(expr: RegExp): SinonMatcher;

• Requires the value to be a string and match the given regular expression.

call signature

(callback: (value: any) => boolean, message?: string): SinonMatcher;

• See custom matchers.

call signature

(obj: object): SinonMatcher;

• Requires the value to be not null or undefined and have at least the same properties as expectation. This supports nested matchers.

method and

and: (expr: SinonMatcher) => SinonMatcher;

• All matchers implement and and or. This allows to logically combine mutliple matchers. The result is a new matchers that requires both (and) or one of the matchers (or) to return true.

  Example 1

  var stringOrNumber = sinon.match.string.or(sinon.match.number); var bookWithPages = sinon.match.instanceOf(Book).and(sinon.match.has("pages"));

method or

or: (expr: SinonMatcher) => SinonMatcher;

• All matchers implement and and or. This allows to logically combine mutliple matchers. The result is a new matchers that requires both (and) or one of the matchers (or) to return true.

  Example 1

  var stringOrNumber = sinon.match.string.or(sinon.match.number); var bookWithPages = sinon.match.instanceOf(Book).and(sinon.match.has("pages"));

method test

test: (val: any) => boolean;

method expects

expects: (method: string) => SinonExpectation;

• Overrides obj.method with a mock function and returns it.

method restore

restore: () => void;

• Restores all mocked methods.

method verify

verify: () => void;

• Verifies all expectations on the mock. If any expectation is not satisfied, an exception is thrown. Also restores the mocked methods.

call signature

(name?: string): SinonExpectation;

call signature

(obj: any): SinonMock;

• Creates a mock for the provided object. Does not change the object, but returns a mock object to set expectations on the object’s methods.

property assert

assert: SinonAssert;

• A convenience reference for sinon.assert Since sinon@2.0.0

property clock

clock: SinonFakeTimers;

property fake

fake: SinonFake;

property match

match: SinonMatch;

property mock

mock: SinonMockStatic;

• Works exactly like sinon.mock

property replace

replace: SandboxReplace;

property requests

requests: SinonFakeXMLHttpRequest[];

property server

server: SinonFakeServer;

property spy

spy: SinonSpyStatic;

• Works exactly like sinon.spy

property stub

stub: SinonStubStatic;

• Works exactly like sinon.stub.

method createStubInstance

createStubInstance: <TType>(
    constructor: StubbableType<TType>,
    overrides?: {
        [K in keyof TType]?:
            | SinonStubbedMember<TType[K]>
            | (TType[K] extends (...args: any[]) => infer R ? R : TType[K]);
    }
) => SinonStubbedInstance<TType>;

• Creates a new object with the given functions as the prototype and stubs all implemented functions.

  TType Type being stubbed.

  Parameter constructor

  Object or class to stub.

  Parameter overrides

  An optional map overriding created stubs

  Returns

  A stubbed version of the constructor.

  Remarks

  The given constructor function is not invoked. See also the stub API.

method define

define: (obj: object, key: PropertyKey, value: unknown) => void;

• Defines a property on the given object which will be torn down when the sandbox is restored

method replaceGetter

replaceGetter: <T, TKey extends keyof T>(
    obj: T,
    prop: TKey,
    replacement: () => T[TKey]
) => () => T[TKey];

• Replaces getter for property on object with replacement argument. Attempts to replace an already replaced getter cause an exception. replacement must be a Function, and can be instances of spies, stubs and fakes.

  Parameter obj

  Parameter prop

  Parameter replacement

method replaceSetter

replaceSetter: <T, TKey extends keyof T>(
    obj: T,
    prop: TKey,
    replacement: (val: T[TKey]) => void
) => (val: T[TKey]) => void;

• Replaces setter for property on object with replacement argument. Attempts to replace an already replaced setter cause an exception. replacement must be a Function, and can be instances of spies, stubs and fakes.

  Parameter obj

  Parameter prop

  Parameter replacement

method reset

reset: () => void;

• Resets the internal state of all fakes created through sandbox.

method resetBehavior

resetBehavior: () => void;

• Resets the behaviour of all stubs created through the sandbox. Since sinon@2.0.0

method resetHistory

resetHistory: () => void;

• Resets the history of all stubs created through the sandbox. Since sinon@2.0.0

method restore

restore: () => void;

• Restores all fakes created through sandbox.

method useFakeServer

useFakeServer: () => SinonFakeServer;

• Fakes XHR and binds a server object to the sandbox such that it too is restored when calling sandbox.restore(). Access requests through sandbox.requests and server through sandbox.server

method useFakeTimers

useFakeTimers: (
    config?: number | Date | Partial<FakeTimers.FakeTimerInstallOpts>
) => SinonFakeTimers;

• * No param : Causes Sinon to replace the global setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, clearImmediate, process.hrtime, performance.now(when available) and Date with a custom implementation which is bound to the returned clock object. Starts the clock at the UNIX epoch (timestamp of 0). * Now : As above, but rather than starting the clock with a timestamp of 0, start at the provided timestamp now. Since sinon@2.0.0 You can also pass in a Date object, and its getTime() will be used for the starting timestamp. * Config : As above, but allows further configuration options, some of which are: * config.now - Number/Date - installs lolex with the specified unix epoch (default: 0) * config.toFake - String[ ] - an array with explicit function names to fake. By default lolex will automatically fake all methods except process.nextTick. You could, however, still fake nextTick by providing it explicitly * config.shouldAdvanceTime - Boolean - tells lolex to increment mocked time automatically based on the real system time shift (default: false) * Please visit the lolex.install documentation for the full feature set. * Important note: when faking nextTick, normal calls to process.nextTick() would not execute automatically as they would during normal event-loop phases. You would have to call either clock.next(), clock.tick(), clock.runAll() or clock.runToLast() (see example below). Please refer to the lolex documentation for more information.

  Parameter config

method useFakeXMLHttpRequest

useFakeXMLHttpRequest: () => SinonFakeXMLHttpRequestStatic;

• Causes Sinon to replace the native XMLHttpRequest object in browsers that support it with a custom implementation which does not send actual requests. In browsers that support ActiveXObject, this constructor is replaced, and fake objects are returned for XMLHTTP progIds. Other progIds, such as XMLDOM are left untouched. The native XMLHttpRequest object will be available at sinon.xhr.XMLHttpRequest

method usingPromise

usingPromise: (promiseLibrary: any) => SinonSandbox;

• Causes all stubs created from the sandbox to return promises using a specific Promise library instead of the global one when using stub.rejects or stub.resolves. Returns the stub to allow chaining. Since sinon@2.0.0

method verify

verify: () => void;

• Verifies all mocks created through the sandbox.

method verifyAndRestore

verifyAndRestore: () => void;

• Verifies all mocks and restores all fakes created through the sandbox.

property assertOptions

assertOptions: {
    shouldLimitAssertionLogs?: boolean;
    assertionLogLimit?: number;
};

• The assert options can help limit the amount of output produced by assert.fail

property injectInto

injectInto: object | null;

• The sandbox’s methods can be injected into another object for convenience. The injectInto configuration option can name an object to add properties to.

property properties

properties: string[];

• What properties to inject. Note that simply naming “server” here is not sufficient to have a server property show up in the target object, you also have to set useFakeServer to true.

property useFakeServer

useFakeServer: boolean | SinonFakeServer;

• If true, server and requests properties are added to the sandbox. Can also be an object to use for fake server. The default one is sinon.fakeServer, but if you’re using jQuery 1.3.x or some other library that does not set the XHR’s onreadystatechange handler, you might want to do:

property useFakeTimers

useFakeTimers: boolean | Partial<FakeTimers.FakeTimerInstallOpts>;

• If set to true, the sandbox will have a clock property. You can optionally pass in a configuration object that follows the specification for fake timers, such as { toFake: ["setTimeout", "setInterval"] }.

method contains

contains: (expected: SimplifiedSet) => SinonMatcher;

• Requires a Set to contain each one of the items the given set has.

method deepEquals

deepEquals: (expected: SimplifiedSet) => SinonMatcher;

• Requires a Set to be deep equal another one.