@friggframework/core 1.0.3-v1-alpha-package-update.5 → 1.0.3-v1-alpha-package-update.6

package/test-environment/auther-definition-method-tester.js

@@ -1,45 +0,0 @@
-const {flushDebugLog} = require('../logs');
-
-async function testDefinitionRequiredAuthMethods(api, definition, authCallbackParams, tokenResponse, userId) {
-
-    // const response = await definition.getToken(api, authCallbackParams);
-    // expect(api.setTokens).toHaveBeenCalled();
-    // if (tokenResponse) {
-    //     expect(response).toMatchObject(tokenResponse);
-    // }
-
-    const entityDetails = await definition.requiredAuthMethods.getEntityDetails(api, authCallbackParams, tokenResponse, userId);
-    expect(entityDetails).toHaveProperty('identifiers');
-    expect(Object.values(entityDetails.identifiers).length).toBeGreaterThan(0);
-    for (const key of Object.keys(entityDetails.identifiers)){
-        expect(key).toBeDefined();
-        expect(entityDetails.identifiers[key]).toBeDefined();
-    }
-
-
-    const credentialDetails = await definition.requiredAuthMethods.getCredentialDetails(api);
-    expect(credentialDetails).toHaveProperty('identifiers');
-    expect(Object.values(entityDetails.identifiers).length).toBeGreaterThan(0);
-    for (const key of Object.keys(entityDetails.identifiers)){
-        expect(key).toBeDefined();
-        expect(entityDetails.identifiers[key]).toBeDefined();
-    }
-
-    const successResponse = await definition.requiredAuthMethods.testAuthRequest(api);
-    expect(successResponse).toBeTruthy();
-    const savedKeys = {};
-    for (const key of definition.requiredAuthMethods.apiPropertiesToPersist.credential){
-        savedKeys[key] = api[key];
-        delete api[key];
-    }
-    let validAuth = false;
-    try {
-        if (await definition.requiredAuthMethods.testAuthRequest(api)) validAuth = true;
-    } catch (e) {
-        flushDebugLog(e);
-    }
-    expect(validAuth).not.toBeTruthy();
-    Object.assign(api, savedKeys);
-}
-
-module.exports = { testDefinitionRequiredAuthMethods }

package/test-environment/auther-definition-tester.js

