Plug internal stores to async-queue plugin & test

Author: yoannmoinet

packages/core/src/types.ts

@@ -212,6 +212,8 @@ export type GetPluginsArg = {
     bundler: any;
     context: GlobalContext;
     options: Options;
+    data: GlobalData;
+    stores: GlobalStores;
 };
 export type GetPlugins = (arg: GetPluginsArg) => PluginOptions[];
 export type GetCustomPlugins = (arg: GetPluginsArg) => CustomPluginOptions[];

packages/factory/src/helpers/logger.test.ts

@@ -2,19 +2,48 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-import type { GlobalData, GlobalStores, Logger } from '@dd/core/types';
+import { datadogEsbuildPlugin } from '@datadog/esbuild-plugin';
+import { datadogRollupPlugin } from '@datadog/rollup-plugin';
+import { datadogRspackPlugin } from '@datadog/rspack-plugin';
+import { datadogVitePlugin } from '@datadog/vite-plugin';
+import { rm } from '@dd/core/helpers/fs';
+import { getSendLog } from '@dd/core/helpers/log';
+import { getUniqueId } from '@dd/core/helpers/strings';
+import type {
+    BundlerFullName,
+    GetPluginsArg,
+    GlobalData,
+    GlobalStores,
+    Logger,
+    Options,
+} from '@dd/core/types';
 import { getLoggerFactory, NAME_SEP } from '@dd/factory/helpers/logger';
-import { getMockData, getMockStores } from '@dd/tests/_jest/helpers/mocks';
+import { getAsyncQueuePlugins } from '@dd/internal-async-queue-plugin';
+import { prepareWorkingDir } from '@dd/tests/_jest/helpers/env';
+import { getWebpackPlugin } from '@dd/tests/_jest/helpers/getWebpackPlugin';
+import {
+    defaultEntry,
+    defaultPluginOptions,
+    getMockData,
+    getMockStores,
+} from '@dd/tests/_jest/helpers/mocks';
+import { BUNDLERS } from '@dd/tests/_jest/helpers/runBundlers';
+import { allBundlers } from '@dd/tools/bundlers';
+// import { allPlugins } from '@dd/tools/plugins';
+import path from 'path';
 import stripAnsi from 'strip-ansi';
+import webpack4 from 'webpack4';
+import webpack5 from 'webpack5';
 
 // Keep a reference to console.log for debugging.
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const log = console.log;
+const error = console.error;
+const warn = console.warn;
 
 // Spy on console to avoid logs in the console and to assert.
-jest.spyOn(console, 'log').mockImplementation(() => {});
-jest.spyOn(console, 'error').mockImplementation(() => {});
-jest.spyOn(console, 'warn').mockImplementation(() => {});
+jest.spyOn(console, 'log').mockImplementation(log);
+jest.spyOn(console, 'error').mockImplementation(error);
+jest.spyOn(console, 'warn').mockImplementation(warn);
 
 const logMock = jest.mocked(console.log);
 const errorMock = jest.mocked(console.error);
@@ -23,6 +52,31 @@ const warnMock = jest.mocked(console.warn);
 // Access logs and strip colors.
 const getOutput = (mock: jest.Mock, index: number) => stripAnsi(mock.mock.calls[index][0]);
 
