Testeando ngZone y navegación.

Así implementé los tests sobre el componente “Action”

it('should openLink', () => {
    const event = new MouseEvent('click');
    const eventCall = spyOn(event, 'preventDefault').and.callFake(() => {});
    const dismiss = spyOn((<any>component).bottomSheetRef, 'dismiss');
    const resolveActionObserver = spyOn(
      (<any>component).pinsService,
      'resolveActionObserver'
    );
    component.openLink(event, '');
    expect(eventCall).toHaveBeenCalled();
    expect(dismiss).toHaveBeenCalled();
    expect(resolveActionObserver).toHaveBeenCalled();
  });

it("edit mode should be true", () => {
    const verifyEditMode = spyOn(component, "verifyEditMode").and.callThrough();

    fixture.ngZone.run(() => {
      (<any>component).router.navigate(['app/add']); 
      fixture.whenStable().then(() => {
        expect(component.editMode).toBe(true);
        expect(verifyEditMode).toHaveBeenCalled();
      });
    });
  });

Mi código completamente funcional:

import { async, ComponentFixture, TestBed } from '@angular/core/testing';

import { ActionsComponent } from './actions.component';
import { MatBottomSheetRef } from '@angular/material';
import { PinsService } from '../pins/pins.service';
import { NO_ERRORS_SCHEMA } from '@angular/core';
import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';

class MatBottomSheetRefStub {
  dismiss() { }
}

class PinsServiceStub {
  resolveActionObserver(action) { }
}

