feat: ngMocks.defaultWipe

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

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

lib/mock-helper/mock-helper.ts

@@ -13,6 +13,7 @@ import mockHelperDefaultExclude from './mock-helper.default-exclude';
 import mockHelperDefaultKeep from './mock-helper.default-keep';
 import mockHelperDefaultMock from './mock-helper.default-mock';
 import mockHelperDefaultReplace from './mock-helper.default-replace';
+import mockHelperDefaultWipe from './mock-helper.default-wipe';
 import mockHelperFaster from './mock-helper.faster';
 import mockHelperFind from './mock-helper.find';
 import mockHelperFindAll from './mock-helper.find-all';
@@ -76,6 +77,11 @@ export const ngMocks: {
    */
   defaultReplace(source: AnyType<any>, destination: AnyType<any>): void;
 
+  /**
+   * @see https://github.com/ike18t/ng-mocks#ngmocksdefaultwipe
+   */
+  defaultWipe(source: AnyType<any> | InjectionToken<any>): void;
+
   /**
    * @see https://github.com/ike18t/ng-mocks#making-angular-tests-faster
    */
@@ -266,6 +272,7 @@ export const ngMocks: {
   defaultKeep: mockHelperDefaultKeep,
   defaultMock: mockHelperDefaultMock,
   defaultReplace: mockHelperDefaultReplace,
+  defaultWipe: mockHelperDefaultWipe,
   faster: mockHelperFaster,
   find: mockHelperFind,
   findAll: mockHelperFindAll,

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

@@ -0,0 +1,137 @@
+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: string = 'target';
+}
+
+@Component({
+  selector: 'target',
+  template: '{{ name }}',
+})
+class FakeComponent {
+  public readonly name: string = 'fake';
+}
+
+@Component({
+  selector: 'target',
+  template: '{{ name }}',
+})
+class ShadowComponent {
+  public readonly name: string = 'shadow';
+}
+
+@NgModule({
+  declarations: [TargetComponent],
+  exports: [TargetComponent],
+})
+class TargetModule {}
+
+ngMocks.defaultExclude(TargetComponent);
+ngMocks.defaultKeep(TargetComponent);
+ngMocks.defaultMock(TargetComponent, () => ({ name: 'mock' }));
+ngMocks.defaultReplace(TargetComponent, FakeComponent);
+ngMocks.defaultWipe(TargetComponent);
+
+describe('ng-mocks-default-replace', () => {
+  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('mocks as usual', () => {
+      const fixture = MockRender<TargetComponent>(
+        '<target></target>',
+      );
+      expect(fixture.nativeElement.innerHTML).toEqual(
+        '<target></target>',
+      );
+      expect(fixture.point.componentInstance.name).toEqual(
+        undefined as any,
+      );
+    });
+  });
+
+  describe('MockBuilder:default', () => {
+    beforeEach(() => MockBuilder(null, TargetModule));
+
+    it('mocks as usual', () => {
+      const fixture = MockRender<TargetComponent>(
+        '<target></target>',
+      );
+      expect(fixture.nativeElement.innerHTML).toEqual(
+        '<target></target>',
+      );
+      expect(fixture.point.componentInstance.name).toEqual(
+        undefined as any,
+      );
+    });
+  });
+
+  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).replace(
+        TargetComponent,
+        ShadowComponent,
+      ),
+    );
+
+    it('switches to replace', () => {
+      const fixture = MockRender('<target></target>');
+      expect(fixture.nativeElement.innerHTML).toEqual(
+        '<target>shadow</target>',
+      );
+    });
+  });
+
+  describe('MockBuilder:keep', () => {
+    beforeEach(() =>
+      MockBuilder(null, TargetModule).keep(TargetComponent),
+    );
+
+    it('switches to keep', () => {
+      const fixture = MockRender('<target></target>');
+      expect(fixture.nativeElement.innerHTML).toEqual(
+        '<target>target</target>',
+      );
+    });
+  });
+});