+// Mock getSendLog for testing forward option
+jest.mock('@dd/core/helpers/log', () => ({
+    getSendLog: jest.fn(() => jest.fn().mockResolvedValue(undefined)),
+}));
+// Mock the getLogger function from the context.
+jest.mock('@dd/factory/helpers/logger', () => {
+    const originalModule = jest.requireActual('@dd/factory/helpers/logger');
+    return {
+        ...originalModule,
+        getLoggerFactory: jest.fn(originalModule.getLoggerFactory),
+    };
+});
+
+jest.mock('@dd/internal-async-queue-plugin', () => {
+    const originalModule = jest.requireActual('@dd/internal-async-queue-plugin');
+    return {
+        ...originalModule,
+        getAsyncQueuePlugins: jest.fn(originalModule.getAsyncQueuePlugins),
+    };
+});
+
+const mockGetSendLog = jest.mocked(getSendLog);
+const mockGetLoggerFactory = jest.mocked(getLoggerFactory);
+const mockGetAsyncQueuePlugins = jest.mocked(getAsyncQueuePlugins);
+
 describe('logger', () => {
     describe('getLoggerFactory', () => {
         const setupLogger = (name: string): [Logger, GlobalStores, GlobalData] => {
@@ -272,5 +326,142 @@ describe('logger', () => {
                 assessStores(`testLogger${NAME_SEP}subLogger`, stores);
             });
         });
+
+        describe('Forward option', () => {
+            test('Should add promises to queue when forward option is used', () => {
+                const [logger, stores] = setupLogger('testLogger');
+                const mockSendLogFn = jest.fn().mockResolvedValue(undefined);
+                mockGetSendLog.mockReturnValue(mockSendLogFn);
+
+                // Log with forward option
+                logger.info('Test forwarded log', { forward: true });
+
+                // Check that sendLog was called
+                expect(mockSendLogFn).toHaveBeenCalledTimes(1);
+
+                // Check that promises were added to the queue
+                expect(stores.queue).toHaveLength(1);
+
+                // Check that sendLog function was called with correct parameters
+                expect(mockSendLogFn).toHaveBeenCalledWith({
+                    message: 'Test forwarded log',
+                    context: { plugin: 'testLogger', status: 'info' },
+                });
+            });
+
+            test('Should not add to queue when forward option is not used', () => {
+                const [logger, stores] = setupLogger('testLogger');
+
+                // Log without forward option
+                logger.info('Test log');
+                logger.error('Test error');
+
+                // Check that queue is empty
+                expect(stores.queue).toHaveLength(0);
+            });
+
+            describe('Full build', () => {
+                let stores: GlobalStores;
+                let logger: Logger;
+                const promiseResolves: (() => void)[] = [];
+                const mockAsyncCall = jest.fn();
+                const outDirsToRm: string[] = [];
+                const buildPromises: Promise<any>[] = [];
+
+                beforeAll(async () => {
+                    // Mocks.
+                    [logger, stores] = setupLogger('testLogger');
+
+                    // Use an async function, manually resolved from outside.
+                    const mockSendLogFn = jest.fn().mockImplementation(() => {
+                        return new Promise((resolve) => {
+                            promiseResolves.push(() => {
+                                mockAsyncCall();
+                                resolve(undefined);
+                            });
+                        });
+                    });
+                    mockGetSendLog.mockReturnValue(mockSendLogFn);
+                    mockGetLoggerFactory.mockReturnValue(() => logger);
+
+                    // Mock the async queue plugins to use our mock stores.
+                    mockGetAsyncQueuePlugins.mockImplementation((args: GetPluginsArg) => {
+                        const original: typeof getAsyncQueuePlugins = jest.requireActual(
+                            '@dd/internal-async-queue-plugin',
+                        ).getAsyncQueuePlugins;
+                        args.stores = stores;
+                        return original(args);
+                    });
+
+                    const pluginConfig: Options = {
+                        ...defaultPluginOptions,
+                        customPlugins: ({ context }) => {
+                            context
+                                .getLogger('testLogger')
+                                .info('Test forwarded log', { forward: true });
+                            return [];
+                        },
+                    };
+
+                    // Prepare the working directory, where we'll output our builds.
+                    const seed: string = `${Math.abs(jest.getSeed())}.${getUniqueId()}`;
+                    const workingDir = await prepareWorkingDir(seed);
+                    outDirsToRm.push(workingDir);
+
+                    // Using these plugins to target the dev files,
+                    // so the mocks are correctly injected.
+                    const allPlugins: Record<BundlerFullName, (config: Options) => any> = {
+                        webpack4: (config) => getWebpackPlugin(config, webpack4),
+                        webpack5: (config) => getWebpackPlugin(config, webpack5),
+                        rspack: (config) => datadogRspackPlugin(config),
+                        esbuild: (config) => datadogEsbuildPlugin(config),
+                        rollup: (config) => datadogRollupPlugin(config),
+                        vite: (config) => datadogVitePlugin(config),
+                    };
+
+                    // Build with all the bundlers.
+                    for (const bundler of BUNDLERS) {
+                        const getPlugin = allPlugins[bundler.name];
+                        const { run, config } = allBundlers[bundler.name];
+                        // Store the promises without awaiting them.
+                        buildPromises.push(
+                            run(
+                                config({
+                                    workingDir,
+                                    entry: { main: path.resolve(workingDir, defaultEntry) },
+                                    outDir: path.join(workingDir, bundler.name),
+                                    plugins: [getPlugin(pluginConfig)],
+                                }),
+                            ),
+                        );
+                    }
+                });
+
+                afterAll(async () => {
+                    if (process.env.NO_CLEANUP) {
+                        return;
+                    }
+                    try {
+                        await Promise.all(outDirsToRm.map((dir) => rm(dir)));
+                    } catch (e) {
+                        // Ignore errors.
+                    }
+                });
+
+                test('Should handle async queue processing', async () => {
+                    // Verify promise was added to queue
+                    expect(stores.queue).toHaveLength(BUNDLERS.length);
+                    // We should not have called the async function yet.
+                    expect(mockAsyncCall).not.toHaveBeenCalled();
+
+                    // Resolve the awaiting promises, so the builds can complete.
+                    promiseResolves.forEach((resolve) => resolve());
+                    await Promise.all(buildPromises);
+
+                    // Verify the promises were resolved
+                    expect(mockAsyncCall).toHaveBeenCalledTimes(BUNDLERS.length);
+                });
+            });
+        });
     });
 });

