test(flagd): rework e2e tests to new format

libs/providers/flagd/src/e2e/constants.ts

@@ -4,7 +4,10 @@ export const FLAGD_NAME = 'flagd';
 export const UNSTABLE_CLIENT_NAME = 'unstable';
 export const UNAVAILABLE_CLIENT_NAME = 'unavailable';
 
+export const GHERKIN_FLAGD = getGherkinTestPath('*.feature');
+export const GHERKIN_CONFIG = getGherkinTestPath('config.feature');
 export const GHERKIN_FLAGD_FEATURE = getGherkinTestPath('flagd.feature');
+export const GHERKIN_FLAGD_TESTING = getGherkinTestPath('testing.feature');
 export const GHERKIN_FLAGD_JSON_EVALUATOR_FEATURE = getGherkinTestPath('flagd-json-evaluator.feature');
 export const GHERKIN_FLAGD_RECONNECT_FEATURE = getGherkinTestPath('flagd-reconnect.feature');
 export const GHERKIN_EVALUATION_FEATURE = getGherkinTestPath(

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

@@ -0,0 +1,46 @@
+import { StepsDefinitionCallbackOptions } from 'jest-cucumber/dist/src/feature-definition-creation';
+import { State, Steps } from './state';
+import { CacheOption, getConfig, ResolverType } from '../../lib/configuration';
+import { mapValueToType } from "./utils";
+
+export const configSteps: Steps = (state: State) => {
+  function mapName(name: string): string {
+    switch (name) {
+      case 'resolver':
+        return 'resolverType';
+      default:
+        return name;
+    }
+  }
+
+  return ({ given, when, then }: StepsDefinitionCallbackOptions) => {
+    beforeEach(() => {
+      state.options = {};
+    });
+    given(/^an option "(.*)" of type "(.*)" with value "(.*)"$/, (name: string, type: string, value: string) => {
+      state.options[mapName(name)] = mapValueToType(value, type);
+    });
+    given(/^an environment variable "(.*)" with value "(.*)"$/, (name, value) => {
+      process.env[name] = value;
+    });
+    when('a config was initialized', () => {
+      state.config = getConfig(state.options);
+    });
+
+    then(
+      /^the option "(.*)" of type "(.*)" should have the value "(.*)"$/,
+      (name: string, type: string, value: string) => {
+        const expected = mapValueToType(value, type);
+        const propertyName = mapName(name);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const configElement = state.config[propertyName];
+        expect(configElement).toBe(expected);
+      },
+    );
+
+    then('we should have an error', () => {
+
+    });
+  };
+};

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

@@ -0,0 +1,32 @@
+import { State, Steps } from './state';
+import { mapValueToType } from './utils';
+
+export const contextSteps: Steps =
+  (state: State) =>
+  ({ given, when, then }) => {
+    beforeEach(() => (state.context = undefined));
+    given(
+      /^a context containing a key "(.*)", with type "(.*)" and with value "(.*)"$/,
+      (key: string, type: string, value: string) => {
+        if (state.context == undefined) {
+          state.context = {};
+        }
+        state.context[key] = mapValueToType(value, type);
+      },
+    );
+    given(
+      /^a context containing a nested property with outer key "(.*)" and inner key "(.*)", with value "(.*)"$/,
+      (outer, inner, value) => {
+        if (state.context == undefined) {
+          state.context = {};
+        }
+        state.context[outer] = { [inner]: value };
+      },
+    );
+    given(/^a context containing a targeting key with value "(.*)"$/, (key) => {
+      if (state.context == undefined) {
+        state.context = {};
+      }
+      state.context.targetingKey = key;
+    });
+  };

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

@@ -0,0 +1,58 @@
+import { State, Steps } from './state';
+import { ConfigChangeEvent, ServerProviderEvents } from "@openfeature/core";
+import { waitFor } from './utils';
+
+export const eventSteps: Steps =
+  (state: State) =>
+  ({ given, when, then }) => {
+    beforeEach(() => {
+      state.events = [];
+    });
+
+    function map(eventType: string): ServerProviderEvents {
+      switch (eventType) {
+        case 'error':
+          return ServerProviderEvents.Error;
+        case 'ready':
+          return ServerProviderEvents.Ready;
+        case 'stale':
+          return ServerProviderEvents.Stale;
+        case 'change':
+          return ServerProviderEvents.ConfigurationChanged;
+
+        default:
+          throw new Error('unknown eventtype');
+      }
+    }
+
+    given(/a (.*) event handler/, async (type: string) => {
+      state.client?.addHandler(map(type), (details) => {
+        state.events.push({ type, details });
+      });
+    });
+
+    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 = [];
+    });
+
+    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 = [];
+      console.error('here bin cih');
+    });
+
+    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 = [];
+    });
+  };