it('fails on invalid additionalProperties', done => {
    const registry = new CoreSchemaRegistry();
    const data = { notNum: 'foo' };

    registry
      .compile({
        properties: {
          num: { type: 'number' },
        },
        additionalProperties: false,
      }).pipe(
        mergeMap(validator => validator(data)),
        map(result => {
          expect(result.success).toBe(false);
          expect(result.errors && result.errors[0].message).toContain(
            'should NOT have additional properties');
        }),
    )
      .toPromise().then(done, done.fail);
  });

export function discover(config: PluginsConfig, coreContext: CoreContext) {
  const log = coreContext.logger.get('plugins-discovery');
  log.debug('Discovering plugins...');

  const discoveryResults$ = processPluginSearchPaths$(config.pluginSearchPaths, log).pipe(
    mergeMap(pluginPathOrError => {
      return typeof pluginPathOrError === 'string'
        ? createPlugin$(pluginPathOrError, log, coreContext)
        : [pluginPathOrError];
    }),
    shareReplay()
  );

  return {
    plugin$: discoveryResults$.pipe(filter((entry): entry is Plugin => entry instanceof Plugin)),
    error$: discoveryResults$.pipe(
      filter((entry): entry is PluginDiscoveryError => !(entry instanceof Plugin))
    ),
  };
}

function inicializarBase() {

    const leerBDD$ = rxjs.from(leerBDD());

    return leerBDD$
        .pipe(
            mergeMap(
                (respuestaLeerBDD: RespuestaBDD) => {
                    if (respuestaLeerBDD.bdd) {
                        // truty / {}
                        return rxjs.of(respuestaLeerBDD)
                    } else {
                        // falsy / null
                        return rxjs.from(crearBDD())
                    }
                }
            )
        )
        ;
}

function preguntarPorIDUsuario(respuestaBDD: RespuestaBDD) {
    return rxjs
        .from(inquirer.prompt(preguntaBuscarUsuario)) //*********************
        .pipe(
            mergeMap( // respuesta del anterior observable
                (respuesta: BuscarUsuarioPorId) => {

                    const idDelUsuario = respuestaBDD.bdd
                        .usuarios
                        .findIndex( // -1
                            (usuario: Usuario) => {
                                console.log(usuario);
                                return usuario.id === respuesta.idUsuario
                            }
                        );
                    if (idDelUsuario === '-1') {
                        console.log('El id no existe, Intente nuevamente \n');
                        return preguntarPorIDUsuario(respuestaBDD);
                    } else {
                        respuestaBDD.idUsuario = idDelUsuario;
                        return rxjs
                            .from(inquirer.prompt(preguntaBuscarNombreUsuario))//***********************
                            .pipe(
                                map(
                                    (nombre:{nombre:string})=>{
                                        respuestaBDD.usuario ={
                                            id:null,
                                            nombre:nombre.nombre,
                                            tipoCuenta:null,
                                            saldo:null,
                                            password:null
                                        };
                                        return respuestaBDD;
                                    }
                                )
                            );
                    }
                }
            )
        );
}

  forkJoin2() {
    const myPromise = val =>
      new Promise(resolve =>
        setTimeout(() => resolve(`Promise Resolved: ${val}`), 5000)
      );

    const source = of([1, 2, 3, 4, 5]);
    // emit array of all 5 results
    const example = source.pipe(mergeMap(q => forkJoin(...q.map(myPromise))));
    /*
      output:
      [
       "Promise Resolved: 1",
       "Promise Resolved: 2",
       "Promise Resolved: 3",
       "Promise Resolved: 4",
       "Promise Resolved: 5"
      ]
    */
    const subscribe = example.subscribe(val => console.log(val));
  }

export const loadStateEpic: Epic<any, any> = action$ =>
    action$.ofType(CoreActionTypes.LOAD_STATE)
        .pipe(
            mergeMap((action: typeof loadState) => {
                const theme = localStorage.getItem('theme') || 'solarized dark'
                const actions: IAction[] = [initSettings({
                    theme
                })]

                let servers: any = localStorage.getItem('servers')
                if (servers) {
                    servers = JSON.parse(servers)
                    actions.push(initServers(servers))
                }

                return from([
                    ...actions,
                    loadStateFinished()
                ])
            })
        )

    function main(_sources: any) {
      const test$ = of(null).pipe(
        delay(1000),
        mergeMap(() =>
          _sources.HTTP.select('cat').pipe(
            mergeAll(),
            map((res: any) => 'I should not show this, ' + res.text)
          )
        )
      );

      const request$ = of({
        category: 'cat',
        url: uri + '/hello',
      });

      return {
        HTTP: request$,
        Test: test$,
      };
    }

/**
 * Perform cleaning of the buffer according to the values set by the user
 * at each clock tick and each times the maxBufferBehind/maxBufferAhead values
 * change.
 *
 * @param {Object} opt
 * @returns {Observable}
 */
export default function BufferGarbageCollector({
  queuedSourceBuffer,
  clock$,
  maxBufferBehind$,
  maxBufferAhead$,
} : {
  queuedSourceBuffer : QueuedSourceBuffer<unknown>;
  clock$ : Observable<number>;
  maxBufferBehind$ : Observable<number>;
  maxBufferAhead$ : Observable<number>;
}) : Observable<never> {
  return observableCombineLatest(clock$, maxBufferBehind$, maxBufferAhead$).pipe(
    mergeMap(([currentTime, maxBufferBehind, maxBufferAhead]) => {
      return clearBuffer(
        queuedSourceBuffer,
        currentTime,
        maxBufferBehind,
        maxBufferAhead
      );
    }));
}

 mergeMap_flatMap3() {
   /*
     you can also supply a second argument which receives the source value and emitted
     value of inner observable or promise
   */
   // emit 'Hello'
   const source = of('Hello');
   // mergeMap also emits result of promise
   const myPromise = val =>
     new Promise(resolve => resolve(`${val} World From Promise!`));
   const example = source.pipe(
     mergeMap(
       val => myPromise(val),
       (valueFromSource, valueFromPromise) => {
         return `Source: ${valueFromSource}, Promise: ${valueFromPromise}`;
       }
     )
   );
   // output: "Source: Hello, Promise: Hello World From Promise!"
   const subscribe = example.subscribe(val => console.log(val));
 }

/**
 * Iterates over every plugin search path and returns a merged stream of all
 * sub-directories. If directory cannot be read or it's impossible to get stat
 * for any of the nested entries then error is added into the stream instead.
 * @param pluginDirs List of the top-level directories to process.
 * @param log Plugin discovery logger instance.
 */
function processPluginSearchPaths$(pluginDirs: ReadonlyArray<string>, log: Logger) {
  return from(pluginDirs).pipe(
    mergeMap(dir => {
      log.debug(`Scanning "${dir}" for plugin sub-directories...`);

      return fsReadDir$(dir).pipe(
        mergeMap((subDirs: string[]) => subDirs.map(subDir => resolve(dir, subDir))),
        mergeMap(path =>
          fsStat$(path).pipe(
            // Filter out non-directory entries from target directories, it's expected that
            // these directories may contain files (e.g. `README.md` or `package.json`).
            // We shouldn't silently ignore the entries we couldn't get stat for though.
            mergeMap(pathStat => (pathStat.isDirectory() ? [path] : [])),
            catchError(err => [PluginDiscoveryError.invalidPluginPath(path, err)])
          )
        ),
        catchError(err => [PluginDiscoveryError.invalidSearchPath(dir, err)])
      );
    })
  );
}