vitest-auto-spy 1.0.1 → 1.1.0

package/README.md

@@ -286,6 +286,10 @@ npm run test:coverage   # 100% thresholds enforced
 npm run build
 ```
 
+Releases are automated: merging a PR into `master` bumps the version from the
+Conventional Commit types and publishes to npm — see
+[CONTRIBUTING.md → Releases](./CONTRIBUTING.md#releases).
+
 If this package saved you time, a ⭐ on [GitHub](https://github.com/ASDAlexey/vitest-auto-spy)
 helps others find it.
 

package/dist/index.cjs

@@ -1,71 +1,116 @@
 'use strict';
 
+var vitest = require('vitest');
+var javascriptStringify = require('javascript-stringify');
 var rxjs = require('rxjs');
 var operators = require('rxjs/operators');
 var testing = require('@angular/core/testing');
-var javascriptStringify = require('javascript-stringify');
-var vitest = require('vitest');
 
-// src/auto-spy.ts
+// src/lib/accessor-spy.ts
+function defineWithEmptyAccessors(obj, prop) {
+  Object.defineProperty(obj, prop, {
+    get() {
+      return void 0;
+    },
+    set(_value) {
+    },
+    configurable: true
+  });
+}
+function spyOnAccessor(autoSpy, accessorName, accessorType) {
+  const key = accessorName;
+  return accessorType === "setter" ? vitest.vi.spyOn(autoSpy, key, "set") : vitest.vi.spyOn(autoSpy, key, "get");
+}
+function createAccessorsSpies(autoSpy, gettersToSpyOn, settersToSpyOn) {
+  const accessorSpies = { getters: {}, setters: {} };
+  autoSpy["accessorSpies"] = accessorSpies;
+  gettersToSpyOn.forEach((getterName) => {
+    defineWithEmptyAccessors(autoSpy, getterName);
+    accessorSpies.getters[getterName] = spyOnAccessor(autoSpy, getterName, "getter");
+  });
+  settersToSpyOn.forEach((setterName) => {
+    if (!Object.prototype.hasOwnProperty.call(autoSpy, setterName)) {
+      defineWithEmptyAccessors(autoSpy, setterName);
+    }
+    accessorSpies.setters[setterName] = spyOnAccessor(autoSpy, setterName, "setter");
+  });
+}
 var ArgsMap = class {
-  constructor() {
-    this.map = {};
-  }
-  // `stringify` always serializes an argument array to a string, so the cast is safe.
+  #map = {};
   set(key, value) {
-    this.map[javascriptStringify.stringify(key)] = value;
+    this.#map[this.#serialize(key)] = value;
   }
   get(key) {
-    return this.map[javascriptStringify.stringify(key)];
+    return this.#map[this.#serialize(key)];
+  }
+  // Keys are always argument arrays, which `javascript-stringify` always renders
+  // to a string. `String(...)` keeps the result total against its `string |
+  // undefined` signature without an unreachable fallback branch.
+  #serialize(key) {
+    return String(javascriptStringify.stringify(key));
   }
 };
+var MUST_BE_CALLED_WITH_PREAMBLE = (functionName) => `The function '${functionName}' was configured with 'mustBeCalledWith' and expects to be called with specific arguments. `;
+var NO_ARGUMENTS_MESSAGE = `But the function was called without any arguments.`;
+var actualArgumentsMessage = (actualArgs) => {
+  const formatted = String(javascriptStringify.stringify(actualArgs));
+  return `But the actual arguments were: ${formatted.substring(1, formatted.length - 1)}`;
+};
 var errorHandler = {
   throwArgumentsError(actualArgs, functionName) {
-    let errorMessage = `The function '${functionName}' was configured with 'mustBeCalledWith' and expects to be called with specific arguments. `;
-    if (actualArgs.length === 0) {
-      errorMessage += `But the function was called without any arguments.`;
-    } else {
-      let formattedArgs = javascriptStringify.stringify(actualArgs);
-      formattedArgs = formattedArgs.substring(1, formattedArgs.length - 1);
-      errorMessage += `But the actual arguments were: ${formattedArgs}`;
-    }
-    throw new Error(errorMessage);
+    const detail = actualArgs.length === 0 ? NO_ARGUMENTS_MESSAGE : actualArgumentsMessage(actualArgs);
+    throw new Error(MUST_BE_CALLED_WITH_PREAMBLE(functionName) + detail);
   }
 };
