TypeMoq [![build badge](https://travis-ci.org/florinn/typemoq.svg?branch=master)](https://travis-ci.org/florinn/typemoq) =================== Simple mocking library for JavaScript targeting [TypeScript](http://www.typescriptlang.org/) development. If you have used before a library like [Moq](https://github.com/Moq/moq4) then the syntax should look familiar, otherwise the examples below should hopefully provide enough information to get you started quickly. Features ------------- * Strongly typed * Auto complete/intellisense support * Static and dynamic mocking * Mock objects, classes (with arguments), constructor functions and interfaces * Control mock behavior * Record and replay expectations * Auto sandbox global objects and types * Support ECMAScript 5 and 6 * Support node.js and browser [![Sauce Test Status](https://saucelabs.com/browser-matrix/florinn.svg)](https://saucelabs.com/u/florinn) Installing ------------- ###### Release version ``` npm install typemoq ``` Or add this *NuGet* dependency to your project: ``` PM> Install-Package typemoq ``` The distribution directory should contain: * *Compiled JavaScript:* `typemoq.js` and its minified version `typemoq-min.js` * *TypeScript definitions:* `typemoq.d.ts` ###### Development version ``` npm install https://github.com/florinn/typemoq ``` ##### Node.js ###### TypeScript 1.6 and later ```typescript import * as TypeMoq from "typemoq"; ``` ###### TypeScript pre 1.6 ```typescript /// TypeMoq = require("typemoq"); ``` ##### Browser Include at the top of your script file: ```typescript /// import * as TypeMoq from "typemoq"; ``` TypeMoq requires some dependencies to run, so make sure to include them in your page before `typemoq.js`: ```html ``` Also in your `tsconfig.json` you need to set the module target as `UMD`: ``` "compilerOptions": { ... "module": "UMD", ... } ``` At this point you should have access in your script to a global variable named `TypeMoq`. Usage ------------- After importing TypeMoq into your project, the following types should be available: Type | Description ---- | ---- *TypeMoq.Mock* | Used for creating 'regular' mocks (see [Create mocks](#create-mocks) and [Setup mocks](#setup-mocks)) *TypeMoq.MockBehavior* | Used to specify how the mock should act when no expectations are defined (see [Control mock behavior](#control-mock-behavior)) *TypeMoq.It* | Helper for matching arguments (see [Setup mocks](#setup-mocks) and [Verify expectations](#verify-expectations)) *TypeMoq.Times* | Helper for performing verification (see [Verify expectations](#verify-expectations)) *TypeMoq.GlobalMock* | Used to create 'global' mocks corresponding to global objects (see [Create global mocks](#create-global-mocks)) *TypeMoq.GlobalScope* | Used to create an execution context that makes use of any specified 'global' mocks (see [Auto sandbox global mocks](#auto-sandbox-global-mocks)) *TypeMoq.MockException* | Exception thrown internally containing debug info ### Create mocks #### Static mocks Static mocks can be created either from class types and constructor arguments or from existing objects, including function objects. ##### Using class types and constructor arguments ```typescript (method) TypeMoq.Mock.ofType(targetConstructor?: { new (...ctorArgs: any[]): T; prototype: Object; }, behavior?: TypeMoq.MockBehavior, shouldOverrideTarget?: boolean, ...targetConstructorArgs: any[]): TypeMoq.IMock (method) TypeMoq.Mock.ofType2(targetConstructor: { new (...ctorArgs: any[]): T; prototype: Object; }, targetConstructorArgs: any[], behavior?: TypeMoq.MockBehavior, shouldOverrideTarget?: boolean): TypeMoq.IMock ``` * *targetConstructor* - target constructor type * *...targetConstructorArgs* - target constructor args * *behavior* - mock behavior (see [Control mock behavior](#control-mock-behavior)) * *shouldOverrideTarget* - override target properties (see [Override target properties](#override-target-properties)) **Note:** During the creation of the static mock, the target object is being instantiated as a regular JavaScript object by executing the target constructor with any provided constructor args Examples: ```typescript interface IBar { value: string; anyValue: any; } class Bar implements IBar { value: string = ''; anyValue: any = undefined; } class Foo { constructor(private _bar: IBar) { this._bar = _bar || new Bar(); } get bar(): IBar { return this._bar; } do(stringValue: string) { return 'Foo.do:' + stringValue; } setBar(value: string) { this._bar.value = value; } } class GenericFoo { private _bar: T; constructor(barCtor?: { new (): T }, public numberValue?: number) { this._bar = new barCtor(); } get bar(): T { return this._bar; } do(stringValue: string) { return 'GenericFoo.do:' + stringValue + ': ' + this._bar.toString(); } } // Using class as constructor parameter const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(Bar); // Using class as constructor parameter and casting result to interface const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(Bar); // Using interface as type variable and class as constructor parameter const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(Bar); // Using class as constructor parameter and constructor arguments const bar = new Bar(); const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(Foo, TypeMoq.MockBehavior.Loose, bar); // Using a generic class as constructor parameter and constructor arguments const mock: TypeMoq.IMock> = TypeMoq.Mock.ofType(GenericFoo, TypeMoq.MockBehavior.Loose, Bar, 999); ``` ##### Using existing objects, including function objects ```typescript (method) TypeMoq.Mock.ofInstance( targetInstance: T, behavior?: TypeMoq.MockBehavior, shouldOverrideTarget?: boolean): TypeMoq.IMock ``` * *targetInstance* - target object * *behavior* - mock behavior (see [Control mock behavior](#control-mock-behavior)) * *shouldOverrideTarget* - override target properties (see [Override target properties](#override-target-properties)) **Note:** To create the static mock, the provided target object is replaced by a deep clone which is accesible through the `.target` property of the resulting mock object Examples: ```typescript function someFunc() { return "someFunc was called"; } function someFuncWithArgs(a: any, b: any, c: any) { return "someFuncWithArgs was called"; } // From an existing object const bar = new Bar(); const mock: TypeMoq.IMock = TypeMoq.Mock.ofInstance(bar); // Or from function objects const mock1: TypeMoq.IMock<() => string> = TypeMoq.Mock.ofInstance(someFunc); const mock2: TypeMoq.IMock<(a: any, b: any, c: any)=>string> = TypeMoq.Mock.ofInstance(someFuncWithArgs); ``` #### Dynamic mocks **Important:** Dynamic mocking requires the runtime (browser or node.js) to support the `Proxy` global object added in ECMAScript 6. If `Proxy` is not detected, TypeMoq is going to throw a MockException. A dynamic mock is created by specifying just a type parameter and some optional args: ```typescript (method) TypeMoq.Mock.ofType(targetConstructor?: { new (...ctorArgs: any[]): T; prototype: Object; }, behavior?: TypeMoq.MockBehavior, shouldOverrideTarget?: boolean): TypeMoq.IMock ``` * *targetConstructor* - always `undefined` for dynamic mocks * *behavior* - mock behavior (see [Control mock behavior](#control-mock-behavior)) * *shouldOverrideTarget* - override target properties (see [Override target properties](#override-target-properties)) **Note:** While creating the dynamic mock, the target object is **not** instantiated by executing the constructor of the provided type parameter The following type parameters are supported: * `Function` (as the type of a [function object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)) ```typescript // Using Function as type parameter const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(); ``` * a class type ```typescript // Using the 'instance' side of the class as type parameter const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(); // Specifying mock behavior const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(undefined, TypeMoq.MockBehavior.Loose); ``` * a constructor function ```typescript // Using the 'static' side of the class as type parameter const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(); ``` * an interface type ```typescript // Using an interface as type parameter const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(); ``` As opposed to static mocks, dynamic mocks have some limitations: * No partial mocking * No embedded mocks passed as constructor arguments * Properties return by default a `function` object and not `undefined` ```typescript interface IThing { getA(a: string): string; getB(b: number): number; getC(): boolean; valueA: string; } const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(); expect(mock.object.getA("abc")).to.be.undefined; expect(mock.object.getB(123)).to.be.undefined; expect(mock.object.getC()).to.be.undefined; expect(mock.object.valueA).to.be.a("function"); ``` As a workaround you may set the property to return `undefined`: ```typescript mock.setup(x => x.valueA).returns(() => undefined); expect(mock.object.valueA).to.be.undefined; ``` This limitation also impacts the scenario where a mocked object is passed to `Promise.resolve`. To be able to handle such scenario, the mocked object must be set as a thenable (i.e. has a "then" method) by returning `undefined` or another value: ```typescript mock.setup((x: any) => x.then).returns(() => undefined); Promise.resolve(mock.object) .then(x => { expect(x).eql(mock.object); }); ``` #### Mocks type Mocks (created in any of the ways listed above) have the type `IMock` and expose a couple important properties: * `(property) TypeMoq.IMock.object: T` - the actual mock object (that has the same type T as the class or object being mocked) * `(property) TypeMoq.IMock.target: T` - the underlying object being mocked ### Setup mocks Mocks allow to match functions, methods and properties and setup return callbacks or exceptions to throw. ```typescript (method) TypeMoq.IMock.setup( expression: (x: T) => TResult): TypeMoq.MethodCallReturn ``` `setup` accepts a function (also referred as 'matcher') taking as input argument the type being mocked and as body the value/property/method (with arguments if that's the case) to match. ##### Parameter matchers Matcher | Description ---- | ---- ```TypeMoq.It.isValue(x: T)``` | Performs deep comparison against the provided object or basic value ```TypeMoq.It.isObjectWith(x: Object)``` | Performs partial deep comparison against the provided object ```TypeMoq.It.isAny()``` | Matches any type ```TypeMoq.It.isAnyObject(x: Ctor)``` | Matches any object compatible with the provided type ```TypeMoq.It.isAnyString()``` | Matches any string ```TypeMoq.It.isAnyNumber()``` | Matches any number ```TypeMoq.It.is(predicate: IFunc2)``` | Performs comparison using the provided predicate If no matcher is specified then an implicit matcher is considered that performs strict equality deep comparison, equivalent to `TypeMoq.It.is(x => _.isEqual(x, a))`. ##### Matching functions ```typescript // Match a no args function const mock: TypeMoq.IMock<() => string> = TypeMoq.Mock.ofInstance(someFunc); mock.setup(x => x()).returns(() => "At vero eos et accusamus"); // Match a function with args const mock: TypeMoq.IMock<(a: any, b: any, c: any) => string> = TypeMoq.Mock.ofInstance(someFuncWithArgs); mock.setup(x => x(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => "At vero eos et accusamus"); ``` ##### Matching methods ```typescript class Doer { doVoid(): void { } doNumber(n?: number): number { return n || 101; } doString(s?: string): string { return s || 'xyz'; } doObject(o?: Object): Object { return o || new Object(); } doBar(b?: Bar): Bar { return b; } } const mock = TypeMoq.Mock.ofType(Doer); // Match a no args method mock.setup(x => x.doNumber()); // Match a method with explicit number value params mock.setup(x => x.doNumber(TypeMoq.It.isValue(321))); // Match a method with implicit number value params mock.setup(x => x.doNumber(321)); // Match a method with explicit string value params mock.setup(x => x.doString(TypeMoq.It.isValue("abc"))); // Match a method with implicit string value params mock.setup(x => x.doString("abc")); // Match a method with object value params const bar = new Bar(); mock.setup(x => x.doObject(TypeMoq.It.isAnyObject(Bar))); // Match a method with implicit object value params const anObject = {}; mock.setup(x => x(anObject)).returns(() => 123); expect(mock.object(anObject)).to.eq(123); // Match a method with any string params mock.setup(x => x.doString(TypeMoq.It.isAnyString())); // Match a method with any number params mock.setup(x => x.doNumber(TypeMoq.It.isAnyNumber())); // Match a method with any interface/class params mock.setup(x => x.doBar(TypeMoq.It.isAnyObject(Bar))); // Match a method by a param predicate const bar1 = new Bar(); bar1.value = "Ut enim ad minim veniam"; const bar2 = new Bar(); const mock = TypeMoq.Mock.ofType(Doer); mock.setup(x => x.doBar(TypeMoq.It.is((x: Bar) => x.value === "Ut enim ad minim veniam"))).returns(() => bar2); ``` To be able to match the static methods of some class, you would need to create a dynamic mock of the type of the class itself. E.g. ```typescript class Greeter { private static _instance: Greeter | null; static instance(): Greeter { if (!this._instance) { this._instance = new Greeter(); } return this._instance; } greet(): string { return 'Hello'; } } const greeter = Greeter.instance(); const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(); mock.setup(x => x.instance()).returns(() => greeter); expect(mock.object.instance()).to.eq(greeter); ``` ##### Matching properties ```typescript class FooWithPublicGetterAndSetter { private _foo: string; public get foo(): string { return this._foo; } public set foo(value: string) { this._foo = value; } } // Match a property getter const mock = TypeMoq.Mock.ofType(FooWithPublicGetterAndSetter); mock.setup(x => x.foo); // Match a property setter mock.object.foo = "Lorem ipsum dolor sit amet"; mock.verify(x => x.foo = TypeMoq.It.isValue("Lorem ipsum dolor sit amet"), Times.atLeastOnce()); ``` To be able to match a property make sure the property is initialized. Otherwise the TypeScript compiler will omit the uninitialized property from the emitted JavaScript and hence TypeMoq will throw a MockException with an 'invalid setup expression' message. ```typescript class Baz { value: string = ''; anyValue: any; } const mock = TypeMoq.Mock.ofType(Baz); mock.setup(x => x.value); // OK mock.setup(x => x.anyValue); // throws MockException - invalid setup expression ``` ##### Matching objects ```typescript interface Baz { bar: string jaz: number } class FooWithObjectArgMethod { private _foo: Object public foo(value: Object): void { } } const mock = TypeMoq.Mock.ofType(FooWithObjectArgMethod); // Match object deeply mock.setup(x => x.foo(TypeMoq.It.isValue({ bar: 'hello', jaz: 42 }))); // Match object partially mock.setup(x => x.foo(TypeMoq.It.isObjectWith({ jaz: 42 }))); ``` For the predicate based matcher, `TypeMoq.It.is(predicate: IFunc2)`, the argument of the predicate is a deep clone of the target argument, thus for doing object equality comparison, `===` should be replaced by `_.isEqual`. ```typescript interface BeanParams { colour: string } interface Service { getBeans(params: BeanParams): string; } const service = TypeMoq.Mock.ofType(); const beanParams: BeanParams = { colour: 'red' }; // Wrong way of doing strict object comparison service.setup(x => x.getBeans(TypeMoq.It.is(x => x === beanParams))).returns(() => 'success'); expect(service.object.getBeans(beanParams)).to.not.eq('success'); // Right way of doing strict object comparison service.setup(x => x.getBeans(TypeMoq.It.is(x => _.isEqual(x, beanParams)))).returns(() => 'success'); service.setup(x => x.getBeans(beanParams)).returns(() => 'success'); // Short form equivalent to the explicit form above expect(service.object.getBeans(beanParams)).to.eq('success'); ``` ##### Attaching return callbacks ```typescript (method) TypeMoq.IReturns.returns( valueFunction: (...x: any[]) => TResult): TypeMoq.IReturnsResult ``` The callback attached to `.returns` has the same signature as the matching function/method. Also the callback gets called with the arguments passed to the matching function/method and it must have the same return type, making possible the following: ```typescript mock.setup(x => x.doString("abc")).returns((s: string) => s.toUpperCase()); ``` ##### Attaching exceptions to throw ```typescript (method) TypeMoq.IThrows.throws(exception: T): TypeMoq.IThrowsResult ``` Example: ```typescript mock.setup(...).throws(new CustomException()); ``` ### Attach callbacks ```typescript (method) TypeMoq.ICallback.callback( action: () => void): TypeMoq.IReturnsThrows (method) TypeMoq.ICallback.callback( action: (x: T) => void): TypeMoq.IReturnsThrows ``` Attached callbacks are called before the `.returns` callback or `.throws` get called, and they have similar signature and behavior to `.returns` callbacks. Examples: ```typescript const mock = TypeMoq.Mock.ofType(Doer); let called1, called2 = false; let numberArg: number; mock.setup(x => x.doString(TypeMoq.It.isAnyString())).callback(() => called1 = true).returns(s => s.toUpperCase()); mock.setup(x => x.doNumber(TypeMoq.It.isAnyNumber())).callback(n => { numberArg = n; called2 = true; }).returns(n => n + 1); ``` ### Record and replay Mocks allow to "record" and "replay" one or more setups for the same matching function, method or property. * If a single setup is recorded then at replay it is always executed: ```typescript const mock = TypeMoq.Mock.ofInstance(() => -1); // record mock.setup(x => x()).returns(() => 0); // replay expect(mock.object()).to.eq(0); expect(mock.object()).to.eq(0); expect(mock.object()).to.eq(0); ``` * If more setups are recorded then at replay they are executed in the order of registration: ```typescript const mock = TypeMoq.Mock.ofInstance(() => -1); // record mock.setup(x => x()).returns(() => 0); mock.setup(x => x()).returns(() => 1); mock.setup(x => x()).returns(() => 2); // replay expect(mock.object()).to.eq(0); expect(mock.object()).to.eq(1); expect(mock.object()).to.eq(2); expect(mock.object()).to.eq(undefined); ``` In the latter case, when there are no more recorded setups left to play, the mock starts returning default values or raises MockException if `MockBehavior.Strict` (see [Control mock behavior](#control-mock-behavior)). ### Reset mocks ```typescript (method) TypeMoq.IMock.reset(): void ``` Calling `.reset()` on a mock returns the mock to its initial state by removing any previous setups. ### Control mock behavior ##### Using MockBehavior At mock creation, use the optional `behavior` argument with value: * `MockBehavior.Loose` (default) - never throws when no corresponding setup is found and just returns default values * `MockBehavior.Strict` - raises exceptions for anything that doesn't have a corresponding setup ```typescript const mock = TypeMoq.Mock.ofType(Doer, TypeMoq.MockBehavior.Strict); ``` ##### Partial mocking ```typescript (property) TypeMoq.IMock.callBase: boolean ``` When the mock property `callBase` is set to `true`, if there's no overriding setup the mock invokes the object being mocked. ```typescript mock.callBase = true; ``` The default value of `callBase` is `false`, so by default when there's no overriding setup the mock returns `undefined`. ### Override target properties At mock creation, use the optional `shouldOverrideTarget` argument with value: * `true` (default) - mock setups are going to be applied to the target object * `false` - mock setups are **not** going to be applied to the target object To be able to use the target object inside `.returns`, you need to choose **not** to override the target properties: ```typescript const targetInstance = { n: 100, getValue() { return this.n; }, setValue(n) { this.n = n; } }; const mock = TypeMoq.Mock.ofInstance(targetInstance, undefined, false); mock.setup(x => x.getValue()).returns(() => mock.target.getValue()); expect(mock.object.getValue()).equal(100); ``` ### Verify expectations ```typescript (method) TypeMoq.IVerifies.verifiable(times?: TypeMoq.Times): void ``` Expectations can be verified either one by one or all at once by marking matchers as verifiable. ##### Expectations Expectation | Description ---- | ---- ```TypeMoq.Times.exactly(n: number)``` | Called exactly `n` times ```TypeMoq.Times.never()``` | Never called ```TypeMoq.Times.once()``` | Called once ```TypeMoq.Times.atLeast(n: number)``` | Called at least `n` times ```TypeMoq.Times.atMost(n: number)``` | Called at most `n` times ```TypeMoq.Times.atLeastOnce()``` | Called at least once (default value) ```TypeMoq.Times.atMostOnce()``` | Called at most once ##### Verify expectations one by one ```typescript (method) TypeMoq.IMock.verify( expression: (x: T) => TResult, times: TypeMoq.Times): void ``` To verify an expectation you can use the `verify` method and specify a matching function and an expectation. Examples: ```typescript // Verify that a no args function was called at least once const mock: TypeMoq.IMock<() => string> = TypeMoq.Mock.ofInstance(someFunc); mock.object(); mock.verify(x => x(), TypeMoq.Times.atLeastOnce()); // Verify that a function with args was called at least once const mock: TypeMoq.IMock<(a: any, b: any, c: any) => string> = TypeMoq.Mock.ofInstance(someFuncWithArgs); mock.object(1, 2, 3); mock.verify(x => x(TypeMoq.It.isAnyNumber(), TypeMoq.It.isAnyNumber(), TypeMoq.It.isAnyNumber()), TypeMoq.Times.atLeastOnce()); // Verify that no args method was called at least once const mock = TypeMoq.Mock.ofType(Doer); mock.object.doVoid(); mock.verify(x => x.doVoid(), TypeMoq.Times.atLeastOnce()); // Verify that method with params was called at least once const mock = TypeMoq.Mock.ofType(Doer); mock.object.doString("Lorem ipsum dolor sit amet"); mock.verify(x => x.doString(TypeMoq.It.isValue("Lorem ipsum dolor sit amet")), TypeMoq.Times.atLeastOnce()); // Verify that value getter was called at least once const mock = TypeMoq.Mock.ofType(Bar); mock.object.value; mock.verify(x => x.value, TypeMoq.Times.atLeastOnce()); // Verify that value setter was called at least once const mock = TypeMoq.Mock.ofType(Bar); mock.object.value = "Lorem ipsum dolor sit amet"; mock.verify(x => x.value = TypeMoq.It.isValue("Lorem ipsum dolor sit amet"), TypeMoq.Times.atLeastOnce()); ``` **Note:** * When constructing a mock, it is allowed to pass mock objects as arguments and later verify expectations on them. E.g.: ```typescript const mockBar = TypeMoq.Mock.ofType(Bar); const mockFoo = TypeMoq.Mock.ofType(Foo, TypeMoq.MockBehavior.Loose, mockBar.object); mockFoo.callBase = true; mockFoo.object.setBar("Lorem ipsum dolor sit amet"); mockBar.verify(x => x.value = TypeMoq.It.isValue("Lorem ipsum dolor sit amet"), TypeMoq.Times.atLeastOnce()); ``` * For static mocks, TypeMoq is able to verify any inner calls inside regular functions but not inside lambda ones. E.g.: ```typescript class FooBar { register(): void { this.canExecute(); } registerLambda = () => { this.canExecute(); } canExecute(): void { console.log("FooBar.canExecute() was called"); } } const mock: TypeMoq.IMock = TypeMoq.Mock.ofType(FooBar); mock.callBase = true; mock.object.register(); mock.object.registerLambda(); // Function calls cannot be verified inside a lambda mock.verify(x => x.canExecute(), TypeMoq.Times.once()); ``` ##### Verify all expectations at once ```typescript (method) TypeMoq.IMock.verifyAll(): void ``` Instead of verifying one expectation at a time, you may specify the expectation at setup time by calling `verifiable(times: TypeMoq.Times)` and then `verifyAll()` to check all expectations. The default value of the `times` parameter is equal to `TypeMoq.Times.once()`. ```typescript mock.setup(x => x.doNumber(999)).verifiable(); // implicitly TypeMoq.Times.once() mock.setup(x => x.doString(TypeMoq.It.isAny())).verifiable(TypeMoq.Times.exactly(2)); mock.setup(x => x.doVoid()).verifiable(TypeMoq.Times.atMostOnce()); mock.object.doVoid(); mock.object.doString("Lorem ipsum dolor sit amet"); mock.object.doString("Ut enim ad minim veniam"); mock.object.doNumber(999); mock.verifyAll(); ``` When mock behavior is `TypeMoq.MockBehavior.Strict`, every call to `.setup()` automatically calls `.verifiable()` behind the scenes, as the default. ```typescript const mock = TypeMoq.Mock.ofType(Doer, TypeMoq.MockBehavior.Strict); mock.setup(x => x.doNumber(999)); // implicitly TypeMoq.Times.once() mock.setup(x => x.doVoid()).verifiable(TypeMoq.Times.atMostOnce()); mock.object.doVoid(); mock.object.doNumber(999); mock.verifyAll(); ``` ##### Verify expectation invocation order Expectation invocation order | Description ---- | ---- ```TypeMoq.ExpectedCallType.InAnyOrder``` | Only call count considered (default value) ```TypeMoq.ExpectedCallType.InSequence``` | Both call count and order considered ```typescript const mock = TypeMoq.Mock.ofInstance((x: number) => { }); mock.setup(x => x(1)).verifiable(TypeMoq.Times.once(), TypeMoq.ExpectedCallType.InSequence); mock.setup(x => x(2)).verifiable(TypeMoq.Times.once(), TypeMoq.ExpectedCallType.InSequence); mock.object(2); mock.object(1); mock.verifyAll(); // it should throw MockException ``` ### Create global mocks #### Static global mocks Static global mocks are created by specifying a class type or an existing object, similar to regular static mocks. You may also specify a container object for the type/object being mocked. For browsers the top global object is the `window` object, which is the default `container` value in `TypeMoq.GlobalMock`. For node.js the top global object is the `global` object. ##### Using class types ```typescript (method) TypeMoq.GlobalMock.ofType(targetConstructor: { new (): T; prototype: Object; }, container?: Object, behavior?: TypeMoq.MockBehavior): TypeMoq.IGlobalMock ``` Due to browser security limitations, global mocks created by specifying class type cannot have constructor arguments. Examples: ```typescript // global scope interface IGlobalBar { value: string; } class GlobalBar implements IGlobalBar { value: string = ''; } // Create an instance using class as ctor parameter const mock: TypeMoq.IGlobalMock = TypeMoq.GlobalMock.ofType(GlobalBar, global); // Create an instance using class as ctor parameter and casting result to interface const mock: TypeMoq.IGlobalMock = TypeMoq.GlobalMock.ofType(GlobalBar, global); // Create an instance using interface as type variable and class as ctor parameter const mock: TypeMoq.IGlobalMock = TypeMoq.GlobalMock.ofType(GlobalBar, global); // Create an instance of 'XmlHttpRequest' global type const mock = TypeMoq.GlobalMock.ofType(XMLHttpRequest, global); ``` ##### Using existing objects, including function objects ```typescript (method) TypeMoq.GlobalMock.ofInstance( targetInstance: T, globalName?: string, container?: Object, behavior?: TypeMoq.MockBehavior): TypeMoq.IGlobalMock ``` When creating mock instances out of global objects (such as `window.localStorage`), you should provide the name of the global object (*"localStorage"* in this case) as the second parameter. Examples: ```typescript // Create an instance using class as ctor parameter and ctor args const bar = new Bar(); const foo = new Foo(bar); const mock: TypeMoq.IGlobalMock = TypeMoq.GlobalMock.ofInstance(foo); // Create an instance using a generic class as ctor parameter and ctor args const foo = new GenericFoo(Bar); const mock: TypeMoq.IGlobalMock> = TypeMoq.GlobalMock.ofInstance(foo); // Create an instance from an existing object const bar = new GlobalBar(); const mock: TypeMoq.IGlobalMock = TypeMoq.GlobalMock.ofInstance(bar); // Create an instance from a function object const mock1: TypeMoq.IGlobalMock<() => string> = TypeMoq.GlobalMock.ofInstance(someGlobalFunc); const mock2: TypeMoq.IGlobalMock<(a: any, b: any, c: any) => string> = TypeMoq.GlobalMock.ofInstance(someGlobalFuncWithArgs); // Create an instance from 'window.localStorage' global object const mock = TypeMoq.GlobalMock.ofInstance(localStorage, "localStorage"); ``` #### Dynamic global mocks ```typescript (method) TypeMoq.GlobalMock.ofType2( globalName: string, container?: Object, behavior?: TypeMoq.MockBehavior): TypeMoq.IGlobalMock ``` Dynamic global mocks are created by specifying a type parameter and the name of the global object as the first constructor argument. ```typescript // Create an instance using a class as type parameter const mock: TypeMoq.IGlobalMock = TypeMoq.GlobalMock.ofType2("GlobalBar", global); // Create an instance using an interface as type parameter const mock: TypeMoq.IGlobalMock = TypeMoq.GlobalMock.ofType2("IGlobalBar", global); // Create an instance of 'XmlHttpRequest' global type const mock = TypeMoq.GlobalMock.ofType2("XMLHttpRequest", global); ``` Compared to static global mocks, dynamic global mocks suffer from the same limitations as regular dynamic mocks. ### Auto sandbox global mocks ```typescript (method) TypeMoq.GlobalScope.using( ...args: TypeMoq.IGlobalMock[]): TypeMoq.IUsingResult (method) TypeMoq.IUsingResult.with(action: () => void): void ``` Replacing and restoring global class types and objects is done automagically by combining global mocks with global scopes. Examples: ```typescript // global scope function someGlobalFunc() { return "someGlobalFunc was called"; } function someGlobalFuncWithArgs(a: any, b: any, c: any) { return "someGlobalFuncWithArgs was called"; } // Global no args function is auto sandboxed const mock = TypeMoq.GlobalMock.ofInstance(someGlobalFunc); TypeMoq.GlobalScope.using(mock).with(() => { someGlobalFunc(); someGlobalFunc(); }); // Global function with args is auto sandboxed const mock = TypeMoq.GlobalMock.ofInstance(someGlobalFuncWithArgs); TypeMoq.GlobalScope.using(mock).with(() => { someGlobalFuncWithArgs(1,2,3); someGlobalFuncWithArgs("1","2","3"); someGlobalFuncWithArgs(1, 2, 3); ); // Global object is auto sandboxed const mock = TypeMoq.GlobalMock.ofType(GlobalBar); TypeMoq.GlobalScope.using(mock).with(() => { const bar1 = new GlobalBar(); bar1.value; bar1.value; }); // 'window.XmlHttpRequest' global object is auto sandboxed const mock = TypeMoq.GlobalMock.ofType(XMLHttpRequest); TypeMoq.GlobalScope.using(mock).with(() => { const xhr1 = new XMLHttpRequest(); xhr1.open("GET", "http://www.typescriptlang.org", true); xhr1.send(); mock.verify(x => x.send(), TypeMoq.Times.exactly(1)); }); const xhr2 = new XMLHttpRequest(); xhr2.open("GET", "http://www.typescriptlang.org", true); xhr2.send(); mock.verify(x => x.send(), TypeMoq.Times.exactly(1)); // 'window.localStorage' global object is auto sandboxed const mock = TypeMoq.GlobalMock.ofInstance(localStorage, "localStorage"); mock.setup(x => x.getItem(TypeMoq.It.isAnyString())).returns((key: string) => "[]"); TypeMoq.GlobalScope.using(mock).with(() => { expect(localStorage.getItem("xyz")).to.eq("[]"); }); localStorage.setItem("xyz", "Lorem ipsum dolor sit amet"); expect(localStorage.getItem("xyz")).to.eq("Lorem ipsum dolor sit amet"); ``` **Note:** Inside the scope of a TypeMoq.GlobalScope, when constructing objects from global functions/class types which are being replaced by mocks, the constructor always returns the mocked object (of corresponding type) passed in as argument to the `TypeMoq.GlobalScope.using` function ## License [MIT](https://github.com/florinn/typemoq/blob/master/LICENSE)

	Stars	Issues	Version	Updated	Created
ts-mockery	42	24	1.2.0	5 years ago	6 years ago
ts-mockito	975	92	2.6.1	4 years ago	8 years ago
ts-mocks	80	13	3.0.1	4 years ago	8 years ago
ts-sinon	69	26	2.0.2	3 years ago	7 years ago
typemoq	427	53	2.1.0	7 years ago	10 years ago

ts-mockery vs ts-mockito vs ts-mocks vs ts-sinon vs typemoq

Downloads in past1 Month3 Months6 Months1 Year2 Years5 YearsAll time

Stats

Sick of boring JavaScript newsletters?

Downloads in past