test('`setup` registers plugin config schema in config service', async () => {
  const configSchema = schema.string();
  jest.spyOn(configService, 'setSchema').mockImplementation(() => Promise.resolve());
  jest.doMock(
    join('path-with-schema', 'server'),
    () => ({
      config: {
        schema: configSchema,
      },
    }),
    {
      virtual: true,
    }
  );
  mockDiscover.mockReturnValue({
    error$: from([]),
    plugin$: from([
      new PluginWrapper(
        'path-with-schema',
        {
          id: 'some-id',
          version: 'some-version',
          configPath: 'path',
          kibanaVersion: '7.0.0',
          requiredPlugins: [],
          optionalPlugins: [],
          server: true,
          ui: true,
        },
        { logger } as any
      ),
    ]),
  });
  await pluginsService.setup(setupDeps);
  expect(configService.setSchema).toBeCalledWith('path', configSchema);
});

 /**
  * @param url
  * @param data
  * @param config 
  */
 post<T, U = string>(url: string, data?: any, config: AxiosRequestConfig = {}): Observable<IResult<T, U>> {
     return from(axios.post(url, data, config))
             .pipe(
                 map(response => response.data),
                 catchError((error: AxiosResponse | undefined) => {
                     console.log(error);
                     if (error === undefined) {
                         return message.error('请求出错');
                     }
                     this.error$ = of(error);
                     this.handleError();
                     return this.error$;
                 })
             );
 }

 /**
  * Adds a comment to a process instance.
  * @param processInstanceId ID of the target process instance
  * @param message Text for the comment
  * @returns Details of the comment added
  */
 addProcessInstanceComment(processInstanceId: string, message: string): Observable<CommentModel> {
     return from(
         this.apiService.getInstance().activiti.commentsApi.addProcessInstanceComment({ message: message }, processInstanceId)
     ).pipe(
         map((response: CommentModel) => {
             return new CommentModel({
                 id: response.id,
                 message: response.message,
                 created: response.created,
                 createdBy: response.createdBy
             });
         }),
         catchError((err: any) => this.handleError(err))
     );
 }

export function wrapIntoObservable<T>(value: T | NgModuleFactory<T>| Promise<T>| Observable<T>):
    Observable<T> {
  if (isObservable(value)) {
    return value;
  }

  if (isPromise(value)) {
    // Use `Promise.resolve()` to wrap promise-like instances.
    // Required ie when a Resolver returns a AngularJS `$q` promise to correctly trigger the
    // change detection.
    return from(Promise.resolve(value));
  }

  return of (value as T);
}

  it('should map values to resolved promises and concatenate', (done) => {
    const source = from([4, 3, 2, 1]);
    const project = (value: number, index: number) => Observable.from(Promise.resolve(value + index));

    const results: number[] = [];
    source.concatMap(project).subscribe(
      (x) => {
        results.push(x);
      }, (err) => {
        done(new Error('Subscriber error handler not supposed to be called.'));
      }, () => {
        expect(results).to.deep.equal([4, 4, 4, 4]);
        done();
      });
  });

 /**
  * Gets process instances for a filter and optionally a process definition.
  * @param requestNode Filter for instances
  * @param processDefinitionKey Limits returned instances to a process definition
  * @returns List of process instances
  */
 getProcessInstances(requestNode: ProcessFilterParamRepresentationModel, processDefinitionKey?: string): Observable<ProcessListModel> {
     return from(this.alfrescoApiService.getInstance().activiti.processApi.getProcessInstances(requestNode))
         .pipe(
             map((res: any) => {
                 if (processDefinitionKey) {
                     const filtered = res.data.filter((process) => process.processDefinitionKey === processDefinitionKey);
                     res.data = filtered;
                     return res;
                 } else {
                     return res;
                 }
             }),
             catchError((err) => this.handleProcessError(err))
         );
 }

    mergeMap(() => {
      const state = state$.value;

      const contentRef$ = from(
        state.core.entities.contents.byRef
          .filter(
            // Don't bother with non-file and non-notebook types for saving
            // (no dummy or directory)
            content => content.type === "file" || content.type === "notebook"
          )
          .keys()
      );

      return contentRef$;
    }),

export function getNpmPackageJson(
  packageName: string,
  logger: logging.LoggerApi,
  options?: {
    registryUrl?: string;
    usingYarn?: boolean;
    verbose?: boolean;
  },
): Observable<Partial<NpmRepositoryPackageJson>> {
  const cachedResponse = npmPackageJsonCache.get(packageName);
  if (cachedResponse) {
    return cachedResponse;
  }

  if (!npmrc) {
    try {
      npmrc = readOptions(logger, false, options && options.verbose);
    } catch { }

    if (options && options.usingYarn) {
      try {
        npmrc = { ...npmrc, ...readOptions(logger, true, options && options.verbose) };
      } catch { }
    }
  }

  const resultPromise: Promise<NpmRepositoryPackageJson> = pacote.packument(
    packageName,
    {
      'full-metadata': true,
      ...npmrc,
      ...(options && options.registryUrl ? { registry: options.registryUrl } : {}),
    },
  );

  // TODO: find some way to test this
  const response = from(resultPromise).pipe(
    shareReplay(),
    catchError(err => {
      logger.warn(err.message || err);

      return EMPTY;
    }),
  );
  npmPackageJsonCache.set(packageName, response);

  return response;
}

    /**
     * Finds groups filtered by name.
     * @param searchParams Object containing the name filter string
     * @returns List of group information
     */
    findGroupsByName(searchParams: GroupSearchParam): Observable<any> {
        if (searchParams.name === '') {
            return of([]);
        }
        const url = this.getGroupsApi();
        const httpMethod = 'GET', pathParams = {}, queryParams = {search: searchParams.name}, bodyParam = {}, headerParams = {},
            formParams = {}, contentTypes = ['application/json'], accepts = ['application/json'];

        return (from(this.apiService.getInstance().oauth2Auth.callCustomApi(
            url, httpMethod, pathParams, queryParams,
            headerParams, formParams, bodyParam,
            contentTypes, accepts, Object, null, null)
        )).pipe(
            catchError((err) => this.handleError(err))
        );
    }

 switchMap(user => {
   if (user) {
     return from(user.getIdToken())
     .pipe(
       switchMap((token) => {
         return next.handle(req.clone({
           setHeaders: {
             Authorization: token
           }
         }));
       })
     );
   } else {
     return next.handle(req);
   }
 })