@hubspot/ui-extensions-dev-server 1.1.5 → 1.1.7

package/dist/lib/__tests__/app-functions/services/services_v20232.spec.js

@@ -0,0 +1,302 @@
+import { describe, it, expect, vi, afterEach, beforeEach, } from 'vitest';
+import httpMocks from 'node-mocks-http';
+import { EventEmitter } from 'node:events';
+import { AppFunctionExecutionService } from "../../../app-functions/services/index.js";
+import { TEST_CONFIG_V20232 as TEST_CONFIG } from "../fixtures/constants.js";
+import * as executor from "../../../app-functions/executor.js";
+import { scopesOnAccessToken as __scopesOnAccessToken } from '@hubspot/local-dev-lib/personalAccessKey';
+import { USER_TOKEN_READ, USER_TOKEN_WRITE, } from "../../../app-functions/services/constants.js";
+import { PrivateAppUserTokenManager } from "../../../app-functions/services/PrivateAppUserTokenManager.js";
+vi.mock('../../../app-functions/services/PrivateAppUserTokenManager.ts');
+vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+const scopesOnAccessToken = __scopesOnAccessToken;
+const callAppFunction = async (functionName, parameters) => {
+    const request = httpMocks.createRequest({
+        method: 'POST',
+        url: '/action/function/100',
+        params: {
+            id: 100,
+        },
+        body: {
+            serverlessFunction: functionName,
+            parameters,
+        },
+    });
+    const response = httpMocks.createResponse({
+        req: request,
+        eventEmitter: EventEmitter,
+    });
+    const handler = AppFunctionExecutionService(TEST_CONFIG);
+    // Hold response until the handler finishes writing to it. THis must
+    // be set up before calling the handler or it may miss the `end` event.
+    const responsePromised = new Promise((resolve) => {
+        response.on('end', () => {
+            resolve(response);
+        });
+    });
+    await handler(request, response);
+    return await responsePromised;
+};
+/**
+ * Validate the service for executing app functions
+ */
+describe('app function dev server', () => {
+    const initialEnvJson = JSON.stringify(process.env);
+    beforeEach(() => {
+        scopesOnAccessToken.mockResolvedValue([USER_TOKEN_READ, USER_TOKEN_WRITE]);
+    });
+    afterEach(() => {
+        // restore process.env
+        process.env = JSON.parse(initialEnvJson);
+        vi.resetAllMocks();
+        vi.restoreAllMocks();
+    });
+    it('returns "200 OK" response if function execution succeeded', async () => {
+        const getTokenspy = vi.spyOn(PrivateAppUserTokenManager.prototype, 'getPrivateAppUserToken');
+        const response = await callAppFunction('returns-text');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(200);
+        expect(response._getJSONData()).toEqual({
+            logId: 'n/a',
+            response: 'result',
+        });
+        // Validate log output
+        expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "returns-text" execution succeeded'));
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        // get the token
+        expect(getTokenspy).toHaveBeenCalledTimes(1);
+    });
+    it('returns "400 Bad Request" response if function execution failed', async () => {
+        const response = await callAppFunction('throws-error');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toEqual('Error: Oops');
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "throws-error" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function encountered an uncaught error.', expect.anything());
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    describe('handles asynchronous functions (promise chaining)', () => {
+        it('returns "200 OK" response if function returns a promise that resolves', async () => {
+            const response = await callAppFunction('returns-promise-resolved');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(200);
+            expect(response._getJSONData()).toEqual({
+                logId: 'n/a',
+                response: { result: 'simulated' },
+            });
+            // Validate log output
+            expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "returns-promise-resolved" execution succeeded'));
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+        it('returns "400 Bad Request" response if function returns a promise that rejects', async () => {
+            const response = await callAppFunction('returns-promise-rejected');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(400);
+            const body = response._getJSONData();
+            expect(body).toHaveProperty('status', 'error');
+            expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+            const exception = body.errors?.[0]?.context?.exception?.[0];
+            expect(exception).toEqual('Error: fail');
+            // Validate log output
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "returns-promise-rejected" execution failed'));
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function encountered an uncaught error.', expect.anything());
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+    });
+    describe('handles asynchronous functions (async/await)', () => {
+        it('returns "200 OK" response if an async function execution succeeded', async () => {
+            const response = await callAppFunction('async-succeeds');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(200);
+            expect(response._getJSONData()).toEqual({
+                logId: 'n/a',
+                response: { result: 'simulated' },
+            });
+            // Validate log output
+            expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "async-succeeds" execution succeeded'));
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+        it('returns "400 Bad Request" response if an async function execution failed', async () => {
+            const response = await callAppFunction('async-fails');
+            // Validate response status and body
+            expect(response.statusCode).toEqual(400);
+            const body = response._getJSONData();
+            expect(body).toHaveProperty('status', 'error');
+            expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+            const exception = body.errors?.[0]?.context?.exception?.[0];
+            expect(exception).toEqual('Error: fail');
+            // Validate log output
+            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "async-fails" execution failed'));
+            expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function encountered an uncaught error.', expect.anything());
+            // Validate process.env is put back to what it was before the call
+            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+        });
+    });
+    it('returns "200 OK" response if function returns implicitly (only 2023.2)', async () => {
+        const response = await callAppFunction('returns-implicitly');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(200);
+        expect(response._getJSONData()).toEqual({
+            logId: 'n/a',
+            response: null,
+        });
+        // Validate log output
+        expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "returns-implicitly" execution succeeded'));
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "400 Bad Request" response if function not found', async () => {
+        const response = await callAppFunction('does-not-exist');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toMatch(/doesn't exist in this project/);
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "does-not-exist" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith(expect.stringContaining('Could not find file'));
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "400 Bad Request" response if function does not export main', async () => {
+        // TEST_CONFIG.functionTimeoutMs = 250
+        const response = await callAppFunction('does-not-export-main');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toMatch(/customerPayload\.main is not a function/);
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "does-not-export-main" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith(expect.stringContaining('Could not find "main" export in'));
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "400 Bad Request" response if function returns invalid json', async () => {
+        // TEST_CONFIG.functionTimeoutMs = 250
+        const response = await callAppFunction('returns-function');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toMatch(/Wrong arguments/);
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "returns-function" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function reponse is not valid JSON.');
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "200 OK" response if function returns before timeout', async () => {
+        // TEST_CONFIG.functionTimeoutMs = 250
+        const response = await callAppFunction('times-out', { delayMs: 200 });
+        const variance = 10; // milliseconds
+        // Validate response status and body
+        expect(response.statusCode).toEqual(200);
+        const body = response._getJSONData();
+        expect(body).toEqual({
+            logId: 'n/a',
+            response: { status: 'success', elapsedMs: expect.anything() },
+        });
+        expect(body.response.elapsedMs).toBeGreaterThanOrEqual(200 - variance);
+        expect(body.response.elapsedMs).toBeLessThanOrEqual(200 + variance);
+        // Validate log output
+        expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "times-out" execution succeeded'));
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "400 Bad Request" response if function returns after timeout', async () => {
+        // TEST_CONFIG.functionTimeoutMs = 250
+        const response = await callAppFunction('times-out', { delayMs: 300 });
+        // Validate response status and body
+        expect(response.statusCode).toEqual(400);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
+        const exception = body.errors?.[0]?.context?.exception?.[0];
+        expect(exception).toMatch(/Task timed out after/);
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "times-out" execution failed'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function failed to callback within 0.25 second.');
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('returns "500 Internal Server Error" response if something went wrong', async () => {
+        const error = new Error('Something went terribly wrong!');
+        vi.spyOn(executor, 'executeFunction').mockImplementation(() => {
+            throw error;
+        });
+        // Act
+        const response = await callAppFunction('returns-text');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(500);
+        const body = response._getJSONData();
+        expect(body).toHaveProperty('status', 'error');
+        expect(body).not.toHaveProperty('category', 'INTERNAL_ERROR');
+        expect(body).toHaveProperty('message', 'internal error');
+        // Validate log output
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "returns-text" execution failed due to server internal error'));
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith(error);
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+    it('logs to console from inside the function', async () => {
+        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const debug = vi.spyOn(console, 'debug').mockImplementation(() => { });
+        const info = vi.spyOn(console, 'info').mockImplementation(() => { });
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const error = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // Act
+        const response = await callAppFunction('logs');
+        // Validate response status and body
+        expect(response.statusCode).toEqual(200);
+        expect(response._getJSONData()).toEqual({
+            logId: 'n/a',
+            response: { status: 'success' },
+        });
+        // Validate function logging
+        expect(log).toHaveBeenCalledTimes(1);
+        expect(log).toHaveBeenCalledWith('log line');
+        expect(debug).toHaveBeenCalledTimes(1);
+        expect(debug).toHaveBeenCalledWith('debug line');
+        expect(info).toHaveBeenCalledTimes(2);
+        expect(info).toHaveBeenNthCalledWith(1, 'info line');
+        expect(info).toHaveBeenNthCalledWith(2, 'print data:', [1, 2]);
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(warn).toHaveBeenCalledWith('warn line');
+        expect(error).toHaveBeenCalledTimes(1);
+        expect(error).toHaveBeenCalledWith('error line');
+        // Validate service logging, which is separate from function logging
+        expect(TEST_CONFIG.logger.debug).toHaveBeenCalledTimes(1);
+        expect(TEST_CONFIG.logger.debug).toHaveBeenNthCalledWith(1, expect.stringContaining('App function "logs" execution succeeded'));
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+        // Validate process.env is put back to what it was before the call
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    });
+});

package/dist/lib/__tests__/app-functions/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/app-functions/setup.js

@@ -0,0 +1,7 @@
+// Overwrite console.debug to only log when in DEBUG mode
+console.debug = (...args) => {
+    if (process.env.DEBUG) {
+        console.log(...args);
+    }
+};
+export {};

package/dist/lib/__tests__/app-functions/signing.spec.d.ts

@@ -0,0 +1 @@
+export {};