Organize and add func() support

Author: Brian Ojeda

index.d.ts

@@ -1,82 +1,110 @@
-export type TestDouble = Function;
 
-export type DoubledObjectWithKey<Key extends string> = {};
+//
+// types and interfaces
+// ----------------------------------------------------------------------------
 
 export type DoubledObject<Subject> = Subject;
 
-export interface TestdoubleConfig {
-  promiseConstructor?: any;
-  ignoreWarnings?: boolean;
-  suppressErrors?: boolean;
-}
-export function config(config: TestdoubleConfig): void;
-
-declare function functionDouble(name?: string): TestDouble;
-export { functionDouble as function };
-
-// When passed class or constructor function
-export function object<T>(constructor: { new (...args: any[]): T }): DoubledObject<T>;
-
-// When passed array of props
-export function object<Key extends string>(props: Key[]): DoubledObjectWithKey<Key>;
-
-// When passed class or constuctor function name as string value
-export function object<T>(object: string): DoubledObject<T>;
+export type DoubledObjectWithKey<Key extends string> = {};
 
-// When passed general object
-export function object<T>(object: T): DoubledObject<T>;
+export type TestDouble<Function> = Function;
 
-export interface Stubber {
-  thenReturn(...args: any[]): TestDouble;
-  thenDo(f: Function): TestDouble;
-  thenThrow(e: Error): TestDouble;
-  thenResolve(v: any): TestDouble;
-  thenReject(e: Error): TestDouble;
-  thenCallback(...args: any[]): TestDouble;
+interface Call {
+  context: {};
+  args: any[];
 }
 
-export function callback(...args: any[]): void;
+export interface Captor {
+  capture(): any;
+  value?: any;
+  values?: any[];
+}
 
-export function when(...args: any[]): Stubber;
+export interface Explanation {
+  callCount: number;
+  calls: Call[];
+  description: string;
+}
 
 export interface Matchers {
   anything(): any;
   isA(type: Function): any;
-  contains(a: string|any[]|{}): any;
+  contains(a: string | any[] | {}): any;
   argThat(matcher: Function): any;
   not(v: any): any;
   captor(): Captor
 }
 
-export interface Captor {
-  capture(): any;
-  value?: any;
-  values?: any[];
-}
-
 export const matchers: Matchers;
 
-export function replace(path: string, f?: any): any;
-export function replace(path: {}, property: string, f?: any): any;
+export interface Stubber {
+  thenReturn<T>(...args: any[]): TestDouble<T>;
+  thenDo<T>(f: Function): TestDouble<T>;
+  thenThrow<T>(e: Error): TestDouble<T>;
+  thenResolve<T>(v: any): TestDouble<T>;
+  thenReject<T>(e: Error): TestDouble<T>;
+  thenCallback<T>(...args: any[]): TestDouble<T>;
+}
 
-export function reset(): void;
+export interface TestdoubleConfig {
+  promiseConstructor?: any;
+  ignoreWarnings?: boolean;
+  suppressErrors?: boolean;
+}
 
 export interface VerificationConfig {
   ignoreExtraArgs?: boolean;
   times?: number;
 }
 
-export function verify(a: any, check?: VerificationConfig): void;
+//
+// general
+// ----------------------------------------------------------------------------
 
-interface Call {
-  context: {};
-  args: any[];
-}
+export function config(config: TestdoubleConfig): void;
 
-export interface Explanation {
-  callCount: number;
-  calls: Call[];
-  description: string;
-}
+export function reset(): void;
+
+export function explain<T>(f: TestDouble<T>): Explanation;
+
+
+//
+// fake: constructors
+// ----------------------------------------------------------------------------
+
+//
+// fake: functions
+// ----------------------------------------------------------------------------
+
+declare function functionDouble(name?: string): TestDouble<Function>;
 
-export function explain(f: TestDouble): Explanation;
+declare function functionDouble<T>(name?: T): TestDouble<T>;
+
+export { functionDouble as function };
+export { functionDouble as func };
+
+//
+// fake: objects
+// ----------------------------------------------------------------------------
+
+export function object<T>(constructor: { new (...args: any[]): T }): DoubledObject<T>;
+
+export function object<Key extends string>(props: Key[]): DoubledObjectWithKey<Key>;
+
+export function object<T>(object: string): DoubledObject<T>;
+
+export function object<T>(object: T): DoubledObject<T>;
+
+//
+// stubbing
+// ----------------------------------------------------------------------------
+
+export function callback(...args: any[]): void;
+
+export function replace(path: string, f?: any): any;
+
+export function replace(path: {}, property: string, f?: any): any;
+
+export function when(...args: any[]): Stubber;
+
+export function verify(a: any, check?: VerificationConfig): void;

test/src/typescript/test.ts

@@ -1,36 +1,72 @@
 import * as td from "../../../";
 
+// dummies
+
+class Dog {
+  constructor() {};
+  bark(): string { return "bark! bark!" }
+}
+
+function sum (first: number, second: number): number {
+  return first + second
+}
+
+// td.functions()
+
 const f = td.function();
 td.when(f(10)).thenReturn(10);
 td.when(f(1)).thenThrow(new Error("ok"));
 td.when(f(td.matchers.isA(String))).thenDo(function(s: string) { return s; });
 td.when(f(td.matchers.not(true))).thenResolve("value");
 td.when(f(td.matchers.not(false))).thenReject(new Error("rejected"));
 
-class Dog {
-  bark() {}
-}
+const fakeSum = td.function(sum);
+td.when(fakeSum(1, 2)).thenReturn(3);
+
+const fakerSum = td.function("sum");
+td.when(fakerSum(1, 2)).thenReturn(3);
+
+const fakestSum = td.function("sum");
+td.when(fakestSum(1, 2)).thenReturn(3);
+
+// td.func()
+
+const ff = td.func();
+td.when(ff(10)).thenReturn(10);
+td.when(ff(1)).thenThrow(new Error("ok"));
+td.when(ff(td.matchers.isA(String))).thenDo(function(s: string) { return s; });
+td.when(ff(td.matchers.not(true))).thenResolve("value");
+td.when(ff(td.matchers.not(false))).thenReject(new Error("rejected"));
+
+// td.constructor()
 
 const dog = td.constructor(Dog);
 td.when(dog.bark()).thenReturn("bark!");
 
+// td.object()
+
 const bird = td.object({ fly: function(){} });
 td.when(bird.fly()).thenReturn("fly!");
 
-class Bear { constructor() {}; sleep() {}; };
-const bear = td.object<Bear>("Bear");
-td.when(bear.sleep()).thenReturn("zzz");
+const bear = td.object<Dog>("Bear");
+td.when(bear.bark()).thenReturn("bark!");
+
+// td.replace()
 
 td.replace({}, "prop");
 td.replace({}, "prop", 42);
 td.replace("../../..");
 td.replace("../../../", 42);
 
+// td.verify()
+
 td.verify(f());
 td.verify(f(), { times: 1 });
 td.verify(f(), { ignoreExtraArgs: false });
 td.verify(f(), { ignoreExtraArgs: true, times: 2 });
 
+// td.explain()
+
 const explanation = td.explain(f);
 console.log(
   explanation.description,