@@ -1,104 +0,0 @@
-const {Auther, ModuleConstants} = require('../module-plugin');
-const { createObjectId, connectToDatabase, disconnectFromDatabase } = require('../database/mongo');
-const { createMockApiObject } = require("./mock-integration");
-
-
-function testAutherDefinition(definition, mocks) {
-    const getModule = async (params) => {
-        const module = await Auther.getInstance({
-            definition,
-            userId: createObjectId(),
-            ...params,
-        });
-        module.api = createMockApiObject(jest, module.api, mocks);
-        return module
-    }
-
-
-    describe(`${definition.moduleName} Module Tests`, () => {
-        let module, authUrl;
-        beforeAll(async () => {
-            await connectToDatabase();
-            module = await getModule();
-        });
-
-        afterAll(async () => {
-            await disconnectFromDatabase();
-        });
-
-        let requirements, authorizeParams;
-        if (definition.API.requesterType === ModuleConstants.authType.oauth2) {
-            authorizeParams = mocks.authorizeResponse;
-            describe('getAuthorizationRequirements() test', () => {
-                it('should return auth requirements', async () => {
-                    requirements = module.getAuthorizationRequirements();
-                    expect(requirements).toBeDefined();
-                    expect(requirements.type).toEqual(ModuleConstants.authType.oauth2);
-                    expect(requirements.url).toBeDefined();
-                    authUrl = requirements.url;
-                });
-            });
-        } else if (definition.API.requesterType === ModuleConstants.authType.basic) {
-            // could also confirm authorizeParams against the auth requirements
-            authorizeParams = mocks.authorizeParams
-            describe('getAuthorizationRequirements() test', () => {
-                it('should return auth requirements', async () => {
-                    requirements = module.getAuthorizationRequirements();
-                    expect(requirements).toBeDefined();
-                    expect(requirements.type).toEqual(ModuleConstants.authType.basic);
-                });
-            });
-        } else if (definition.API.requesterType === ModuleConstants.authType.apiKey) {
-            // could also confirm authorizeParams against the auth requirements
-            authorizeParams = mocks.authorizeParams
-            describe('getAuthorizationRequirements() test', () => {
-                it('should return auth requirements', async () => {
-                    requirements = module.getAuthorizationRequirements();
-                    expect(requirements).toBeDefined();
-                    expect(requirements.type).toEqual(ModuleConstants.authType.apiKey);
-                });
-            });
-        }
-
-        describe('Authorization requests', () => {
-            let firstRes;
-            it('processAuthorizationCallback()', async () => {
-                firstRes = await module.processAuthorizationCallback(authorizeParams);
-                expect(firstRes).toBeDefined();
-                expect(firstRes.entity_id).toBeDefined();
-                expect(firstRes.credential_id).toBeDefined();
-            });
-            it('retrieves existing entity on subsequent calls', async () => {
-                const res = await module.processAuthorizationCallback(authorizeParams);
-                expect(res).toEqual(firstRes);
-            });
-        });
-
-        describe('Test credential retrieval and module instantiation', () => {
-            it('retrieve by entity id', async () => {
-                const newModule = await getModule({
-                    userId: module.userId,
-                    entityId: module.entity.id
-                });
-                expect(newModule).toBeDefined();
-                expect(newModule.entity).toBeDefined();
-                expect(newModule.credential).toBeDefined();
-                expect(await newModule.testAuth()).toBeTruthy();
-
-            });
-
-            it('retrieve by credential id', async () => {
-                const newModule = await getModule({
-                    userId: module.userId,
-                    credentialId: module.credential.id
-                });
-                expect(newModule).toBeDefined();
-                expect(newModule.credential).toBeDefined();
-                expect(await newModule.testAuth()).toBeTruthy();
-            });
-        });
-    });
-}
-
-module.exports = { testAutherDefinition }
-

package/test-environment/index.js

@@ -1,24 +0,0 @@
-const { TestMongo } = require('./mongodb');
-const {
-    overrideEnvironment,
-    restoreEnvironment,
-} = require('./override-environment');
-const globalTeardown = require('./jest-global-teardown');
-const globalSetup = require('./jest-global-setup');
-const {testDefinitionRequiredAuthMethods} = require('./auther-definition-method-tester');
-const {createMockIntegration, createMockApiObject} = require('./mock-integration');
-const { testAutherDefinition } = require('./auther-definition-tester');
-const Authenticator = require('./Authenticator')
-
-module.exports = {
-    TestMongo,
-    overrideEnvironment,
-    restoreEnvironment,
-    globalTeardown,
-    globalSetup,
-    createMockIntegration,
-    createMockApiObject,
-    testDefinitionRequiredAuthMethods,
-    testAutherDefinition,
-    Authenticator
-};

package/test-environment/integration-validator.js

@@ -1,2 +0,0 @@
-// TODO input for poll worker (etc), run as if in staging, set up env just right, enable debugging with debugger,
-// TODO write up or help automate (?) knowing where to update tests/mocks when a problem is found

package/test-environment/jest-global-setup.js

@@ -1,6 +0,0 @@
-const { TestMongo } = require('./mongodb');
-
-module.exports = async function () {
-    global.testMongo = new TestMongo();
-    await global.testMongo.start();
-};

package/test-environment/jest-global-teardown.js

@@ -1,3 +0,0 @@
-module.exports = async function () {
-    await global.testMongo.stop();
-};

package/test-environment/jest-preset.js

@@ -1,14 +0,0 @@
-module.exports = {
-    collectCoverage: true,
-    testTimeout: 20_000,
-    runner: 'groups',
-    coverageReporters: ['text'],
-    coverageThreshold: {
-        global: {
-            statements: 80,
-            branches: 80,
-            functions: 80,
-            lines: 80,
-        },
-    },
-};

