initialize(): Q.Promise<PartitionService> {
        var deferred = Q.defer<PartitionService>();
        this.refresh().then(() => {
            deferred.resolve(this);
        });

        return deferred.promise;
    }

 export function updateOrCreatePerson (personData: PersonModel): Promise<any> {
     var model = new MongoModel('person');
     var deferred = Q.defer();
     model.updateOrCreate({email: personData.email}, personData).then(function () {
         deferred.resolve();
     }).catch(deferred.reject);
     return deferred.promise; 
 }

 export function getPersonDataFromEmail (email: string): Promise<IPerson> {
     var model = new MongoModel('person');
     var deferred = Q.defer();
     model.findOne({ email: email }).then(function (personData?: PersonModel) {
         deferred.resolve(personData);
     }).catch(deferred.reject);
     return deferred.promise;
 }

 /**
  * Teardown and destroy the environment and do any associated cleanup.
  * Shuts down the drivers and server.
  *
  * @public
  * @override
  * @return {q.promise} A promise which will resolve when the environment
  *     is down.
  */
 teardownEnv(): q.Promise<any> {
   let deferred = q.defer();
   super.teardownEnv().then(() => {
     logger.info('Shutting down selenium standalone server.');
     this.server_.stop().then(() => { deferred.resolve(); });
   });
   return deferred.promise;
 }

export function promiseError( msg: string, resName : string, errcode: number = 500  ) : Q.Promise< relaxjs.Embodiment > {
  var later = Q.defer< relaxjs.Embodiment >();
  _.defer( () => {
    _log.error(msg);
    later.reject( emitError( msg, resName, errcode )  )
  });
  return later.promise;
}

 beforeEach(async () => {
   deferred = $q.defer({});
   historySrv.calculateDiff = jest.fn(() => deferred.promise);
   deferred.resolve(compare('json'));
   historyListCtrl.revisions[1].checked = true;
   historyListCtrl.revisions[3].checked = true;
   await historyListCtrl.getDiff('json');
 });

			public getOwner (): Promise<PersonBE> {
				var deferred = Q.defer();
				getOwnerDataFromCredentials(this.email, this.password).then(function (personData: IPerson) {
					if (!personData) deferred.resolve();
					else deferred.resolve(new PersonBE(personData));
				}).catch(deferred.reject);
				return deferred.promise;
			}

export let run = (configArg: IPlrConfig) => {
    let done = q.defer<IPlrConfig>()
    smartbrowserInst = new plugins.smartbrowser.Smartbrowser({
        webroot: paths.cwd,
        watchFiles: [plugins.path.join(paths.cwd, '**/*')]
    })
    return done.promise
}

			searchPerson (email: string, password: string): Promise<PersonBE> {
				let deferred = Q.defer();
				let credential = new Credential(email, password);
				credential.getOwner().then(function (owner?: PersonBE) {
					deferred.resolve(owner);
				}).catch(this.sendError);
				return deferred.promise;
			}

 /**
  * Configure and launch (if applicable) the object's environment.
  * @return {q.promise} A promise which will resolve when the environment is
  *     ready to test.
  */
 protected setupDriverEnv(): q.Promise<any> {
   const defer = q.defer();
   this.config_.seleniumWebDriver.getSession().then((session) => {
     logger.info('Using session id - ' + session.getId());
     return defer.resolve();
   });
   return q(undefined);
 }