fixup: upgarding test-harnes

Signed-off-by: Simon Schrottner <[email protected]>

Author: aepfli

libs/providers/flagd-web/schemas

@@ -38,5 +38,9 @@ export const configSteps: Steps = (state: State) => {
         expect(configElement).toBe(expected);
       },
     );
+
+    then('we should have an error', () => {
+
+    });
   };
 };

libs/providers/flagd/schemas

@@ -34,16 +34,25 @@ export const eventSteps: Steps =
     then(/^the (.*) event handler should have been executed$/, async (type: string) => {
       await waitFor(() => expect(state.events.find((value) => value.type == type)).toBeDefined(), { timeout: 20000 });
       expect(state.events.find((value) => value.type == type)).toBeDefined();
-      state.events = state.events.filter((a) => a.type !== type);
+      state.events = [];
     });
 
     then(/^the (.*) event handler should have been executed within (\d+)ms$/, async (type: string, ms: number) => {
       await waitFor(() => expect(state.events.find((value) => value.type == type)).toBeDefined(), { timeout: ms });
       const actual = state.events.find((value) => value.type == type);
       expect(actual).toBeDefined();
-      state.events = state.events.filter((a) => a.type !== type);
+      state.events = [];
       console.error('here bin cih');
     });
 
-    when(/^a (.*) event was fired$/, () => {});
+    when(/^a (.*) event was fired$/, async (type: string) => {
+      await waitFor(() => expect(state.events.find((value) => value.type == type)), { timeout: 2000 });
+      expect(state.events.find((value) => value.type == type)).toBeDefined();
+      state.events = [];
+    });
+
+    then('the flag should be part of the event payload', async () => {
+      await waitFor(() => expect(state.events.find((value) => value.type == 'change')), { timeout: 2000 });
+      state.events = [];
+    });
   };

libs/providers/flagd/spec

@@ -64,15 +64,4 @@ export const flagSteps: Steps =
     then(/^the variant should be "(.*)"$/, (arg0) => {
       expect(state.details?.variant).toBe(arg0);
     });
-    when('the flag was modified', async () => {
-      await waitFor(
-        () =>
-          expect(
-            state.events.find(
-              (value) => value.type == 'change' && (value.details?.flagsChanged as string[]).includes(state.flag!.name),
-            ),
-          ).toBeDefined(),
-        { timeout: 5000 },
-      );
-    });
   };

libs/providers/flagd/src/e2e/step-definitions/configSteps.ts

@@ -2,64 +2,59 @@ import { OpenFeature } from '@openfeature/server-sdk';
 import { FlagdContainer } from '../tests/flagdContainer';
 import { State, Steps } from './state';
 import { FlagdProvider } from '../../lib/flagd-provider';