package/test-environment/mock-api-readme.md

@@ -1,102 +0,0 @@
-# Mocked Requests Set Up for Your API Module
-
-## Add Tooling to the Test File
-
-Example code:
-
-```js
-const Api = require('./Api');
-const { mockApi } = require('../../../../test/utils/mockApi');
-
-const MockedApi = mockApi(Api, {
-    authenticationMode: 'browser',
-});
-
-describe('DemoNock API', async () => {
-    before(async function () {
-        await MockedApi.initialize({ test: this.test });
-    });
-
-    after(async function () {
-        await MockedApi.clean({ test: this.test });
-    });
-
-    it('tests a nice thing', async () => {
-        const api = await MockedApi.mock();
-        const users = await api.getUsers();
-        expect(users).to.have.length(2);
-    });
-});
-```
-
-Api - the LH API class that is being tested/mocked
-
-mockApi - tool to record/playback requests and automate login to API
-
-MockedApi - Api class with wrapper around it to record/playback requests and automate login to API. `authenticationMode` sets how to handle authentication when recording requests. Browser means it will require a manual step in the browser (uses Authenticator). Client credentials mode gets a token automcaitcally with machine-to-machine token. Manual means the developer will handle authentication manually, like setting an API key. By default mockApi will use the class name of the mocked API to name the output file. This can be overidden by passing in `displayName`.
-test/recorded-requests - the directory where recorded API requests are saved
-
-before - make sure to use the `async function` form here, so we can access mocha's `this` object. The call to `initialize` sets up the tooling for recording/playback
-
-after - same here need to use the `async function` form and pass in `this.test` to `clean`. This stops recording/playback and removes all hooks and other tooling from Node's HTTP code.
-
-test - instead of using `new Api` in your tests, use `await MockedApi.mock`. Any parameters you would normally pass into `new Api` will be passed through with the call to `mock`. The instance of the Api class that is returned will already be authenticated (unless using manual mode).
-
-## Creating new API tests
-
-When running your tests while creating them, use `npm --record-apis=demonock test`.
-
-This tells the tooling to record the requests made while running the tests for the DemoNockApi class.
-
-## Finalizing API tests
-
-When satisified with your tests, run `npm test` without adding the `--record-apis` flag to make sure the recorded requests worked. The tests should pass without needing you to perform a login step in the browser.
-
-## Tests that fail...
-
-Sometimes a "finished" test that was previously working starts to fail. Or, a test passes when it should fail (false negative). There are a few reasons this might happen.
-
-### Test fails after code updates
-
-If you made updates to the code, this may cause a test to fail. In this case the developer doesn't need to update mocks. To make the test pass, the updated code should be fixed, or the test should be updated to reflect the new data shape.
-
-One way to test for this scenario is running `npm test` in the main branch, seeing that all tests pass, and then confirming tests fail in your feature branch. This would show that the test is almost certainly failing due to a change in your branch.
-
-### Test should fail but passes
-
-If a test is passing, but in the "real world" the code is failing, the API response may have changed. Re-record mocks by running tests with `--record-apis=nockdemo`. Hopefully, one or more tests will now fail. These tests and related code should be updated to work with the new API response data shape.
-
-When creating the PR for this update, flag that the mocks were re-recorded so the updated mocks will be sure to be reviewed by another team member as part of code review.
-
-### Mocks in error state
-
-If the recorded files get messed up when updating (sometimes unavoidable under certain error conditions) just `git restore test/recorded-requests` or delete the file(s) in that directory and re-record.
-
-## Miscellaneous Notes
-
-More than one API can be set to record mode at a time: `npm --record-apis=activecampaign,hubspot test`
-
-You can use .only when --record-apis is passed, but only for the root level test suite. Otherwise an error will be thrown to prevent partial recording of the mocks. .skip is fine to use to skip tests that should not be recorded.
-
-CAN UPDATE RECORDED REQUESTS:
-
-```js
-describe('Nock Demo API', () => {
-    it('does x');
-    it.skip('does y');
-});
-```
-
-CANNOT UPDATE RECORDED REQUESTS:
-
-```js
-describe('Nock Demo API', () => {
-    it('does x');
-    it('does y');
-});
-```
-
-## Caveats
-
--   Client credential mode may only work with Crossbeam currently
--   Puppet mode (browser automation) for login is not yet implemented

