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

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "1.1.1-canary.282.4de1ac1.0",
+  "version": "1.2.0-canary.293.5731c31.0",
   "dependencies": {
     "@babel/eslint-parser": "^7.18.9",
-    "@friggframework/core": "1.1.1-canary.282.4de1ac1.0",
     "eslint": "^8.22.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-json": "^3.1.0",
@@ -37,5 +36,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4de1ac138121295b795e1e9e0bb9e37bea2e8492"
+  "gitHead": "5731c31f2ef22a9b47b43a626cd8ff0e849bd561"
 }

package/test-environment/index.js

@@ -5,9 +5,6 @@ const {
 } = 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 = {

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

@@ -1,8 +1,6 @@
 const { TestMongo } = require('./mongodb');
-const { overrideEnvironment} = require('./override-environment');
 
 module.exports = async function () {
-    overrideEnvironment({ STAGE: 'dev'})
     global.testMongo = new TestMongo();
     await global.testMongo.start();
 };

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

@@ -1,5 +1,3 @@
-const { restoreEnvironment } = require('./override-environment');
 module.exports = async function () {
-    restoreEnvironment();
     await global.testMongo.stop();
 };

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

@@ -1,45 +0,0 @@
-const {flushDebugLog} = require('@friggframework/core');
-
-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,125 +0,0 @@
-const {
-    Auther,
-    ModuleConstants,
-    createObjectId,
-    connectToDatabase,
-    disconnectFromDatabase,
-} = require('@friggframework/core');
-const { createMockApiObject } = require("./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/test-environment/mock-integration.js

@@ -1,81 +0,0 @@
-const { Auther, Credential, Entity, IntegrationModel, mongoose } = require('@friggframework/core');
-
-
-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};