convert a bunch of services to FtrService

packages/kbn-test/src/functional_test_runner/lib/providers/provider_collection.ts

@@ -12,6 +12,7 @@ import { loadTracer } from '../load_tracer';
 import { createAsyncInstance, isAsyncInstance } from './async_instance';
 import { Providers } from './read_provider_spec';
 import { createVerboseInstance } from './verbose_instance';
+import { GenericFtrService } from '../../../../types/ftr';
 
 export class ProviderCollection {
   private readonly instances = new Map();
@@ -58,12 +59,19 @@ export class ProviderCollection {
   }
 
   public invokeProviderFn(provider: (args: any) => any) {
-    return provider({
+    const ctx = {
       getService: this.getService,
       hasService: this.hasService,
       getPageObject: this.getPageObject,
       getPageObjects: this.getPageObjects,
-    });
+    };
+
+    if (provider.prototype instanceof GenericFtrService) {
+      const Constructor = (provider as any) as new (ctx: any) => any;
+      return new Constructor(ctx);
+    }
+
+    return provider(ctx);
   }
 
   private findProvider(type: string, name: string) {

packages/kbn-test/types/ftr.d.ts → packages/kbn-test/types/ftr.ts

@@ -43,7 +43,12 @@ export type ProvidedType<T extends (...args: any[]) => any> = MaybeAsyncInstance
  * promise types into the async instances that other providers will receive.
  */
 type ProvidedTypeMap<T extends {}> = {
-  [K in keyof T]: T[K] extends (...args: any[]) => any ? ProvidedType<T[K]> : unknown;
+  [K in keyof T]:
+    T[K] extends { new (...args: any[]): infer X }
+      ? X
+      : T[K] extends (...args: any[]) => any
+        ? ProvidedType<T[K]>
+        : unknown;
 };
 
 export interface GenericFtrProviderContext<
@@ -88,6 +93,10 @@ export interface GenericFtrProviderContext<
   loadTestFile(path: string): void;
 }
 
+export class GenericFtrService<ProviderContext extends GenericFtrProviderContext<any, any>> {
+  constructor(protected readonly ctx: ProviderContext) {}
+}
+
 export interface FtrConfigProviderContext {
   log: ToolingLog;
   readConfigFile(path: string): Promise<Config>;

test/common/ftr_provider_context.d.ts

@@ -6,8 +6,9 @@
  * Side Public License, v 1.
  */
 
-import { GenericFtrProviderContext } from '@kbn/test/types/ftr';
+import { GenericFtrProviderContext, GenericFtrService } from '@kbn/test/types/ftr';
 
 import { services } from './services';
 
 export type FtrProviderContext = GenericFtrProviderContext<typeof services, {}>;
+export class FtrService extends GenericFtrService<FtrProviderContext> {}

test/common/services/index.ts

@@ -11,7 +11,7 @@ import { LegacyEsProvider } from './legacy_es';
 import { ElasticsearchProvider } from './elasticsearch';
 import { EsArchiverProvider } from './es_archiver';
 import { KibanaServerProvider } from './kibana_server';
-import { RetryProvider } from './retry';
+import { RetryService } from './retry';
 import { RandomnessProvider } from './randomness';
 import { SecurityServiceProvider } from './security';
 import { EsDeleteAllIndicesProvider } from './es_delete_all_indices';
@@ -23,7 +23,7 @@ export const services = {
   es: ElasticsearchProvider,
   esArchiver: EsArchiverProvider,
   kibanaServer: KibanaServerProvider,
-  retry: RetryProvider,
+  retry: RetryService,
   randomness: RandomnessProvider,
   security: SecurityServiceProvider,
   esDeleteAllIndices: EsDeleteAllIndicesProvider,

test/common/services/retry/index.ts

@@ -6,4 +6,4 @@
  * Side Public License, v 1.
  */
 
-export { RetryProvider } from './retry';
+export { RetryService } from './retry';

test/common/services/retry/retry.ts

@@ -6,64 +6,62 @@
  * Side Public License, v 1.
  */
 
-import { FtrProviderContext } from '../../ftr_provider_context';
+import { FtrService } from '../../ftr_provider_context';
 import { retryForSuccess } from './retry_for_success';
 import { retryForTruthy } from './retry_for_truthy';
 
-export function RetryProvider({ getService }: FtrProviderContext) {
-  const config = getService('config');
-  const log = getService('log');
+export class RetryService extends FtrService {
+  private readonly config = this.ctx.getService('config');
+  private readonly log = this.ctx.getService('log');
 
-  return new (class Retry {
-    public async tryForTime<T>(
-      timeout: number,
-      block: () => Promise<T>,
-      onFailureBlock?: () => Promise<T>
-    ) {
-      return await retryForSuccess(log, {
-        timeout,
-        methodName: 'retry.tryForTime',
-        block,
-        onFailureBlock,
-      });
-    }
+  public async tryForTime<T>(
+    timeout: number,
+    block: () => Promise<T>,
+    onFailureBlock?: () => Promise<T>
+  ) {
+    return await retryForSuccess(this.log, {
+      timeout,
+      methodName: 'retry.tryForTime',
+      block,
+      onFailureBlock,
+    });
+  }
 
-    public async try<T>(block: () => Promise<T>, onFailureBlock?: () => Promise<T>) {
-      return await retryForSuccess(log, {
-        timeout: config.get('timeouts.try'),
-        methodName: 'retry.try',
-        block,
-        onFailureBlock,
-      });
-    }
+  public async try<T>(block: () => Promise<T>, onFailureBlock?: () => Promise<T>) {
+    return await retryForSuccess(this.log, {
+      timeout: this.config.get('timeouts.try'),
+      methodName: 'retry.try',
+      block,
+      onFailureBlock,
+    });
+  }
 
-    public async waitForWithTimeout(
-      description: string,
-      timeout: number,
-      block: () => Promise<boolean>,
-      onFailureBlock?: () => Promise<any>
-    ) {
-      await retryForTruthy(log, {
-        timeout,
-        methodName: 'retry.waitForWithTimeout',
-        description,
-        block,
-        onFailureBlock,
-      });
-    }
+  public async waitForWithTimeout(
+    description: string,
+    timeout: number,
+    block: () => Promise<boolean>,
+    onFailureBlock?: () => Promise<any>
+  ) {
+    await retryForTruthy(this.log, {
+      timeout,
+      methodName: 'retry.waitForWithTimeout',
+      description,
+      block,
+      onFailureBlock,
+    });
+  }
 
-    public async waitFor(
-      description: string,
-      block: () => Promise<boolean>,
-      onFailureBlock?: () => Promise<any>
-    ) {
-      await retryForTruthy(log, {
-        timeout: config.get('timeouts.waitFor'),
-        methodName: 'retry.waitFor',
-        description,
-        block,
-        onFailureBlock,
-      });
-    }
-  })();
+  public async waitFor(
+    description: string,
+    block: () => Promise<boolean>,
+    onFailureBlock?: () => Promise<any>
+  ) {
+    await retryForTruthy(this.log, {
+      timeout: this.config.get('timeouts.waitFor'),
+      methodName: 'retry.waitFor',
+      description,
+      block,
+      onFailureBlock,
+    });
+  }
 }

test/functional/ftr_provider_context.d.ts → test/functional/ftr_provider_context.ts

@@ -6,9 +6,10 @@
  * Side Public License, v 1.
  */
 
-import { GenericFtrProviderContext } from '@kbn/test/types/ftr';
+import { GenericFtrProviderContext, GenericFtrService } from '@kbn/test/types/ftr';
 
 import { pageObjects } from './page_objects';
 import { services } from './services';
 
 export type FtrProviderContext = GenericFtrProviderContext<typeof services, typeof pageObjects>;
+export class FtrService extends GenericFtrService<FtrProviderContext> {}