beforeEach(async(() => {
    const eventServiceStub = {
      event$: of({}),
      product$: of({})
    };

    const metadataServiceStub = {
      getMetadata: jasmine.createSpy('metadataService::get'),
      metadata$: of({})
    };

    TestBed.configureTestingModule({
      declarations: [
        MetadataComponent,
        MockComponent({ selector: 'shakemap-input', inputs: ['smInput'] }),
        MockComponent({
          inputs: ['smMultiGmpe'],
          selector: 'shakemap-multigmpe'
        }),
        MockComponent({ selector: 'shakemap-output', inputs: ['smOutput'] }),
        MockComponent({
          inputs: ['smProcessing'],
          selector: 'shakemap-processing'
        })
      ],
      providers: [
        { provide: EventService, useValue: eventServiceStub },
        { provide: MetadataService, useValue: metadataServiceStub }
      ]
    }).compileComponents();
  }));

  beforeEach(async(() => {
    const eventServiceStub = {
      event$: of(new Event({})),
      product$: of(null)
    };

    const shakeAlertServiceStub = {
      getSummary: () => null,
      summary$: of(null)
    };

    TestBed.configureTestingModule({
      declarations: [
        ShakeAlertComponent,
        ShakeAlertDeletedComponent,
        ShakeAlertMissedComponent,
        ShakeAlertPendingComponent,

        MockComponent({ inputs: ['productType'], selector: 'product-page' }),
        MockComponent({
          inputs: ['summary', 'cities', 'properties'],
          selector: 'shake-alert-confirmed'
        })
      ],
      providers: [
        { provide: EventService, useValue: eventServiceStub },
        { provide: ShakeAlertService, useValue: shakeAlertServiceStub }
      ]
    }).compileComponents();
  }));

export function waitForMap<A, B>(
    obj: {[k: string]: A}, fn: (k: string, a: A) => Observable<B>): Observable<{[k: string]: B}> {
  const waitFor: Observable<B>[] = [];
  const res: {[k: string]: B} = {};

  forEach(obj, (a: A, k: string) => {
    if (k === PRIMARY_OUTLET) {
      waitFor.push(map.call(fn(k, a), (_: B) => {
        res[k] = _;
        return _;
      }));
    }
  });

  forEach(obj, (a: A, k: string) => {
    if (k !== PRIMARY_OUTLET) {
      waitFor.push(map.call(fn(k, a), (_: B) => {
        res[k] = _;
        return _;
      }));
    }
  });

  if (waitFor.length > 0) {
    const concatted$ = concatAll.call(of (...waitFor));
    const last$ = l.last.call(concatted$);
    return map.call(last$, () => res);
  } else {
    return of (res);
  }
}

  beforeEach(async(() => {
    const eventServiceStub = {
      event$: of(new Event({})),
      getProduct: jasmine.createSpy('eventService::getProduct')
    };

    const contributorServiceStub = {
      contributors$: of({})
    };

    TestBed.configureTestingModule({
      declarations: [
        BasicPinComponent,

        MockComponent({
          inputs: ['product'],
          selector: 'shared-product-attribution'
        }),
        MockPipe('contributorList')
      ],
      imports: [
        MatListModule,
        MatButtonModule,
        MatCardModule,
        MatDividerModule,
        RouterTestingModule
      ],
      providers: [
        { provide: EventService, useValue: eventServiceStub },
        { provide: ContributorService, useValue: contributorServiceStub }
      ]
    }).compileComponents();
  }));