packages/factory/src/index.ts

@@ -167,6 +167,8 @@ export const buildPluginFactory = ({
                     bundler,
                     context,
                     options,
+                    data,
+                    stores,
                 }),
             );
         }

packages/plugins/async-queue/src/index.ts

@@ -9,9 +9,8 @@ import { PLUGIN_NAME } from './constants';
 export { PLUGIN_NAME };
 
 export const getAsyncQueuePlugins: GetInternalPlugins = (arg: GetPluginsArg) => {
-    const { context } = arg;
+    const { context, stores } = arg;
     const log = context.getLogger(PLUGIN_NAME);
-    const promises: Promise<any>[] = [];
     const errors: string[] = [];
 
     // Initialize the queue function
@@ -20,16 +19,15 @@ export const getAsyncQueuePlugins: GetInternalPlugins = (arg: GetPluginsArg) =>
         const wrappedPromise = promise.catch((error: any) => {
             errors.push(error.message || error.toString());
         });
-        promises.push(wrappedPromise);
+        stores.queue.push(wrappedPromise);
     };
 
     return [
         {
             name: PLUGIN_NAME,
             asyncTrueEnd: async () => {
                 // Await for all promises to finish processing.
-                await Promise.all(promises);
-
+                await Promise.all(stores.queue);
                 if (errors.length > 0) {
                     log.error(
                         `Error occurred while processing async queue:\n  ${errors.join('\n  ')}`,

packages/tests/src/_jest/helpers/mocks.ts

@@ -205,6 +205,8 @@ export const getGetPluginsArg = (
     return {
         options: optionsOverrides,
         context: getContextMock(contextOverrides),
+        data: getMockData(),
+        stores: getMockStores(),
         bundler: {},
     };
 };

packages/tools/src/helpers.ts

@@ -10,6 +10,8 @@ import type {
     GetPluginsArg,
     GetPlugins,
     OptionsWithDefaults,
+    GlobalData,
+    GlobalStores,
 } from '@dd/core/types';
 import { getContext } from '@dd/factory/helpers/context';
 import chalk from 'chalk';
@@ -183,6 +185,27 @@ export const getWorkspaces = async (
 
 // TODO: Update this, it's a bit hacky.
 export const getSupportedBundlers = (getPlugins: GetPlugins) => {
+    const data: GlobalData = {
+        bundler: {
+            name: 'esbuild',
+            fullName: 'esbuild',
+            variant: '',
+            version: '1.0.0',
+        },
+        metadata: {},
+        env: 'test',
+        packageName: '@datadog/esbuild-plugin',
+        version: '0',
+    };
+
+    const stores: GlobalStores = {
+        errors: [],
+        warnings: [],
+        logs: [],
+        timings: [],
+        queue: [],
+    };
+
     const arg: GetPluginsArg = {
         options: {
             telemetry: {},
@@ -198,26 +221,11 @@ export const getSupportedBundlers = (getPlugins: GetPlugins) => {
             // We don't care, this is a hack.
             start: 0,
             options: {} as OptionsWithDefaults,
-            data: {
-                bundler: {
-                    name: 'esbuild',
-                    fullName: 'esbuild',
-                    variant: '',
-                    version: '1.0.0',
-                },
-                metadata: {},
-                env: 'test',
-                packageName: '@datadog/esbuild-plugin',
-                version: '0',
-            },
-            stores: {
-                errors: [],
-                warnings: [],
-                logs: [],
-                timings: [],
-                queue: [],
-            },
+            data,
+            stores,
         }),
+        data,
+        stores,
         bundler: {},
     };