@squiz/dxp-cli-next 5.24.0 → 5.25.0-develop.1

package/lib/page/utils/server.spec.js

@@ -0,0 +1,275 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = require("./server");
+const render_1 = require("./render");
+const fs = __importStar(require("fs/promises"));
+const http = __importStar(require("http"));
+const opener_1 = __importDefault(require("opener"));
+const definitions_1 = require("./definitions");
+jest.mock('./render');
+jest.mock('./definitions');
+jest.mock('fs/promises');
+jest.mock('fs', () => ({
+    existsSync: jest.fn().mockImplementation(path => {
+        return true;
+    }),
+    createReadStream: jest.fn().mockReturnValue({
+        pipe: jest.fn(),
+        on: jest.fn(),
+    }),
+}));
+jest.mock('http');
+jest.mock('opener');
+jest.mock('@squiz/dx-logger-lib', () => ({
+    getLogger: () => ({
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+    }),
+}));
+describe('startDevServer', () => {
+    const mockRenderLayout = render_1.renderLayout;
+    const mockLoadLayoutDefinition = definitions_1.loadLayoutDefinition;
+    const mockLoadLayoutFromFile = definitions_1.loadLayoutFromFile;
+    const mockReadFile = fs.readFile;
+    const mockStat = fs.stat;
+    const mockCreateServer = http.createServer;
+    const mockOpener = opener_1.default;
+    let mockServer;
+    const mockLayoutDefinition = {
+        name: 'test-layout',
+        displayName: 'Test Layout',
+        description: 'A test layout',
+        entry: 'path/to/template.html',
+        template: '<div class="{{options.size}}">{{{zones.main}}}</div>',
+        zones: {
+            main: {
+                displayName: 'Main Content',
+                description: 'Main content area',
+                minNodes: 1,
+            },
+            sidebar: {
+                displayName: 'Sidebar',
+                description: 'Sidebar content',
+                minNodes: 0,
+                maxNodes: 3,
+            },
+        },
+        options: {
+            size: {
+                displayName: 'Size',
+                description: 'Container size',
+                values: ['small', 'medium', 'large'],
+            },
+        },
+    };
+    const mockServerOptions = {
+        configPath: '/path/to/config.yaml',
+        layoutDefinition: mockLayoutDefinition,
+        zoneContent: {
+            main: ['/path/to/main.html'],
+            sidebar: ['/path/to/sidebar1.html', '/path/to/sidebar2.html'],
+        },
+        layoutOptions: {
+            size: 'large',
+        },
+        stylesheet: '/path/to/styles.css',
+        port: 4040,
+        openBrowser: true,
+    };
+    const originalProcessOn = process.on;
+    beforeAll(() => {
+        // @ts-ignore - we need to mock process.on
+        process.on = jest.fn();
+    });
+    beforeEach(() => {
+        jest.resetAllMocks();
+        mockServer = {
+            listen: jest.fn().mockImplementation((port, callback) => {
+                if (callback)
+                    callback();
+                return mockServer;
+            }),
+            close: jest.fn().mockReturnValue(mockServer),
+            on: jest.fn().mockReturnValue(mockServer),
+            requestListener: undefined,
+        };
+        mockCreateServer.mockImplementation(handler => {
+            if (typeof handler === 'function') {
+                mockServer.requestListener = handler;
+            }
+            return mockServer;
+        });
+        mockReadFile.mockImplementation(path => {
+            if (typeof path === 'string') {
+                if (path.includes('main.html')) {
+                    return Promise.resolve('<p>Main content</p>');
+                }
+                else if (path.includes('sidebar')) {
+                    return Promise.resolve('<div>Sidebar item</div>');
+                }
+                else if (path.includes('styles.css')) {
+                    return Promise.resolve('body { color: #333; }');
+                }
+            }
+            return Promise.resolve('');
+        });
+        mockStat.mockImplementation(() => {
+            return Promise.resolve({
+                mtime: new Date(),
+                isFile: () => true,
+                isDirectory: () => false,
+                size: 100,
+            });
+        });
+        mockLoadLayoutDefinition.mockResolvedValue(mockLayoutDefinition);
+        mockLoadLayoutFromFile.mockResolvedValue(mockLayoutDefinition.template);
+        mockRenderLayout.mockResolvedValue('<div class="rendered-layout">Content</div>');
+    });
+    afterAll(() => {
+        process.on = originalProcessOn;
+    });
+    it('should initialize server with provided options', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, server_1.startDevServer)(mockServerOptions);
+        expect(mockCreateServer).toHaveBeenCalled();
+        expect(mockServer.listen).toHaveBeenCalled();
+        expect(mockCreateServer).toHaveBeenCalledWith(expect.any(Function));
+    }));
+    it('should load content from files for each zone', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, server_1.startDevServer)(mockServerOptions);
+        const mockRequest = {
+            url: '/',
+            on: jest.fn(),
+        };
+        const mockResponse = {
+            writeHead: jest.fn(),
+            end: jest.fn(),
+            write: jest.fn(),
+        };
+        const requestListener = mockServer.requestListener;
+        if (!requestListener) {
+            fail('Request listener was not set');
+            return;
+        }
+        yield requestListener(mockRequest, mockResponse);
+        expect(mockReadFile).toHaveBeenCalledWith('/path/to/main.html', 'utf-8');
+        expect(mockReadFile).toHaveBeenCalledWith('/path/to/sidebar1.html', 'utf-8');
+        expect(mockReadFile).toHaveBeenCalledWith('/path/to/sidebar2.html', 'utf-8');
+    }));
+    it('should open browser if openBrowser is true', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, server_1.startDevServer)(mockServerOptions);
+        expect(mockOpener).toHaveBeenCalledWith('http://localhost:4040/');
+    }));
+    it('should not open browser if openBrowser is false', () => __awaiter(void 0, void 0, void 0, function* () {
+        const options = Object.assign(Object.assign({}, mockServerOptions), { openBrowser: false });
+        yield (0, server_1.startDevServer)(options);
+        expect(mockOpener).not.toHaveBeenCalled();
+    }));
+    it('should pass concatenated zone content to renderLayout', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockRequest = {
+            url: '/',
+            on: jest.fn(),
+        };
+        const mockResponse = {
+            writeHead: jest.fn(),
+            end: jest.fn(),
+            write: jest.fn(),
+        };
+        yield (0, server_1.startDevServer)(mockServerOptions);
+        const requestListener = mockServer.requestListener;
+        if (!requestListener) {
+            fail('Request listener was not set');
+            return;
+        }
+        yield requestListener(mockRequest, mockResponse);
+        // Check that renderLayout was called with concatenated content
+        expect(mockRenderLayout).toHaveBeenCalledWith(mockLayoutDefinition.template, expect.objectContaining({
+            main: '<p>Main content</p>',
+            sidebar: '<div>Sidebar item</div><div>Sidebar item</div>',
+        }), mockServerOptions.layoutOptions, mockLayoutDefinition);
+    }));
+    it('should set up check-changes endpoint for client polling', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockRequest = {
+            url: '/check-changes?lastModified=2023-01-01T00:00:00.000Z',
+            on: jest.fn(),
+            searchParams: {
+                get: jest.fn().mockReturnValue('2023-01-01T00:00:00.000Z'),
+            },
+        };
+        const mockResponse = {
+            writeHead: jest.fn(),
+            end: jest.fn(),
+            write: jest.fn(),
+        };
+        yield (0, server_1.startDevServer)(mockServerOptions);
+        const requestListener = mockServer.requestListener;
+        if (!requestListener) {
+            fail('Request listener was not set');
+            return;
+        }
+        yield requestListener(mockRequest, mockResponse);
+        expect(mockResponse.writeHead).toHaveBeenCalledWith(200, {
+            'Content-Type': 'application/json',
+        });
+    }));
+    it('should redirect to root for unknown paths', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockRequest = {
+            url: '/unknown-path',
+            on: jest.fn(),
+        };
+        const mockResponse = {
+            writeHead: jest.fn(),
+            end: jest.fn(),
+            write: jest.fn(),
+        };
+        yield (0, server_1.startDevServer)(mockServerOptions);
+        const requestListener = mockServer.requestListener;
+        if (!requestListener) {
+            fail('Request listener was not set');
+            return;
+        }
+        yield requestListener(mockRequest, mockResponse);
+        expect(mockResponse.writeHead).toHaveBeenCalledWith(302, {
+            Location: '/',
+        });
+    }));
+    it('should set up process exit handler', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, server_1.startDevServer)(mockServerOptions);
+        expect(process.on).toHaveBeenCalledWith('SIGINT', expect.any(Function));
+    }));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/dxp-cli-next",
-  "version": "5.24.0",
+  "version": "5.25.0-develop.1",
   "repository": {
     "url": "https://gitlab.squiz.net/dxp/dxp-cli-next"
   },
@@ -51,6 +51,7 @@
     "dotenv": "^16.3.1",
     "env-paths": "2.2.1",
     "esbuild": "^0.21.4",
+    "handlebars": "^4.7.8",
     "inquirer": "8.2.5",
     "opener": "1.5.2",
     "ora": "^5.4.1",