@friggframework/core 1.1.1-canary.282.4de1ac1.0 → 1.2.0-canary.293.5731c31.0

package/index.js

@@ -36,7 +36,9 @@ const {
     IntegrationHelper,
     createIntegrationRouter,
     checkRequiredParams,
-    createFriggBackend
+    createFriggBackend,
+    createMockIntegration,
+    createMockApiObject
 } = require('./integrations/index');
 const { TimeoutCatcher } = require('./lambda/index');
 const {
@@ -55,7 +57,9 @@ const {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther
+    Auther,
+    testAutherDefinition,
+    testDefinitionRequiredAuthMethods
 } = require('./module-plugin/index');
 
 // const {Sync } = require('./syncs/model');
@@ -103,6 +107,8 @@ module.exports = {
     checkRequiredParams,
     createIntegrationRouter,
     createFriggBackend,
+    createMockIntegration,
+    createMockApiObject,
     // lambda
     TimeoutCatcher,
     // logs
@@ -120,5 +126,7 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther
+    Auther,
+    testAutherDefinition,
+    testDefinitionRequiredAuthMethods
 }

package/integrations/index.js

@@ -5,6 +5,7 @@ const { IntegrationMapping } = require('./integration-mapping');
 const { IntegrationFactory, IntegrationHelper } = require('./integration-factory');
 const { createIntegrationRouter, checkRequiredParams } = require('./integration-router');
 const { createFriggBackend } = require('./create-frigg-backend');
+const { createMockApiObject, createMockIntegration } = require('./mock-integration');
 
 module.exports = {
     IntegrationBase,
@@ -15,5 +16,7 @@ module.exports = {
     IntegrationHelper,
     createIntegrationRouter,
     checkRequiredParams,
-    createFriggBackend
+    createFriggBackend,
+    createMockIntegration,
+    createMockApiObject
 };

package/integrations/mock-integration.js

@@ -0,0 +1,83 @@
+const { Auther, Credential, Entity } = require('../module-plugin')
+const { IntegrationModel } = require('./integration-model');
+const { createObjectId } = require('../database');
+
+async function createMockIntegration(IntegrationClassDef, userId = null, config = {},) {
+    const integration = new IntegrationClassDef();
+    userId = userId || createObjectId();
+    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){
+        if (Object.entries(IntegrationClassDef.modules).length <= i) break
+        const [moduleName, ModuleDef] = Object.entries(IntegrationClassDef.modules)[i];
+        const module = await 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};

package/module-plugin/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/module-plugin/auther-definition-tester.js

@@ -0,0 +1,121 @@
+const { Auther } = require('./auther');
+const { ModuleConstants } = require('./ModuleConstants');
+const { createObjectId,connectToDatabase, disconnectFromDatabase } = require('../database');
+const { createMockApiObject } = require("../integrations/mock-integration");
+
+
+function testAutherDefinition(definition, mocks) {
+    const getModule = async (params) => {
+        const module = await Auther.getInstance({
+            definition,
+            userId: createObjectId(),
+            ...params,
+        });
+        if (mocks.tokenResponse) {
+            mocks.getTokenFrom = async function(code) {
+                await this.setTokens(mocks.tokenResponse);
+                return mocks.tokenResponse
+            }
+            mocks.getTokenFromCode = mocks.getTokenFromCode || mocks.getTokenFrom
+            mocks.getTokenFromCodeBasicAuthHeader = mocks.getTokenFromCodeBasicAuthHeader || mocks.getTokenFrom
+            mocks.getTokenFromClientCredentials = mocks.getTokenFromClientCredentials || mocks.getTokenFrom
+            mocks.getTokenFromUsernamePassword = mocks.getTokenFromUsernamePassword || mocks.getTokenFrom
+        }
+        if (mocks.refreshResponse) {
+            mocks.refreshAccessToken = async function(code) {
+                await this.setTokens(mocks.refreshResponse);
+                return mocks.refreshResponse
+            }
+        }
+        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, authCallbackParams;
+        if (definition.API.requesterType === ModuleConstants.authType.oauth2) {
+            authCallbackParams = mocks.authorizeResponse || mocks.authorizeParams;
+            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 authCallbackParams against the auth requirements
+            authCallbackParams = 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 authCallbackParams against the auth requirements
+            authCallbackParams = 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(authCallbackParams);
+                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(authCallbackParams);
+                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/module-plugin/index.js

@@ -9,6 +9,8 @@ const { Requester } = require('./requester/requester');
 const { ModuleConstants } = require('./ModuleConstants');
 const { ModuleFactory } = require('./module-factory');
 const { Auther } = require('./auther');
+const { testAutherDefinition } = require('./auther-definition-tester');
+const { testDefinitionRequiredAuthMethods } = require('./auther-definition-method-tester');
 
 module.exports = {
     Credential,
@@ -21,5 +23,7 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther
+    Auther,
+    testAutherDefinition,
+    testDefinitionRequiredAuthMethods
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "1.1.1-canary.282.4de1ac1.0",
+  "version": "1.2.0-canary.293.5731c31.0",
   "dependencies": {
     "@hapi/boom": "^10.0.1",
     "aws-sdk": "^2.1200.0",
@@ -15,7 +15,7 @@
     "node-fetch": "^2.6.7"
   },
   "devDependencies": {
-    "@friggframework/devtools": "1.1.1-canary.282.4de1ac1.0",
+    "@friggframework/devtools": "1.2.0-canary.293.5731c31.0",
     "@types/lodash": "^4.14.191",
     "@typescript-eslint/eslint-plugin": "^5.55.0",
     "chai": "^4.3.6",
@@ -47,5 +47,5 @@
   },
   "homepage": "https://github.com/friggframework/frigg#readme",
   "description": "",
-  "gitHead": "4de1ac138121295b795e1e9e0bb9e37bea2e8492"
+  "gitHead": "5731c31f2ef22a9b47b43a626cd8ff0e849bd561"
 }

package/bump0.txt

@@ -1 +0,0 @@
-2