Here is an example that demonstrates how easy it can be:

By using the TestBed.configureTestingModule() method with imports like [RouterTestingModule], we can easily compile the components.
    
...
    
In this snippet of code, a new NavigationEnd event is created with parameters (42, '/', '/'). By injecting the Router through TestBed.inject(Router) and emitting this event using the .next() method on the events Subject<Event>, we can simulate a navigation event.

After analyzing the problem thoroughly, I have crafted a solution that involves diving deeper into the initial approach:

import { of } from 'rxjs';
import { NavigationEnd, Router } from '@angular/router';

providers: [
    {
      provide: Router,
      useValue: {
        url: '/non-pdp/phases/8',
        events: of(new NavigationEnd(0, 'http://localhost:4200/#/non-pdp/phases/8', 'http://localhost:4200/#/non-pdp/phases/8')),
        navigate: jasmine.createSpy('navigate')
      }
    }
]

Here is a helpful tip: include a footer component with routerLinks in the template to avoid the "root not provided" error. In order to control navigation events, use a "real" router with a spied variable directing router.events to a test observable.

export type Spied<T> = { [Method in keyof T]: jasmine.Spy };

describe("FooterComponent", () => {
   let component: FooterComponent;
   let fixture: ComponentFixture<FooterComponent>;
   let de: DebugElement;
   const routerEvent$ = new BehaviorSubject<RouterEvent>(null);
   let router: Spied<Router>;

 beforeEach(async(() => {
    TestBed.configureTestingModule({
        providers: [provideMock(SomeService), provideMock(SomeOtherService)],
        declarations: [FooterComponent],
        imports: [RouterTestingModule]
    }).compileComponents();

    router = TestBed.get(Router);
    (<any>router).events = routerEvent$.asObservable();

    fixture = TestBed.createComponent(FooterComponent);
    component = fixture.componentInstance;
    de = fixture.debugElement;
}));
// component subscribes to router nav event...checking url to hide/show a link
it("should return false for showSomeLink()", () => {
    routerEvent$.next(new NavigationEnd(1, "/someroute", "/"));
    component.ngOnInit();
    expect(component.showSomeLink()).toBeFalsy();
    fixture.detectChanges();
    const htmlComponent = de.query(By.css("#someLinkId"));
    expect(htmlComponent).toBeNull();
});

After exploring different options, I discovered a new method that is compatible with RouterTestingModule, similar to what @daniel-sc suggested.

   const events = new Subject<{}>();
   const router = TestBed.get(Router);
   spyOn(router.events, 'pipe').and.returnValue(events);
   events.next('Result of pipe');

Just wanted to share what I did to address this:

const eventsData = new BehaviorSubject<Event>(null);
    export class RouterData {
      eventsList = eventsData;
    }

    beforeEach(async(() => {
        TestBed.configureTestingModule({
          declarations: [AppComponent],
          imports: [RouterTestingModule],
          providers: [
            { provide: HttpClient, useValue: {} },
            { provide: Router, useClass: RouterData },
            Store,
            CybermetrieCentralizedService,
            TileMenuComponentService,
            HttpErrorService
          ],
          schemas: [NO_ERRORS_SCHEMA]
        }).compileComponents();
        fixture = TestBed.createComponent(AppComponent);
        routerData = TestBed.get(Router);
        tileMenuService = TestBed.get(TileMenuComponentService);
        component = fixture.componentInstance;
      }));

During the testing phase, I followed these steps:

     it('should trigger menu close on dashboard navigation completion', async(() => {
        spyOn(tileMenuService.menuOpened, 'next');
        component.checkRouterEvents();
        routerData.eventsList.next(new NavigationEnd (1, '/', '/'));
        expect(tileMenuService.menuOpened.next).toHaveBeenCalledWith(false);
      }));

This was crucial for verifying if the expected action is executed after navigating to route '/'.

Whenever I find myself needing to unit test a router event, I always end up revisiting my old code and thinking "there has to be a better way". While this page contains some valuable insights and code snippets, there are a few things to keep in mind:

• RouterTestingModule is no longer recommended
• It's important to test with properly constructed objects for better (compliance / linting)
• Writing source code solely for testing purposes is not ideal

Step 1 - Create quality test objects

const routerEvent$: Subject<RouterEvent> = new Subject<RouterEvent>();
const navStartEvent: NavigationStart = new NavigationStart(1, '/fakeUrl');
const navEndEvent: new NavigationEnd(1, '/fakeUrl', '/anotherFakeUrl');

Make sure to import necessary modules from @angular/router / rxjs

Step 2 - Inject these objects into your unit tests

beforeEach(() => {
 TestBed.configureTestingModule({
   ...
    providers: [
      {
        provide: Router,
        useValue: { events: routerEvent$ }
      }
    ]
  });

There are alternate methods available, but this approach aligns well with Angular conventions. A less favorable (incorrect) alternative involves adding .pipe() between router.events and .subscribe() in your component.ts file. In your .spec.ts file, you can simply do

spyOn(router.events, 'pipe').and.returnValue(routerEvent$);

Step 3 - Simulate specific router events during unit testing

it('should perform different actions on navigation start / end', () => {
  expect(loadingSvc.spinnerOn).not.toHaveBeenCalled();
  expect(loadingSvc.spinnerOff).not.toHaveBeenCalled();
  routerEvent$.next(navStartEvent); // Triggers navigation start event
  fixture.detectChanges();
  expect(loadingSvc.spinnerOn).toHaveBeenCalledTimes(1);
  expect(loadingSvc.spinnerOff).not.toHaveBeenCalled();
  routerEvent$.next(navEndEvent); // Triggers navigation end event
  fixture.detectChanges();
  expect(loadingSvc.spinnerOn).toHaveBeenCalledTimes(1);
  expect(loadingSvc.spinnerOff).toHaveBeenCalledTimes(1);
});

The example uses a loading spinner, but there are better ways to handle such scenarios available!