fdescribe('ActionsComponent', () => {
  let component: ActionsComponent;
  let fixture: ComponentFixture<ActionsComponent>;

  beforeEach(async(() => {
    TestBed.configureTestingModule({
      declarations: [ActionsComponent],
      providers: [
        { provide: MatBottomSheetRef, useClass: MatBottomSheetRefStub },
        { provide: PinsService, useClass: PinsServiceStub }
      ],
      schemas: [NO_ERRORS_SCHEMA, CUSTOM_ELEMENTS_SCHEMA]
    })
      .compileComponents();
  }));

  beforeEach(() => {
    fixture = TestBed.createComponent(ActionsComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });

  it('should execute openLink', () => {

    // se crea el evento
    const event = new MouseEvent('click');

    // se crean los espias de las funciones que queremos comprobar que fueron llamadas
    const eventSpy = spyOn(event, 'preventDefault').and.callFake(() => { });
    const bottomSheetRefSpy = spyOn((<any>component).bottomSheetRef, 'dismiss');
    const pinsServiceSpy = spyOn((<any>component).pinsService, 'resolveActionObserver');

    // la funcion que estamos probando, la espiamos sin modificar su comportamiento
    const openLink = spyOn(component, 'openLink').and.callThrough();


    // ejecutamos la funcion
    component.openLink(event, 'send');

    // comprobamos los resultados
    expect(openLink).toHaveBeenCalledWith(event, 'send');
    expect(eventSpy).toHaveBeenCalled();
    expect(bottomSheetRefSpy).toHaveBeenCalled();
    expect(pinsServiceSpy).toHaveBeenCalledWith('send');
  });
});

En versiones mas recientes de Angular al ejecutar fixture.whenStable().then() se debe invocar el it mediante un async o sino nuestra prueba nos arrojara un warn diciendo que no tiene ningun expect.

El codigo actualizado seria asi

it("should set the edit mode to false", async(() => {
	const verifyEditmode = spyOn(component, "verifyEditMode").and.callThrough();

	fixture.ngZone.run(() => {
		(<any>component).router.navigate(["/"]);

		fixture.whenStable().then(() => {
			expect(component.editMode).toBeFalsy();
			expect(verifyEditmode).toHaveBeenCalled();
		});
	});
}));

No me queda claro porque forzas la prueba. A caso no deberia correr y ya? Porque no te corren y tenes que forzarlo?

Configure asi para testear la ruta ‘/app/add’

declarations: [LayoutComponent, FormComponent],
      providers: [{ provide: MatBottomSheet, useClass: MatBottomSheetStub }],
      imports: [RouterTestingModule.withRoutes([
        { path: '', component: LayoutComponent },
        {
          path: "app", component: LayoutComponent,
          children: [{ path: "add", component: FormComponent }]
        },
      ])],
      schemas: [NO_ERRORS_SCHEMA, CUSTOM_ELEMENTS_SCHEMA]

Y agregue este import
import { FormComponent } from ‘…/form/form.component’;

Pero me da este error
Error: StaticInjectorError(DynamicTestModule)[FormComponent -> FormBuilder]:

Que me falta hacer?

import { async, ComponentFixture, TestBed } from "@angular/core/testing";

import { ActionsComponent } from "./actions.component";
import { MatBottomSheetRef } from "@angular/material";
import { PinsService } from "../pins/pins.service";
import { NO_ERRORS_SCHEMA, CUSTOM_ELEMENTS_SCHEMA } from "@angular/core";

export class MatBottomSheetRefSTUB {
  dismiss() {}
}

export class PinsServiceSTUB {
  resolveActionObserver(action) {}
}

fdescribe("ActionsComponent", () => {
  let component: ActionsComponent;
  let fixture: ComponentFixture<ActionsComponent>;

  beforeEach(async(() => {
    TestBed.configureTestingModule({
      declarations: [ActionsComponent],
      providers: [
        { provide: MatBottomSheetRef, useClass: MatBottomSheetRefSTUB },
        { provide: PinsService, useClass: PinsServiceSTUB },
      ],
      schemas: [NO_ERRORS_SCHEMA, CUSTOM_ELEMENTS_SCHEMA],
    }).compileComponents();
  }));

  beforeEach(() => {
    fixture = TestBed.createComponent(ActionsComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();
  });

  it("should create", () => {
    expect(component).toBeTruthy();
  });

  it("preventDefault should be called", () => {
    const mouseEvent = new MouseEvent("click");
    const mouseEventSpy = spyOn(
      mouseEvent,
      "preventDefault"
    ).and.callFake(() => {});
    component.openLink(mouseEvent, "send");
    expect(mouseEventSpy).toHaveBeenCalled();
  });

  it("dismiss should be called", () => {
    const mouseEvent = new MouseEvent("click");
    spyOn(mouseEvent, "preventDefault").and.callFake(() => {});
    const bottomSheetRefSpy = spyOn((<any>component).bottomSheetRef, "dismiss");
    component.openLink(mouseEvent, "send");
    expect(bottomSheetRefSpy).toHaveBeenCalled();
  });

  it("dismiss should be called", () => {
    const mouseEvent = new MouseEvent("click");
    spyOn(mouseEvent, "preventDefault").and.callFake(() => {});
    const pinsServiceSpy = spyOn(
      (<any>component).pinsService,
      "resolveActionObserver"
    );
    component.openLink(mouseEvent, "send");
    expect(pinsServiceSpy).toHaveBeenCalled();
  });
});

Esto fue lo que hice 😅. Por cierto, el casting también lo pueden hacer como (component as any).

class MatBottomSheetRefStub<T> {
  dismiss() {}
}

class PinsServiceStub {
  resolveActionObserver(action: string) {}
}

describe('ActionsComponent', () => {
  let component: ActionsComponent;
  let fixture: ComponentFixture<ActionsComponent>;

  beforeEach(async(() => {
    TestBed.configureTestingModule({
      declarations: [ ActionsComponent ],
      providers: [
        { provide: MatBottomSheetRef, useClass: MatBottomSheetRefStub },
        { provide: PinsService, useClass: PinsServiceStub }
      ]
    })
    .compileComponents();
  }));

  beforeEach(() => {
    fixture = TestBed.createComponent(ActionsComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });

  it('should open a link', () => {
    const event = new MouseEvent('click');
    const mouseEvent = spyOn(event, 'preventDefault');
    const dismiss = spyOn((component as any).bottomSheetRef, 'dismiss');
    const resolve = spyOn((component as any).pinsService, 'resolveActionOberver');
    component.openLink(event, 'ok');
    expect(mouseEvent).toHaveBeenCalled();
    expect(dismiss).toHaveBeenCalled();
    expect(resolve).toHaveBeenCalledWith('ok');
  });
});

Que es ese (<any>component) que pones??

import { CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA } from '@angular/core';
import {
  async,
  ComponentFixture,
  TestBed,
  waitForAsync,
} from '@angular/core/testing';
import { MatBottomSheet } from '@angular/material/bottom-sheet';
import { RouterTestingModule } from '@angular/router/testing';
import { ActionsComponent } from '../actions/actions.component';

import { LayoutComponent } from './layout.component';

class MatBottomSheetStub {
  open() {}
}

fdescribe('LayoutComponent', () => {
  let component: LayoutComponent;
  let fixture: ComponentFixture<LayoutComponent>;

  beforeEach(
    waitForAsync(() => {
      TestBed.configureTestingModule({
        declarations: [LayoutComponent],
        providers: [{ provide: MatBottomSheet, useClass: MatBottomSheetStub }],
        imports: [
          RouterTestingModule.withRoutes([
            { path: '', component: LayoutComponent },
            { path: 'app/add', component: LayoutComponent },
          ]),
        ],
        schemas: [NO_ERRORS_SCHEMA, CUSTOM_ELEMENTS_SCHEMA],
      }).compileComponents();
    })
  );

  beforeEach(() => {
    fixture = TestBed.createComponent(LayoutComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });

  it('Should set the editMode to false', () => {
    const verifyEditMode = spyOn(component, 'verifyEditMode').and.callThrough();

    fixture.ngZone.run(() => {
      (<any>component).router.navigate(['/']);

      fixture.whenStable().then(() => {
        expect(component.editMode).toBeFalsy();
        expect(verifyEditMode).toHaveBeenCalled();
      });
    });
  });

  it('Should open', () => {
    const open = spyOn((<any>component).bottomSheet, 'open');

    component.openBottomSheet();

    expect(open).toHaveBeenCalledWith(ActionsComponent);
  });


  it('Should set the editMode to true', () => {
    const verifyEditMode = spyOn(component, 'verifyEditMode').and.callThrough();

    fixture.ngZone.run(() => {
      (<any>component).router.navigate(['app/add']);

      fixture.whenStable().then(() => {
        expect(component.editMode).toBeTruthy();
        expect(verifyEditMode).toHaveBeenCalled();
      });
    });
  });
});