meno-core 1.0.0

package/lib/server/ssrRenderer.test.ts

@@ -0,0 +1,1005 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { 
+  generateSSRHTML,
+  renderPageSSR,
+  extractPageMeta,
+  generateMetaTags
+} from "./ssrRenderer";
+import type { ComponentNode, ComponentDefinition, JSONPage } from "../shared/types";
+
+// Mock jsonLoader
+const mockLoadBreakpointConfig = async () => ({
+  tablet: 1024,
+  mobile: 540
+});
+
+// Mock the jsonLoader module
+const originalJsonLoader = await import("./jsonLoader");
+if (originalJsonLoader) {
+  // We'll need to test with actual imports, but can provide mocks where needed
+}
+
+describe("SSR Renderer - extractPageMeta", () => {
+  test("should extract basic meta information", () => {
+    const pageData: JSONPage = {
+      meta: {
+        title: "Test Page",
+        description: "Test description",
+        keywords: "test, page"
+      }
+    };
+    
+    const meta = extractPageMeta(pageData);
+    
+    expect(meta.title).toBe("Test Page");
+    expect(meta.description).toBe("Test description");
+    expect(meta.keywords).toBe("test, page");
+  });
+
+  test("should extract Open Graph meta", () => {
+    const pageData: JSONPage = {
+      meta: {
+        title: "Test Page",
+        ogTitle: "OG Title",
+        ogDescription: "OG Description",
+        ogImage: "https://example.com/image.jpg",
+        ogType: "article"
+      }
+    };
+    
+    const meta = extractPageMeta(pageData);
+    
+    expect(meta.ogTitle).toBe("OG Title");
+    expect(meta.ogDescription).toBe("OG Description");
+    expect(meta.ogImage).toBe("https://example.com/image.jpg");
+    expect(meta.ogType).toBe("article");
+  });
+
+  test("should use title as fallback for ogTitle", () => {
+    const pageData: JSONPage = {
+      meta: {
+        title: "Test Page"
+      }
+    };
+    
+    const meta = extractPageMeta(pageData);
+    
+    expect(meta.ogTitle).toBe("Test Page");
+  });
+
+  test("should use description as fallback for ogDescription", () => {
+    const pageData: JSONPage = {
+      meta: {
+        description: "Test description"
+      }
+    };
+    
+    const meta = extractPageMeta(pageData);
+    
+    expect(meta.ogDescription).toBe("Test description");
+  });
+
+  test("should default ogType to 'website'", () => {
+    const pageData: JSONPage = {
+      meta: {}
+    };
+    
+    const meta = extractPageMeta(pageData);
+    
+    expect(meta.ogType).toBe("website");
+  });
+
+  test("should handle missing meta object", () => {
+    const pageData: JSONPage = {};
+    
+    const meta = extractPageMeta(pageData);
+    
+    expect(Object.keys(meta).length).toBe(0);
+  });
+});
+
+describe("SSR Renderer - generateMetaTags", () => {
+  test("should generate title tag", () => {
+    const meta = {
+      title: "Test Page"
+    };
+    
+    const tags = generateMetaTags(meta);
+    
+    expect(tags).toContain("<title>Test Page</title>");
+  });
+
+  test("should generate description meta tag", () => {
+    const meta = {
+      description: "Test description"
+    };
+    
+    const tags = generateMetaTags(meta);
+    
+    expect(tags).toContain(`<meta name="description" content="Test description" />`);
+  });
+
+  test("should generate keywords meta tag", () => {
+    const meta = {
+      keywords: "test, keywords"
+    };
+    
+    const tags = generateMetaTags(meta);
+    
+    expect(tags).toContain(`<meta name="keywords" content="test, keywords" />`);
+  });
+
+  test("should generate Open Graph tags", () => {
+    const meta = {
+      ogTitle: "OG Title",
+      ogDescription: "OG Description",
+      ogImage: "https://example.com/image.jpg",
+      ogType: "article"
+    };
+    
+    const tags = generateMetaTags(meta);
+    
+    expect(tags).toContain(`<meta property="og:title" content="OG Title" />`);
+    expect(tags).toContain(`<meta property="og:description" content="OG Description" />`);
+    expect(tags).toContain(`<meta property="og:image" content="https://example.com/image.jpg" />`);
+    expect(tags).toContain(`<meta property="og:type" content="article" />`);
+  });
+
+  test("should generate canonical URL", () => {
+    const meta = {};
+    const url = "https://example.com/page";
+    
+    const tags = generateMetaTags(meta, url);
+    
+    expect(tags).toContain(`<link rel="canonical" href="https://example.com/page" />`);
+    expect(tags).toContain(`<meta property="og:url" content="https://example.com/page" />`);
+  });
+
+  test("should escape HTML in meta content", () => {
+    const meta = {
+      title: "Test & Page",
+      description: "Test <description>"
+    };
+    
+    const tags = generateMetaTags(meta);
+    
+    expect(tags).toContain("<title>Test &amp; Page</title>");
+    expect(tags).toContain(`content="Test &lt;description&gt;"`);
+  });
+
+  test("should handle empty meta", () => {
+    const meta = {};
+    
+    const tags = generateMetaTags(meta);
+    
+    expect(tags).toBe("");
+  });
+});
+
+describe("SSR Renderer - renderPageSSR", () => {
+  describe("HTML generation", () => {
+    test("should render simple div element", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: ["Hello World"]
+        }
+      };
+      
+      const result = await renderPageSSR(pageData);
+      
+      expect(result.html).toContain("<div");
+      expect(result.html).toContain("Hello World");
+      expect(result.html).toContain("</div>");
+    });
+
+    test("should render nested component structures", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: [
+            {
+              type: "node",
+          tag: "div",
+              children: [
+                {
+                  type: "node",
+              tag: "span",
+                  children: ["Nested"]
+                }
+              ]
+            }
+          ]
+        }
+      };
+      
+      const result = await renderPageSSR(pageData);
+      
+      expect(result.html).toContain("<div");
+      expect(result.html).toContain("<span");
+      expect(result.html).toContain("Nested");
+    });
+
+    test("should render children arrays", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: [
+            { type: "node", tag: "p", children: ["First"] },
+            { type: "node", tag: "p", children: ["Second"] }
+          ]
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.html).toContain("First");
+      expect(result.html).toContain("Second");
+    });
+
+    test("should render string children", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "p",
+          children: ["Simple text"]
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.html).toContain("Simple text");
+    });
+
+    test("should render number children", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "span",
+          children: [42]
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.html).toContain("42");
+    });
+
+    test("should escape HTML in text content", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: ["<script>alert('xss')</script>"]
+        }
+      };
+      
+      const result = await renderPageSSR(pageData);
+      
+      expect(result.html).toContain("&lt;script&gt;");
+      expect(result.html).not.toContain("<script>");
+    });
+
+    test("should render anchor tag", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "a",
+          children: ["Go to About"]
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.html).toContain(`<a`);
+      expect(result.html).toContain("Go to About");
+      expect(result.html).toContain("</a>");
+    });
+  });
+
+  describe("CSS generation", () => {
+    test("should generate CSS for responsive styles", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          style: {
+            base: {
+              fontSize: "16px",
+              color: "red"
+            },
+            tablet: {
+              fontSize: "14px"
+            },
+            mobile: {
+              fontSize: "12px"
+            }
+          }
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      // SSR renders HTML with styles (may be inline or via classes)
+      expect(result.html).toBeDefined();
+      expect(result.html).toContain("<div");
+    });
+
+    test("should generate CSS class names for responsive styles", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          style: {
+            base: {
+              color: "red"
+            }
+          }
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      // HTML should be generated with styles
+      expect(result.html).toBeDefined();
+      expect(result.html).toContain("<div");
+    });
+
+    test("should handle empty responsive styles", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          style: {
+            base: {},
+            tablet: {},
+            mobile: {}
+          }
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      // Should still render HTML
+      expect(result.html).toContain("<div");
+      // componentCSS might be empty or minimal
+      expect(result.componentCSS).toBeDefined();
+    });
+  });
+
+  describe("Component rendering", () => {
+    test("should render Button component (from Button.json)", async () => {
+      const buttonComponent: ComponentDefinition = {
+        type: "Button",
+        component: {
+          interface: {
+            variant: {
+              type: "select",
+              default: "primary"
+            },
+            children: {
+              type: "slot",
+              default: "Click me"
+            }
+          },
+          structure: {
+            type: "node",
+            tag: "button",
+            style: {
+              base: {
+                background: {
+                  _mapping: true,
+                  prop: "variant",
+                  values: {
+                    primary: "blue",
+                    secondary: "gray"
+                  }
+                } as any,
+                color: "white"
+              }
+            },
+            children: "{{children}}"
+          }
+        }
+      };
+      
+      const pageData: JSONPage = {
+        root: {
+          type: "component",
+          component: "Button",
+          props: {
+            variant: "primary"
+          },
+          children: ["Custom Button"]
+        }
+      };
+
+      const globalComponents = {
+        Button: buttonComponent
+      };
+
+      const result = await renderPageSSR(pageData, globalComponents);
+
+      // Should render button element
+      expect(result.html).toContain("<button");
+      // Should render children
+      expect(result.html).toContain("Custom Button");
+    });
+
+    test("should render BasicCard component with template evaluation", async () => {
+      const cardComponent: ComponentDefinition = {
+        type: "BasicCard",
+        component: {
+          interface: {
+            title: {
+              type: "string",
+              default: "Card Title"
+            }
+          },
+          structure: {
+            type: "node",
+            tag: "div",
+            children: [
+              {
+                type: "node",
+                tag: "h3",
+                children: ["{{title}}"]
+              }
+            ]
+          }
+        }
+      };
+      
+      const pageData: JSONPage = {
+        root: {
+          type: "component",
+          component: "BasicCard",
+          props: {
+            title: "My Card"
+          }
+        }
+      };
+
+      const globalComponents = {
+        BasicCard: cardComponent
+      };
+
+      const result = await renderPageSSR(pageData, globalComponents);
+
+      expect(result.html).toContain("<div");
+      expect(result.html).toContain("<h3");
+      expect(result.html).toContain("My Card");
+    });
+  });
+
+  describe("Template evaluation in SSR", () => {
+    test("should evaluate template expressions in structure", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: ["Hello {{name}}"]
+        }
+      };
+      
+      // Note: This test may need adjustment based on actual template evaluation in SSR
+      const result = await renderPageSSR(pageData);
+      
+      // Template should be evaluated or passed through
+      expect(result.html).toBeDefined();
+    });
+
+    test("should handle style mappings in component structures", async () => {
+      const buttonComponent: ComponentDefinition = {
+        type: "Button",
+        component: {
+          interface: {
+            variant: {
+              type: "select",
+              default: "primary"
+            }
+          },
+          structure: {
+            type: "node",
+            tag: "button",
+            style: {
+              base: {
+                background: {
+                  _mapping: true,
+                  prop: "variant",
+                  values: {
+                    primary: "blue",
+                    secondary: "gray"
+                  }
+                } as any
+              }
+            }
+          }
+        }
+      };
+      
+      const pageData: JSONPage = {
+        root: {
+          type: "component",
+          component: "Button",
+          props: {
+            variant: "primary"
+          }
+        }
+      };
+
+      const globalComponents = {
+        Button: buttonComponent
+      };
+
+      const result = await renderPageSSR(pageData, globalComponents);
+
+      // Should resolve style mapping based on variant prop
+      expect(result.html).toBeDefined();
+      // CSS should include resolved background color or inline style
+      expect(result.html.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Error handling", () => {
+    test("should handle missing root node", async () => {
+      const pageData: JSONPage = {};
+
+      // Implementation throws error for missing root
+      await expect(renderPageSSR(pageData)).rejects.toThrow('Page data must have a root node');
+    });
+
+    test("should handle null root node", async () => {
+      const pageData: JSONPage = {
+        root: null as any
+      };
+
+      // Implementation throws error for null root
+      await expect(renderPageSSR(pageData)).rejects.toThrow('Page data must have a root node');
+    });
+
+    test("should handle component with missing structure", async () => {
+      const invalidComponent: ComponentDefinition = {
+        type: "Invalid",
+        component: {} as any
+      };
+      
+      const pageData: JSONPage = {
+        root: {
+          type: "Invalid"
+        }
+      };
+      
+      const globalComponents = {
+        Invalid: invalidComponent
+      };
+      
+      // Should not throw, but return empty HTML for invalid component
+      const result = await renderPageSSR(pageData, globalComponents);
+      
+      expect(result.html).toBe("");
+    });
+
+    test("should handle malformed JSON structures gracefully", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: [
+            null as any,
+            undefined as any
+          ]
+        }
+      };
+      
+      const result = await renderPageSSR(pageData);
+      
+      // Should skip null/undefined children
+      expect(result.html).toBeDefined();
+      expect(result.html).toContain("<div");
+    });
+  });
+
+  describe("Meta information in SSR", () => {
+    test("should extract and return meta information", async () => {
+      const pageData: JSONPage = {
+        meta: {
+          title: "Test Page",
+          description: "Test description"
+        },
+        root: {
+          type: "node",
+          tag: "div",
+          children: ["Content"]
+        }
+      };
+      
+      const result = await renderPageSSR(pageData);
+      
+      expect(result.title).toBe("Test Page");
+      expect(result.meta).toContain("Test Page");
+      expect(result.meta).toContain("Test description");
+    });
+
+    test("should use default title when meta not provided", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div"
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.title).toBe("UPLO");
+    });
+  });
+});
+
+describe("SSR Renderer - Security (XSS Prevention)", () => {
+  describe("Text content sanitization", () => {
+    test("should escape script tags in text content", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: ["<script>alert('xss')</script>"]
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.html).toContain("&lt;script&gt;");
+      expect(result.html).not.toContain("<script>alert");
+    });
+
+    test("should escape event handlers in text content", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: ['<img onerror="alert(1)" src="x">']
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.html).not.toContain('onerror="alert');
+      expect(result.html).toContain("&lt;img");
+    });
+
+    test("should escape javascript: URLs in text content", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: ['<a href="javascript:alert(1)">click</a>']
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.html).not.toContain('href="javascript:');
+      expect(result.html).toContain("&lt;a");
+    });
+
+    test("should escape HTML entities in text content", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "p",
+          children: ['Test & <special> "quotes" \'apostrophe\'']
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.html).toContain("&amp;");
+      expect(result.html).toContain("&lt;special&gt;");
+      expect(result.html).toContain("&quot;quotes&quot;");
+    });
+
+    test("should escape nested malicious content", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: [
+            {
+              type: "node",
+              tag: "p",
+              children: ["<script>document.cookie</script>"]
+            }
+          ]
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      expect(result.html).not.toContain("<script>document");
+      expect(result.html).toContain("&lt;script&gt;");
+    });
+  });
+
+  describe("Meta tag sanitization", () => {
+    test("should escape HTML in page title", () => {
+      const meta = {
+        title: "Test <script>alert('xss')</script> Page"
+      };
+
+      const tags = generateMetaTags(meta);
+
+      expect(tags).toContain("<title>Test &lt;script&gt;");
+      expect(tags).not.toContain("<script>alert");
+    });
+
+    test("should escape HTML in meta description", () => {
+      const meta = {
+        description: 'Description with "quotes" and <tags>'
+      };
+
+      const tags = generateMetaTags(meta);
+
+      expect(tags).toContain("&quot;quotes&quot;");
+      expect(tags).toContain("&lt;tags&gt;");
+    });
+
+    test("should escape HTML in Open Graph tags", () => {
+      const meta = {
+        ogTitle: "<script>alert('og')</script>",
+        ogDescription: "Description <img src=x onerror=alert(1)>"
+      };
+
+      const tags = generateMetaTags(meta);
+
+      // Script tags should be escaped
+      expect(tags).not.toContain("<script>alert");
+      expect(tags).toContain("&lt;script&gt;");
+      // IMG tag should be escaped, preventing onerror from executing
+      expect(tags).not.toContain("<img src=x");
+      expect(tags).toContain("&lt;img");
+    });
+  });
+
+  describe("Attribute sanitization", () => {
+    test("should not allow malicious attributes through style", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          style: {
+            base: {
+              // Attempting to inject via style properties
+              color: 'red; background-image: url("javascript:alert(1)")'
+            }
+          }
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      // Style should be processed safely via utility classes
+      expect(result.html).toBeDefined();
+      expect(result.html).toContain("<div");
+    });
+
+    test("should handle unicode escape sequences safely", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "node",
+          tag: "div",
+          children: ["\u003cscript\u003ealert('unicode')\u003c/script\u003e"]
+        }
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      // Unicode-encoded script tags should still be escaped
+      expect(result.html).not.toContain("<script>alert");
+    });
+  });
+
+  describe("Component prop sanitization", () => {
+    test("should sanitize component props with HTML content", async () => {
+      const cardComponent: ComponentDefinition = {
+        type: "Card",
+        component: {
+          interface: {
+            title: { type: "string", default: "" }
+          },
+          structure: {
+            type: "node",
+            tag: "div",
+            children: [
+              {
+                type: "node",
+                tag: "h3",
+                children: ["{{title}}"]
+              }
+            ]
+          }
+        }
+      };
+
+      const pageData: JSONPage = {
+        root: {
+          type: "component",
+          component: "Card",
+          props: {
+            title: "<script>alert('props')</script>"
+          }
+        }
+      };
+
+      const globalComponents = {
+        Card: cardComponent
+      };
+
+      const result = await renderPageSSR(pageData, globalComponents);
+
+      // Script tags should be escaped when rendering
+      expect(result.html).not.toContain("<script>alert");
+    });
+  });
+
+  describe("Image sanitization", () => {
+    test("should escape src attribute in image nodes", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "image",
+          tag: "img",
+          src: 'javascript:alert("img")',
+          alt: "test"
+        } as any
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      // Implementation should handle this safely
+      expect(result.html).toBeDefined();
+    });
+
+    test("should escape alt attribute in image nodes", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "image",
+          tag: "img",
+          src: "/test.jpg",
+          alt: '"><script>alert("alt")</script><img x="'
+        } as any
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      // Alt should be escaped
+      expect(result.html).not.toContain('<script>alert("alt")');
+    });
+  });
+
+  describe("Embed content sanitization", () => {
+    test("should sanitize embed HTML with DOMPurify", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "embed",
+          tag: "div",
+          html: '<div onclick="alert(1)"><script>alert(2)</script><p>safe</p></div>'
+        } as any
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      // onclick should be stripped
+      expect(result.html).not.toContain('onclick="alert');
+      // script tags should be stripped
+      expect(result.html).not.toContain('<script>alert');
+      // Safe content should remain
+      expect(result.html).toContain("safe");
+    });
+
+    test("should allow safe SVG in embeds", async () => {
+      const pageData: JSONPage = {
+        root: {
+          type: "embed",
+          tag: "div",
+          html: '<svg viewBox="0 0 24 24"><circle cx="12" cy="12" r="10" fill="red"/></svg>'
+        } as any
+      };
+
+      const result = await renderPageSSR(pageData);
+
+      // Safe SVG should be preserved
+      expect(result.html).toContain("<svg");
+      expect(result.html).toContain("<circle");
+    });
+  });
+});
+
+describe("SSR Renderer - generateSSRHTML", () => {
+  test("should generate complete HTML document", async () => {
+    const pageData: JSONPage = {
+      meta: {
+        title: "Test Page"
+      },
+      root: {
+              type: "node",
+              tag: "div",
+        children: ["Hello World"]
+      }
+    };
+    
+    const html = await generateSSRHTML(pageData, {}, "/", "");
+    
+    expect(html).toContain("<!DOCTYPE html>");
+    expect(html).toContain("<html");
+    expect(html).toContain("<head");
+    expect(html).toContain("<body");
+    expect(html).toContain('<div id="root">');
+    expect(html).toContain("Hello World");
+    expect(html).toContain("Test Page");
+  });
+
+  test("should include CSS in style tag", async () => {
+    const pageData: JSONPage = {
+      root: {
+        type: "node",
+        tag: "div",
+        style: {
+          base: {
+            color: "red"
+          }
+        }
+      }
+    };
+
+    const html = await generateSSRHTML(pageData);
+
+    // HTML should be generated with styles (either inline or in style tag)
+    expect(html).toContain("<div");
+    expect(html).toBeDefined();
+  });
+
+  test("should include client script", async () => {
+    const pageData: JSONPage = {
+      root: {
+        type: "node",
+        tag: "div"
+      }
+    };
+
+    const html = await generateSSRHTML(pageData, {}, "/", "", false);
+
+    expect(html).toContain('src="/client-router.tsx"');
+  });
+
+  test("should use built bundle when specified", async () => {
+    const pageData: JSONPage = {
+      root: {
+        type: "node",
+        tag: "div"
+      }
+    };
+
+    const html = await generateSSRHTML(pageData, {}, "/", "", true);
+
+    // When useBuiltBundle is true, implementation generates static HTML without client script
+    expect(html).toBeDefined();
+    expect(html).toContain("<div");
+  });
+
+  test("should include viewport meta tag", async () => {
+    const pageData: JSONPage = {
+      root: {
+        type: "node",
+        tag: "div"
+      }
+    };
+
+    const html = await generateSSRHTML(pageData);
+
+    expect(html).toContain('name="viewport"');
+    expect(html).toContain('content="width=device-width, initial-scale=1.0"');
+  });
+});