feat: ngMocks.defaultKeep

lib/mock-helper/mock-helper.default-keep.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+
+import { AnyType } from '../common/core.types';
+import ngMocksUniverse from '../common/ng-mocks-universe';
+
+export default (source: AnyType<any> | InjectionToken<any>): void => {
+  ngMocksUniverse.getDefaults().set(source, source);
+};

lib/mock-helper/mock-helper.ts

@@ -10,6 +10,7 @@ import { CustomMockFunction, MockedFunction } from '../mock-service/types';
 
 import mockHelperAutoSpy from './mock-helper.auto-spy';
 import mockHelperDefaultExclude from './mock-helper.default-exclude';
+import mockHelperDefaultKeep from './mock-helper.default-keep';
 import mockHelperDefaultMock from './mock-helper.default-mock';
 import mockHelperFaster from './mock-helper.faster';
 import mockHelperFind from './mock-helper.find';
@@ -43,6 +44,11 @@ export const ngMocks: {
    */
   defaultExclude(source: AnyType<any> | InjectionToken<any>): void;
 
+  /**
+   * @see https://github.com/ike18t/ng-mocks#ngmocksdefaultkeep
+   */
+  defaultKeep(source: AnyType<any> | InjectionToken<any>): void;
+
   /**
    * @see https://github.com/ike18t/ng-mocks#ngmocksdefaultmock
    */
@@ -251,6 +257,7 @@ export const ngMocks: {
 } = {
   autoSpy: mockHelperAutoSpy,
   defaultExclude: mockHelperDefaultExclude,
+  defaultKeep: mockHelperDefaultKeep,
   defaultMock: mockHelperDefaultMock,
   faster: mockHelperFaster,
   find: mockHelperFind,

tests/ng-mocks-default-keep-modules/fixtures.ts

@@ -0,0 +1,52 @@
+import { Component, NgModule } from '@angular/core';
+
+@Component({
+  selector: 'target1',
+  template: '{{ name }}',
+})
+export class Target1Component {
+  public readonly name = 'target1';
+}
+
+@Component({
+  selector: 'target1',
+  template: '{{ name }}',
+})
+export class Fake1Component {
+  public readonly name = 'fake1';
+}
+
+@NgModule({
+  declarations: [Target1Component],
+  exports: [Target1Component],
+})
+export class Target1Module {}
+
+@Component({
+  selector: 'target2',
+  template: '{{ name }}',
+})
+export class Target2Component {
+  public readonly name = 'target2';
+}
+
+@Component({
+  selector: 'normal2',
+  template: '{{ name }}',
+})
+export class Normal2Component {
+  public readonly name = 'normal2';
+}
+
+@NgModule({
+  declarations: [Target2Component, Normal2Component],
+  exports: [Target2Component, Normal2Component],
+  imports: [Target1Module],
+})
+export class Target2Module {}
+
+@NgModule({
+  exports: [Target1Component, Target2Component, Normal2Component],
+  imports: [Target1Module, Target2Module],
+})
+export class Target3Module {}

tests/ng-mocks-default-keep-modules/test.spec.ts

@@ -0,0 +1,40 @@
+import { TestBed } from '@angular/core/testing';
+import { MockModule, MockRender, ngMocks } from 'ng-mocks';
+
+import {
+  Fake1Component,
+  Target1Component,
+  Target2Component,
+  Target2Module,
+  Target3Module,
+} from './fixtures';
+
+ngMocks.defaultExclude(Target2Component);
+ngMocks.defaultKeep(Target2Module);
+ngMocks.defaultReplace(Target1Component, Fake1Component);
+
+describe('ng-mocks-default-keep-modules', () => {
+  beforeEach(() => {
+    return TestBed.configureTestingModule({
+      imports: [MockModule(Target3Module)],
+    });
+  });
+
+  it('replaces Target1Component', () => {
+    const fixture = MockRender('<target1></target1>');
+    expect(fixture.nativeElement.innerHTML).toEqual(
+      '<target1>fake1</target1>',
+    );
+  });
+
+  it('excludes Target2Component', () => {
+    expect(() => MockRender('<target2></target2>')).toThrow();
+  });
+
+  it('keeps Normal2Component', () => {
+    const fixture = MockRender('<normal2></normal2>');
+    expect(fixture.nativeElement.innerHTML).toEqual(
+      '<normal2>normal2</normal2>',
+    );
+  });
+});

tests/ng-mocks-default-keep/test.spec.ts

@@ -0,0 +1,115 @@
+import { Component, NgModule } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import {
+  MockBuilder,
+  MockComponent,
+  MockModule,
+  MockRender,
+  ngMocks,
+} from 'ng-mocks';
+
+@Component({
+  selector: 'target',
+  template: '{{ name }}',
+})
+class TargetComponent {
+  public readonly name = 'target';
+}
+
+@Component({
+  selector: 'target',
+  template: '{{ name }}',
+})
+class FakeComponent {
+  public readonly name = 'fake';
+}
+
+@NgModule({
+  declarations: [TargetComponent],
+  exports: [TargetComponent],
+})
+class TargetModule {}
+
+ngMocks.defaultKeep(TargetComponent);
+
+describe('ng-mocks-default-keep', () => {
+  describe('MockComponent', () => {
+    beforeEach(() =>
+      TestBed.configureTestingModule({
+        declarations: [MockComponent(TargetComponent)],
+      }),
+    );
+
+    it('works as usual', () => {
+      const fixture = MockRender('<target></target>');
+      expect(fixture.nativeElement.innerHTML).toEqual(
+        '<target></target>',
+      );
+    });
+  });
+
+  describe('MockModule', () => {
+    beforeEach(() =>
+      TestBed.configureTestingModule({
+        imports: [MockModule(TargetModule)],
+      }),
+    );
+
+    it('keeps out of the box', () => {
+      const fixture = MockRender('<target></target>');
+      expect(fixture.nativeElement.innerHTML).toEqual(
+        '<target>target</target>',
+      );
+    });
+  });
+
+  describe('MockBuilder:default', () => {
+    beforeEach(() => MockBuilder(null, TargetModule));
+
+    it('keeps out of the box', () => {
+      const fixture = MockRender('<target></target>');
+      expect(fixture.nativeElement.innerHTML).toEqual(
+        '<target>target</target>',
+      );
+    });
+  });
+
+  describe('MockBuilder:exclude', () => {
+    beforeEach(() =>
+      MockBuilder(null, TargetModule).exclude(TargetComponent),
+    );
+
+    it('switches to exclude', () => {
+      expect(() => MockRender('<target></target>')).toThrow();
+    });
+  });
+
+  describe('MockBuilder:mock', () => {
+    beforeEach(() =>
+      MockBuilder(null, TargetModule).mock(TargetComponent),
+    );
+
+    it('switches to mock', () => {
+      const fixture = MockRender('<target></target>');
+      expect(fixture.nativeElement.innerHTML).toEqual(
+        '<target></target>',
+      );
+    });
+  });
+
+  describe('MockBuilder:replace', () => {
+    beforeEach(() =>
+      MockBuilder(null, TargetModule).replace(
+        TargetComponent,
+        FakeComponent,
+      ),
+    );
+
+    it('switches to replace', () => {
+      const fixture = MockRender('<target></target>');
+      expect(fixture.nativeElement.innerHTML).toEqual(
+        '<target>fake</target>',
+      );
+    });
+  });
+});