@qwickapps/react-framework 1.3.4 → 1.4.0

package/src/__tests__/components/layout/GridLayout.serialization.test.tsx

@@ -0,0 +1,311 @@
+/**
+ * GridLayout Component Serialization Tests
+ * 
+ * Tests for the GridLayout component's ModelView implementation and 
+ * serialization capabilities using ComponentTransformer.
+ * 
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { ComponentTransformer } from '../../../schemas/transformers/ComponentTransformer';
+import { GridLayout } from '../../../components/layout/GridLayout';
+import { GridCell } from '../../../components/layout/GridCell';
+import { Text } from '../../../components/layout/../blocks/Text';
+import { Button } from '../../../components/layout/../buttons/Button';
+
+describe('GridLayout Serialization', () => {
+  beforeEach(() => {
+    // Clear component registry for clean tests
+    ComponentTransformer.clearRegistry();
+    
+    // Register all necessary components
+    ComponentTransformer.registerComponent(GridLayout as any);
+    ComponentTransformer.registerComponent(GridCell as any);
+    ComponentTransformer.registerComponent(Text as any);
+    ComponentTransformer.registerComponent(Button as any);
+  });
+
+  afterEach(() => {
+    ComponentTransformer.clearRegistry();
+  });
+
+  describe('Basic Serialization', () => {
+    it('should serialize and deserialize basic grid layout', () => {
+      // Create original component
+      const originalComponent = (
+        <GridLayout 
+          columns={3}
+          spacing="medium"
+          equalHeight={true}
+        >
+          <div>Column 1</div>
+          <div>Column 2</div>
+          <div>Column 3</div>
+        </GridLayout>
+      );
+
+      // Serialize
+      const serialized = ComponentTransformer.serialize(originalComponent);
+      expect(serialized).toBeTruthy();
+      expect(typeof serialized).toBe('string');
+
+      // Parse to check structure
+      const parsed = JSON.parse(serialized);
+      expect(parsed.tag).toBe('GridLayout');
+      expect(parsed.version).toBe('1.0.0');
+      expect(parsed.data.columns).toBe(3);
+      expect(parsed.data.spacing).toBe('medium');
+      expect(parsed.data.equalHeight).toBe(true);
+      
+      // Children should be serialized as JSON string
+      expect(typeof parsed.data.children).toBe('string');
+      const children = JSON.parse(parsed.data.children);
+      expect(Array.isArray(children)).toBe(true);
+      expect(children).toHaveLength(3);
+    });
+
+    it('should serialize empty grid layout', () => {
+      const originalComponent = (
+        <GridLayout columns={2} />
+      );
+
+      const serialized = ComponentTransformer.serialize(originalComponent);
+      const parsed = JSON.parse(serialized);
+      
+      expect(parsed.tag).toBe('GridLayout');
+      expect(parsed.data.columns).toBe(2);
+      expect(parsed.data.children).toBeUndefined();
+    });
+
+    it('should serialize grid layout with dimension props', () => {
+      const originalComponent = (
+        <GridLayout 
+          columns={2}
+          height="400px"
+          width="100%"
+          maxWidth="800px"
+          className="custom-grid"
+        >
+          <div>Content</div>
+        </GridLayout>
+      );
+
+      const serialized = ComponentTransformer.serialize(originalComponent);
+      const parsed = JSON.parse(serialized);
+      
+      expect(parsed.data.height).toBe('400px');
+      expect(parsed.data.width).toBe('100%');
+      expect(parsed.data.maxWidth).toBe('800px');
+      expect(parsed.data.className).toBe('custom-grid');
+    });
+  });
+
+  describe('Nested Component Serialization', () => {
+    it('should serialize grid with nested GridCell components', () => {
+      const originalComponent = (
+        <GridLayout columns={2} spacing="large">
+          <GridCell span={6}>
+            <Text content="First Cell" variant="h3" />
+          </GridCell>
+          <GridCell span={6}>
+            <Text content="Second Cell" variant="body1" />
+          </GridCell>
+        </GridLayout>
+      );
+
+      const serialized = ComponentTransformer.serialize(originalComponent);
+      const parsed = JSON.parse(serialized);
+      
+      expect(parsed.tag).toBe('GridLayout');
+      
+      // Children should be serialized as JSON string
+      expect(typeof parsed.data.children).toBe('string');
+      const children = JSON.parse(parsed.data.children);
+      expect(Array.isArray(children)).toBe(true);
+      expect(children).toHaveLength(2);
+      
+      // Check that nested GridCell components are serialized
+      const firstChild = children[0];
+      expect(typeof firstChild).toBe('object');
+      expect(firstChild.tag).toBe('GridCell');
+      expect(firstChild.data.span).toBe(6);
+      
+      // Check that Text components inside GridCell are serialized
+      expect(typeof firstChild.data.children).toBe('string');
+      const nestedText = JSON.parse(firstChild.data.children);
+      expect(nestedText.tag).toBe('Text');
+      expect(nestedText.data.content).toBe('First Cell');
+    });
+
+    it('should serialize grid with mixed nested components', () => {
+      const originalComponent = (
+        <GridLayout columns={3} spacing="medium">
+          <GridCell xs={12} sm={4}>
+            <Text content="Column 1" variant="h4" />
+          </GridCell>
+          <div>Regular div content</div>
+          <GridCell xs={12} sm={8}>
+            <Button label="Action Button" variant="primary" />
+          </GridCell>
+        </GridLayout>
+      );
+
+      const serialized = ComponentTransformer.serialize(originalComponent);
+      const parsed = JSON.parse(serialized);
+      
+      // Children should be serialized as JSON string
+      expect(typeof parsed.data.children).toBe('string');
+      const children = JSON.parse(parsed.data.children);
+      expect(Array.isArray(children)).toBe(true);
+      expect(children).toHaveLength(3);
+      
+      // First child is GridCell with Text
+      expect(children[0].tag).toBe('GridCell');
+      expect(children[0].data.xs).toBe(12);
+      expect(children[0].data.sm).toBe(4);
+      
+      // Second child is regular div (serialized as react node)
+      expect(typeof children[1]).toBe('object');
+      expect(children[1].tag).toBe('__react_node__');
+      
+      // Third child is GridCell with Button
+      expect(children[2].tag).toBe('GridCell');
+      const buttonChild = JSON.parse(children[2].data.children);
+      expect(buttonChild.tag).toBe('Button');
+      expect(buttonChild.data.label).toBe('Action Button');
+    });
+  });
+
+  describe('Deserialization', () => {
+    it('should deserialize back to working component', () => {
+      const originalComponent = (
+        <GridLayout columns={2} spacing="small" equalHeight={true}>
+          <GridCell span={8}>
+            <Text content="Main Content" />
+          </GridCell>
+          <GridCell span={4}>
+            <Text content="Sidebar" />
+          </GridCell>
+        </GridLayout>
+      );
+
+      // Serialize and deserialize
+      const serialized = ComponentTransformer.serialize(originalComponent);
+      const deserialized = ComponentTransformer.deserialize(serialized);
+
+      // Render both to compare
+      const { container: originalContainer } = render(originalComponent);
+      const { container: deserializedContainer } = render(deserialized);
+
+      // Check that both render successfully
+      expect(originalContainer.firstChild).toBeTruthy();
+      expect(deserializedContainer.firstChild).toBeTruthy();
+      
+      // Both should have grid container classes
+      const originalGrid = originalContainer.querySelector('.MuiGrid-container');
+      const deserializedGrid = deserializedContainer.querySelector('.MuiGrid-container');
+      expect(originalGrid).toBeTruthy();
+      expect(deserializedGrid).toBeTruthy();
+    });
+
+    it('should preserve all layout properties after round-trip serialization', () => {
+      const originalComponent = (
+        <GridLayout 
+          columns={4}
+          spacing="huge"
+          equalHeight={false}
+          height="300px"
+          minHeight="200px"
+          maxWidth="1200px"
+          className="test-grid"
+        >
+          <div>Test content</div>
+        </GridLayout>
+      );
+
+      // Double serialization to test round-trip
+      const serialized1 = ComponentTransformer.serialize(originalComponent);
+      const deserialized1 = ComponentTransformer.deserialize(serialized1);
+      const serialized2 = ComponentTransformer.serialize(deserialized1);
+      const parsed2 = JSON.parse(serialized2);
+
+      // Properties should be preserved
+      expect(parsed2.data.columns).toBe(4);
+      expect(parsed2.data.spacing).toBe('huge');
+      expect(parsed2.data.equalHeight).toBe(false);
+      expect(parsed2.data.height).toBe('300px');
+      expect(parsed2.data.minHeight).toBe('200px');
+      expect(parsed2.data.maxWidth).toBe('1200px');
+      expect(parsed2.data.className).toBe('test-grid');
+    });
+  });
+
+  describe('Performance', () => {
+    it('should serialize large grid efficiently', () => {
+      const gridItems = Array.from({ length: 50 }, (_, i) => (
+        <GridCell key={i} xs={12} sm={6} md={4} lg={3}>
+          <Text content={`Item ${i + 1}`} />
+        </GridCell>
+      ));
+
+      const largeGrid = (
+        <GridLayout columns={4} spacing="medium">
+          {gridItems}
+        </GridLayout>
+      );
+
+      const startTime = performance.now();
+      const serialized = ComponentTransformer.serialize(largeGrid);
+      const endTime = performance.now();
+
+      expect(serialized).toBeTruthy();
+      expect(endTime - startTime).toBeLessThan(100); // Should complete within 100ms
+      
+      const parsed = JSON.parse(serialized);
+      const children = JSON.parse(parsed.data.children);
+      expect(children).toHaveLength(50);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle grid with invalid children gracefully', () => {
+      const gridWithNullChild = (
+        <GridLayout columns={2}>
+          <div>Valid content</div>
+          {null}
+          <div>More valid content</div>
+        </GridLayout>
+      );
+
+      expect(() => {
+        const serialized = ComponentTransformer.serialize(gridWithNullChild);
+        const parsed = JSON.parse(serialized);
+        const children = JSON.parse(parsed.data.children);
+        expect(children).toHaveLength(3); // null becomes a child
+      }).not.toThrow();
+    });
+
+    it('should handle grid with complex nested structures', () => {
+      const complexGrid = (
+        <GridLayout columns={1}>
+          <GridCell>
+            <div>
+              <span>Complex</span>
+              <strong>Nested</strong>
+              <em>Structure</em>
+            </div>
+          </GridCell>
+        </GridLayout>
+      );
+
+      expect(() => {
+        const serialized = ComponentTransformer.serialize(complexGrid);
+        const deserialized = ComponentTransformer.deserialize(serialized);
+        render(deserialized);
+      }).not.toThrow();
+    });
+  });
+});

package/src/__tests__/hooks/usePrintMode.test.ts

@@ -0,0 +1,89 @@
+/**
+ * usePrintMode Hook Tests
+ * 
+ * Tests for print mode detection and management
+ */
+
+import { PrintConfigSchema } from '../../schemas/PrintConfigSchema';
+
+// Mock QwickApp context
+const mockUpdateConfig = jest.fn();
+jest.mock('../../contexts/QwickAppContext', () => ({
+  useQwickApp: () => ({
+    updateConfig: mockUpdateConfig,
+  }),
+}));
+
+describe('PrintConfig Integration', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should merge print configurations correctly', () => {
+    const baseConfig = PrintConfigSchema.createWithDefaults();
+    const overrideConfig = {
+      theme: 'dark' as const,
+      printTitle: 'Custom Title'
+    };
+    
+    const merged = { ...baseConfig, ...overrideConfig };
+    
+    expect(merged.theme).toBe('dark');
+    expect(merged.palette).toBe('default'); // Should retain base value
+    expect(merged.hideScaffolding).toBe(true); // Should retain base value
+    expect(merged.printTitle).toBe('Custom Title');
+  });
+
+  it('should validate print config properties', async () => {
+    const config = {
+      theme: 'light' as const,
+      palette: 'cosmic',
+      hideScaffolding: true,
+      optimizeForMonochrome: false,
+      printTitle: 'Test Document'
+    };
+    
+    const result = await PrintConfigSchema.validate(config);
+    expect(result.isValid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('should create proper default print configuration', () => {
+    const config = PrintConfigSchema.createWithDefaults();
+    
+    expect(config.theme).toBe('light');
+    expect(config.palette).toBe('default');
+    expect(config.hideScaffolding).toBe(true);
+    expect(config.hideInteractiveElements).toBe(false);
+    expect(config.optimizeForMonochrome).toBe(false);
+    expect(config.showPrintDate).toBe(true);
+  });
+
+  it('should support custom print configuration values', () => {
+    const customConfig = {
+      theme: 'dark' as const,
+      palette: 'ocean',
+      hideScaffolding: false,
+      optimizeForMonochrome: true,
+      printTitle: 'Custom Print Title',
+      printHeader: 'Custom Header',
+      printFooter: 'Custom Footer'
+    };
+    
+    const config = PrintConfigSchema.createWithDefaults(customConfig);
+    
+    expect(config.theme).toBe('dark');
+    expect(config.palette).toBe('ocean');
+    expect(config.hideScaffolding).toBe(false);
+    expect(config.optimizeForMonochrome).toBe(true);
+    expect(config.printTitle).toBe('Custom Print Title');
+    expect(config.printHeader).toBe('Custom Header');
+    expect(config.printFooter).toBe('Custom Footer');
+  });
+
+  it('should export PrintModeState interface from usePrintMode', () => {
+    // This test ensures the types are properly exported
+    const { usePrintMode } = require('../../hooks/usePrintMode');
+    expect(typeof usePrintMode).toBe('function');
+  });
+});

package/src/__tests__/schemas/PageTemplateSchema.test.ts

@@ -0,0 +1,161 @@
+/**
+ * PageTemplate Schema Tests
+ * 
+ * Tests for PageTemplateSchema functionality and validation
+ */
+
+import { PageTemplateSchema } from '../../schemas/PageTemplateSchema';
+import { PrintConfigSchema } from '../../schemas/PrintConfigSchema';
+
+describe('PageTemplateSchema', () => {
+  it('should create a valid PageTemplateSchema instance', () => {
+    const pageTemplate = new PageTemplateSchema();
+    expect(pageTemplate).toBeInstanceOf(PageTemplateSchema);
+  });
+
+  it('should have correct schema metadata', () => {
+    const schema = PageTemplateSchema.getSchema();
+    expect(schema.name).toBe('PageTemplate');
+    expect(schema.version).toBe('1.0.0');
+  });
+
+  it('should inherit from ViewModel properties', async () => {
+    const data = {
+      className: 'page-template',
+      id: 'test-page',
+      'aria-label': 'Test Page Template'
+    };
+    
+    const result = await PageTemplateSchema.validate(data);
+    expect(result.isValid).toBe(true);
+    
+    const pageTemplate = PageTemplateSchema.createWithDefaults(data);
+    expect(pageTemplate.className).toBe('page-template');
+    expect(pageTemplate.id).toBe('test-page');
+    expect(pageTemplate['aria-label']).toBe('Test Page Template');
+  });
+
+  it('should validate page-specific properties correctly', async () => {
+    const data = {
+      slug: 'about-us',
+      name: 'About Us',
+      description: 'Learn more about our company',
+      title: 'About Us | Company Name',
+      metaKeywords: 'about, company, information',
+      metaAuthor: 'Web Team',
+      canonicalUrl: 'https://example.com/about-us',
+      children: '<div>Page content here</div>',
+      layout: 'default',
+      icon: 'info',
+      requiresAuth: false,
+      requiredRoles: 'user',
+      showInNavigation: true,
+      navigationPriority: 1,
+      indexable: true
+    };
+    
+    const result = await PageTemplateSchema.validate(data);
+    expect(result.isValid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('should create instance with page data correctly', () => {
+    const data = {
+      slug: 'contact',
+      name: 'Contact Us',
+      description: 'Get in touch with us',
+      title: 'Contact | Company',
+      layout: 'fullwidth',
+      showInNavigation: true,
+      navigationPriority: 5
+    };
+    
+    const pageTemplate = PageTemplateSchema.createWithDefaults(data);
+    expect(pageTemplate.slug).toBe('contact');
+    expect(pageTemplate.name).toBe('Contact Us');
+    expect(pageTemplate.description).toBe('Get in touch with us');
+    expect(pageTemplate.title).toBe('Contact | Company');
+    expect(pageTemplate.layout).toBe('fullwidth');
+    expect(pageTemplate.showInNavigation).toBe(true);
+    expect(pageTemplate.navigationPriority).toBe(5);
+  });
+
+  it('should handle print configuration integration', () => {
+    const printConfig = PrintConfigSchema.createWithDefaults({
+      theme: 'dark',
+      palette: 'ocean',
+      hideScaffolding: false,
+      printTitle: 'Page Print Title'
+    });
+    
+    const pageData = {
+      name: 'Test Page',
+      slug: 'test-page',
+      printConfig: printConfig
+    };
+    
+    const pageTemplate = PageTemplateSchema.createWithDefaults(pageData);
+    expect(pageTemplate.name).toBe('Test Page');
+    expect(pageTemplate.slug).toBe('test-page');
+    expect(pageTemplate.printConfig).toBeDefined();
+    expect(pageTemplate.printConfig?.theme).toBe('dark');
+    expect(pageTemplate.printConfig?.palette).toBe('ocean');
+    expect(pageTemplate.printConfig?.hideScaffolding).toBe(false);
+    expect(pageTemplate.printConfig?.printTitle).toBe('Page Print Title');
+  });
+
+  it('should handle boolean default values correctly', () => {
+    const pageTemplate = PageTemplateSchema.createWithDefaults();
+    
+    // These are the default values as specified in the schema
+    expect(pageTemplate.requiresAuth).toBe(false); // @Field({ defaultValue: false })
+    expect(pageTemplate.showInNavigation).toBe(true); // @Field({ defaultValue: true })
+    expect(pageTemplate.navigationPriority).toBe(0); // @Field({ defaultValue: 0 })
+    expect(pageTemplate.indexable).toBe(true); // @Field({ defaultValue: true })
+  });
+
+  it('should support comprehensive page metadata', async () => {
+    const comprehensiveData = {
+      slug: 'comprehensive-page',
+      name: 'Comprehensive Test Page',
+      description: 'A page with all possible metadata',
+      title: 'Complete Page | Site',
+      metaKeywords: 'test, comprehensive, page, metadata',
+      metaAuthor: 'Test Author',
+      canonicalUrl: 'https://example.com/comprehensive',
+      children: '<h1>Welcome</h1><p>This is a comprehensive test page.</p>',
+      layout: 'sidebar',
+      icon: 'star',
+      requiresAuth: true,
+      requiredRoles: 'admin,moderator',
+      showInNavigation: false,
+      navigationPriority: 10,
+      indexable: false,
+      className: 'comprehensive-page',
+      id: 'comp-page',
+      hidden: false
+    };
+    
+    const result = await PageTemplateSchema.validate(comprehensiveData);
+    expect(result.isValid).toBe(true);
+    
+    const pageTemplate = PageTemplateSchema.createWithDefaults(comprehensiveData);
+    expect(pageTemplate.slug).toBe('comprehensive-page');
+    expect(pageTemplate.name).toBe('Comprehensive Test Page');
+    expect(pageTemplate.description).toBe('A page with all possible metadata');
+    expect(pageTemplate.title).toBe('Complete Page | Site');
+    expect(pageTemplate.metaKeywords).toBe('test, comprehensive, page, metadata');
+    expect(pageTemplate.metaAuthor).toBe('Test Author');
+    expect(pageTemplate.canonicalUrl).toBe('https://example.com/comprehensive');
+    expect(pageTemplate.layout).toBe('sidebar');
+    expect(pageTemplate.icon).toBe('star');
+    expect(pageTemplate.requiresAuth).toBe(true);
+    expect(pageTemplate.requiredRoles).toBe('admin,moderator');
+    expect(pageTemplate.showInNavigation).toBe(false);
+    expect(pageTemplate.navigationPriority).toBe(10);
+    expect(pageTemplate.indexable).toBe(false);
+    expect(pageTemplate.className).toBe('comprehensive-page');
+    expect(pageTemplate.id).toBe('comp-page');
+    expect(pageTemplate.hidden).toBe(false);
+  });
+});

package/src/__tests__/schemas/PrintConfigSchema.test.ts

@@ -0,0 +1,127 @@
+/**
+ * PrintConfig Schema Tests
+ * 
+ * Tests for PrintConfigSchema functionality and validation
+ */
+
+import { PrintConfigSchema } from '../../schemas/PrintConfigSchema';
+
+describe('PrintConfigSchema', () => {
+  it('should create a valid PrintConfigSchema instance', () => {
+    const printConfig = new PrintConfigSchema();
+    expect(printConfig).toBeInstanceOf(PrintConfigSchema);
+  });
+
+  it('should have correct schema metadata', () => {
+    const schema = PrintConfigSchema.getSchema();
+    expect(schema.name).toBe('PrintConfig');
+    expect(schema.version).toBe('1.0.0');
+  });
+
+  it('should have proper default values', () => {
+    const printConfig = PrintConfigSchema.createWithDefaults();
+    expect(printConfig.theme).toBe('light');
+    expect(printConfig.palette).toBe('default');
+    expect(printConfig.hideScaffolding).toBe(true);
+    expect(printConfig.hideInteractiveElements).toBe(false);
+    expect(printConfig.optimizeForMonochrome).toBe(false);
+    expect(printConfig.showPrintDate).toBe(true);
+  });
+
+  it('should validate theme values correctly', async () => {
+    const lightData = { theme: 'light' as const };
+    const darkData = { theme: 'dark' as const };
+    
+    const lightResult = await PrintConfigSchema.validate(lightData);
+    const darkResult = await PrintConfigSchema.validate(darkData);
+    
+    expect(lightResult.isValid).toBe(true);
+    expect(darkResult.isValid).toBe(true);
+  });
+
+  it('should validate boolean properties correctly', async () => {
+    const data = {
+      hideScaffolding: false,
+      hideInteractiveElements: true,
+      optimizeForMonochrome: true,
+      showPrintDate: false
+    };
+    
+    const result = await PrintConfigSchema.validate(data);
+    expect(result.isValid).toBe(true);
+    
+    const printConfig = PrintConfigSchema.createWithDefaults(data);
+    expect(printConfig.hideScaffolding).toBe(false);
+    expect(printConfig.hideInteractiveElements).toBe(true);
+    expect(printConfig.optimizeForMonochrome).toBe(true);
+    expect(printConfig.showPrintDate).toBe(false);
+  });
+
+  it('should handle optional string properties', async () => {
+    const data = {
+      printTitle: 'Custom Print Title',
+      printHeader: 'Custom Header',
+      printFooter: 'Custom Footer',
+      palette: 'ocean'
+    };
+    
+    const result = await PrintConfigSchema.validate(data);
+    expect(result.isValid).toBe(true);
+    
+    const printConfig = PrintConfigSchema.createWithDefaults(data);
+    expect(printConfig.printTitle).toBe('Custom Print Title');
+    expect(printConfig.printHeader).toBe('Custom Header');
+    expect(printConfig.printFooter).toBe('Custom Footer');
+    expect(printConfig.palette).toBe('ocean');
+  });
+
+  it('should create instance with data correctly', () => {
+    const data = {
+      theme: 'dark' as const,
+      palette: 'cosmic',
+      printTitle: 'Test Document',
+      hideScaffolding: false
+    };
+    
+    const printConfig = PrintConfigSchema.createWithDefaults(data);
+    expect(printConfig.theme).toBe('dark');
+    expect(printConfig.palette).toBe('cosmic');
+    expect(printConfig.printTitle).toBe('Test Document');
+    expect(printConfig.hideScaffolding).toBe(false);
+  });
+
+  it('should restore from JSON correctly', () => {
+    const jsonData = {
+      theme: 'dark' as const,
+      palette: 'winter',
+      hideScaffolding: false,
+      optimizeForMonochrome: true,
+      printTitle: 'Restored Document',
+      printHeader: 'Restored Header'
+    };
+    
+    const printConfig = PrintConfigSchema.createWithDefaults(jsonData);
+    expect(printConfig.theme).toBe('dark');
+    expect(printConfig.palette).toBe('winter');
+    expect(printConfig.hideScaffolding).toBe(false);
+    expect(printConfig.optimizeForMonochrome).toBe(true);
+    expect(printConfig.printTitle).toBe('Restored Document');
+    expect(printConfig.printHeader).toBe('Restored Header');
+  });
+
+  it('should merge configurations correctly', () => {
+    const baseConfig = new PrintConfigSchema();
+    baseConfig.theme = 'light';
+    baseConfig.palette = 'default';
+    
+    const overrideData = {
+      theme: 'dark',
+      printTitle: 'Override Title'
+    };
+    
+    const merged = { ...baseConfig, ...overrideData };
+    expect(merged.theme).toBe('dark');
+    expect(merged.palette).toBe('default'); // Should retain base value
+    expect(merged.printTitle).toBe('Override Title');
+  });
+});