+
+// src/lib/constants.ts
+var REPLAY_BUFFER_SIZE = 1;
+
+// src/lib/spy-decoration.ts
+function decorate(target, helpers) {
+  return Object.assign(target, helpers);
+}
+
+// src/lib/value-config-guards.ts
+function isCompleteConfig(config) {
+  return "complete" in config;
+}
+function isNextValueConfig(config) {
+  return "value" in config;
+}
+function isErrorConfig(config) {
+  return "errorValue" in config;
+}
+
+// src/lib/observable-spy.ts
 function createReplaySubject() {
-  return new rxjs.ReplaySubject(1);
+  return new rxjs.ReplaySubject(REPLAY_BUFFER_SIZE);
 }
 function mergeSubjectWithDefaultValues(subject, valuesConfigs) {
-  const onCompleteSubject = new rxjs.ReplaySubject(1);
+  const onCompleteSubject = new rxjs.ReplaySubject(REPLAY_BUFFER_SIZE);
   const results$ = rxjs.from(valuesConfigs).pipe(
-    operators.concatMap((valueConfig) => {
-      if ("complete" in valueConfig && valueConfig.complete && valueConfig.delay) {
-        return rxjs.of(valueConfig).pipe(operators.delay(valueConfig.delay));
-      }
-      return rxjs.of(valueConfig);
-    }),
-    operators.takeWhile((valueConfig) => {
-      if (!("complete" in valueConfig)) {
+    // Honor a delay on a completion entry before it stops the stream.
+    operators.concatMap(
+      (config) => isCompleteConfig(config) && config.complete && config.delay ? rxjs.of(config).pipe(operators.delay(config.delay)) : rxjs.of(config)
+    ),
+    // Stop (and signal completion) as soon as a `{ complete: true }` entry arrives.
+    operators.takeWhile((config) => {
+      if (!isCompleteConfig(config)) {
         return true;
       }
-      if (valueConfig.complete) {
+      if (config.complete) {
         onCompleteSubject.next();
         return false;
       }
       return true;
     }),
-    operators.concatMap((valueConfig) => {
-      if ("value" in valueConfig && valueConfig.value) {
-        if (valueConfig.delay) {
-          return rxjs.of(valueConfig.value).pipe(operators.delay(valueConfig.delay));
-        }
-        return rxjs.of(valueConfig.value);
+    // Map each remaining entry to its emission: a value, an error, or nothing.
+    operators.concatMap((config) => {
+      if (isNextValueConfig(config) && config.value) {
+        return config.delay ? rxjs.of(config.value).pipe(operators.delay(config.delay)) : rxjs.of(config.value);
       }
-      if ("errorValue" in valueConfig && valueConfig.errorValue) {
-        if (valueConfig.delay) {
-          return rxjs.timer(valueConfig.delay).pipe(operators.switchMap(() => rxjs.throwError(() => valueConfig.errorValue)));
-        }
-        return rxjs.throwError(() => valueConfig.errorValue);
+      if (isErrorConfig(config) && config.errorValue) {
+        return config.delay ? rxjs.timer(config.delay).pipe(operators.switchMap(() => rxjs.throwError(() => config.errorValue))) : rxjs.throwError(() => config.errorValue);
       }
       return rxjs.EMPTY;
     })
@@ -73,57 +118,65 @@ function mergeSubjectWithDefaultValues(subject, valuesConfigs) {
   return rxjs.merge(results$, subject.pipe(operators.takeUntil(onCompleteSubject)));
 }
 function addObservableHelpers(objectToDecorate, providedSubject, onSubjectConfigured) {
-  objectToDecorate.nextWith = (value) => {
-    providedSubject.next(value);
-    onSubjectConfigured(providedSubject);
-  };
-  objectToDecorate.nextOneTimeWith = (value) => {
-    providedSubject.next(value);
-    providedSubject.complete();
-    onSubjectConfigured(providedSubject);
-  };
-  objectToDecorate.nextWithValues = (valuesConfigs) => {
-    if (valuesConfigs.length === 0) {
-      return;
+  decorate(objectToDecorate, {
+    nextWith: (value) => {
+      providedSubject.next(value);
+      onSubjectConfigured(providedSubject);
+    },
+    nextOneTimeWith: (value) => {
+      providedSubject.next(value);
+      providedSubject.complete();
+      onSubjectConfigured(providedSubject);
+    },
+    nextWithValues: (valuesConfigs) => {
+      if (valuesConfigs.length === 0) {
+        return;
+      }
+      onSubjectConfigured(mergeSubjectWithDefaultValues(providedSubject, valuesConfigs));
+    },
+    throwWith: (value) => {
+      providedSubject.error(value);
+      onSubjectConfigured(providedSubject);
+    },
+    complete: () => {
+      providedSubject.complete();
+      onSubjectConfigured(providedSubject);
+    },
+    returnSubject: () => {
+      onSubjectConfigured(providedSubject);
+      return providedSubject;
     }
-    onSubjectConfigured(mergeSubjectWithDefaultValues(providedSubject, valuesConfigs));
-  };
-  objectToDecorate.throwWith = (value) => {
-    providedSubject.error(value);
-    onSubjectConfigured(providedSubject);
-  };
-  objectToDecorate.complete = () => {
-    providedSubject.complete();
-    onSubjectConfigured(providedSubject);
-  };
-  objectToDecorate.returnSubject = () => {
-    onSubjectConfigured(providedSubject);
-    return providedSubject;
-  };
+  });
+}
+function buildPerCallObservable(replaySubject, config) {
+  let observable = replaySubject.asObservable();
+  if (config.delay) {
+    observable = observable.pipe(operators.delay(config.delay));
+  }
+  if (!config.doNotComplete) {
+    observable = observable.pipe(operators.take(1));
+  }
+  return observable;
 }
 function addNextWithPerCall(objectToDecorate, returnValueContainer, onConfigured = () => void 0) {
-  objectToDecorate.nextWithPerCall = (valueConfigsPerCall) => {
-    const returnedSubjects = [];
-    if (valueConfigsPerCall.length === 0) {
+  decorate(objectToDecorate, {
+    nextWithPerCall: (valueConfigsPerCall) => {
+      const returnedSubjects = [];
+      if (valueConfigsPerCall.length === 0) {
+        return returnedSubjects;
+      }
+      const valuesPerCalls = [];
+      valueConfigsPerCall.forEach((config) => {
+        const replaySubject = createReplaySubject();
+        replaySubject.next(config.value);
+        returnedSubjects.push(replaySubject);
+        valuesPerCalls.push({ wrappedValue: buildPerCallObservable(replaySubject, config) });
+      });
+      returnValueContainer.valuesPerCalls = valuesPerCalls;
+      onConfigured(returnValueContainer);
       return returnedSubjects;
     }
-    returnValueContainer.valuesPerCalls = [];
-    valueConfigsPerCall.forEach((valueConfiguration) => {
-      const replaySubject = new rxjs.ReplaySubject(1);
-      replaySubject.next(valueConfiguration.value);
-      returnedSubjects.push(replaySubject);
-      let returnedObservable = replaySubject.asObservable();
-      if (valueConfiguration.delay) {
-        returnedObservable = returnedObservable.pipe(operators.delay(valueConfiguration.delay));
-      }
-      if (!valueConfiguration.doNotComplete) {
-        returnedObservable = returnedObservable.pipe(operators.take(1));
-      }
-      returnValueContainer.valuesPerCalls.push({ wrappedValue: returnedObservable });
-    });
-    onConfigured(returnValueContainer);
-    return returnedSubjects;
-  };
+  });
 }
 function addObservableHelpersToFunctionSpy(spyFunction, valueContainer) {
   const subject = createReplaySubject();
@@ -146,108 +199,107 @@ function addObservableHelpersToCalledWithObject(calledWithObject, calledWithArgs
 function createObservableWithValues(valuesConfigs, config) {
   const subject = createReplaySubject();
   const values$ = mergeSubjectWithDefaultValues(subject, valuesConfigs);
-  if (config && config.returnSubject) {
-    return { values$, subject };
-  }
-  return values$;
+  return config?.returnSubject ? { values$, subject } : values$;
 }
 function createObservablePropSpy() {
-  let subject = createReplaySubject();
-  const observableSpy = rxjs.defer(() => subject);
-  addObservableHelpers(observableSpy, subject, (configuredSubject) => {
-    subject = configuredSubject;
+  const providedSubject = createReplaySubject();
+  let published$ = providedSubject;
+  const observableSpy = rxjs.defer(() => published$);
+  addObservableHelpers(observableSpy, providedSubject, (configuredSubject) => {
+    published$ = configuredSubject;
   });
   return observableSpy;
 }
-function addPromiseHelpersToFunctionSpy(spyFunction, valueContainer) {
-  spyFunction.resolveWith = (value) => {
-    valueContainer.value = Promise.resolve(value);
-  };
-  spyFunction.rejectWith = (value) => {
-    valueContainer.value = value;
-    valueContainer._isRejectedPromise = true;
-  };
-  spyFunction.resolveWithPerCall = (valueConfigsPerCall) => {
-    if (valueConfigsPerCall.length === 0) {
-      return;
+
+// src/lib/promise-spy.ts
+function toResolvedPerCallValues(valueConfigsPerCall) {
+  return valueConfigsPerCall.map((config) => ({
+    wrappedValue: config.delay === void 0 ? Promise.resolve(config.value) : new Promise((resolve) => setTimeout(() => resolve(config.value), config.delay))
+  }));
+}
+function addPromiseHelpers(target, store) {
+  decorate(target, {
+    resolveWith: (value) => {
+      store({ value: Promise.resolve(value) });
+    },
+    rejectWith: (value) => {
+      store({ value, _isRejectedPromise: true });
+    },
+    resolveWithPerCall: (valueConfigsPerCall) => {
+      if (valueConfigsPerCall.length === 0) {
+        return;
+      }
+      store({ value: void 0, valuesPerCalls: toResolvedPerCallValues(valueConfigsPerCall) });
     }
-    valueContainer.valuesPerCalls = [];
-    valueConfigsPerCall.forEach((valueConfiguration) => {
-      valueContainer.valuesPerCalls.push({
-        wrappedValue: Promise.resolve(valueConfiguration.value),
-        delay: valueConfiguration.delay
-      });
-    });
-  };
+  });
+}
+function addPromiseHelpersToFunctionSpy(spyFunction, valueContainer) {
+  addPromiseHelpers(spyFunction, (container) => {
+    valueContainer.value = container.value;
+    valueContainer._isRejectedPromise = container._isRejectedPromise ?? false;
+    valueContainer.valuesPerCalls = container.valuesPerCalls ?? [];
+  });
 }
 function addPromiseHelpersToCalledWithObject(calledWithObject, calledWithArgs) {
-  calledWithObject.resolveWith = (value) => {
-    calledWithObject.argsToValuesMap.set(calledWithArgs, { value: Promise.resolve(value) });
-  };
-  calledWithObject.rejectWith = (value) => {
-    calledWithObject.argsToValuesMap.set(calledWithArgs, { value, _isRejectedPromise: true });
-  };
-  calledWithObject.resolveWithPerCall = (valueConfigsPerCall) => {
-    if (valueConfigsPerCall.length === 0) {
-      return;
-    }
-    const valueContainer = { value: void 0, valuesPerCalls: [] };
-    valueConfigsPerCall.forEach((valueConfiguration) => {
-      valueContainer.valuesPerCalls.push({
-        wrappedValue: Promise.resolve(valueConfiguration.value),
-        delay: valueConfiguration.delay
-      });
-    });
-    calledWithObject.argsToValuesMap.set(calledWithArgs, valueContainer);
-  };
+  addPromiseHelpers(calledWithObject, (container) => {
+    calledWithObject.argsToValuesMap.set(calledWithArgs, container);
+  });
 }
-function getNextCallValue(valueContainer) {
-  const wrapped = valueContainer.valuesPerCalls.shift();
-  let returnedValue = wrapped?.wrappedValue;
-  if (wrapped && wrapped.delay) {
-    returnedValue = returnedValue.then(
-      (value) => new Promise((resolve) => setTimeout(() => resolve(value), wrapped.delay))
-    );
+
+// src/lib/function-spy.ts
+function isReturnValueContainer(value) {
+  return typeof value === "object" && value !== null && "value" in value;
+}
+function unwrapContainer(container) {
+  if (container._isRejectedPromise) {
+    return Promise.reject(container.value);
+  }
+  const wrapped = container.valuesPerCalls?.shift();
+  if (wrapped) {
+    return wrapped.wrappedValue;
+  }
+  return container.value;
+}
+function lookupConfigured(calledWithObject, actualArgs) {
+  const configured = calledWithObject.argsToValuesMap.get(actualArgs);
+  if (isReturnValueContainer(configured)) {
+    return { found: true, value: unwrapContainer(configured) };
   }
-  return returnedValue;
+  return { found: false, value: void 0 };
 }
 function returnTheCorrectFakeValue(calledWithObject, mustBeCalledWithObject, valueContainer, actualArgs, functionName) {
   if (calledWithObject.wasConfigured) {
-    const configured = calledWithObject.argsToValuesMap.get(actualArgs);
-    if (configured) {
-      return unwrapContainer(configured);
+    const match = lookupConfigured(calledWithObject, actualArgs);
+    if (match.found) {
+      return match.value;
     }
   }
   if (mustBeCalledWithObject.wasConfigured) {
-    const configured = mustBeCalledWithObject.argsToValuesMap.get(actualArgs);
-    if (configured) {
-      return unwrapContainer(configured);
+    const match = lookupConfigured(mustBeCalledWithObject, actualArgs);
+    if (match.found) {
+      return match.value;
     }
     errorHandler.throwArgumentsError(actualArgs, functionName);
   }
   return unwrapContainer(valueContainer);
 }
-function unwrapContainer(container) {
-  if (container._isRejectedPromise) {
-    return Promise.reject(container.value);
-  }
-  if (container.valuesPerCalls?.length) {
-    return getNextCallValue(container);
-  }
-  return container.value;
-}
 function addMethodsToCalledWith(calledWith, calledWithArgs) {
   calledWith.wasConfigured = true;
-  calledWith.mockReturnValue = (value) => {
-    calledWith.argsToValuesMap.set(calledWithArgs, { value });
-  };
+  decorate(calledWith, {
+    mockReturnValue: (value) => {
+      calledWith.argsToValuesMap.set(calledWithArgs, { value });
+    }
+  });
   addPromiseHelpersToCalledWithObject(calledWith, calledWithArgs);
   addObservableHelpersToCalledWithObject(calledWith, calledWithArgs);
   return calledWith;
 }
+function createCalledWithObject() {
+  return { wasConfigured: false, argsToValuesMap: new ArgsMap() };
+}
 function createFunctionSpy(name) {
-  const calledWithObject = { wasConfigured: false, argsToValuesMap: new ArgsMap() };
-  const mustBeCalledWithObject = { wasConfigured: false, argsToValuesMap: new ArgsMap() };
+  const calledWithObject = createCalledWithObject();
+  const mustBeCalledWithObject = createCalledWithObject();
   const valueContainer = { value: void 0 };
   const functionSpy = vitest.vi.fn(
     (...actualArgs) => returnTheCorrectFakeValue(calledWithObject, mustBeCalledWithObject, valueContainer, actualArgs, name)
@@ -255,78 +307,56 @@ function createFunctionSpy(name) {
   functionSpy.mockName(name);
   addPromiseHelpersToFunctionSpy(functionSpy, valueContainer);
   addObservableHelpersToFunctionSpy(functionSpy, valueContainer);
-  functionSpy.calledWith = (...calledWithArgs) => addMethodsToCalledWith(calledWithObject, calledWithArgs);
-  functionSpy.mustBeCalledWith = (...calledWithArgs) => addMethodsToCalledWith(mustBeCalledWithObject, calledWithArgs);
-  return functionSpy;
-}
-function defineWithEmptyAccessors(obj, prop) {
-  Object.defineProperty(obj, prop, {
-    get() {
-      return void 0;
-    },
-    set(_value) {
-    },
-    configurable: true
+  const spy = decorate(functionSpy, {
+    calledWith: (...calledWithArgs) => addMethodsToCalledWith(calledWithObject, calledWithArgs),
+    mustBeCalledWith: (...calledWithArgs) => addMethodsToCalledWith(mustBeCalledWithObject, calledWithArgs)
   });
+  return exposeAsSpy(spy);
 }
-function accessorSpyFactory(autoSpy, accessorName, accessorType) {
-  if (accessorType === "setter") {
-    return vitest.vi.spyOn(autoSpy, accessorName, "set");
-  }
-  return vitest.vi.spyOn(autoSpy, accessorName, "get");
-}
-function createAccessorsSpies(autoSpy, gettersToSpyOn, settersToSpyOn) {
-  autoSpy.accessorSpies = { getters: {}, setters: {} };
-  gettersToSpyOn.forEach((getterName) => {
-    defineWithEmptyAccessors(autoSpy, getterName);
-    autoSpy.accessorSpies.getters[getterName] = accessorSpyFactory(autoSpy, getterName, "getter");
-  });
-  settersToSpyOn.forEach((setterName) => {
-    if (!Object.prototype.hasOwnProperty.call(autoSpy, setterName)) {
-      defineWithEmptyAccessors(autoSpy, setterName);
-    }
-    autoSpy.accessorSpies.setters[setterName] = accessorSpyFactory(autoSpy, setterName, "setter");
-  });
+function exposeAsSpy(spy) {
+  return spy;
 }
+
+// src/lib/create-spy-from-class.ts
+var EMPTY_CONFIGURATION = {
+  methodsToSpyOn: [],
+  observablePropsToSpyOn: [],
+  settersToSpyOn: [],
+  gettersToSpyOn: []
+};
 function extractMethodsFromObject(obj) {
   const descriptors = Object.getOwnPropertyDescriptors(obj);
-  return Object.keys(descriptors).reduce((names, name) => {
-    if (name !== "constructor" && !descriptors[name].get) {
-      names.push(name);
-    }
-    return names;
-  }, []);
+  return Object.keys(descriptors).filter((name) => name !== "constructor" && !descriptors[name]?.get);
 }
-function getAllMethodNames(obj) {
-  let methods = [];
-  while (obj) {
-    const parentObj = Object.getPrototypeOf(obj);
+function getAllMethodNames(prototype) {
+  const methods = /* @__PURE__ */ new Set();
+  let current = prototype;
+  while (current) {
+    const parentObj = Object.getPrototypeOf(current);
     if (parentObj) {
-      methods = methods.concat(extractMethodsFromObject(obj));
+      extractMethodsFromObject(current).forEach((name) => methods.add(name));
     }
-    obj = parentObj;
+    current = parentObj;
   }
-  return methods;
+  return [...methods];
 }
-function createSpyFromClass(ObjectClass, methodsToSpyOnOrConfig) {
-  const methodNames = getAllMethodNames(ObjectClass.prototype);
-  let methodsToSpyOn = [];
-  let observablePropsToSpyOn = [];
-  let settersToSpyOn = [];
-  let gettersToSpyOn = [];
-  if (methodsToSpyOnOrConfig) {
-    if (Array.isArray(methodsToSpyOnOrConfig)) {
-      methodsToSpyOn = methodsToSpyOnOrConfig;
-    } else {
-      methodsToSpyOn = methodsToSpyOnOrConfig.methodsToSpyOn || [];
-      observablePropsToSpyOn = methodsToSpyOnOrConfig.observablePropsToSpyOn || [];
-      settersToSpyOn = methodsToSpyOnOrConfig.settersToSpyOn || [];
-      gettersToSpyOn = methodsToSpyOnOrConfig.gettersToSpyOn || [];
-    }
+function resolveConfiguration(methodsToSpyOnOrConfig) {
+  if (!methodsToSpyOnOrConfig) {
+    return { ...EMPTY_CONFIGURATION };
   }
-  if (methodsToSpyOn.length > 0) {
-    methodNames.push(...methodsToSpyOn);
+  if (Array.isArray(methodsToSpyOnOrConfig)) {
+    return { ...EMPTY_CONFIGURATION, methodsToSpyOn: methodsToSpyOnOrConfig };
   }
+  return {
+    methodsToSpyOn: methodsToSpyOnOrConfig.methodsToSpyOn ?? [],
+    observablePropsToSpyOn: methodsToSpyOnOrConfig.observablePropsToSpyOn ?? [],
+    settersToSpyOn: methodsToSpyOnOrConfig.settersToSpyOn ?? [],
+    gettersToSpyOn: methodsToSpyOnOrConfig.gettersToSpyOn ?? []
+  };
+}
+function createSpyFromClass(ObjectClass, methodsToSpyOnOrConfig) {
+  const { methodsToSpyOn, observablePropsToSpyOn, settersToSpyOn, gettersToSpyOn } = resolveConfiguration(methodsToSpyOnOrConfig);
+  const methodNames = methodsToSpyOn.length > 0 ? methodsToSpyOn : getAllMethodNames(ObjectClass.prototype);
   const autoSpy = {};
   observablePropsToSpyOn.forEach((observablePropName) => {
     autoSpy[observablePropName] = createObservablePropSpy();
@@ -344,7 +374,8 @@ function provideAutoSpy(ObjectClass, methodsToSpyOnOrConfig) {
   };
 }
 function injectSpy(token) {
-  return testing.TestBed.inject(token);
+  const injected = testing.TestBed.inject(token);
+  return injected;
 }
 function mockReadonlyProp(object, property, value) {
   Object.defineProperty(object, property, { get: () => value, configurable: true });