export function waitForMap<A, B>(
    obj: {[k: string]: A}, fn: (k: string, a: A) => Observable<B>): Observable<{[k: string]: B}> {
  const waitFor: Observable<B>[] = [];
  const res: {[k: string]: B} = {};

  forEach(obj, (a: A, k: string) => {
    if (k === PRIMARY_OUTLET) {
      waitFor.push(fn(k, a).map((_: B) => {
        res[k] = _;
        return _;
      }));
    }
  });

  forEach(obj, (a: A, k: string) => {
    if (k !== PRIMARY_OUTLET) {
      waitFor.push(fn(k, a).map((_: B) => {
        res[k] = _;
        return _;
      }));
    }
  });

  if (waitFor.length > 0) {
    return of (...waitFor).concatAll().last().map((last) => res);
  } else {
    return of (res);
  }
}

    getTranslation(lang: string): Observable<any> {
        if (lang === 'fake') {
            return of(fakeTranslation);
        }

        return of(translations);
    }

  beforeEach(async(() => {
    const eventServiceStub = {
      event$: of({}),
      product$: of({})
    };

    const stationServiceStub = {
      getStations: jasmine.createSpy('stationService::get'),
      stationsJson$: of({})
    };

    TestBed.configureTestingModule({
      declarations: [
        StationListComponent,

        MockComponent({selector: 'shared-station', inputs: ['station']}),
        MockPipe('sharedOrderBy')
      ],
      imports: [
        MatDividerModule,
        MatIconModule,
        MatMenuModule
      ],
      providers: [
        { provide: EventService, useValue: eventServiceStub },
        { provide: StationService, useValue: stationServiceStub }
      ]
    }).compileComponents();
  }));

  beforeEach(async(() => {
    const eventServiceStub = {
      product$: of(null)
    };

    const oafServiceStub = {
      oaf$: of(null)
    };

    TestBed.configureTestingModule({
      declarations: [
        CommentaryComponent,

        MockComponent({ selector: 'oaf-commentary-details', inputs: ['bin'] }),

        MockPipe('oafPercent'),
        MockPipe('sharedDateTime'),
        MockPipe('sharedNumber'),
        MockPipe('sharedNumberWithSeparator'),
        MockPipe('sharedRoundDown'),
        MockPipe('sharedRoundUp'),
        MockPipe('sharedSignificantFigure'),
        MockPipe('updateTime')
      ],
      providers: [
        { provide: EventService, useValue: eventServiceStub },
        { provide: OafService, useValue: oafServiceStub }
      ]
    }).compileComponents();
  }));

    beforeEach(() => {
      const embedComponentsService = TestBed.get(EmbedComponentsService) as MockEmbedComponentsService;

      destroyEmbeddedComponentsSpy = spyOn(docViewer, 'destroyEmbeddedComponents');
      embedIntoSpy = embedComponentsService.embedInto.and.returnValue(of([]));
      prepareTitleAndTocSpy = spyOn(docViewer, 'prepareTitleAndToc');
      swapViewsSpy = spyOn(docViewer, 'swapViews').and.returnValue(of(undefined));
    });

describe("StatusBarComponent", () => {
    let component: StatusBarComponent;
    let fixture: ComponentFixture<StatusBarComponent>;
    let layoutService: Partial<LayoutService>;
    let statusBarService: Partial<StatusBarService>;

    const layoutServiceStub = {
        sidebarHidden: false,
        toggleSidebar: () => {
        }
    };

    const statusBarServiceStub = {
        status: of([]),
        queueSize: of([]),
        controls: {
            subscribe: (expr) => {
            }
        }
    };

    beforeEach(async(() => {
        TestBed.configureTestingModule({
            declarations: [StatusBarComponent, TimeAgoPipe],
            schemas: [NO_ERRORS_SCHEMA],
            providers: [
                {provide: LayoutService, useValue: layoutServiceStub},
                {provide: StatusBarService, useValue: statusBarServiceStub}
            ]
        }).compileComponents();
    }));

    beforeEach(() => {
        fixture          = TestBed.createComponent(StatusBarComponent);
        component        = fixture.componentInstance;
        layoutService    = fixture.debugElement.injector.get(LayoutService);
        statusBarService = fixture.debugElement.injector.get(StatusBarService);

        fixture.detectChanges();
    });

    it("should call toggleSidebar", () => {
        const toggleBtn = fixture.debugElement.query(By.css(".sidebar-toggle"));
        spyOn(layoutService, "toggleSidebar");

        toggleBtn.triggerEventHandler("click", null);
        expect(layoutService.toggleSidebar).toHaveBeenCalled();
    });

    it("should change icon arrow direction", () => {
        const toggleBtnIcon         = fixture.debugElement.query(By.css(".sidebar-toggle .fa"));
        layoutService.sidebarHidden = true;
        fixture.detectChanges();
        expect(toggleBtnIcon.nativeElement.classList.contains("fa-angle-double-right")).toBe(true);
    });
});