@datadome/module-nextjs/src/middleware.test.ts

DataDome module for Next.js applications

import test from 'ava';
import { DataDomeMiddleware, Logger } from './middleware';
import { DEFAULT_SERVER_SIDE_URL, DEFAULT_TIMEOUT, MODULE_NAME, MODULE_VERSION } from './constants';

function createLogger(spy: Record<string, any> = {}): Logger {
    return {
        debug: spy.debug || (() => {}),
        info: spy.info || (() => {}),
        warn: spy.warn || (() => {}),
        error: spy.error || (() => {}),
    };
}

test('constructor throws if serverSideKey is missing', (t) => {
    t.throws(
        () => {
            // @ts-expect-error
            new DataDomeMiddleware();
        },
        { message: 'Missing API key' },
    );

    t.throws(
        () => {
            new DataDomeMiddleware('');
        },
        { message: 'Missing API key' },
    );
});

test('constructor uses default values if no parameters provided', (t) => {
    const logger = createLogger();
    const middleware = new DataDomeMiddleware('key', { logger });
    t.is(middleware.serverSideKey, 'key');
    t.is(middleware.endpointHost, 'https://' + DEFAULT_SERVER_SIDE_URL);
    t.is(middleware.timeout, DEFAULT_TIMEOUT);
    t.true(middleware.urlPatternExclusion instanceof RegExp);
    t.is(middleware.logger, logger);
    t.is(middleware.moduleName, MODULE_NAME);
    t.is(middleware.moduleVersion, MODULE_VERSION);
});

test('constructor uses provided endpointHost and adds https:// if missing', (t) => {
    let infoCalled = '';
    const logger = createLogger({
        info: (msg: string) => {
            infoCalled = msg;
        },
    });
    const middleware = new DataDomeMiddleware('key', { endpointHost: 'custom.host', logger });
    t.is(middleware.endpointHost, 'https://custom.host');
    t.true(infoCalled.includes('https://custom.host'));
});

test('constructor does not add https:// if endpointHost already has it', (t) => {
    let infoCalled = '';
    const logger = createLogger({
        info: (msg: string) => {
            infoCalled = msg;
        },
    });
    const middleware = new DataDomeMiddleware('key', { endpointHost: 'https://already.secure', logger });
    t.is(middleware.endpointHost, 'https://already.secure');
    t.true(infoCalled.includes('https://already.secure'));
});

test('constructor uses provided timeout if > 0', (t) => {
    const logger = createLogger();
    const middleware = new DataDomeMiddleware('key', { timeout: 1234, logger });
    t.is(middleware.timeout, 1234);
});

test('constructor falls back to default timeout if <= 0 and logs warning', (t) => {
    let warnCalled = '';
    const logger = createLogger({
        warn: (msg: string) => {
            warnCalled = msg;
        },
    });
    const middleware = new DataDomeMiddleware('key', { timeout: 0, logger });
    t.is(middleware.timeout, DEFAULT_TIMEOUT);
    t.true(warnCalled.includes('using default timeout'));
});

test('constructor uses provided urlPatternExclusion', (t) => {
    const logger = createLogger();
    const middleware = new DataDomeMiddleware('key', { urlPatternExclusion: '^/api', logger });
    t.true(middleware.urlPatternExclusion instanceof RegExp);
    t.is(middleware.urlPatternExclusion.source, '^\\/api');
});

test('constructor uses provided logger', (t) => {
    const logger = createLogger();
    const middleware = new DataDomeMiddleware('key', { logger });
    t.is(middleware.logger, logger);
});