Typescriptify and shim kbn_tp_run_pipeline test plugin (#50645) (#51714)

* Typscriptify and shim kbn_tp_run_pipeline test plugin

* fix imports to not re-export ‘legacy’ from root of plugin

Author: Dosant

scripts/functional_tests.js

@@ -22,6 +22,6 @@ require('@kbn/test').runTestsCli([
   require.resolve('../test/functional/config.js'),
   require.resolve('../test/api_integration/config.js'),
   require.resolve('../test/plugin_functional/config.js'),
-  require.resolve('../test/interpreter_functional/config.js'),
+  require.resolve('../test/interpreter_functional/config.ts'),
   require.resolve('../test/ui_capabilities/newsfeed_err/config.ts'),
 ]);

src/plugins/expressions/public/index.ts

@@ -20,14 +20,17 @@
 import { PluginInitializerContext } from '../../../core/public';
 import { ExpressionsPublicPlugin } from './plugin';
 
-export function plugin(initializerContext: PluginInitializerContext) {
-  return new ExpressionsPublicPlugin(initializerContext);
-}
-
 export { ExpressionsPublicPlugin as Plugin };
 
 export * from './plugin';
 export * from './types';
 export * from '../common';
 export { interpreterProvider, ExpressionInterpret } from './interpreter_provider';
 export { ExpressionRenderer, ExpressionRendererProps } from './expression_renderer';
+export { ExpressionDataHandler } from './execute';
+
+export { RenderResult, ExpressionRenderHandler } from './render';
+
+export function plugin(initializerContext: PluginInitializerContext) {
+  return new ExpressionsPublicPlugin(initializerContext);
+}

src/plugins/expressions/public/render.ts

@@ -30,15 +30,17 @@ interface RenderError {
 
 export type IExpressionRendererExtraHandlers = Record<string, any>;
 
+export type RenderResult = RenderId | RenderError;
+
 export class ExpressionRenderHandler {
-  render$: Observable<RenderId | RenderError>;
+  render$: Observable<RenderResult>;
   update$: Observable<any>;
   events$: Observable<event>;
 
   private element: HTMLElement;
   private destroyFn?: any;
   private renderCount: number = 0;
-  private renderSubject: Rx.BehaviorSubject<RenderId | RenderError | null>;
+  private renderSubject: Rx.BehaviorSubject<RenderResult | null>;
   private eventsSubject: Rx.Subject<unknown>;
   private updateSubject: Rx.Subject<unknown>;
   private handlers: IInterpreterRenderHandlers;
@@ -49,11 +51,11 @@ export class ExpressionRenderHandler {
     this.eventsSubject = new Rx.Subject();
     this.events$ = this.eventsSubject.asObservable().pipe(share());
 
-    this.renderSubject = new Rx.BehaviorSubject(null as RenderId | RenderError | null);
+    this.renderSubject = new Rx.BehaviorSubject(null as RenderResult | null);
     this.render$ = this.renderSubject.asObservable().pipe(
       share(),
       filter(_ => _ !== null)
-    ) as Observable<RenderId | RenderError>;
+    ) as Observable<RenderResult>;
 
     this.updateSubject = new Rx.Subject();
     this.update$ = this.updateSubject.asObservable().pipe(share());

tasks/config/run.js

@@ -254,7 +254,7 @@ module.exports = function (grunt) {
       cmd: NODE,
       args: [
         'scripts/functional_tests',
-        '--config', 'test/interpreter_functional/config.js',
+        '--config', 'test/interpreter_functional/config.ts',
         '--bail',
         '--debug',
         '--kibana-install-dir', KIBANA_INSTALL_DIR,

test/functional/services/browser.ts

@@ -470,7 +470,10 @@ export async function BrowserProvider({ getService }: FtrProviderContext) {
       );
     }
 
-    public async executeAsync<R>(fn: string | ((...args: any[]) => R), ...args: any[]): Promise<R> {
+    public async executeAsync<R>(
+      fn: string | ((...args: any[]) => Promise<R>),
+      ...args: any[]
+    ): Promise<R> {
       return await driver.executeAsyncScript(
         fn,
         ...cloneDeep<any>(args, arg => {

test/interpreter_functional/README.md

@@ -3,25 +3,25 @@
 This folder contains interpreter functional tests.
 
 Add new test suites into the `test_suites` folder and reference them from the
-`config.js` file. These test suites work the same as regular functional test.
+`config.ts` file. These test suites work the same as regular functional test.
 
 ## Run the test
 
 To run these tests during development you can use the following commands:
 
 ```
 # Start the test server (can continue running)
-node scripts/functional_tests_server.js --config test/interpreter_functional/config.js
+node scripts/functional_tests_server.js --config test/interpreter_functional/config.ts
 
 # Start a test run
-node scripts/functional_test_runner.js --config test/interpreter_functional/config.js
+node scripts/functional_test_runner.js --config test/interpreter_functional/config.ts
 ```
 
 # Writing tests
 
-Look into test_suites/run_pipeline/basic.js for examples
+Look into test_suites/run_pipeline/basic.ts for examples
 
 to update baseline screenshots and snapshots run with:
 ```
-node scripts/functional_test_runner.js --config test/interpreter_functional/config.js --updateBaselines
+node scripts/functional_test_runner.js --config test/interpreter_functional/config.ts --updateBaselines
 ```

test/interpreter_functional/config.js renamed to test/interpreter_functional/config.ts

@@ -19,25 +19,26 @@
 
 import path from 'path';
 import fs from 'fs';
+import { FtrConfigProviderContext } from '@kbn/test/types/ftr';
 
-export default async function ({ readConfigFile }) {
+export default async function({ readConfigFile }: FtrConfigProviderContext) {
   const functionalConfig = await readConfigFile(require.resolve('../functional/config'));
 
   // Find all folders in ./plugins since we treat all them as plugin folder
   const allFiles = fs.readdirSync(path.resolve(__dirname, 'plugins'));
-  const plugins = allFiles.filter(file => fs.statSync(path.resolve(__dirname, 'plugins', file)).isDirectory());
+  const plugins = allFiles.filter(file =>
+    fs.statSync(path.resolve(__dirname, 'plugins', file)).isDirectory()
+  );
 
   return {
-    testFiles: [
-      require.resolve('./test_suites/run_pipeline'),
-    ],
+    testFiles: [require.resolve('./test_suites/run_pipeline')],
     services: functionalConfig.get('services'),
     pageObjects: functionalConfig.get('pageObjects'),
     servers: functionalConfig.get('servers'),
     esTestCluster: functionalConfig.get('esTestCluster'),
     apps: functionalConfig.get('apps'),
     esArchiver: {
-      directory: path.resolve(__dirname, '../es_archives')
+      directory: path.resolve(__dirname, '../es_archives'),
     },
     snapshots: {
       directory: path.resolve(__dirname, 'snapshots'),
@@ -49,7 +50,9 @@ export default async function ({ readConfigFile }) {
       ...functionalConfig.get('kbnTestServer'),
       serverArgs: [
         ...functionalConfig.get('kbnTestServer.serverArgs'),
-        ...plugins.map(pluginDir => `--plugin-path=${path.resolve(__dirname, 'plugins', pluginDir)}`),
+        ...plugins.map(
+          pluginDir => `--plugin-path=${path.resolve(__dirname, 'plugins', pluginDir)}`
+        ),
       ],
     },
   };

test/interpreter_functional/plugins/kbn_tp_run_pipeline/index.js renamed to test/interpreter_functional/plugins/kbn_tp_run_pipeline/index.ts

@@ -16,24 +16,34 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { Legacy } from 'kibana';
+import {
+  ArrayOrItem,
+  LegacyPluginApi,
+  LegacyPluginSpec,
+  LegacyPluginOptions,
+} from 'src/legacy/plugin_discovery/types';
 
-export default function (kibana) {
-  return new kibana.Plugin({
+// eslint-disable-next-line import/no-default-export
+export default function(kibana: LegacyPluginApi): ArrayOrItem<LegacyPluginSpec> {
+  const pluginSpec: Partial<LegacyPluginOptions> = {
+    id: 'kbn_tp_run_pipeline',
     uiExports: {
       app: {
         title: 'Run Pipeline',
         description: 'This is a sample plugin to test running pipeline expressions',
-        main: 'plugins/kbn_tp_run_pipeline/app',
-      }
+        main: 'plugins/kbn_tp_run_pipeline/legacy',
+      },
     },
 
-    init(server) {
+    init(server: Legacy.Server) {
       // The following lines copy over some configuration variables from Kibana
       // to this plugin. This will be needed when embedding visualizations, so that e.g.
       // region map is able to get its configuration.
       server.injectUiAppVars('kbn_tp_run_pipeline', async () => {
-        return await server.getInjectedUiAppVars('kibana');
+        return server.getInjectedUiAppVars('kibana');
       });
-    }
-  });
+    },
+  };
+  return new kibana.Plugin(pluginSpec);
 }