package/test-environment/mock-api.js

@@ -1,284 +0,0 @@
-const nock = require('nock');
-const Authenticator = require('./Authenticator');
-const { join: joinPath } = require('path');
-const { parse: parseUrl } = require('url');
-const { mkdir, readFile, rename, rm, writeFile } = require('fs/promises');
-
-// TODO store in DB?
-const tokenDirectory = joinPath(process.cwd(), 'test', '.token-cache');
-const fixtureDirectory = joinPath(process.cwd(), 'test', 'recorded-requests');
-nock.back.fixtures = fixtureDirectory;
-
-// Try to rename but fail silently if the file does not exist.
-const tryRename = async (a, b) => {
-    try {
-        await rename(a, b);
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            return;
-        }
-        throw error;
-    }
-};
-const getJestGlobalState = () => {
-    const globalSymbols = Object.getOwnPropertySymbols(global);
-    let jestState;
-    globalSymbols.forEach((sym) => {
-        if (sym.toString() === 'Symbol(JEST_STATE_SYMBOL)') {
-            jestState = global[sym];
-        }
-    });
-
-    return jestState;
-};
-
-const checkForOnlies = () => {
-    let didFindOnly = false;
-    const findOnly = (child) => {
-        if (child.mode === 'only') {
-            didFindOnly = true;
-        }
-        if (child.children) {
-            child.children.forEach((nestedChild) => {
-                findOnly(nestedChild);
-            });
-        }
-    };
-    const jestState = getJestGlobalState();
-    const rootDescribe = jestState.rootDescribeBlock;
-
-    for (const child of rootDescribe.children) {
-        findOnly(child);
-    }
-
-    return didFindOnly;
-};
-
-const mockApi = (Api, classOptionByName = {}) => {
-    const {
-        authenticationMode,
-        displayName = Api.name,
-        filteringScope,
-    } = classOptionByName;
-    // The tag is the lower case display name, with any trailing 'Api' in the string removed.
-    const tag = displayName.replace(/Api$/i, '').toLowerCase();
-    const tokenFile = `${displayName}.json`;
-    const tokenFileFullPath = joinPath(tokenDirectory, tokenFile);
-
-    return class MockedApi extends Api {
-        static name = `Mocked${displayName}`;
-        static tokenResponse = null;
-        static excludedRecordingPaths = [];
-        static #context = {};
-
-        static async initialize() {
-            this.#context = {};
-
-            const didFindOnlies = checkForOnlies();
-
-            if (didFindOnlies) {
-                throw new Error(
-                    'Cancelled recording API mocks because some tests were marked `.only`.  Please remove any `.only`s from any `describe` blocks deeper than the root level, and all `it` blocks.'
-                );
-            }
-
-            this.#context.originalNockMode = nock.back.currentMode;
-
-            const { npm_config_record_apis: apisToRecordText = '' } =
-                process.env;
-            const apisToRecord = apisToRecordText
-                .split(',')
-                .map((name) => name.trim().toLowerCase());
-
-            if (apisToRecord.includes(tag)) {
-                this.#context.nockMode = 'update';
-            } else {
-                this.#context.nockMode = 'lockdown';
-            }
-
-            nock.back.setMode(this.#context.nockMode);
-
-            const fixtureFile = `${displayName}.json`;
-
-            if (this.#context.nockMode === 'update') {
-                const fixtureFileFullPath = joinPath(
-                    fixtureDirectory,
-                    fixtureFile
-                );
-                const fixtureFileBackupFullPath = joinPath(
-                    fixtureDirectory,
-                    `.${displayName}.json.backup`
-                );
-
-                await tryRename(fixtureFileFullPath, fixtureFileBackupFullPath);
-
-                this.#context.restoreFixture = async () =>
-                    await tryRename(
-                        fixtureFileBackupFullPath,
-                        fixtureFileFullPath
-                    );
-                this.#context.deleteFixtureBackup = async () =>
-                    await rm(fixtureFileBackupFullPath, { force: true });
-            }
-
-            const nockBack = await nock.back(fixtureFile, {
-                before: (scope) => {
-                    if (filteringScope) {
-                        scope.options.filteringScope = filteringScope;
-                    }
-                },
-                // Filter out token URLs
-                afterRecord: (recordings) =>
-                    recordings.filter(
-                        ({ path }) =>
-                            !this.excludedRecordingPaths.includes(path)
-                    ),
-                recorder: {
-                    output_objects: true,
-                    enable_reqheaders_recording: false,
-                },
-            });
-
-            this.#context.assertAllRequests = () =>
-                nockBack.context.assertScopesFinished();
-            this.#context.done = () => nockBack.nockDone();
-        }
-
-        static async clean() {
-            const {
-                assertAllRequests,
-                done,
-                nockMode,
-                originalNockMode,
-                restoreFixture,
-                deleteFixtureBackup,
-            } = this.#context;
-
-            const { didAllTestsPass } = global.mockApiResults;
-
-            if (done) {
-                done();
-            }
-            if (originalNockMode) {
-                nock.back.setMode(originalNockMode);
-            }
-            if (assertAllRequests && nockMode !== 'update') {
-                assertAllRequests();
-            }
-
-            nock.cleanAll();
-            nock.restore();
-
-            if (nockMode === 'update') {
-                if (!didAllTestsPass) {
-                    try {
-                        await restoreFixture();
-                    } finally {
-                        throw new Error(
-                            'Cancelled recording API mocks because some tests failed.  Please fix the failing tests and try to record again.'
-                        );
-                    }
-                } else {
-                    await deleteFixtureBackup();
-                }
-            }
-        }
-
-        static async saveCachedTokenResponse() {
-            if (!this.tokenResponse) {
-                return;
-            }
-
-            await mkdir(tokenDirectory, { recursive: true });
-            await writeFile(
-                tokenFileFullPath,
-                JSON.stringify(this.tokenResponse)
-            );
-        }
-
-        static async loadCachedTokenResponse() {
-            try {
-                const tokenResponseText = await readFile(tokenFileFullPath);
-                this.tokenResponse = JSON.parse(tokenResponseText);
-            } catch (error) {
-                if (error.code === 'ENOENT') {
-                    this.tokenResponse = null;
-                    return;
-                }
-                throw error;
-            }
-        }
-
-        static async mock(...constructorParameters) {
-            const api = new this(...constructorParameters);
-
-            if (nock.back.currentMode !== 'lockdown') {
-                await this.loadCachedTokenResponse();
-            }
-
-            // TODO read authentication mode from module package
-            if (authenticationMode === 'client_credentials') {
-                // TODO make generic (tied to crossbeam api)
-                api.grantType = 'client_credentials';
-                api.refreshAccessToken = api.getTokenFromClientCredentials;
-
-                if (process.env.CROSSBEAM_API_BASE_URL)
-                    api.baseUrl = process.env.CROSSBEAM_API_BASE_URL;
-                if (process.env.CROSSBEAM_API_AUTH_URL)
-                    api.tokenUri = `${process.env.CROSSBEAM_API_AUTH_URL}/oauth/token`;
-                if (process.env.CROSSBEAM_API_AUDIENCE)
-                    api.audience = process.env.CROSSBEAM_API_AUDIENCE;
-
-                api.client_secret = process.env.CROSSBEAM_TEST_CLIENT_SECRET;
-                api.client_id = process.env.CROSSBEAM_TEST_CLIENT_ID;
-                api.refreshAccessToken = api.getTokenFromClientCredentials;
-
-                this.tokenResponse = await api.getTokenFromClientCredentials();
-            } else if (authenticationMode === 'puppet') {
-                throw new Error('Not yet implemented');
-            } else if (authenticationMode === 'browser') {
-                if (nock.back.currentMode !== 'lockdown') {
-                    const { path: tokenPath } = parseUrl(api.tokenUri);
-                    this.excludedRecordingPaths.push(tokenPath);
-
-                    if (this.tokenResponse) {
-                        await api.setTokens(this.tokenResponse);
-
-                        try {
-                            await api.testAuth();
-                        } catch {
-                            this.tokenResponse = null;
-                            nock.cleanAll();
-                            await rm(tokenFileFullPath, {
-                                force: true,
-                            });
-                        }
-                    }
-
-                    if (!this.tokenResponse) {
-                        const url = api.authorizationUri;
-                        const { data } = await Authenticator.oauth2(url);
-                        const { code } = data;
-                        this.tokenResponse = await api.getTokenFromCode(code);
-                        await api.setTokens(this.tokenResponse);
-                        nock.cleanAll();
-                    }
-                }
-            } else if (authenticationMode === 'manual') {
-                // NOOP.  This space intentionally left blank.  No action should be performed in this mode, and the developer writing the test will handle authentication externally to this module.
-            } else {
-                throw new Error(
-                    'Unrecognized authentication mode for mocked API.'
-                );
-            }
-
-            if (nock.back.currentMode !== 'lockdown') {
-                await this.saveCachedTokenResponse();
-            }
-
-            return api;
-        }
-    };
-};
-
-module.exports = { mockApi };

package/test-environment/mock-integration.js

@@ -1,82 +0,0 @@
-const { Auther, Credential, Entity } = require('../module-plugin');
-const { IntegrationModel } = require('../integrations');
-const { mongoose } = require('../database/mongoose');
-
-async function createMockIntegration(IntegrationClassDef, userId = null, config = {},) {
-    const integration = new IntegrationClassDef();
-    userId = userId || new mongoose.Types.ObjectId();
-    integration.delegateTypes.push(...IntegrationClassDef.Config.events)
-
-    const insertOptions = {
-        new: true,
-        upsert: true,
-        setDefaultsOnInsert: true,
-    }
-    const user = {user: userId}
-
-    const credential = await Credential.findOneAndUpdate(
-        user,
-        { $set: user },
-        insertOptions
-    );
-    const entity1 = await Entity.findOneAndUpdate(
-        user,
-        {
-            $set: {
-                credential: credential.id,
-                user: userId,
-                name: 'Test user',
-                externalId: '1234567890123456',
-            },
-        },
-        insertOptions
-    );
-    const entity2 = await Entity.findOneAndUpdate(
-        user,
-        {
-            $set: {
-                credential: credential.id,
-                user: userId,
-            },
-        },
-        insertOptions
-    );
-
-    const entities = [entity1, entity2]
-    integration.record = await IntegrationModel.create({
-        entities,
-        user: userId,
-        config: {type: IntegrationClassDef.Config.name, ...config}
-    })
-
-    integration.id = integration.record._id
-
-    for (const i in entities){
-        const [moduleName, ModuleDef] = Object.entries(IntegrationClassDef.modules)[i];
-        const module = Auther.getInstance({definition: ModuleDef, userId: userId})
-        module.entity = entities[i];
-        integration[moduleName] = module;
-    }
-
-    return integration
-}
-
-function createMockApiObject(jest, api = {}, mockMethodMap) {
-    // take in an api class and object with keys that are method names
-    // and values which are the mock response (or implementation)
-    const clone = (data) => JSON.parse(JSON.stringify(data));
-
-    for (const [methodName, mockDataOrImplementation] of Object.entries(mockMethodMap)) {
-        if (mockDataOrImplementation instanceof Function) {
-            api[methodName] = jest.fn(mockDataOrImplementation);
-        }
-        else if (api[methodName]?.constructor?.name === "AsyncFunction") {
-            api[methodName] = jest.fn().mockResolvedValue(clone(mockDataOrImplementation));
-        } else {
-            api[methodName] = jest.fn().mockReturnValue(clone(mockDataOrImplementation));
-        }
-    }
-    return api;
-}
-
-module.exports = {createMockIntegration, createMockApiObject};