Merge pull request #93 from stbestichhh/84-update-spy

Spy standalone functions

Author: stbestichhh

CHANGELOG.md

@@ -7,7 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 ## Added:
-* New assertions. See [assertions API](README.md#assertions-api) 
+* New assertions. See [assertions API](README.md#assertions-api)
+* New spy method `call(...args: any[])`, which allows to run function with spying it 
 
 ## Fix:
 * Fixed error on wrong keybinding pressed

README.md

@@ -142,7 +142,7 @@ $ npx stest
 | `toBeTypeOf(type: any)`                                        | Check if actual is type of expected. Example: `assertThat('a').toBeTypeOf('string')`, `assertThat(TypeError).toBeTypeOf(Error)`                         |
 | `toHaveProperty(property: any)`                                | Check if actual has expected property                                                                                                                   |
 | `toHavePropertyEqual(property: any, value: any)`               | Check if actual has expected property which is equal to value                                                                                           |
-| `toHaveProperties(properties: any[])`                          | Check if actual has all of expected properties                                                                                                          |
+| `toHaveAllProperties(properties: any[])`                       | Check if actual has all of expected properties                                                                                                          |
 | `toHaveAnyProperties(properties: any[])`                       | Check if actual has any of expected properties                                                                                                          |
 | `toThrow(expectedError?: ErrorConstructor, ...args: any[])`    | Check if actual throw an error or expected error. Also you can provide arguments for actual function                                                    |
 | `toNotThrow(expectedError?: ErrorConstructor, ...args: any[])` | Check if actual do not throw an error or do not throw an error provided to as 'expectedError' param. Also you can provide arguments for actual function |
@@ -185,10 +185,27 @@ $ npx stest
 #### Spy API
 
 Create a new spy by `spyOn(instance: any, methodName: string)` function:
-```TypeScript
-const example = new ExampleClass();
-const greetSpy = spyOn(example, 'greet');
-```
+
+* Spy methods:
+  ```TypeScript
+  const example = new ExampleClass();
+  const greetSpy = spyOn(example, 'greet');
+  
+  // Call method
+  example.greet('Hello, World!');
+  ```
+* Spy functions
+  ```TypeScript
+  const func = () => { return 'Hello' };
+  const greetSpy = spyOn(func);
+  
+  // Call function  
+  greetSpy.call('Hello, World!');
+  greetSpy.getCallCount(); // 1
+  
+  // Spy won't work for calling function directly
+  func('Hello, World!'); // still 1
+  ```
 
 | Class                                    | Method                                | Description                                                                 |
 |------------------------------------------|---------------------------------------|-----------------------------------------------------------------------------|
@@ -200,6 +217,7 @@ const greetSpy = spyOn(example, 'greet');
 |                                          | `getThrownErrors(callIndex?: number)` | Returns an array with with all thrown errors                                |
 |                                          | `wasCalled(amount?: number)`          | Returns true if method was called at least once or more than `amount` times |
 |                                          | `wasCalledWith(...args: any[])`       | Returns true if method was called with specified arguments at least once    |
+|                                          | `call(...args: any[])`                | Calls spied function                                                        |
 
 #### Snapshots API
 

example/assertions/property_assertions.ts

@@ -6,11 +6,20 @@ class PropertyTests {
   @Case('Should have property')
   checkHaveProperty() {
     const obj = { name: 'John', age: 30 };
-    assertThat(obj).toHaveProperty('name');
+    assertThat(obj)
+      .toHaveProperty('name')
+      .toHaveAllProperties(['name', 'age'])
+      .toHaveAnyProperties(['a', 'age']);
   }
 
   @Case('Should satisfy predicate')
-  checkSatisfyPredicate() {
+  checkLength() {
     assertThat([1, 2, 3, 4, 5]).toHaveLength(5);
   }
+
+  @Case()
+  checkPropertyEqual() {
+    const obj = { name: 'John', age: 30 };
+    assertThat(obj).toHavePropertyEqual('age', 30);
+  }
 }

example/spy/spy_example.ts

@@ -6,10 +6,26 @@ class ExampleClass {
   }
 }
 
+const greet = (name: string) => {
+  return `Hello, ${name}!`;
+}
+
 @Test('Spying Example')
 class SpyingTestSuite {
 
   @Case('should track function calls')
+  testFunctionSpying() {
+    const greetSpy = spyOn(greet);
+
+    greetSpy.call('Alice');
+    greetSpy.call('Bob');
+
+    assertThat(greetSpy.getCallCount()).toEqual(2);
+    assertThat(greetSpy.wasCalledWith('Alice')).toBeTruthy();
+    assertThat(greetSpy.getCallArgs(1)[0]).toEqual('Bob');
+  }
+
+  @Case('should track method calls')
   testFunctionSpying() {
     const example = new ExampleClass();
     const greetSpy = spyOn(example, 'greet');
@@ -22,7 +38,7 @@ class SpyingTestSuite {
     assertThat(greetSpy.getCallArgs(1)[0]).toEqual('Bob');
   }
 
-  @Case('should track the order of function calls')
+  @Case('should track the order of method calls')
   testFunctionCallOrder() {
     const example = new ExampleClass();
     const greetSpy = spyOn(example, 'greet');
@@ -36,7 +52,7 @@ class SpyingTestSuite {
     assertThat(callOrder[1]).toEqual(2);
   }
 
-  @Case('should track errors thrown by the function')
+  @Case('should track errors thrown by the method')
   testFunctionThrowsError() {
     const example = new ExampleClass();
     const mock = new Mock(example);

lib/assertions/assert.ts

@@ -236,7 +236,7 @@ export function assertThat(actual: any): IAssertion {
       return this;
     },
 
-    toHaveProperties(properties: any[]): IAssertion {
+    toHaveAllProperties(properties: any[]): IAssertion {
       for (const prop of properties) {
         if (!Object.hasOwn(actual, prop)) {
           throw new AssertionException(

lib/interfaces/IAssertion.ts

@@ -45,7 +45,7 @@ interface ITypeAssertion {
 
 interface IPropertyAssertion {
   toHaveProperty(property: any): IAssertion;
-  toHaveProperties(properties: any[]): IAssertion;
+  toHaveAllProperties(properties: any[]): IAssertion;
   toHaveAnyProperties(properties: any[]): IAssertion;
   toHavePropertyEqual(property: any, value: any): IAssertion;
   toHaveLength(expected: number): IAssertion;

lib/spy/spy.ts

@@ -2,12 +2,12 @@ import { AnyFunction } from '../types';
 
 export class Spy {
   private originalFunction: AnyFunction;
-  private context: any;
   private callCount: number = 0;
   private callArgs: any[][] = [];
   private callResults: any[] = [];
   private callOrder: number[] = [];
   private thrownExceptions: any[] = [];
+  private readonly context: any;
 
   constructor(originalFunction: AnyFunction, context: any = null) {
     this.originalFunction = originalFunction;
@@ -61,6 +61,10 @@ export class Spy {
     return this.callArgs.some((callArgs) => this.compareArgs(callArgs, args));
   }
 
+  public call(...args: any[]) {
+    this.spyWrapper(...args);
+  }
+
   private compareArgs(args1: any[], args2: any[]) {
     return JSON.stringify(args1) === JSON.stringify(args2);
   }

lib/spy/spyOn.ts

@@ -1,17 +1,34 @@
 import { Spy } from './spy';
 import { MockRegistry } from '../mocking';
 
-export function spyOn(object: any, methodName: string) {
-  const originalMethod = object[methodName];
-  const spy = new Spy(originalMethod, object);
+export function spyOn(object: any, methodName?: string) {
+  if (
+    methodName === '__proto__' ||
+    methodName === 'constructor' ||
+    methodName === 'prototype'
+  ) {
+    throw new Error('Invalid method name');
+  }
+  const isFunctionSpy = typeof object === 'function' && !methodName;
 
-  object[methodName] = spy.spyFn;
+  const originalMethod = isFunctionSpy ? object : object[methodName!];
+  const spy = new Spy(originalMethod, isFunctionSpy ? null : object);
 
-  MockRegistry.registerMock({
-    restoreAll: () => {
-      object[methodName] = originalMethod;
-    },
-  });
+  if (isFunctionSpy) {
+    object = spy.spyFn;
+    MockRegistry.registerMock({
+      restoreAll: () => {
+        object = originalMethod;
+      },
+    });
+  } else {
+    object[methodName!] = spy.spyFn;
+    MockRegistry.registerMock({
+      restoreAll: () => {
+        object[methodName!] = originalMethod;
+      },
+    });
+  }
 
   return spy;
 }

stutil.d.ts

@@ -46,7 +46,7 @@ interface ITypeAssertion {
 
 interface IPropertyAssertion {
   toHaveProperty(property: any): IAssertion;
-  toHaveProperties(properties: any[]): IAssertion;
+  toHaveAllProperties(properties: any[]): IAssertion;
   toHaveAnyProperties(properties: any[]): IAssertion;
   toHavePropertyEqual(property: any, value: any): IAssertion;
   toHaveLength(expected: number): IAssertion;
@@ -154,9 +154,10 @@ class Spy {
   public getThrownErrors(callIndex?: number): any[];
   public wasCalled(): boolean;
   public wasCalledWith(...args: any[]): boolean;
+  public call(...args: any[]): void;
 }
 
-export function spyOn(object: any, methodName: string): Spy;
+export function spyOn(object: any, methodName?: string): Spy;
 
 // Snapshot
 export function shot(name: string, data: any): void;