flagsmith-nodejs 1.1.1 → 2.0.0-beta.1

package/sdk/utils.ts

@@ -0,0 +1,45 @@
+import fetch, { Response } from 'node-fetch';
+// @ts-ignore
+if (typeof fetch.default !== 'undefined') fetch = fetch.default;
+
+export function generateIdentitiesData(identifier: string, traits?: { [key: string]: any }) {
+    const traitsGenerated = Object.values(traits || {}).map(trait => ({
+        trait_key: trait[0],
+        trait_value: trait[1]
+    }));
+    return {
+        identifier: identifier,
+        traits: traitsGenerated
+    };
+}
+
+export const delay = (ms: number) =>
+    new Promise(resolve => setTimeout(() => resolve(undefined), ms));
+
+export const retryFetch = (
+    url: string,
+    fetchOptions = {},
+    retries = 3,
+    retryDelay = 1000,
+    timeout: number
+): Promise<Response> => {
+    return new Promise((resolve, reject) => {
+        // check for timeout
+        if (timeout) setTimeout(() => reject('error: timeout'), timeout);
+
+        const wrapper = (n: number) => {
+            fetch(url, fetchOptions)
+                .then(res => resolve(res))
+                .catch(async err => {
+                    if (n > 0) {
+                        await delay(retryDelay);
+                        wrapper(--n);
+                    } else {
+                        reject(err);
+                    }
+                });
+        };
+
+        wrapper(retries);
+    });
+};

package/tests/engine/e2e/engine.test.ts

@@ -0,0 +1,51 @@
+import { readFileSync } from 'fs';
+import { getIdentityFeatureStates } from '../../../flagsmith-engine';
+import { EnvironmentModel } from '../../../flagsmith-engine/environments/models';
+import { buildEnvironmentModel } from '../../../flagsmith-engine/environments/util';
+import { IdentityModel } from '../../../flagsmith-engine/identities/models';
+import { buildIdentityModel } from '../../../flagsmith-engine/identities/util';
+
+function extractTestCases(
+    filePath: string
+): {
+    environment: EnvironmentModel;
+    identity: IdentityModel;
+    response: any;
+}[] {
+    const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+    const environmentModel = buildEnvironmentModel(data['environment']);
+    const test_data = data['identities_and_responses'].map((test_case: any) => {
+        const identity = buildIdentityModel(test_case['identity']);
+
+        return {
+            environment: environmentModel,
+            identity: identity,
+            response: test_case['response']
+        };
+    });
+    return test_data;
+}
+
+test('Test Engine', () => {
+    const testCases = extractTestCases(
+        __dirname + '/../engine-tests/engine-test-data/data/environment_n9fbf9h3v4fFgH3U3ngWhb.json'
+    );
+    for (const testCase of testCases) {
+        const engine_response = getIdentityFeatureStates(testCase.environment, testCase.identity);
+        const sortedEngineFlags = engine_response.sort((a, b) =>
+            a.feature.name > b.feature.name ? 1 : -1
+        );
+        const sortedAPIFlags = testCase.response['flags'].sort((a: any, b: any) =>
+            a.feature.name > b.feature.name ? 1 : -1
+        );
+
+        expect(sortedEngineFlags.length).toBe(sortedAPIFlags.length);
+
+        for (let i = 0; i < sortedEngineFlags.length; i++) {
+            expect(sortedEngineFlags[i].getValue(testCase.identity.djangoID)).toBe(
+                sortedAPIFlags[i]['feature_state_value']
+            );
+            expect(sortedEngineFlags[i].enabled).toBe(sortedAPIFlags[i]['enabled']);
+        }
+    }
+});