Add unit tests for backend functions

sdkennedy2 · sdkennedy2 · commit 788c479ace95 · 2026-03-16T14:12:40.000-04:00
diff --git a/packages/plugins/apps/src/backend/discovery.test.ts b/packages/plugins/apps/src/backend/discovery.test.ts
@@ -0,0 +1,159 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+import { discoverBackendFunctions } from '@dd/apps-plugin/backend/discovery';
+import { getMockLogger, mockLogFn } from '@dd/tests/_jest/helpers/mocks';
+import fs from 'fs';
+import path from 'path';
+
+const log = getMockLogger();
+const backendDir = '/project/backend';
+
+const fileStat = { isDirectory: () => false, isFile: () => true };
+const dirStat = { isDirectory: () => true, isFile: () => false };
+
+describe('Backend Functions - discoverBackendFunctions', () => {
+    let readdirSpy: jest.SpyInstance;
+    let statSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+        readdirSpy = jest.spyOn(fs, 'readdirSync');
+        statSpy = jest.spyOn(fs, 'statSync');
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('file discovery', () => {
+        const cases = [
+            {
+                description: 'discover a single .ts file',
+                entries: ['handler.ts'],
+                stats: { [path.join(backendDir, 'handler.ts')]: fileStat },
+                expected: [{ name: 'handler', entryPath: path.join(backendDir, 'handler.ts') }],
+            },
+            {
+                description: 'discover a single .js file',
+                entries: ['handler.js'],
+                stats: { [path.join(backendDir, 'handler.js')]: fileStat },
+                expected: [{ name: 'handler', entryPath: path.join(backendDir, 'handler.js') }],
+            },
+            {
+                description: 'discover a directory with index.ts',
+                entries: ['myFunc'],
+                stats: {
+                    [path.join(backendDir, 'myFunc')]: dirStat,
+                    [path.join(backendDir, 'myFunc', 'index.ts')]: fileStat,
+                },
+                expected: [
+                    {
+                        name: 'myFunc',
+                        entryPath: path.join(backendDir, 'myFunc', 'index.ts'),
+                    },
+                ],
+            },
+            {
+                description: 'discover multiple functions (mix of files and directories)',
+                entries: ['handler.ts', 'myFunc'],
+                stats: {
+                    [path.join(backendDir, 'handler.ts')]: fileStat,
+                    [path.join(backendDir, 'myFunc')]: dirStat,
+                    [path.join(backendDir, 'myFunc', 'index.ts')]: fileStat,
+                },
+                expected: [
+                    { name: 'handler', entryPath: path.join(backendDir, 'handler.ts') },
+                    {
+                        name: 'myFunc',
+                        entryPath: path.join(backendDir, 'myFunc', 'index.ts'),
+                    },
+                ],
+            },
+            {
+                description: 'skip non-matching extensions',
+                entries: ['config.json', 'styles.css', 'handler.ts'],
+                stats: {
+                    [path.join(backendDir, 'config.json')]: fileStat,
+                    [path.join(backendDir, 'styles.css')]: fileStat,
+                    [path.join(backendDir, 'handler.ts')]: fileStat,
+                },
+                expected: [{ name: 'handler', entryPath: path.join(backendDir, 'handler.ts') }],
+            },
+            {
+                description: 'skip directory with no valid index file',
+                entries: ['emptyDir'],
+                stats: {
+                    [path.join(backendDir, 'emptyDir')]: dirStat,
+                },
+                expected: [],
+            },
+            {
+                description: 'return empty array for empty directory',
+                entries: [],
+                stats: {},
+                expected: [],
+            },
+        ];
+
+        test.each(cases)('Should $description', ({ entries, stats, expected }) => {
+            readdirSpy.mockReturnValue(entries);
+            statSpy.mockImplementation((p: string) => {
+                const stat = stats[p];
+                if (!stat) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                return stat;
+            });
+
+            const result = discoverBackendFunctions(backendDir, log);
+            expect(result).toEqual(expected);
+        });
+    });
+
+    describe('error handling', () => {
+        test('Should return empty array and log debug when directory does not exist', () => {
+            readdirSpy.mockImplementation(() => {
+                throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+            });
+
+            const result = discoverBackendFunctions('/nonexistent', log);
+            expect(result).toEqual([]);
+            expect(mockLogFn).toHaveBeenCalledWith(
+                expect.stringContaining('No backend directory found'),
+                'debug',
+            );
+        });
+
+        test('Should rethrow non-ENOENT errors', () => {
+            readdirSpy.mockImplementation(() => {
+                throw Object.assign(new Error('EACCES'), { code: 'EACCES' });
+            });
+
+            expect(() => discoverBackendFunctions(backendDir, log)).toThrow('EACCES');
+        });
+    });
+
+    describe('extension priority', () => {
+        test('Should prefer .ts over .js for directory index', () => {
+            readdirSpy.mockReturnValue(['myFunc']);
+            statSpy.mockImplementation((p) => {
+                if (p === path.join(backendDir, 'myFunc')) {
+                    return dirStat;
+                }
+                if (p === path.join(backendDir, 'myFunc', 'index.ts')) {
+                    return fileStat;
+                }
+                throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+            });
+
+            const result = discoverBackendFunctions(backendDir, log);
+            expect(result).toEqual([
+                {
+                    name: 'myFunc',
+                    entryPath: path.join(backendDir, 'myFunc', 'index.ts'),
+                },
+            ]);
+        });
+    });
+});
diff --git a/packages/plugins/apps/src/backend/index.test.ts b/packages/plugins/apps/src/backend/index.test.ts
@@ -0,0 +1,86 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+import { BACKEND_VIRTUAL_PREFIX, getBackendPlugin } from '@dd/apps-plugin/backend/index';
+import { getMockLogger, mockLogFn } from '@dd/tests/_jest/helpers/mocks';
+
+const log = getMockLogger();
+
+const functions = [
+    { name: 'myHandler', entryPath: '/src/backend/myHandler.ts' },
+    { name: 'otherFunc', entryPath: '/src/backend/otherFunc/index.ts' },
+];
+
+describe('Backend Functions - getBackendPlugin', () => {
+    beforeEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('plugin shape', () => {
+        test('Should return a plugin with correct name and enforce', () => {
+            const plugin = getBackendPlugin(functions, new Map(), log);
+            expect(plugin.name).toBe('datadog-apps-backend-plugin');
+            expect(plugin.enforce).toBe('pre');
+        });
+
+        test('Should have rollup and vite properties', () => {
+            const plugin = getBackendPlugin(functions, new Map(), log);
+            expect(plugin.rollup).toBeDefined();
+            expect(plugin.vite).toBeDefined();
+        });
+    });
+
+    describe('resolveId', () => {
+        const cases = [
+            {
+                description: 'resolve virtual backend module ID',
+                input: `${BACKEND_VIRTUAL_PREFIX}myHandler`,
+                expected: `${BACKEND_VIRTUAL_PREFIX}myHandler`,
+            },
+            {
+                description: 'return null for non-backend module',
+                input: 'some-other-module',
+                expected: null,
+            },
+            {
+                description: 'return null for empty string',
+                input: '',
+                expected: null,
+            },
+        ];
+
+        test.each(cases)('Should $description', ({ input, expected }) => {
+            const plugin = getBackendPlugin(functions, new Map(), log);
+            const resolveId = plugin.resolveId as Function;
+            expect(resolveId(input, undefined, {})).toBe(expected);
+        });
+    });
+
+    describe('load', () => {
+        test('Should return virtual entry content for known function', () => {
+            const plugin = getBackendPlugin(functions, new Map(), log);
+            const load = plugin.load as Function;
+            const content = load(`${BACKEND_VIRTUAL_PREFIX}myHandler`);
+            expect(content).toContain('import { myHandler }');
+            expect(content).toContain('export async function main($)');
+        });
+
+        test('Should return null and log error for unknown function', () => {
+            const plugin = getBackendPlugin(functions, new Map(), log);
+            const load = plugin.load as Function;
+            const content = load(`${BACKEND_VIRTUAL_PREFIX}unknownFunc`);
+            expect(content).toBeNull();
+            expect(mockLogFn).toHaveBeenCalledWith(
+                expect.stringContaining('Backend function "unknownFunc" not found'),
+                'error',
+            );
+        });
+
+        test('Should return null for non-prefixed ID', () => {
+            const plugin = getBackendPlugin(functions, new Map(), log);
+            const load = plugin.load as Function;
+            expect(load('regular-module')).toBeNull();
+        });
+    });
+});
diff --git a/packages/plugins/apps/src/backend/shared.test.ts b/packages/plugins/apps/src/backend/shared.test.ts
@@ -0,0 +1,30 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+import {
+    ACTION_CATALOG_IMPORT,
+    SET_EXECUTE_ACTION_SNIPPET,
+    isActionCatalogInstalled,
+} from '@dd/apps-plugin/backend/shared';
+
+describe('Backend Functions - shared', () => {
+    describe('isActionCatalogInstalled', () => {
+        test('Should return false when action-catalog is not installed', () => {
+            // In the test environment, @datadog/action-catalog is not installed.
+            expect(isActionCatalogInstalled()).toBe(false);
+        });
+    });
+
+    describe('constants', () => {
+        test('ACTION_CATALOG_IMPORT should contain action-catalog import', () => {
+            expect(ACTION_CATALOG_IMPORT).toContain('@datadog/action-catalog/action-execution');
+            expect(ACTION_CATALOG_IMPORT).toContain('setExecuteActionImplementation');
+        });
+
+        test('SET_EXECUTE_ACTION_SNIPPET should contain the bridge implementation', () => {
+            expect(SET_EXECUTE_ACTION_SNIPPET).toContain('setExecuteActionImplementation');
+            expect(SET_EXECUTE_ACTION_SNIPPET).toContain('$.Actions');
+        });
+    });
+});
diff --git a/packages/plugins/apps/src/backend/virtual-entry.test.ts b/packages/plugins/apps/src/backend/virtual-entry.test.ts
@@ -0,0 +1,78 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+import * as shared from '@dd/apps-plugin/backend/shared';
+import { generateVirtualEntryContent } from '@dd/apps-plugin/backend/virtual-entry';
+
+describe('Backend Functions - generateVirtualEntryContent', () => {
+    beforeEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('without action-catalog', () => {
+        beforeEach(() => {
+            jest.spyOn(shared, 'isActionCatalogInstalled').mockReturnValue(false);
+        });
+
+        test('Should import the function by name from the entry path', () => {
+            const result = generateVirtualEntryContent('myHandler', '/src/backend/handler.ts');
+            expect(result).toContain('import { myHandler } from "/src/backend/handler.ts"');
+        });
+
+        test('Should export an async main($) function', () => {
+            const result = generateVirtualEntryContent('myHandler', '/src/handler.ts');
+            expect(result).toContain('export async function main($)');
+        });
+
+        test('Should set globalThis.$ = $', () => {
+            const result = generateVirtualEntryContent('myHandler', '/src/handler.ts');
+            expect(result).toContain('globalThis.$ = $');
+        });
+
+        test('Should include backendFunctionArgs template expression', () => {
+            const result = generateVirtualEntryContent('myHandler', '/src/handler.ts');
+            // eslint-disable-next-line no-template-curly-in-string
+            expect(result).toContain("JSON.parse('${backendFunctionArgs}'");
+        });
+
+        test('Should call the function with spread args', () => {
+            const result = generateVirtualEntryContent('myHandler', '/src/handler.ts');
+            expect(result).toContain('await myHandler(...args)');
+        });
+
+        test('Should include the setExecuteActionImplementation bridge snippet', () => {
+            const result = generateVirtualEntryContent('myHandler', '/src/handler.ts');
+            expect(result).toContain('typeof setExecuteActionImplementation');
+        });
+
+        test('Should not include action-catalog import', () => {
+            const result = generateVirtualEntryContent('myHandler', '/src/handler.ts');
+            expect(result).not.toContain('@datadog/action-catalog');
+        });
+    });
+
+    describe('with action-catalog', () => {
+        beforeEach(() => {
+            jest.spyOn(shared, 'isActionCatalogInstalled').mockReturnValue(true);
+        });
+
+        test('Should include action-catalog import', () => {
+            const result = generateVirtualEntryContent('myHandler', '/src/handler.ts');
+            expect(result).toContain(
+                "import { setExecuteActionImplementation } from '@datadog/action-catalog/action-execution'",
+            );
+        });
+
+        test('Should still include the bridge snippet', () => {
+            const result = generateVirtualEntryContent('myHandler', '/src/handler.ts');
+            expect(result).toContain('typeof setExecuteActionImplementation');
+        });
+    });
+
+    test('Should escape entry paths with special characters', () => {
+        jest.spyOn(shared, 'isActionCatalogInstalled').mockReturnValue(false);
+        const result = generateVirtualEntryContent('handler', '/path/with "quotes"/handler.ts');
+        expect(result).toContain('from "/path/with \\"quotes\\"/handler.ts"');
+    });
+});
