import { TestScheduler } from 'rxjs/testing';
import { throttleTime } from 'rxjs';

const testScheduler = new TestScheduler((actual, expected) => {
  // asserting the two objects are equal - required
  // for TestScheduler assertions to work via your test framework
  // e.g. using chai.
  expect(actual).deep.equal(expected);
});

// This test runs synchronously.
it('generates the stream correctly', () => {
  testScheduler.run((helpers) => {
    const { cold, time, expectObservable, expectSubscriptions } = helpers;
    const e1 = cold(' -a--b--c---|');
    const e1subs = '  ^----------!';
    const t = time('   ---|       '); // t = 3
    const expected = '-a-----c---|';

    expectObservable(e1.pipe(throttleTime(t))).toBe(expected);
    expectSubscriptions(e1.subscriptions).toBe(e1subs);
  });

  testScheduler.run((helpers) => {
	  const { time, cold } = helpers;
	  const source = cold('---a--b--|');
	  const t = time('        --|    ');
	  //                         --|
	  const expected = '   -----a--b|';
	  const result = source.pipe(delay(t));
	  expectObservable(result).toBe(expected);
	});

  testScheduler.run((helpers) => {
	  const { animate, cold } = helpers;
	  animate('              ---x---x---x---x');
	  const requests = cold('-r-------r------');
	  /* ... */
	  const expected = '     ---a-------b----';
	});
});

import { HttpErrorResponse } from '@angular/common/http';
import { ErrorHandler, Injectable, NgZone } from '@angular/core';

@Injectable()
export class GlobalErrorHandler implements ErrorHandler {
  constructor() {}

  public handleError(error: any): void {
    // Check if it's an error from an HTTP response
    const isServerError = error instanceof HttpErrorResponse;

    if (!isServerError) {
       // TODO
    }

    console.error('Error from Global Error Handler', error);
  }
}

@NgModule({
  declarations: [AppComponent],
  imports: [
    CommonModule,
    HttpClientModule,
  ],
  providers: [
    { provide: ErrorHandler, useClass: GlobalErrorHandler },
  ],
  bootstrap: [AppComponent],
})
export class AppModule {}

import { PreloadAllModules } from '@angular/router';
RouterModule.forRoot(
  appRoutes,
  {
    preloadingStrategy: PreloadAllModules
  }
)

import { Resolve } from '@angular/router';

...

/* An interface that represents your data model */
export interface Crisis {
  id: number;
  name: string;
}

export class CrisisDetailResolverService implements Resolve {
  resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable {
    // your logic goes here
  }
}

import { CrisisDetailResolverService } from './crisis-detail-resolver.service';
{
  path: '/your-path',
  component: YourComponent,
  resolve: {
    crisis: CrisisDetailResolverService
  }
}

import { ActivatedRoute } from '@angular/router';

@Component({ ... })
class YourComponent {
  constructor(private route: ActivatedRoute) {}

  ngOnInit() {
    this.route.data
      .subscribe(data => {
        const crisis: Crisis = data.crisis;
        // ...
      });
  }
}

import {NgModule} from '@angular/core';
import {Routes, RouterModule} from '@angular/router';
import {CustomPreloadingStrategyService} from './custom-preloading-strategy.service';
const routes: Routes = [
  {path: 'about', data: {preload: true}, loadChildren: () => import('./about/about.module').then(m => m.AboutModule)},
  {path: 'users', loadChildren: () => import('./users/users.module').then(m => m.UsersModule)},
  {path: '', redirectTo: '', pathMatch: 'full'}
];
@NgModule({
  imports: [RouterModule.forRoot(routes, {preloadingStrategy: CustomPreloadingStrategyService})],
  exports: [RouterModule]
})
export class AppRoutingModule {
}

import {Injectable} from '@angular/core';
import {PreloadingStrategy, Route} from '@angular/router';
import {Observable, of} from 'rxjs';
@Injectable({
  providedIn: 'root'
})
export class CustomPreloadingStrategyService implements PreloadingStrategy {
preload(route: Route, fn: () => Observable<any>): Observable<any> {
    if (route.data && route.data.preload) {
	      return fn();  // Proceeds with preloading
    }
    return of(null);  // Proceeds without preloading
  }
}

import {HttpTestingController} from '@angular/common/http/testing';

describe('DataService', () => {
    let service: DataService;
    let httpMock: HttpTestingController;
    beforeEach(() => {
        TestBed.configureTestingModule({
            imports: [HttpClientModule],
            providers: [DataService]
        });
        service = TestBed.get(DataService);
        httpMock = TestBed.get(HttpTestingController);
    });
		afterEach(() => {
		    httpMock.verify();
		});

		it('be able to retrieve posts from the API bia GET', () => {
			const dummyPosts: Post[] = [{
			    userId: '1',
			    id: 1,
			    body: 'Hello World',
			    title: 'testing Angular'
			    }, {
			    userId: '2',
			    id: 2,
			    body: 'Hello World2',
			    title: 'testing Angular2'
			}];
			service.getPost().subscribe(posts => {
			    expect(posts.length).toBe(2);
			    expect(posts).toEqual(dummyPosts);
			});
			const request = httpMock.expectOne( `${service.ROOT_URl}/posts`);
			expect(request.request.method).toBe('GET');
			request.flush(dummyPosts);
		});
});