backend-test-utils: remove services from startTestBackend

Signed-off-by: Vincenzo Scamporlino <vincenzos@spotify.com>

packages/backend-test-utils/api-report.md

@@ -21,7 +21,6 @@ import { RootConfigService } from '@backstage/backend-plugin-api';
 import { RootLifecycleService } from '@backstage/backend-plugin-api';
 import { SchedulerService } from '@backstage/backend-plugin-api';
 import { ServiceFactory } from '@backstage/backend-plugin-api';
-import { ServiceRef } from '@backstage/backend-plugin-api';
 import { TokenManagerService } from '@backstage/backend-plugin-api';
 import { UrlReaderService } from '@backstage/backend-plugin-api';
 
@@ -127,11 +126,8 @@ export function setupRequestMockHandlers(worker: {
 }): void;
 
 // @public (undocumented)
-export function startTestBackend<
-  TServices extends any[],
-  TExtensionPoints extends any[],
->(
-  options: TestBackendOptions<TServices, TExtensionPoints>,
+export function startTestBackend<TExtensionPoints extends any[]>(
+  options: TestBackendOptions<TExtensionPoints>,
 ): Promise<TestBackend>;
 
 // @public (undocumented)
@@ -140,10 +136,7 @@ export interface TestBackend extends Backend {
 }
 
 // @public (undocumented)
-export interface TestBackendOptions<
-  TServices extends any[],
-  TExtensionPoints extends any[],
-> {
+export interface TestBackendOptions<TExtensionPoints extends any[]> {
   // (undocumented)
   extensionPoints?: readonly [
     ...{
@@ -154,16 +147,7 @@ export interface TestBackendOptions<
     },
   ];
   // (undocumented)
-  features?: BackendFeature[];
-  // (undocumented)
-  services?: readonly [
-    ...{
-      [index in keyof TServices]:
-        | ServiceFactory<TServices[index]>
-        | (() => ServiceFactory<TServices[index]>)
-        | [ServiceRef<TServices[index]>, Partial<TServices[index]>];
-    },
-  ];
+  features?: Array<BackendFeature | (() => BackendFeature)>;
 }
 
 // @public

packages/backend-test-utils/src/next/wiring/TestBackend.test.ts

@@ -31,7 +31,6 @@ import { startTestBackend } from './TestBackend';
 let globalTestBackendHasBeenStopped = false;
 beforeAll(async () => {
   await startTestBackend({
-    services: [],
     features: [
       createBackendModule({
         moduleId: 'test.module',
@@ -46,7 +45,7 @@ beforeAll(async () => {
             },
           });
         },
-      })(),
+      }),
     ],
   });
 });
@@ -68,17 +67,37 @@ describe('TestBackend', () => {
     const extensionPoint5 = createExtensionPoint<Obj>({ id: 'b5' });
     await expect(
       startTestBackend({
-        services: [
+        features: [
           // @ts-expect-error
           [extensionPoint1, { a: 'a' }],
-          [serviceRef, { a: 'a' }],
-          [serviceRef, { a: 'a', b: 'b' }],
-          // @ts-expect-error
-          [serviceRef, { c: 'c' }],
-          // @ts-expect-error
-          [serviceRef, { a: 'a', c: 'c' }],
-          // @ts-expect-error
-          [serviceRef, { a: 'a', b: 'b', c: 'c' }],
+          createServiceFactory(() => ({
+            service: serviceRef,
+            deps: {},
+            // @ts-expect-error
+            factory: async () => ({ a: 'a' }),
+          })),
+          createServiceFactory(() => ({
+            service: serviceRef,
+            deps: {},
+            factory: async () => ({ a: 'a', b: 'b' }),
+          })),
+          createServiceFactory(() => ({
+            service: serviceRef,
+            deps: {},
+            // @ts-expect-error
+            factory: async () => ({ c: 'c' }),
+          })),
+          createServiceFactory(() => ({
+            service: serviceRef,
+            deps: {},
+            // @ts-expect-error
+            factory: async () => ({ a: 'a', c: 'c' }),
+          })),
+          createServiceFactory(() => ({
+            service: serviceRef,
+            deps: {},
+            factory: async () => ({ a: 'a', b: 'b', c: 'c' }),
+          })),
         ],
         extensionPoints: [
           // @ts-expect-error
@@ -124,8 +143,7 @@ describe('TestBackend', () => {
     });
 
     await startTestBackend({
-      services: [sf],
-      features: [testModule()],
+      features: [testModule(), sf()],
     });
 
     expect(testFn).toHaveBeenCalledWith('winning');
@@ -150,7 +168,6 @@ describe('TestBackend', () => {
     });
 
     const backend = await startTestBackend({
-      services: [],
       features: [testModule()],
     });
 
@@ -192,7 +209,6 @@ describe('TestBackend', () => {
     });
 
     await startTestBackend({
-      services: [],
       features: [testPlugin()],
     });
   });
@@ -244,7 +260,7 @@ describe('TestBackend', () => {
                 },
               });
             },
-          })(),
+          }),
           createBackendModule({
             pluginId: 'testB',
             moduleId: 'test',
@@ -256,7 +272,7 @@ describe('TestBackend', () => {
                 },
               });
             },
