meno-core 1.0.21 → 1.0.23

package/lib/client/templateEngine.ts

@@ -167,6 +167,71 @@ export function resolveStyleMapping(
   return mappedValue !== undefined ? mappedValue : undefined;
 }
 
+/**
+ * Process a single style value - resolves mappings and evaluates templates.
+ * Skips item templates ({{item.field}}, {{varName.field}}) which are resolved later during rendering.
+ *
+ * @param styleValue - The style value to process (may be string, number, or mapping object)
+ * @param props - Component props for resolving mappings and templates
+ * @returns The processed style value, or undefined if the value should be skipped
+ */
+function processStyleValue(
+  styleValue: unknown,
+  props: Record<string, unknown> | undefined
+): string | number | undefined {
+  // First try style mapping resolution
+  const resolved = resolveStyleMapping(styleValue, props);
+  if (resolved !== undefined) {
+    return resolved;
+  }
+
+  // String values - evaluate templates (but skip item templates)
+  if (typeof styleValue === 'string') {
+    if (hasTemplates(styleValue) && !hasItemTemplates(styleValue)) {
+      return processCodeTemplates(styleValue, props);
+    }
+    return styleValue;
+  }
+
+  // Number values - pass through
+  if (typeof styleValue === 'number') {
+    return styleValue;
+  }
+
+  return undefined;
+}
+
+/**
+ * Build evaluation context for template processing.
+ * Merges global context, props, componentDef, and optionally itemContext.
+ *
+ * @param context - The TemplateContext containing props and componentDef
+ * @param includeItemContext - Whether to include itemContext from the context object
+ * @returns A flat object suitable for template evaluation
+ */
+function buildEvalContext(
+  context: TemplateContext,
+  includeItemContext: boolean = false
+): Record<string, unknown> {
+  const evalContext: Record<string, unknown> = {
+    ...getGlobalTemplateContext(),
+    ...context.props
+  };
+
+  if (context.componentDef && typeof context.componentDef === 'object') {
+    Object.assign(evalContext, context.componentDef as Record<string, unknown>);
+  }
+
+  if (includeItemContext) {
+    const itemContext = (context as Record<string, unknown>).itemContext as Record<string, unknown> | undefined;
+    if (itemContext) {
+      Object.assign(evalContext, itemContext);
+    }
+  }
+
+  return evalContext;
+}
+
 /** Maximum allowed expression length to prevent DoS via complex expressions */
 const MAX_EXPRESSION_LENGTH = 500;
 
