@friggframework/core 0.2.31-v1-alpha-package-update.0 → 1.0.1-v1-alpha-package-update.0

package/test-environment/Authenticator.js

@@ -0,0 +1,73 @@
+// "use strict";
+const http = require('http');
+const url = require('url');
+const open = require('open');
+
+class Authenticator {
+    static searchParamsToDictionary(params) {
+        const entries = params.entries();
+        const result = {};
+        for (const entry of entries) {
+            const [key, value] = entry;
+            result[key] = value;
+        }
+        return result;
+    }
+
+    static async oauth2(authorizeUrl, port = 3000) {
+        return new Promise((resolve, reject) => {
+            const server = http
+                .createServer(async (req, res) => {
+                    try {
+                        const qs = new url.URL(
+                            req.url,
+                            `http://localhost:${port}`
+                        ).searchParams;
+
+                        // gets the last parameter in the slash
+                        const urlPostfix = req.url.split('?')[0];
+
+                        const params =
+                            Authenticator.searchParamsToDictionary(qs);
+
+                        res.end(
+                            `<h1 style="position: absolute;top: 50%;left: 50%;transform: translate(-50%, -50%);">Feel free to close the Brow Brow now</h1>
+                                        <style>@media (prefers-color-scheme: dark) {
+                                            body {
+                                                color: #b0b0b0;
+                                                background-color: #101010;
+                                            }
+                                        </style>`
+                        );
+                        server.close();
+                        resolve({
+                            base: urlPostfix,
+                            data: params,
+                        });
+                    } catch (e) {
+                        reject(e);
+                    }
+                })
+                .listen(port, () => {
+                    // open the browser to the authorize url to start the workflow
+                    open(authorizeUrl).then((childProcess) => {
+                        childProcess.unref();
+                        clearTimeout(timeoutId);
+                    });
+                });
+
+            const timeoutId = setTimeout(() => {
+                if (server.listening) {
+                    try {
+                        server.close();
+                    } finally {
+                        throw new Error(
+                            'Authenticator timed out before authentication completed in the browser.'
+                        );
+                    }
+                }
+            }, 59_000);
+        });
+    }
+}
+module.exports = Authenticator;

package/test-environment/CHANGELOG.md

@@ -0,0 +1,46 @@
+# v1.1.6 (Tue Jan 31 2023)
+
+#### 🐛 Bug Fix
+
+- Updates/api module yotpo [#108](https://github.com/friggframework/frigg/pull/108) ([@seanspeaks](https://github.com/seanspeaks))
+- # mock-api.js Work in Progress ([@seanspeaks](https://github.com/seanspeaks))
+- Bump independent versions \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v1.1.5 (Mon Jan 09 2023)
+
+#### 🐛 Bug Fix
+
+- Merge remote-tracking branch 'origin/main' into gitbook-updates [#48](https://github.com/friggframework/frigg/pull/48) ([@seanspeaks](https://github.com/seanspeaks))
+- Bump independent versions \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+- Merge remote-tracking branch 'origin/main' into simplify-mongoose-models ([@seanspeaks](https://github.com/seanspeaks))
+- Add READMEs for all packages and api-modules [#20](https://github.com/friggframework/frigg/pull/20) ([@seanspeaks](https://github.com/seanspeaks))
+- Add READMEs for all packages and api-modules ([@seanspeaks](https://github.com/seanspeaks))
+
+#### ⚠️ Pushed to `main`
+
+- Merge branch 'main' into gitbook-updates ([@seanspeaks](https://github.com/seanspeaks))
+- Refactored for more conventional naming (at least for packages) ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v1.1.4 (Mon Sep 19 2022)
+
+#### 🐛 Bug Fix
+
+- Test environment setup for all modules [#49](https://github.com/friggframework/frigg/pull/49) ([@seanspeaks](https://github.com/seanspeaks))
+- Test environment setup for all modules ([@seanspeaks](https://github.com/seanspeaks))
+- Merge remote-tracking branch 'origin/main' into gitbook-updates [#48](https://github.com/friggframework/frigg/pull/48) ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))

package/test-environment/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2022 Left Hook Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/test-environment/README.md

@@ -0,0 +1,3 @@
+# test-environment
+
+This package exports the `test-environment` defaults used in [Frigg](https://friggframework.org). You can find its documentation [on Frigg's website](https://docs.friggframework.org/packages/test-environment).

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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,2 @@
+// 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

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

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

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

package/test-environment/jest-preset.js

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,102 @@
+# 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