@servicetitan/startup 27.3.0 → 27.4.0-canary.0

package/src/cli/utils/__tests__/assets-copy.test.ts

@@ -5,10 +5,7 @@ import { assetsCopy, assetsCopyWatch } from '../assets-copy';
 import { assetExtensions } from '../index';
 
 jest.mock('cpx2', () => ({
-    copy: jest.fn().mockImplementation((...args: any[]) => {
-        const callback = args[args.length - 1];
-        callback(null);
-    }),
+    copySync: jest.fn(),
     watch: jest.fn(() => ({ on: (_eventName: string, listener: Function) => listener() })),
 }));
 jest.mock('../../../utils', () => ({
@@ -28,10 +25,9 @@ describe('[startup] Cli Utils (Assets)', () => {
         test('copies assets from source to destination', async () => {
             await subject();
 
-            expect(cpx.copy).toHaveBeenCalledWith(
+            expect(cpx.copySync).toHaveBeenCalledWith(
                 `${source}/**/*.{${assetExtensions.join()}}`,
-                destination,
-                expect.anything()
+                destination
             );
         });
     });

package/src/cli/utils/__tests__/bundle.test.ts

@@ -2,7 +2,12 @@ import { fs, vol } from 'memfs';
 import path from 'path';
 import webpack from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
-import { getFolders, getPackageData, loadSharedDependencies } from '../../../utils';
+import {
+    getConfiguration,
+    getFolders,
+    getPackageData,
+    loadSharedDependencies,
+} from '../../../utils';
 import { createWebpackConfig } from '../../../webpack';
 import { createPackage } from '../../../__mocks__';
 
@@ -44,12 +49,12 @@ describe('[startup] Cli Utils', () => {
         return expect.stringContaining(name);
     }
 
-    function packageFS() {
-        return { 'package.json': JSON.stringify(pkg) };
+    function packageFS(configuration: ReturnType<typeof getConfiguration> = {} as any) {
+        return { 'package.json': JSON.stringify({ ...pkg, cli: configuration }) };
     }
 
-    function webComponentFS() {
-        return { 'package.json': JSON.stringify({ ...pkg, cli: { 'web-component': true } }) };
+    function webComponentFS(configuration: ReturnType<typeof getConfiguration> = {} as any) {
+        return packageFS({ 'web-component': true, ...configuration });
     }
 
     describe(`${bundle.name}`, () => {
@@ -287,6 +292,19 @@ describe('[startup] Cli Utils', () => {
             );
         });
 
+        describe('when webpack.devServer is set to false in package.json', () => {
+            beforeEach(() => {
+                vol.fromJSON(packageFS({ webpack: { devServer: false } } as any));
+            });
+
+            test('runs webpack and not webpack development server', async () => {
+                await subject();
+
+                expect(webpack).toHaveBeenCalledWith(createWebpackResult);
+                expect(WebpackDevServer).not.toHaveBeenCalled();
+            });
+        });
+
         function itUsesConfig(params: { name: string; config: () => Record<string, any> }) {
             test(`uses ${params.name}`, async () => {
                 const { devServer, ...config } = params.config();
@@ -351,7 +369,8 @@ describe('[startup] Cli Utils', () => {
                     ...options,
                     embed: true,
                 });
-                expect(webpack).toHaveBeenCalledWith(createWebpackResult);
+                expect(webpack).toHaveBeenNthCalledWith(1, createWebpackResult);
+                expect(webpack).toHaveBeenNthCalledWith(2, createWebpackResult);
                 expect(compiler.watch).toHaveBeenCalled();
                 expect(WebpackDevServer).toHaveBeenCalledWith(
                     { host: 'localhost', port: 8080 },
@@ -359,6 +378,26 @@ describe('[startup] Cli Utils', () => {
                 );
             });
 
+            describe('when webpack.devServer is set to false in package.json', () => {
+                beforeEach(() => {
+                    vol.fromJSON(webComponentFS({ webpack: { devServer: false } } as any));
+                });
+
+                test('runs webpack and not webpack development server', async () => {
+                    const options = { name: expectPackageName() };
+                    const overrides = { configuration: { mode: 'development' } };
+
+                    await subject();
+
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
+                        ...options,
+                        embed: true,
+                    });
+                    expect(WebpackDevServer).not.toHaveBeenCalled();
+                });
+            });
+
             function itUsesConfig(params: { name: string; config: () => Record<string, any> }) {
                 test(`uses ${params.name}`, async () => {
                     const options = { name: expectPackageName() };

package/src/cli/utils/__tests__/cli-os.test.ts

@@ -1,6 +1,7 @@
 import { execSync, spawn } from 'child_process';
 
 import { runCommand, runCommandOutput } from '../cli-os';
+import { log } from '../../../utils';
 
 jest.mock('child_process', () => ({ execSync: jest.fn(), spawn: jest.fn() }));
 jest.mock('../../../utils', () => ({ log: { info: jest.fn() } })); // suppress log output
@@ -11,6 +12,7 @@ describe('[startup] Cli Utils (OS)', () => {
         let childProcess: ReturnType<typeof spawn>;
 
         beforeEach(() => {
+            jest.clearAllMocks();
             exitCode = 0;
             childProcess = {
                 stderr: { pipe: jest.fn() },
@@ -25,7 +27,7 @@ describe('[startup] Cli Utils (OS)', () => {
         test('runs command', () => {
             expect(subject('foo bar')).resolves.toBe(undefined);
 
-            expect(spawn).toHaveBeenCalledWith('foo', ['bar'], undefined);
+            expect(spawn).toHaveBeenCalledWith('foo', ['bar'], {});
         });
 
         test('runs command with options', async () => {
@@ -37,7 +39,7 @@ describe('[startup] Cli Utils (OS)', () => {
         test('runs command array', async () => {
             await subject(['foo', 'bar', '--baz']);
 
-            expect(spawn).toHaveBeenCalledWith('foo', ['bar', '--baz'], undefined);
+            expect(spawn).toHaveBeenCalledWith('foo', ['bar', '--baz'], {});
         });
 
         test("pipes stdout and stderr to parent's streams", async () => {
@@ -60,10 +62,28 @@ describe('[startup] Cli Utils (OS)', () => {
                 expect(subject(command)).rejects.toBeUndefined();
             })
         );
+
+        test('logs command and exit status', async () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            await subject('foo');
+
+            expect(logInfoSpy).toHaveBeenCalledWith('run command foo');
+            expect(logInfoSpy).toHaveBeenCalledWith('command finished with code 0', 'foo');
+        });
+
+        test('quiet option suppresses output', async () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            await subject('foo', { quiet: true });
+
+            expect(logInfoSpy).not.toHaveBeenCalled();
+        });
     });
 
     describe(`${runCommandOutput.name}`, () => {
-        beforeEach(() => jest.mocked(execSync).mockReturnValue(''));
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.mocked(execSync).mockReturnValue('');
+        });
 
         const subject = (...args: Parameters<typeof runCommandOutput>) => runCommandOutput(...args);
 
@@ -73,7 +93,7 @@ describe('[startup] Cli Utils (OS)', () => {
 
             expect(subject('foo bar')).toBe(result);
 
-            expect(execSync).toHaveBeenCalledWith('foo bar', undefined);
+            expect(execSync).toHaveBeenCalledWith('foo bar', {});
         });
 
         test('runs command with options', () => {
@@ -85,13 +105,13 @@ describe('[startup] Cli Utils (OS)', () => {
         test('runs command array', () => {
             subject(['foo', 'bar']);
 
-            expect(execSync).toHaveBeenCalledWith('foo bar', undefined);
+            expect(execSync).toHaveBeenCalledWith('foo bar', {});
         });
 
         test('ignores false and "" array values', () => {
             subject(['', 'foo', false, '', 'bar', false]);
 
-            expect(execSync).toHaveBeenCalledWith('foo bar', undefined);
+            expect(execSync).toHaveBeenCalledWith('foo bar', {});
         });
 
         ['', [], ['']].forEach(command =>
@@ -99,5 +119,20 @@ describe('[startup] Cli Utils (OS)', () => {
                 expect(() => subject(command)).toThrow();
             })
         );
+
+        test('logs command and result', () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            subject('foo');
+
+            expect(logInfoSpy).toHaveBeenCalledWith('run command foo');
+            expect(logInfoSpy).toHaveBeenCalledWith('command finished', '');
+        });
+
+        test('quiet option suppresses output', () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            subject('foo', { quiet: true });
+
+            expect(logInfoSpy).not.toHaveBeenCalled();
+        });
     });
 });

package/src/cli/utils/__tests__/styles-copy.test.ts

@@ -5,10 +5,7 @@ import { stylesCopy, stylesCopyWatch } from '../styles-copy';
 import { styleExtensions } from '../index';
 
 jest.mock('cpx2', () => ({
-    copy: jest.fn().mockImplementation((...args: any[]) => {
-        const callback = args[args.length - 1];
-        callback(null);
-    }),
+    copySync: jest.fn(),
     watch: jest.fn(() => ({ on: (_eventName: string, listener: Function) => listener() })),
 }));
 jest.mock('../../../utils', () => ({
@@ -28,10 +25,9 @@ describe('[startup] Cli Utils (Styles)', () => {
         test('copies styles from source to destination', async () => {
             await subject();
 
-            expect(cpx.copy).toHaveBeenCalledWith(
+            expect(cpx.copySync).toHaveBeenCalledWith(
                 `${source}/**/*.{${styleExtensions.join()}}`,
-                destination,
-                expect.anything()
+                destination
             );
         });
     });

package/src/cli/utils/assets-copy.ts

@@ -1,15 +1,15 @@
 import cpx from 'cpx2';
-import util from 'util';
 
 import { getFolders, log } from '../../utils';
 import { assetExtensions } from '.';
 
-export async function assetsCopy() {
+export function assetsCopy() {
     const { source, destination } = getFolders();
 
     log.info('Copying asset files...');
 
-    await util.promisify(cpx.copy)(`${source}/**/*.{${assetExtensions.join()}}`, destination);
+    cpx.copySync(`${source}/**/*.{${assetExtensions.join()}}`, destination);
+    return Promise.resolve();
 }
 
 export async function assetsCopyWatch() {

package/src/cli/utils/bundle.ts

@@ -6,7 +6,7 @@ import { getPortPromise } from 'portfinder';
 import webpack, { Configuration } from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
 
-import { getPackageName, isWebComponent, log } from '../../utils';
+import { getPackageName, isDevServerDisabled, isWebComponent, log } from '../../utils';
 import { Overrides, createWebpackConfig } from '../../webpack';
 
 interface Options {
@@ -62,6 +62,7 @@ export async function bundleWatch(options: Options = {}) {
     const mode = 'development';
     const config = readWebpackConfig({ ...options, fallback: `./${webpackDevConfigFileName}` });
     const { codeCoverage, esbuild, experimentalBundlers } = options;
+    const configOverrides = { codeCoverage, esbuild, experimentalBundlers, name };
 
     if (isWebComponent()) {
         const webpackConfig: Overrides = {
@@ -72,31 +73,24 @@ export async function bundleWatch(options: Options = {}) {
         return Promise.all([
             runWatch(
                 createWebpackConfig(webpackConfig, {
-                    codeCoverage,
                     embed: true,
-                    name,
-                    esbuild,
-                    experimentalBundlers,
-                })
-            ),
-            runServe(
-                createWebpackConfig(webpackConfig, {
-                    name,
-                    codeCoverage,
-                    esbuild,
-                    experimentalBundlers,
+                    ...configOverrides,
                 })
             ),
+            isDevServerDisabled()
+                ? runWatch(createWebpackConfig(webpackConfig, configOverrides))
+                : runServe(createWebpackConfig(webpackConfig, configOverrides)),
         ]);
     }
 
-    return runServe(
-        config ??
-            createWebpackConfig(
-                { configuration: { mode } },
-                { name, codeCoverage, esbuild, experimentalBundlers }
-            )
-    );
+    const webpackConfig =
+        config ?? createWebpackConfig({ configuration: { mode } }, configOverrides);
+
+    if (isDevServerDisabled()) {
+        return runWatch(webpackConfig);
+    }
+
+    return runServe(webpackConfig);
 }
 
 function readWebpackConfig({ config, fallback }: Options & { fallback: string }) {

package/src/cli/utils/cli-os.ts

@@ -6,9 +6,11 @@ import {
 } from 'child_process';
 import { log } from '../../utils';
 
+type RunCommandOptions = SpawnOptionsWithoutStdio & { quiet?: boolean };
+
 export const runCommand = (
     command: string | (string | false)[],
-    opts?: SpawnOptionsWithoutStdio
+    { quiet, ...spawnOptions }: RunCommandOptions = {}
 ): Promise<void> => {
     return new Promise((resolve, reject) => {
         const commandArray: string[] = Array.isArray(command)
@@ -28,15 +30,19 @@ export const runCommand = (
             return;
         }
 
-        log.info(`run command ${fullCommand}`);
+        if (!quiet) {
+            log.info(`run command ${fullCommand}`);
+        }
 
-        const proc = spawn(commandName, commandArray, opts);
+        const proc = spawn(commandName, commandArray, spawnOptions);
 
         proc.stdout.pipe(process.stdout);
         proc.stderr.pipe(process.stderr);
 
         proc.on('exit', function (code: any) {
-            log.info(`command finished with code ${code}`, fullCommand);
+            if (!quiet) {
+                log.info(`command finished with code ${code}`, fullCommand);
+            }
 
             if (code) {
                 reject();
@@ -47,9 +53,11 @@ export const runCommand = (
     });
 };
 
+type RunCommandOutputOptions = ExecSyncOptionsWithBufferEncoding & { quiet?: boolean };
+
 export const runCommandOutput = (
     command: string | (string | false)[],
-    options?: ExecSyncOptionsWithBufferEncoding
+    { quiet, ...execSyncOptions }: RunCommandOutputOptions = {}
 ): string => {
     const commandArray: string[] = Array.isArray(command)
         ? command
@@ -66,11 +74,15 @@ export const runCommandOutput = (
         throw new Error();
     }
 
-    log.info(`run command ${fullCommand}`);
+    if (!quiet) {
+        log.info(`run command ${fullCommand}`);
+    }
 
-    const result = execSync(fullCommand, options).toString();
+    const result = execSync(fullCommand, execSyncOptions).toString();
 
-    log.info('command finished', result);
+    if (!quiet) {
+        log.info('command finished', result);
+    }
 
     return result;
 };

package/src/cli/utils/styles-copy.ts

@@ -1,15 +1,15 @@
 import cpx from 'cpx2';
-import util from 'util';
 
 import { getFolders, log } from '../../utils';
 import { styleExtensions } from '.';
 
-export async function stylesCopy() {
+export function stylesCopy() {
     const { source, destination } = getFolders();
 
     log.info('Copying style files...');
 
-    await util.promisify(cpx.copy)(`${source}/**/*.{${styleExtensions.join()}}`, destination);
+    cpx.copySync(`${source}/**/*.{${styleExtensions.join()}}`, destination);
+    return Promise.resolve();
 }
 
 export async function stylesCopyWatch() {

package/src/index.ts

@@ -1,3 +1,5 @@
 export * from './webpack';
 export * from './jest';
 export * from './utils/get-packages';
+
+export { ExposedDependency, getExposedDependencies, loadSharedDependencies } from './utils';

package/src/utils/__tests__/get-configuration.test.ts

@@ -8,6 +8,7 @@ import {
     getStylelintConfiguration,
     isBundle,
     isCustomStyleRules,
+    isDevServerDisabled,
     isExposeSharedDependencies,
     isLegacy,
     isLegacyRoot,
@@ -193,6 +194,11 @@ describe('[startup] Utils', () => {
             defaultValue: false,
             trigger: { cli: { webpack: { 'custom-style-rules': true } } },
         },
+        {
+            fn: isDevServerDisabled,
+            defaultValue: false,
+            trigger: { cli: { webpack: { devServer: false } } },
+        },
         {
             fn: isExposeSharedDependencies,
             defaultValue: false,

package/src/utils/get-configuration.ts

@@ -30,7 +30,7 @@ export interface WebpackConfiguration
     'contentBase'?: boolean | string | string[] | number; // deprecated 2024-07
     'custom-style-rules'?: boolean;
     'expose-shared-dependencies'?: boolean;
-    'devServer'?: WebpackDevServerConfiguration;
+    'devServer'?: false | WebpackDevServerConfiguration;
     'disable-style-check'?: boolean;
     'minify'?: MinifyOptions;
     'proxy'?: WebpackDevServerConfiguration['proxy'] | string;
@@ -128,6 +128,11 @@ export function isCustomStyleRules() {
     return getWebpackConfiguration()['custom-style-rules'] === true;
 }
 
+export function isDevServerDisabled() {
+    const webpackConfiguration = getWebpackConfiguration();
+    return webpackConfiguration.devServer === false;
+}
+
 export function isExposeSharedDependencies() {
     return getWebpackConfiguration()['expose-shared-dependencies'] === true;
 }

package/src/utils/get-exposed-dependencies.ts

@@ -0,0 +1,19 @@
+export interface ExposedDependency {
+    version: string;
+    variable: string;
+}
+
+export type ExposedDependencies = Record<string, ExposedDependency>;
+
+export function getExposedDependencies(
+    sharedDependencies: Record<string, string>,
+    getVersion: (dependency: string) => string
+) {
+    return Object.entries(sharedDependencies).reduce(
+        (result, [dependency, variable]) => ({
+            ...result,
+            [dependency]: { version: getVersion(dependency), variable },
+        }),
+        {} as ExposedDependencies
+    );
+}

package/src/utils/get-folders.ts

@@ -1,6 +1,6 @@
 import path from 'path';
 
-import { readJson } from '.';
+import { readJson } from './read-json';
 
 /**
  * Returns folders of sources and compilation target

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 export * from './get-configuration';
 export * from './get-destination-folders';
+export * from './get-exposed-dependencies';
 export * from './get-folders';
 export * from './get-jest-config';
 export * from './get-package-data';

package/src/webpack/__tests__/create-webpack-config-web-component.test.ts

@@ -67,16 +67,19 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     const indexCode = ({
         embed = false,
         legacyRoot = false,
-    }: { embed?: boolean; legacyRoot?: boolean } = {}) =>
+        designSystem,
+    }: { embed?: boolean; legacyRoot?: boolean; designSystem?: boolean } = {}) =>
         [
-            ...(embed ? [] : [`require('./design-system.css');`]),
+            ...(designSystem ? [`require('./design-system.css');`] : []),
             `import { register } from '@servicetitan/web-components';`,
             `import { App } from './app';`,
-            `register(App, ${embed}, { legacyRoot: ${legacyRoot}, sharedDependenciesNames: [] });`,
+            `register(App, ${embed}, { legacyRoot: ${legacyRoot}, sharedDependenciesNames: ${JSON.stringify(Object.keys(sharedDependencies))} });`,
         ].join('\n');
 
     let overrides: Parameters<typeof createWebpackConfig>[0];
     let options: NonNullable<Parameters<typeof createWebpackConfig>[1]>;
+    let dependencies: Record<string, string>;
+    let sharedDependencies: Record<string, string>;
 
     function mockPlugIn(name: string) {
         return (options: Record<string, any>): any => ({ [name]: options });
@@ -85,6 +88,10 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     beforeEach(() => {
         overrides = { plugins: { HtmlWebpackPlugin: { favicon: 'foo' } } };
         options = { name: packageName };
+        dependencies = { '@servicetitan/design-system': '*' };
+        sharedDependencies = {
+            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
+        };
 
         jest.resetAllMocks();
         jest.mocked(MiniCssExtractPlugin).mockImplementation(mockPlugIn('MiniCssExtractPlugin'));
@@ -95,11 +102,11 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
 
         jest.mocked(getCallerFile).mockReturnValue('');
         jest.mocked(getFolders).mockReturnValue({ source, destination });
-        jest.mocked(getPackageData).mockReturnValue({
+        jest.mocked(getPackageData).mockImplementation(() => ({
             name: packageName,
-            dependencies: {},
-            sharedDependencies: {},
-        });
+            dependencies,
+            sharedDependencies,
+        }));
         jest.mocked(getPackages).mockReturnValue([]);
         jest.mocked(getTsConfig).mockReturnValue(tsConfig);
         jest.mocked(isLegacyRoot).mockReturnValue(false);
@@ -233,7 +240,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             expect(subject().plugins).toContainEqual(
                 new VirtualModulesPlugin({
                     [designSystemPath()]: designSystemCode,
-                    [indexPath()]: indexCode(),
+                    [indexPath()]: indexCode({ designSystem: true }),
                 })
             );
         });
@@ -245,7 +252,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 expect(subject().plugins).toContainEqual(
                     new VirtualModulesPlugin({
                         [designSystemPath()]: designSystemCode,
-                        [indexPath()]: indexCode({ legacyRoot: true }),
+                        [indexPath()]: indexCode({ designSystem: true, legacyRoot: true }),
                     })
                 );
             });
@@ -262,7 +269,22 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             test('omits design system virtual module', () => {
                 expect(subject().plugins).toContainEqual(
                     new VirtualModulesPlugin({
-                        [indexPath()]: indexCode(),
+                        [indexPath()]: indexCode({ designSystem: true }),
+                    })
+                );
+            });
+        });
+
+        describe('when package does not depend on design system', () => {
+            beforeEach(() => {
+                delete dependencies['@servicetitan/design-system'];
+                delete sharedDependencies['@servicetitan/design-system'];
+            });
+
+            test('omits design system', () => {
+                expect(subject().plugins).toContainEqual(
+                    new VirtualModulesPlugin({
+                        [indexPath()]: indexCode({ designSystem: false }),
                     })
                 );
             });
@@ -271,11 +293,10 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         describe('when embed option is set to true', () => {
             beforeEach(() => (options.embed = true));
 
-            test(`changes virtual index module to omit design system and to register App`, () => {
+            test(`omits design system and registers App with embed set to true`, () => {
                 expect(subject().plugins).toContainEqual(
                     new VirtualModulesPlugin({
-                        [designSystemPath()]: designSystemCode,
-                        [indexPath()]: indexCode({ embed: true }),
+                        [indexPath()]: indexCode({ designSystem: false, embed: true }),
                     })
                 );
             });
@@ -285,6 +306,19 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                     expect.stringContaining(path.join(destination, 'bundle', 'light'))
                 );
             });
+
+            describe('when package does not share design system', () => {
+                beforeEach(() => delete sharedDependencies['@servicetitan/design-system']);
+
+                test('includes design system', () => {
+                    expect(subject().plugins).toContainEqual(
+                        new VirtualModulesPlugin({
+                            [designSystemPath()]: designSystemCode,
+                            [indexPath()]: indexCode({ designSystem: true, embed: true }),
+                        })
+                    );
+                });
+            });
         });
 
         describe.each([webpackDevConfigFileName, webpackProdConfigFileName])(

package/src/webpack/__tests__/create-webpack-config.test.ts

@@ -25,6 +25,7 @@ import {
     getTsConfig,
     getWebpackConfiguration,
     isCustomStyleRules,
+    isDevServerDisabled,
     isWebComponent,
     loadSharedDependencies,
     log,
@@ -64,6 +65,7 @@ jest.mock('../../utils', () => ({
     getTsConfig: jest.fn(),
     getWebpackConfiguration: jest.fn(),
     isCustomStyleRules: jest.fn(),
+    isDevServerDisabled: jest.fn(),
     isExposeSharedDependencies: jest.fn(),
     isWebComponent: jest.fn(),
     loadSharedDependencies: jest.fn(),
@@ -220,6 +222,14 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         expect(subject().devServer).toEqual(defaultDefServerConfig);
     });
 
+    describe('when "devServer" is disabled', () => {
+        beforeEach(() => jest.mocked(isDevServerDisabled).mockReturnValue(true));
+
+        test('omits "devServer" configuration', () => {
+            expect(subject().devServer).toBeUndefined();
+        });
+    });
+
     describe('with custom devServer options', () => {
         const options: WebpackDevServer.Configuration = {
             // allowed options