import { TestBed } from '@angular/core/testing';
import { AngularFireAuth } from 'angularfire2/auth';
import { BehaviorSubject } from 'rxjs/BehaviorSubject';
import { Subscription } from 'rxjs/Subscription';
import { UserService } from './user.service';
const credentialsMock = {
 email: 'abc@123.com',
 password: 'password'
};
const userMock = {
 uid: 'ABC123',
 email: credentialsMock.email,
};
const fakeAuthState = new BehaviorSubject(null); // <= Pay attention to this guy
const fakeSignInHandler = (email, password): Promise<any> => {
 fakeAuthState.next(userMock);
 return Promise.resolve(userMock);
};
const fakeSignOutHandler = (): Promise<any> => {
 fakeAuthState.next(null);
 return Promise.resolve();
};
const angularFireAuthStub = {
 authState: fakeAuthState,
 auth: {
 createUserWithEmailAndPassword: jasmine
 .createSpy('createUserWithEmailAndPassword')
 .and
 .callFake(fakeSignInHandler),
 signInWithEmailAndPassword: jasmine
 .createSpy('signInWithEmailAndPassword')
 .and
 .callFake(fakeSignInHandler),
 signOut: jasmine
 .createSpy('signOut')
 .and
 .callFake(fakeSignOutHandler),
 },
};
describe('UserService', () => {
 let service: UserService;
 let afAuth: AngularFireAuth;
 let isAuth$: Subscription;
 let isAuthRef: boolean;
 beforeEach(() => {
 TestBed.configureTestingModule({
 providers: [
 UserService,
 { provide: AngularFireAuth, useValue: angularFireAuthStub },
 ],
 });
 service = TestBed.get(UserService);
 afAuth = TestBed.get(AngularFireAuth);
 });
 beforeEach(() => {
 isAuth$ = service.isAuthenticated$
 .subscribe(isAuth => {
 isAuthRef = isAuth;
 });
 });
 afterEach(() => {
 fakeAuthState.next(null);
 isAuth$.unsubscribe();
 });
 it('should be created', () => {
 expect(service).toBeTruthy();
 });
 it('should not be initially authenticated', () => {
 expect(isAuthRef).toBe(false);
 });
 it('should be authenticated after register', () => {
 service.register(credentialsMock);
 expect(afAuth.auth.createUserWithEmailAndPassword)
 .toHaveBeenCalledWith(credentialsMock.email, credentialsMock.password);
 expect(isAuthRef).toBe(true);
 expect(service.user.email).toEqual(credentialsMock.email);
 });
 it('should be authenticated after logging in', () => {
 service.logIn(credentialsMock);
 expect(afAuth.auth.signInWithEmailAndPassword)
 .toHaveBeenCalledWith(credentialsMock.email, credentialsMock.password);
 expect(isAuthRef).toBeTruthy();
 expect(service.user.email).toEqual(credentialsMock.email);
 });
 it('should not be authenticated after logging out', () => {
 fakeAuthState.next(userMock);
 expect(isAuthRef).toBe(true);
 expect(service.user.email).toEqual(credentialsMock.email);
 service.logOut();
 expect(isAuthRef).toBe(false);
 expect(service.user).toBe(null);
 });
});

import { Injectable } from '@angular/core';
import { AngularFireAuth } from 'angularfire2/auth';
import { User } from 'firebase/app';
import { Observable } from 'rxjs/Observable';
class Credentials {
 email: string;
 password: string;
}
@Injectable()
export class UserService {
 public user: User;
 public get isAuthenticated$(): Observable<boolean> {
 return this.afAuth.authState.map(user => user !== null);
 }
 constructor(
 private afAuth: AngularFireAuth,
 ) {
 this.afAuth.authState.subscribe(user => {
 this.user = user;
 });
 }
 register(credentials: Credentials): Promise<any> {
 return this.afAuth.auth
 .createUserWithEmailAndPassword(
 credentials.email,
 credentials.password,
 );
 }
 logIn(credentials: Credentials): Promise<any> {
 return this.afAuth.auth
 .signInWithEmailAndPassword(
 credentials.email,
 credentials.password,
 );
 }
 logOut(): Promise<any> {
 return this.afAuth.auth
 .signOut();
 }
}

export class AngularFireDatabaseMock {
 list(query: string): any {
 return {
 valueChanges() {
 return Observable.of([
 {
 date: 12345,
 name: 'Hello World'
 },
 {
 date: 456779,
 name: 'Hola Mundo'
 }
 ])
 }
 }
 }
}

export class FirebaseMock {
 public ref(path: string) {
 return {
 getDownloadURL() {
 return Observable.of(path)
 }
 }
 }
}

 let mock: any;
 let service: TownhallPictureService;
 beforeEach(() => {
 mock = new FirebaseMock();
 service = new TownhallPictureService(mock);
 });

import { map } from 'rxjs/observables';
...
...snapshotChanges().pipe(map(a => ...))

`
firebaseRoot = new MockFirebase("Mock://");
firebaseRoot.autoFlush(true); 
statsRef = firebaseRoot.child("stats");
 externalServiceMock.getCapacities.and.callFake(function(){
 return of(helper.getSnapShotChanges(capacitiesRef,true))
 });`

`beforeEach(()=>{
statsRef.set({*dataObject*})
})
it('subscribes',()=>{
 service.getSnapshotChangesOfData().subscribe(data =>{
 expect(data).toContain({dataObj}); 
 })
})
`

 getSnapShotChanges(data: object, asObserv: boolean){
 const dataKeys = Object.keys(data);
 for(let i = 0; i < dataKeys.length; i++){
 this.actions.push({
 payload: {
 val: function() { return data[dataKeys[i]] },
 key: dataKeys[i]
 },
 prevKey: null,
 type: "value"
 });
 }
 if(asObserv){
 return of(this.actions);
 }else{
 return this.actions;
 }
 };```
This is what we have been doing to allow us to follow on from angularjs testing,its made fairly similar now

Error: AngularFireModule has not been provided