ng-mocks 13.5.2 → 14.0.2

package/examples/TestStandaloneDirective/test.spec.ts

@@ -0,0 +1,68 @@
+import {
+  Directive,
+  Injectable,
+  Input,
+  OnInit,
+  VERSION,
+} from '@angular/core';
+
+import { MockBuilder, MockRender, ngMocks } from 'ng-mocks';
+
+// @TODO remove with A5 support
+const injectableRootServiceArgs = [
+  {
+    providedIn: 'root',
+  } as never,
+];
+
+// A root service we want to mock.
+@Injectable(...injectableRootServiceArgs)
+class RootService {
+  trigger(name: string | null) {
+    // does something very cool
+
+    return name;
+  }
+}
+
+// A standalone directive we are going to test.
+@Directive({
+  selector: 'standalone',
+  standalone: true,
+} as never)
+class StandaloneDirective implements OnInit {
+  @Input() public readonly name: string | null = null;
+
+  constructor(public readonly rootService: RootService) {}
+
+  ngOnInit(): void {
+    this.rootService.trigger(this.name);
+  }
+}
+
+describe('TestStandaloneDirective', () => {
+  if (Number.parseInt(VERSION.major, 10) < 14) {
+    it('needs a14', () => {
+      // pending('Need Angular > 5');
+      expect(true).toBeTruthy();
+    });
+
+    return;
+  }
+
+  beforeEach(() => {
+    return MockBuilder(StandaloneDirective);
+  });
+
+  it('renders dependencies', () => {
+    // Rendering the directive.
+    MockRender(StandaloneDirective, {
+      name: 'test',
+    });
+
+    // Asserting that StandaloneDirective calls RootService.trigger.
+    const rootService = ngMocks.findInstance(RootService);
+    // it's possible because of autoSpy.
+    expect(rootService.trigger).toHaveBeenCalledWith('test');
+  });
+});

package/examples/TestStandalonePipe/test.spec.ts

@@ -0,0 +1,85 @@
+import {
+  Injectable,
+  Pipe,
+  PipeTransform,
+  VERSION,
+} from '@angular/core';
+
+import {
+  MockBuilder,
+  MockInstance,
+  MockRender,
+  ngMocks,
+} from 'ng-mocks';
+
+// @TODO remove with A5 support
+const injectableRootServiceArgs = [
+  {
+    providedIn: 'root',
+  } as never,
+];
+
+// A root service we want to mock.
+@Injectable(...injectableRootServiceArgs)
+class RootService {
+  trigger(name: string) {
+    // does something very cool
+
+    return name;
+  }
+}
+
+// A standalone pipe we are going to test.
+@Pipe({
+  name: 'standalone',
+  standalone: true,
+} as never)
+class StandalonePipe implements PipeTransform {
+  constructor(public readonly rootService: RootService) {}
+
+  transform(value: string): string {
+    return this.rootService.trigger(value);
+  }
+}
+
+describe('TestStandalonePipe', () => {
+  if (Number.parseInt(VERSION.major, 10) < 14) {
+    it('needs a14', () => {
+      // pending('Need Angular > 5');
+      expect(true).toBeTruthy();
+    });
+
+    return;
+  }
+
+  // It creates a context for mocks which will be reset after each test.
+  MockInstance.scope();
+
+  beforeEach(() => {
+    return MockBuilder(StandalonePipe);
+  });
+
+  it('renders dependencies', () => {
+    // Customizing what RootService does.
+    MockInstance(
+      RootService,
+      'trigger',
+      typeof jest === 'undefined'
+        ? jasmine.createSpy().and.returnValue('mock')
+        : jest.fn().mockReturnValue('mock'),
+    );
+
+    // Rendering the pipe.
+    const fixture = MockRender(StandalonePipe, {
+      $implicit: 'test',
+    });
+
+    // Asserting that StandalonePipe calls RootService.trigger.
+    const rootService = ngMocks.findInstance(RootService);
+    // It's possible because of autoSpy.
+    expect(rootService.trigger).toHaveBeenCalledWith('test');
+
+    // Asserting that StandalonePipe has rendered the result of the RootService
+    expect(ngMocks.formatText(fixture)).toEqual('mock');
+  });
+});

package/examples/TestToken/test.spec.ts

