describe('FirebaseObjectObservable', () => {

  let O: FirebaseObjectObservable<any>;
  let ref: Reference;
  let app: FBApp;
  let db: AngularFireDatabase;

  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [
        AngularFireModule.initializeApp(COMMON_CONFIG),
        AngularFireDatabaseModule
      ]
    });
    inject([FirebaseApp, AngularFireDatabase], (_app: FBApp, _db: AngularFireDatabase) => {
      app = _app;
      db = _db;
      ref = app.database().ref();
      O = new FirebaseObjectObservable((observer: Observer<any>) => {
      }, ref);
    })();
  });

  afterEach(done => {
    ref.off();
    ref.remove();
    app.delete().then(done, done.fail);
  });

  it('should return an instance of FirebaseObservable when calling operators', () => {
    let O = new FirebaseObjectObservable((observer: Observer<any>) => { });
    expect(map.call(O, noop) instanceof FirebaseObjectObservable).toBe(true);
  });

  describe('$ref', () => {
    it('should match the database path passed in the constructor', () => {
      expect(O.$ref!.toString()).toEqual(ref.toString());
    });
  });

  describe('set', () => {

    it('should call set on the underlying ref', (done: any) => {
      let setSpy = spyOn(ref, 'set');

      O.subscribe();
      O.set(1);
      expect(setSpy).toHaveBeenCalledWith(1);
      done();
    });

    it('should throw an exception if set when not subscribed', () => {
      O = new FirebaseObjectObservable((observer: Observer<any>) => { });

      expect(() => {
        O.set('foo');
      }).toThrowError('No ref specified for this Observable!')
    });

    it('should accept any type of value without compilation error', () => {
      O.set('foo');
    });


    it('should resolve returned thenable when successful', (done: any) => {
      O.set('foo').then(done, done.fail);
    });

  });

  describe('update', () => {
    const updateObject = { hot: 'firebae' };
    it('should call update on the underlying ref', () => {
      let updateSpy = spyOn(ref, 'update');

      O.subscribe();
      O.update(updateObject);
      expect(updateSpy).toHaveBeenCalledWith(updateObject);
    });

    it('should throw an exception if updated when not subscribed', () => {
      O = new FirebaseObjectObservable((observer: Observer<any>) => { });

      expect(() => {
        O.update(updateObject);
      }).toThrowError('No ref specified for this Observable!')
    });

    it('should accept any type of value without compilation error', () => {
      O.update(updateObject);
    });

    it('should resolve returned thenable when successful', (done: any) => {
      O.update(updateObject).then(done, done.fail);
    });

  });

  describe('remove', () => {

//.........这里部分代码省略.........

describe('angularfire', () => {
  let subscription:Subscription;
  let app: FirebaseApp;
  let rootRef: Reference;
  let questionsRef: Reference;
  let listOfQuestionsRef: Reference;
  let defaultPlatform: PlatformRef;

  const APP_NAME = 'super-awesome-test-firebase-app-name';

  beforeEach(() => {

    TestBed.configureTestingModule({
      imports: [AngularFireModule.initializeApp(COMMON_CONFIG, APP_NAME)]
    });

    inject([FirebaseApp, PlatformRef], (_app: FirebaseApp, _platform: PlatformRef) => {
      app = _app;
      rootRef = app.database!().ref();
      questionsRef = rootRef.child('questions');
      listOfQuestionsRef = rootRef.child('list-of-questions');
      defaultPlatform = _platform;
    })();

  });

  afterEach((done) => {
    rootRef.remove()
    if(subscription && !subscription.closed) {
      subscription.unsubscribe();
    }
    app.delete().then(done, done.fail);
  });

  describe('FirebaseApp', () => {
    it('should provide a FirebaseApp for the FirebaseApp binding', () => {
      expect(typeof app.delete).toBe('function');
    });
    it('should have the provided name', () => {
      expect(app.name).toBe(APP_NAME);
    })
    it('should use an already intialized firebase app if it exists', done => {
      @NgModule({
        imports: [
          AngularFireModule.initializeApp(COMMON_CONFIG, APP_NAME),
          BrowserModule
        ]})
      class MyModule {
        ngDoBootstrap() {}
      }

      const compilerFactory: CompilerFactory =
          defaultPlatform.injector.get(CompilerFactory, null);
      const moduleFactory = compilerFactory.createCompiler().compileModuleSync(MyModule);

      defaultPlatform.bootstrapModuleFactory(moduleFactory)
        .then(moduleRef => {
          const ref = moduleRef.injector.get(FirebaseApp);
          expect(ref.name).toEqual(app.name);
        }).then(done, e => {
          fail(e);
          done()
        });
    })
  });
});

 inject([FirebaseApp, PlatformRef], (_app: FirebaseApp, _platform: PlatformRef) => {
   app = _app;
   rootRef = app.database!().ref();
   questionsRef = rootRef.child('questions');
   listOfQuestionsRef = rootRef.child('list-of-questions');
   defaultPlatform = _platform;
 })();

 afterEach((done) => {
   rootRef.remove()
   if(subscription && !subscription.closed) {
     subscription.unsubscribe();
   }
   app.delete().then(done, done.fail);
 });

 it('should match the database path passed in the constructor', () => {
   expect(O.$ref!.toString()).toEqual(ref.toString());
 });

 afterEach(done => {
   ref.off();
   ref.remove();
   app.delete().then(done, done.fail);
 });

 remove(): Promise<void> {
   if(!this.$ref) {
     throw new Error('No ref specified for this Observable!');
   }
   return this.$ref.remove();
 }