-
-type Containers = Record<string, FlagdContainer> & { default: FlagdContainer };
+import { waitFor } from "./utils";
 
 export const providerSteps: Steps =
   (state: State) =>
   ({ given, when, then }) => {
-    const containers: Containers = {
-      default: FlagdContainer.build(),
-    };
+    const container: FlagdContainer = FlagdContainer.build();
     beforeAll(async () => {
       console.log('Setting flagd provider...');
 
-      const promises = [];
-
-      for (const container of Object.values(containers)) {
-        promises.push(container.start());
-      }
-
-      return Promise.all(promises);
+      return container.start();
     }, 50000);
 
     afterAll(async () => {
       await OpenFeature.close();
-      for (const container of Object.values(containers)) {
-        await container.stop();
-      }
+      await container.stop();
     });
 
     beforeEach(async () => {
-      const promises = [];
-
-      for (const container of Object.values(containers)) {
-        promises.push(container.start());
+      if (container.isStarted()) {
+        return container.start();
       }
-
-      return Promise.all(promises);
+      return Promise.resolve();
     }, 50000);
-
-    function getContainer(providerType: string): FlagdContainer {
-      if (Object.hasOwn(containers, providerType)) {
-        return containers[providerType];
+    afterEach(async () => {
+      if (state.client) {
+        await fetch('http://' + container.getLaunchpadUrl() + '/stop');
+        await new Promise((r) => setTimeout(r, 100));
       }
-      return containers.default;
-    }
+      return Promise.resolve();
+    }, 50000);
 
     given(/a (.*) flagd provider/, async (providerType: string) => {
-      const container = getContainer(providerType);
       const flagdOptions: Record<string, unknown> = {
         resolverType: state.resolverType,
+        deadlineMs: 2000,
       };
+      let type = 'default';
       switch (providerType) {
         default:
           flagdOptions['port'] = container.getPort(state.resolverType);
           break;
         case 'unavailable':
           flagdOptions['port'] = 9999;
           break;
+        case 'ssl':
+          // todo: configure properly
+          flagdOptions['port'] = container.getPort(state.resolverType);
+          type = 'ssl';
+          break;
       }
+
+      await fetch('http://' + container.getLaunchpadUrl() + '/start?config=' + type);
+      await new Promise((r) => setTimeout(r, 50));
       if (providerType == 'unavailable') {
         OpenFeature.setProvider(providerType, new FlagdProvider(flagdOptions));
       } else {
@@ -71,8 +66,13 @@ export const providerSteps: Steps =
     });
 
     when(/^the connection is lost for (\d+)s$/, async (time) => {
-      const container = getContainer(state.providerType!);
-      await container.stop();
-      setTimeout(() => container.start(), time * 1000);
+      console.log('stopping flagd');
+      await fetch('http://' + container.getLaunchpadUrl() + '/restart?seconds=' + time);
+      await new Promise((r) => setTimeout(r, 50));
+    });
+
+    when('the flag was modified', async () => {
+      await fetch('http://' + container.getLaunchpadUrl() + '/change');
+      await new Promise((r) => setTimeout(r, 50));
     });
   };

libs/providers/flagd/src/e2e/step-definitions/eventSteps.ts

@@ -8,12 +8,13 @@ export class FlagdContainer extends GenericContainer {
   private started: StartedTestContainer | undefined;
   private stopped: StoppedTestContainer | undefined;
 
-  public static build(feature: string | undefined = undefined) {
-    return new FlagdContainer(this.generateImageName(feature)).withExposedPorts(8013, 8014, 8015, 8016);
+  public static build() {
+    return new FlagdContainer(this.generateImageName());
   }
 
   private constructor(image: string) {
     super(image);
+    this.withExposedPorts(8080, 8013, 8014, 8015, 8016);
   }
 
   isStarted(): boolean {
@@ -42,15 +43,15 @@ export class FlagdContainer extends GenericContainer {
     return containerPromise;
   }
 
-  private static generateImageName(feature: string | undefined): string {
+  getLaunchpadUrl() {
+    return this.started?.getHost() + ':' + this.started?.getMappedPort(8080);
+  }
+
+  private static generateImageName(): string {
     const image = this.imageBase;
     const file = path.join(__dirname, './../../../../../shared/flagd-core/test-harness/', 'version.txt');
     const version = fs.readFileSync(file, 'utf8').trim();
-    let featurePart = '';
-    if (feature) {
-      featurePart = `-${feature}`;
-    }
-    return `${image}${featurePart}:v${version}`;
+    return `${image}:v${version}`;
   }
 
   getPort(resolverType: ResolverType) {

libs/providers/flagd/src/e2e/step-definitions/flagSteps.ts

@@ -10,7 +10,7 @@ import { contextSteps } from '../step-definitions/contextSteps';
 const steps = [providerSteps, configSteps, eventSteps, flagSteps, contextSteps];
 
 jest.setTimeout(50000);
-describe('rpc', () => {
+describe('in-process', () => {
   const state: State = {
     resolverType: 'in-process',
     options: {},

libs/providers/flagd/src/e2e/step-definitions/providerSteps.ts

@@ -20,7 +20,8 @@ describe('rpc', () => {
   };
   autoBindSteps(
     loadFeatures(GHERKIN_FLAGD, {
-      tagFilter: '@rpc and not @targetURI and not @customCert and not @events and not @sync  and not @offline and not @grace',
+      tagFilter:
+        '@rpc and not @targetURI and not @customCert and not @events and not @stream and not @grace',
       scenarioNameTemplate: (vars) => {
         return `${vars.scenarioTitle} (${vars.scenarioTags.join(',')} ${vars.featureTags.join(',')})`;
       },