@@ -52,12 +52,10 @@ describe('TestToken', () => {
   // initialization we need to pass its module as the second
   // parameter.
   beforeEach(() => {
-    return MockBuilder()
-      .mock(TargetModule)
-      .keep(TOKEN_CLASS)
-      .keep(TOKEN_EXISTING)
-      .keep(TOKEN_FACTORY)
-      .keep(TOKEN_VALUE);
+    return MockBuilder(
+      [TOKEN_CLASS, TOKEN_EXISTING, TOKEN_FACTORY, TOKEN_VALUE],
+      TargetModule,
+    );
   });
 
   it('creates TOKEN_CLASS', () => {

package/examples/ngMocksFaster/test.spec.ts

@@ -1,4 +1,4 @@
-import { Component, Injectable } from '@angular/core';
+import { Component, Injectable, NgModule } from '@angular/core';
 
 import {
   MockBuilder,
@@ -26,15 +26,20 @@ class TargetComponent {
   public constructor(public readonly service: TargetService) {}
 }
 
+@NgModule({
+  declarations: [TargetComponent],
+  providers: [TargetService],
+})
+class ItsModule {}
+
 describe('examples:performance', () => {
   describe('beforeEach:mock-instance', () => {
     ngMocks.faster(); // <-- add it before
 
     // A normal setup of the TestBed, TargetService will be replaced
     // with its mock copy.
-    beforeEach(() => {
-      return MockBuilder(TargetComponent).mock(TargetService);
-    });
+    // TargetService is a provider in ItsModule.
+    beforeEach(() => MockBuilder(TargetComponent, ItsModule));
 
     // Configuring behavior of the mock TargetService.
     beforeAll(() => {
@@ -108,7 +113,11 @@ describe('examples:performance', () => {
     // A normal setup of the TestBed, TargetService will be replaced
     // with its mock copy.
     beforeEach(() => {
-      return MockBuilder(TargetComponent).mock(TargetService, mock);
+      return (
+        MockBuilder(TargetComponent, ItsModule)
+          // TargetService is a provider in ItsModule.
+          .mock(TargetService, mock)
+      );
     });
 
     it('test:1', () => {

package/{ng-mocks.d.ts → index.d.ts}

@@ -8,7 +8,7 @@ interface Type<T> extends Function {
 	new (...args: any[]): T;
 }
 declare type AnyType<T> = Type<T> | AbstractType<T>;
-declare type AnyDeclaration<T> = AnyType<T> | InjectionToken<T>;
+declare type AnyDeclaration<T> = AnyType<T> | InjectionToken<T> | string;
 declare type DebugNodeSelector = DebugNode | ComponentFixture<any> | string | [
 	string
 ] | [
@@ -106,6 +106,10 @@ export interface IMockBuilderConfigAll {
 	 * @see https://ng-mocks.sudo.eu/api/MockBuilder#export-flag
 	 */
 	export?: boolean;
+	/**
+	 * @see https://ng-mocks.sudo.eu/api/MockBuilder#shallow-flag
+	 */
+	shallow?: boolean;
 }
 /**
  * The interface with flags which are suitable for modules in MockBuilder chain functions.
@@ -612,7 +616,7 @@ export declare const isMockControlValueAccessor: <T>(value: T) => value is T & M
  * isMockNgDef(ArbitraryClass, 'c'); // returns false
  * ```
  */
-export declare function isMockNgDef<T>(component: Type<T>, ngType: "c"): component is Type<MockedComponent<T>>;
+export declare function isMockNgDef<T>(component: AnyType<T>, ngType: "c"): component is Type<MockedComponent<T>>;
 /**
  * isMockNgDef verifies whether a class is a mock directive class.
  *
@@ -624,7 +628,7 @@ export declare function isMockNgDef<T>(component: Type<T>, ngType: "c"): compone
  * isMockNgDef(ArbitraryClass, 'd'); // returns false
  * ```
  */
-export declare function isMockNgDef<T>(directive: Type<T>, ngType: "d"): directive is Type<MockedDirective<T>>;
+export declare function isMockNgDef<T>(directive: AnyType<T>, ngType: "d"): directive is Type<MockedDirective<T>>;
 /**
  * isMockNgDef verifies whether a class is a mock pipe class.
  *
@@ -636,7 +640,7 @@ export declare function isMockNgDef<T>(directive: Type<T>, ngType: "d"): directi
  * isMockNgDef(ArbitraryClass, 'p'); // returns false
  * ```
  */
-export declare function isMockNgDef<T>(pipe: Type<T>, ngType: "p"): pipe is Type<MockedPipe<T>>;
+export declare function isMockNgDef<T>(pipe: AnyType<T>, ngType: "p"): pipe is Type<MockedPipe<T>>;
 /**
  * isMockNgDef verifies whether a class is a mock module class.
  *
@@ -648,7 +652,7 @@ export declare function isMockNgDef<T>(pipe: Type<T>, ngType: "p"): pipe is Type
  * isMockNgDef(ArbitraryClass, 'm'); // returns false
  * ```
  */
-export declare function isMockNgDef<T>(module: Type<T>, ngType: "m"): module is Type<MockedModule<T>>;
+export declare function isMockNgDef<T>(module: AnyType<T>, ngType: "m"): module is Type<MockedModule<T>>;
 /**
  * isMockNgDef verifies whether a class is a mock class.
  *
@@ -2072,6 +2076,17 @@ export declare const ngMocks: {
 	 * ```
 	 */
 	get<T, D>(elSelector: DebugNodeSelector, provider: AnyDeclaration<T>, notFoundValue: D): D | T;
+	/**
+	 * ngMocks.get tries to get an instance of provider or token for TestBed.
+	 *
+	 * @see https://ng-mocks.sudo.eu/api/ngMocks/get
+	 *
+	 * ```ts
+	 * const myComponent = ngMocks.get(MyComponent);
+	 * const myDirective = ngMocks.get(MyDirective);
+	 * ```
+	 */
+	get<T>(provider: AnyDeclaration<T>): T;
 	/**
 	 * ngMocks.findInstance searches for an instance of declaration, provider or token,
 	 * and returns the first one.
@@ -2404,6 +2419,7 @@ export declare const ngMocks: {
 	 */
 	config(config: {
 		mockRenderCacheSize?: number | null;
+		onMockBuilderMissingDependency?: "throw" | "warn" | "i-know-but-disable" | null;
 		onMockInstanceRestoreNeed?: "throw" | "warn" | "i-know-but-disable" | null;
 		onTestBedFlushNeed?: "throw" | "warn" | "i-know-but-disable" | null;
 	}): void;