@@ -315,22 +380,8 @@ export function processStructure(
     }
 
     if (typeof structure === 'string') {
-      // Build evaluation context from TemplateContext
-      // Start with global context, then merge props (props take precedence)
-      const evalContext: Record<string, unknown> = { ...getGlobalTemplateContext(), ...context.props };
-
-      // Add componentDef properties to context (for backward compatibility)
-      if (context.componentDef && typeof context.componentDef === 'object') {
-        Object.assign(evalContext, context.componentDef as Record<string, unknown>);
-      }
-
-      // Add parent cms-list item context for nested template resolution
-      // This enables {{item.field}} in components rendered inside cms-list
-      const itemContext = (context as Record<string, unknown>).itemContext as Record<string, unknown> | undefined;
-      if (itemContext) {
-        Object.assign(evalContext, itemContext);
-      }
-
+      // Build evaluation context with item context for nested template resolution
+      const evalContext = buildEvalContext(context, true);
 
       // Check if entire string is a complete template {{expr}}
       // Use evaluateTemplate to preserve type (objects, arrays, numbers)
@@ -504,12 +555,12 @@ export function processStructure(
             if (isHtmlNode(processed) || isListNode(processed)) {
               if (typeof value === 'string') {
                 // Process template in tag (e.g., "h{{size}}" -> "h1")
-                const evalContext: Record<string, unknown> = { ...getGlobalTemplateContext(), ...context.props };
-                if (context.componentDef && typeof context.componentDef === 'object') {
-                  Object.assign(evalContext, context.componentDef as Record<string, unknown>);
-                }
+                const evalContext = buildEvalContext(context, false);
                 // Use processCodeTemplates to handle partial templates like "h{{size}}"
                 (processed as any).tag = processCodeTemplates(value, evalContext);
+              } else if (value === false) {
+                // Preserve boolean false for fragment mode (no container)
+                (processed as any).tag = false;
               } else {
                 (processed as any).tag = String(value);
               }
@@ -526,16 +577,8 @@ export function processStructure(
             // Handle html property for embed nodes - process templates like {{propName}}
             if (preservedType === NODE_TYPE.EMBED) {
               if (typeof value === 'string') {
-                // Build evaluation context from props (same as tag processing)
-                const evalContext: Record<string, unknown> = { ...getGlobalTemplateContext(), ...context.props };
-                if (context.componentDef && typeof context.componentDef === 'object') {
-                  Object.assign(evalContext, context.componentDef as Record<string, unknown>);
-                }
-                // Add parent cms-list item context for nested template resolution
-                const itemContext = (context as Record<string, unknown>).itemContext as Record<string, unknown> | undefined;
-                if (itemContext) {
-                  Object.assign(evalContext, itemContext);
-                }
+                // Build evaluation context with item context for nested template resolution
+                const evalContext = buildEvalContext(context, true);
                 // Check if entire string is a complete template {{expr}}
                 if (/^\{\{.+\}\}$/.test(value) && !hasItemTemplates(value)) {
                   const result = evaluateTemplate(value, evalContext);
@@ -583,78 +626,29 @@ export function processStructure(
             if (processedStyle && typeof processedStyle === 'object' && !Array.isArray(processedStyle)) {
               // Check if it's a responsive style object
               if (isResponsiveStyle(processedStyle as StyleValue)) {
-                if (preserveResponsiveStyles) {
-                  // Preserve responsive styles as-is (for SSR)
-                  // Just resolve templates and mappings within each breakpoint
-                  const resolvedResponsive: ResponsiveStyleObject = {};
-                  for (const [bkeyName, bkeyValue] of Object.entries(processedStyle)) {
-                    if (typeof bkeyValue === 'object' && bkeyValue !== null) {
-                      resolvedResponsive[bkeyName] = {};
-                      for (const [styleKey, styleValue] of Object.entries(bkeyValue)) {
-                        const resolved = resolveStyleMapping(styleValue, context.props);
-                        if (resolved !== undefined) {
-                          resolvedResponsive[bkeyName]![styleKey] = resolved;
-                        } else if (typeof styleValue === 'string') {
-                          if (hasTemplates(styleValue)) {
-                            const evaluated = processCodeTemplates(styleValue, context.props);
-                            resolvedResponsive[bkeyName]![styleKey] = evaluated;
-                          } else {
-                            resolvedResponsive[bkeyName]![styleKey] = styleValue;
-                          }
-                        } else if (typeof styleValue === 'number') {
-                          resolvedResponsive[bkeyName]![styleKey] = styleValue;
-                        }
-                      }
-                    }
-                  }
-                  resolvedStyle = resolvedResponsive;
-                } else {
-                  // Preserve responsive styles for editor (same as SSR)
-                  // responsiveStylesToClasses will generate prefixed classes (t-, mob-)
-                  // CSS media queries will handle displaying the correct styles based on viewport
-                  const resolvedResponsive: ResponsiveStyleObject = {};
-                  for (const [bkeyName, bkeyValue] of Object.entries(processedStyle)) {
-                    if (typeof bkeyValue === 'object' && bkeyValue !== null) {
-                      resolvedResponsive[bkeyName] = {};
-                      for (const [styleKey, styleValue] of Object.entries(bkeyValue)) {
-                        const resolved = resolveStyleMapping(styleValue, context.props);
-                        if (resolved !== undefined) {
-                          resolvedResponsive[bkeyName]![styleKey] = resolved;
-                        } else if (typeof styleValue === 'string') {
-                          if (hasTemplates(styleValue)) {
-                            const evaluated = processCodeTemplates(styleValue, context.props);
-                            resolvedResponsive[bkeyName]![styleKey] = evaluated;
-                          } else {
-                            resolvedResponsive[bkeyName]![styleKey] = styleValue;
-                          }
-                        } else if (typeof styleValue === 'number') {
-                          resolvedResponsive[bkeyName]![styleKey] = styleValue;
-                        }
+                // Preserve responsive styles (for both SSR and editor)
+                // responsiveStylesToClasses will generate prefixed classes (t-, mob-)
+                // CSS media queries will handle displaying the correct styles based on viewport
+                const resolvedResponsive: ResponsiveStyleObject = {};
+                for (const [bkeyName, bkeyValue] of Object.entries(processedStyle)) {
+                  if (typeof bkeyValue === 'object' && bkeyValue !== null) {
+                    resolvedResponsive[bkeyName] = {};
+                    for (const [styleKey, styleValue] of Object.entries(bkeyValue)) {
+                      const processedValue = processStyleValue(styleValue, context.props);
+                      if (processedValue !== undefined) {
+                        resolvedResponsive[bkeyName]![styleKey] = processedValue;
                       }
                     }
                   }
-                  resolvedStyle = resolvedResponsive;
                 }
+                resolvedStyle = resolvedResponsive;
               } else {
                 // Legacy flat style object - resolve mappings and evaluate templates
                 resolvedStyle = {};
                 for (const [styleKey, styleValue] of Object.entries(processedStyle)) {
-                  // First resolve style mappings
-                  const resolved = resolveStyleMapping(styleValue, context.props);
-                  if (resolved !== undefined) {
-                    resolvedStyle[styleKey] = resolved;
-                  } else if (typeof styleValue === 'string') {
-                    // Evaluate template strings in style values (supports partial templates like "{{size}}px")
-                    // Use processCodeTemplates to handle templates with text before/after
-                    if (hasTemplates(styleValue)) {
-                      const evaluated = processCodeTemplates(styleValue, context.props);
-                      resolvedStyle[styleKey] = evaluated;
-                    } else {
-                      // No templates, keep original value
-                      resolvedStyle[styleKey] = styleValue;
-                    }
-                  } else if (typeof styleValue === 'number') {
-                    resolvedStyle[styleKey] = styleValue;
+                  const processedValue = processStyleValue(styleValue, context.props);
+                  if (processedValue !== undefined) {
+                    resolvedStyle[styleKey] = processedValue;
                   }
                 }
               }
@@ -712,10 +706,7 @@ export function processStructure(
             // Special handling for attributes - process templates but don't treat as node structure
             // This preserves type="checkbox" etc. which would otherwise be caught by node type handling
             const processedAttributes: Record<string, unknown> = {};
-            const evalContext: Record<string, unknown> = { ...getGlobalTemplateContext(), ...context.props };
-            if (context.componentDef && typeof context.componentDef === 'object') {
-              Object.assign(evalContext, context.componentDef as Record<string, unknown>);
-            }
+            const evalContext = buildEvalContext(context, false);
             for (const [attrKey, attrValue] of Object.entries(value)) {
               if (typeof attrValue === 'string' && hasTemplates(attrValue)) {
                 // Check if entire string is a complete template {{expr}} - preserve type (boolean, number)

package/lib/server/__integration__/api-routes.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Integration Tests: API Routes
+ * Tests core API endpoints through real HTTP requests
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { createTestServer, fetch, TEST_PAGE_JSON, TEST_COMPONENT_DEF } from './test-helpers';
+
+let ctx: Awaited<ReturnType<typeof createTestServer>>;
+
+beforeAll(async () => {
+  const components = new Map();
+  components.set('TestButton', TEST_COMPONENT_DEF);
+
+  ctx = await createTestServer({
+    pages: {
+      '/': TEST_PAGE_JSON,
+      '/about': JSON.stringify({
+        meta: { title: 'About', description: 'About page' },
+        root: { type: 'node', tag: 'div', children: 'About content' },
+      }, null, 2),
+    },
+    components,
+  });
+});
+
+afterAll(() => {
+  ctx?.cleanup();
+});
+
+describe('API Routes', () => {
+  // ========== Pages ==========
+
+  test('GET /api/pages returns page list', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/pages`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data.pages).toBeArray();
+    expect(data.pages.length).toBe(2);
+
+    const paths = data.pages.map((p: any) => p.path);
+    expect(paths).toContain('/');
+    expect(paths).toContain('/about');
+  });
+
+  test('GET /api/page-data/:path returns page JSON with line map', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/page-data/`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data.meta).toBeDefined();
+    expect(data.meta.title).toBe('Test Page');
+    expect(data.root).toBeDefined();
+    expect(data._lineMap).toBeDefined();
+  });
+
+  test('GET /api/page-data/nonexistent returns 404', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/page-data/nonexistent`);
+    expect(res.status).toBe(404);
+
+    const data = await res.json();
+    expect(data.error).toBeDefined();
+  });
+
+  // ========== Components ==========
+
+  test('GET /api/components returns component list', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/components`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(typeof data).toBe('object');
+    // Components loaded via mock loader - verify response structure
+    expect(data).toBeDefined();
+  });
+
+  test('GET /api/component-data/:name returns 404 for missing component', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/component-data/NonExistentComponent`);
+    expect(res.status).toBe(404);
+
+    const data = await res.json();
+    expect(data.error).toBeDefined();
+  });
+
+  // ========== Config ==========
+
+  test('GET /api/config returns project config', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/config`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    // Returns default config when no project.config.json exists
+    expect(data).toBeDefined();
+  });
+
+  // ========== Colors ==========
+
+  test('GET /api/colors returns color variables', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/colors`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data).toBeDefined();
+  });
+
+  // ========== Usage ==========
+
+  test('GET /api/usage returns usage stats', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/usage`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(typeof data.pages).toBe('number');
+    expect(typeof data.locales).toBe('number');
+    expect(typeof data.cmsCollections).toBe('number');
+  });
+
+  // ========== Slug Mappings ==========
+
+  test('GET /api/slug-mappings returns slug translations', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/slug-mappings`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data.mappings).toBeArray();
+  });
+
+  // ========== Response Headers ==========
+
+  test('API responses have JSON content-type', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/pages`);
+    const contentType = res.headers.get('Content-Type');
+    expect(contentType).toContain('application/json');
+  });
+
+  test('API responses have cache-control: no-store', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/pages`);
+    const cacheControl = res.headers.get('Cache-Control');
+    expect(cacheControl).toContain('no-store');
+  });
+
+  test('API responses include CORS headers', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/pages`);
+    const origin = res.headers.get('Access-Control-Allow-Origin');
+    expect(origin).toBeTruthy();
+  });
+});

package/lib/server/__integration__/cms-integration.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Integration Tests: CMS Integration
+ * Tests CMS CRUD flow and route matching through HTTP
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { createTestServer, fetch, createTempProject, TEST_CMS_TEMPLATE } from './test-helpers';
+import { FileSystemCMSProvider } from '../providers/fileSystemCMSProvider';
+import { CMSService } from '../services/cmsService';
+import { setProjectRoot } from '../projectContext';
+
+let ctx: Awaited<ReturnType<typeof createTestServer>>;
+let tempProject: ReturnType<typeof createTempProject>;
+let originalProjectRoot: string;
+
+beforeAll(async () => {
+  // Save original project root to restore later
+  const { getProjectRoot } = await import('../projectContext');
+  originalProjectRoot = getProjectRoot();
+
+  // Create temp project with CMS template and items
+  tempProject = createTempProject({
+    'pages/templates/posts.json': TEST_CMS_TEMPLATE,
+    'cms/posts/hello-world.json': JSON.stringify({
+      _id: 'hello-world',
+      title: 'Hello World',
+      slug: 'hello-world',
+      body: 'This is a blog post about hello world.',
+    }),
+    'cms/posts/second-post.json': JSON.stringify({
+      _id: 'second-post',
+      title: 'Second Post',
+      slug: 'second-post',
+      body: 'This is the second blog post.',
+    }),
+    'project.config.json': JSON.stringify({ siteUrl: 'https://example.com' }),
+  });
+
+  // Point project context to temp directory
+  setProjectRoot(tempProject.projectDir);
+
+  // Create CMS provider and service with real file system
+  const cmsProvider = new FileSystemCMSProvider(
+    `${tempProject.projectDir}/pages`,
+    `${tempProject.projectDir}/cms`
+  );
+  const cmsService = new CMSService(cmsProvider);
+  await cmsService.initialize();
+
+  ctx = await createTestServer({
+    pages: {},
+    cmsService,
+    cmsProvider,
+  });
+});
+
+afterAll(() => {
+  ctx?.cleanup();
+  tempProject?.cleanup();
+  // Restore original project root
+  setProjectRoot(originalProjectRoot);
+});
+
+describe('CMS Integration', () => {
+  // ========== Collections API ==========
+
+  test('GET /api/cms/collections returns collection list', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/cms/collections`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data.collections).toBeArray();
+    expect(data.collections.length).toBeGreaterThanOrEqual(1);
+
+    const postCollection = data.collections.find((c: any) => c.collection === 'posts');
+    expect(postCollection).toBeDefined();
+    expect(postCollection.urlPattern).toBe('/blog/{{slug}}');
+  });
+
+  test('GET /api/cms/collections/:id returns schema for specific collection', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/cms/collections/posts`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data.schema).toBeDefined();
+    expect(data.schema.fields).toBeDefined();
+    expect(data.schema.fields.title).toBeDefined();
+    expect(data.schema.fields.slug).toBeDefined();
+  });
+
+  // ========== Items API ==========
+
+  test('GET /api/cms/:collection returns item list', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/cms/posts`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data.items).toBeArray();
+    expect(data.items.length).toBe(2);
+    expect(data.total).toBe(2);
+
+    const titles = data.items.map((i: any) => i.title);
+    expect(titles).toContain('Hello World');
+    expect(titles).toContain('Second Post');
+  });
+
+  test('GET /api/cms/:collection?search=term returns filtered items', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/cms/posts?search=hello`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data.items.length).toBe(1);
+    expect(data.items[0].title).toBe('Hello World');
+  });
+
+  test('GET /api/cms/:collection/:slug returns single item', async () => {
+    const res = await fetch(`${ctx.baseUrl}/api/cms/posts/hello-world`);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data.item).toBeDefined();
+    expect(data.item.title).toBe('Hello World');
+    expect(data.item.slug).toBe('hello-world');
+  });
+
+  // ========== Client Data Endpoint ==========
+
+  test('GET /data/:collection/index.json returns items as JSON', async () => {
+    const res = await fetch(`${ctx.baseUrl}/data/posts/index.json`);
+    expect(res.status).toBe(200);
+
+    const contentType = res.headers.get('Content-Type');
+    expect(contentType).toContain('application/json');
+
+    const data = await res.json();
+    expect(data).toBeArray();
+    expect(data.length).toBe(2);
+  });
+
+  // ========== CMS Route Matching ==========
+
+  test('GET /blog/:slug renders CMS template with item data', async () => {
+    const res = await fetch(`${ctx.baseUrl}/blog/hello-world`);
+    expect(res.status).toBe(200);
+
+    const html = await res.text();
+    expect(html).toContain('<!DOCTYPE html>');
+    // The template interpolates {{cms.title}} and {{cms.body}}
+    expect(html).toContain('Hello World');
+    expect(html).toContain('hello world');
+  });
+
+  test('CMS page template interpolates {{cms.field}} values', async () => {
+    const res = await fetch(`${ctx.baseUrl}/blog/second-post`);
+    expect(res.status).toBe(200);
+
+    const html = await res.text();
+    expect(html).toContain('Second Post');
+    expect(html).toContain('second blog post');
+  });
+});

package/lib/server/__integration__/server-lifecycle.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Integration Tests: Server Lifecycle
+ * Tests server start, stop, port handling, and CORS
+ */
+
+import { describe, test, expect, afterAll } from 'bun:test';
+import { createTestServer, fetch, TEST_PAGE_JSON } from './test-helpers';
+
+// Track servers for cleanup
+const servers: Array<{ cleanup: () => void }> = [];
+afterAll(() => {
+  servers.forEach(s => s.cleanup());
+});
+
+describe('Server Lifecycle', () => {
+  test('starts on specified port and responds to requests', async () => {
+    const ctx = await createTestServer({
+      pages: { '/': TEST_PAGE_JSON },
+    });
+    servers.push(ctx);
+
+    const res = await fetch(`${ctx.baseUrl}/api/pages`);
+    expect(res.status).toBe(200);
+    expect(res.ok).toBe(true);
+  });
+
+  test('returns 404 for unknown file requests', async () => {
+    const ctx = await createTestServer({
+      pages: { '/': TEST_PAGE_JSON },
+    });
+    servers.push(ctx);
+
+    // Unknown file paths (with extension) return 404
+    const res = await fetch(`${ctx.baseUrl}/nonexistent.json`);
+    expect(res.status).toBe(404);
+  });
+
+  test('handles CORS preflight (OPTIONS) requests', async () => {
+    const ctx = await createTestServer();
+    servers.push(ctx);
+
+    const res = await fetch(`${ctx.baseUrl}/api/pages`, {
+      method: 'OPTIONS',
+    });
+    expect(res.status).toBe(204);
+    expect(res.headers.get('Access-Control-Allow-Origin')).toBeTruthy();
+    expect(res.headers.get('Access-Control-Allow-Methods')).toBeTruthy();
+  });
+
+  test('gracefully shuts down with server.stop()', async () => {
+    const ctx = await createTestServer({
+      pages: { '/': TEST_PAGE_JSON },
+    });
+
+    // Verify it's running
+    const res = await fetch(`${ctx.baseUrl}/api/pages`);
+    expect(res.status).toBe(200);
+
+    // Stop it
+    ctx.cleanup();
+
+    // After stop, fetch should fail
+    try {
+      await fetch(`${ctx.baseUrl}/api/pages`);
+      // If we reach here, the server is still up (shouldn't happen)
+      expect(false).toBe(true);
+    } catch (error) {
+      // Expected - connection refused
+      expect(error).toBeTruthy();
+    }
+  });
+
+  test('multiple servers can run in parallel on different ports', async () => {
+    const ctx1 = await createTestServer({
+      pages: { '/': TEST_PAGE_JSON },
+    });
+    servers.push(ctx1);
+
+    const ctx2 = await createTestServer({
+      pages: { '/about': TEST_PAGE_JSON },
+    });
+    servers.push(ctx2);
+
+    expect(ctx1.port).not.toBe(ctx2.port);
+
+    const [res1, res2] = await Promise.all([
+      fetch(`${ctx1.baseUrl}/api/pages`),
+      fetch(`${ctx2.baseUrl}/api/pages`),
+    ]);
+
+    expect(res1.status).toBe(200);
+    expect(res2.status).toBe(200);
+
+    const data1 = await res1.json();
+    const data2 = await res2.json();
+
+    // First server has '/' page, second has '/about'
+    expect(data1.pages.some((p: any) => p.path === '/')).toBe(true);
+    expect(data2.pages.some((p: any) => p.path === '/about')).toBe(true);
+  });
+});