-          })(),
+          }),
         ],
       }),
     ).resolves.not.toBeUndefined();
@@ -277,7 +293,7 @@ describe('TestBackend', () => {
                 async init() {},
               });
             },
-          })(),
+          }),
           createBackendModule({
             pluginId: 'testB',
             moduleId: 'test',
@@ -287,7 +303,7 @@ describe('TestBackend', () => {
                 async init() {},
               });
             },
-          })(),
+          }),
         ],
       }),
     ).rejects.toThrow(

packages/backend-test-utils/src/next/wiring/TestBackend.ts

@@ -24,8 +24,6 @@ import {
 } from '@backstage/backend-app-api';
 import { HostDiscovery } from '@backstage/backend-common';
 import {
-  ServiceFactory,
-  ServiceRef,
   createServiceFactory,
   BackendFeature,
   ExtensionPoint,
@@ -40,18 +38,7 @@ import express from 'express';
 import { InternalBackendFeature } from '@backstage/backend-plugin-api/src/wiring/types';
 
 /** @public */
-export interface TestBackendOptions<
-  TServices extends any[],
-  TExtensionPoints extends any[],
-> {
-  services?: readonly [
-    ...{
-      [index in keyof TServices]:
-        | ServiceFactory<TServices[index]>
-        | (() => ServiceFactory<TServices[index]>)
-        | [ServiceRef<TServices[index]>, Partial<TServices[index]>];
-    },
-  ];
+export interface TestBackendOptions<TExtensionPoints extends any[]> {
   extensionPoints?: readonly [
     ...{
       [index in keyof TExtensionPoints]: [
@@ -60,7 +47,7 @@ export interface TestBackendOptions<
       ];
     },
   ];
-  features?: BackendFeature[];
+  features?: Array<BackendFeature | (() => BackendFeature)>;
 }
 
 /** @public */
@@ -95,17 +82,22 @@ const defaultServiceFactories = [
  * @returns
  */
 function createExtensionPointTestModules(
-  features: BackendFeature[],
+  features: Array<BackendFeature | (() => BackendFeature)>,
   extensionPointTuples?: readonly [
     ref: ExtensionPoint<unknown>,
     impl: unknown,
   ][],
-): BackendFeature[] {
+): Array<() => BackendFeature> {
   if (!extensionPointTuples) {
     return [];
   }
 
-  const registrations = features.flatMap(feature => {
+  const registrations = features.flatMap(featureOrFunction => {
+    const feature =
+      typeof featureOrFunction === 'function'
+        ? featureOrFunction()
+        : featureOrFunction;
+
     if (feature.$$type !== '@backstage/BackendFeature') {
       throw new Error(
         `Failed to add feature, invalid type '${feature.$$type}'`,
@@ -170,7 +162,7 @@ function createExtensionPointTestModules(
 
           reg.registerInit({ deps: {}, async init() {} });
         },
-      })(),
+      }),
     );
   }
 
@@ -180,18 +172,10 @@ function createExtensionPointTestModules(
 const backendInstancesToCleanUp = new Array<Backend>();
 
 /** @public */
-export async function startTestBackend<
-  TServices extends any[],
-  TExtensionPoints extends any[],
->(
-  options: TestBackendOptions<TServices, TExtensionPoints>,
+export async function startTestBackend<TExtensionPoints extends any[]>(
+  options: TestBackendOptions<TExtensionPoints>,
 ): Promise<TestBackend> {
-  const {
-    services = [],
-    extensionPoints,
-    features = [],
-    ...otherOptions
-  } = options;
+  const { extensionPoints, features = [], ...otherOptions } = options;
 
   let server: ExtendedHttpServer;
 
@@ -247,40 +231,10 @@ export async function startTestBackend<
     },
   });
 
-  const factories = services.map(serviceDef => {
-    if (Array.isArray(serviceDef)) {
-      // if type is ExtensionPoint?
-      // do something differently?
-      const [ref, impl] = serviceDef;
-      if (ref.scope === 'plugin') {
-        return createServiceFactory({
-          service: ref as ServiceRef<unknown, 'plugin'>,
-          deps: {},
-          factory: async () => impl,
-        })();
-      }
-      return createServiceFactory({
-        service: ref as ServiceRef<unknown, 'root'>,
-        deps: {},
-        factory: async () => impl,
-      })();
-    }
-    if (typeof serviceDef === 'function') {
-      return serviceDef();
-    }
-    return serviceDef as ServiceFactory;
-  });
-
-  for (const factory of defaultServiceFactories) {
-    if (!factories.some(f => f.service.id === factory.service.id)) {
-      factories.push(factory);
-    }
-  }
-
   const backend = createSpecializedBackend({
     ...otherOptions,
     defaultServiceFactories: [
-      ...factories,
+      ...defaultServiceFactories,
       rootHttpRouterFactory,
       discoveryFactory,
     ],