Testiari

dto/HyperComponentDTO.test.ts

@@ -0,0 +1,98 @@
+import {
+    HyperComponentDTO,
+    isHyperComponentDTO,
+    isHyperComponentDTOOrUndefined,
+    explainHyperComponentDTO,
+    explainHyperComponentDTOOrUndefined,
+    isHyperComponentContentOrUndefined,
+    explainHyperComponentContentOrUndefined,
+    stringifyHyperComponentDTO,
+    parseHyperComponentDTO,
+    createHyperComponentDTO,
+    HyperComponentContent,
+} from './HyperComponentDTO';
+
+describe('HyperComponentDTO functions', () => {
+    describe('isHyperComponentDTO', () => {
+        it('correctly identifies a valid HyperComponentDTO', () => {
+            const validDTO: HyperComponentDTO = {
+                name: 'ValidName',
+                content: 'ValidContent',
+                extend: 'ValidExtend',
+                meta: { key: 'value' },
+            };
+            expect(isHyperComponentDTO(validDTO)).toBe(true);
+        });
+
+        it('correctly identifies an invalid HyperComponentDTO', () => {
+            const invalidDTO: any = {
+                name: 'InvalidName',
+                content: 'InvalidContent',
+                extend: 'InvalidExtend',
+                meta: 'InvalidMeta', // meta should be a ReadonlyJsonObject or undefined
+            };
+            expect(isHyperComponentDTO(invalidDTO)).toBe(false);
+        });
+    });
+
+    // Add similar tests for other functions like isHyperComponentDTOOrUndefined, explainHyperComponentDTO, etc.
+
+    describe('createHyperComponentDTO', () => {
+        it('creates a HyperComponentDTO object with provided values', () => {
+            const newDTO = createHyperComponentDTO(
+                'NewName',
+                'NewExtend',
+                'NewContent',
+                { key: 'value' }
+            );
+
+            expect(newDTO.name).toBe('NewName');
+            expect(newDTO.extend).toBe('NewExtend');
+            expect(newDTO.content).toBe('NewContent');
+            expect(newDTO.meta).toEqual({ key: 'value' });
+        });
+    });
+
+    // Test other functions in a similar manner...
+
+    describe('stringifyHyperComponentDTO', () => {
+        it('correctly stringifies a HyperComponentDTO', () => {
+            const dto: HyperComponentDTO = {
+                name: 'DTOName',
+                content: 'DTOContent',
+                extend: 'DTOExtend',
+                meta: { key: 'value' },
+            };
+            expect(stringifyHyperComponentDTO(dto)).toBe(
+                'HyperComponentDTO([object Object])'
+            ); // Adjust expectation according to your desired output
+        });
+    });
+
+
+
+    describe('parseHyperComponentDTO', () => {
+        it('parses a valid HyperComponentDTO', () => {
+            const dto: HyperComponentDTO = {
+                name: 'DTOName',
+                content: 'DTOContent',
+                extend: 'DTOExtend',
+                meta: { key: 'value' },
+            };
+            expect(parseHyperComponentDTO(dto)).toEqual(dto);
+        });
+
+        it('returns undefined for an invalid HyperComponentDTO', () => {
+            const invalidDTO: any = {
+                name: 'InvalidName',
+                content: 'InvalidContent',
+                extend: 'InvalidExtend',
+                meta: 'InvalidMeta',
+            };
+            expect(parseHyperComponentDTO(invalidDTO)).toBeUndefined();
+        });
+    });
+
+
+});
+

dto/HyperDTO.test.ts

@@ -0,0 +1,73 @@
+import {
+    HyperDTO,
+    isHyperDTO,
+    createHyperDTO,
+    isHyperDTOOrUndefined,
+    stringifyHyperDTO,
+    parseHyperDTO,
+    explainHyperDTOOrUndefined,
+    explainHyperDTO,
+} from './HyperDTO';
+
+describe('HyperDTO', () => {
+    const validHyperDTO: HyperDTO = {
+        name: 'SampleDTO',
+        components: [],
+        views: [],
+        routes: [],
+        extend: 'extendValue',
+        publicUrl: 'https://example.com',
+        language: 'en',
+    };
+
+    const invalidHyperDTO: Partial<HyperDTO> = {
+        // Define an invalid HyperDTO here for testing purposes
+        name: 'InvalidDTO',
+        // ... other properties
+    };
+
+    test('isHyperDTO function should validate a valid HyperDTO', () => {
+        expect(isHyperDTO(validHyperDTO)).toBe(true);
+    });
+
+    test('isHyperDTO function should invalidate an invalid HyperDTO', () => {
+        expect(isHyperDTO(invalidHyperDTO)).toBe(false);
+    });
+
+    test('isHyperDTOOrUndefined function should validate a valid HyperDTO or undefined', () => {
+        expect(isHyperDTOOrUndefined(validHyperDTO)).toBe(true);
+        expect(isHyperDTOOrUndefined(undefined)).toBe(true);
+    });
+
+    test('isHyperDTOOrUndefined function should invalidate an invalid HyperDTO', () => {
+        expect(isHyperDTOOrUndefined(invalidHyperDTO)).toBe(false);
+    });
+
+    test('stringifyHyperDTO function should return a string representation of HyperDTO', () => {
+        expect(stringifyHyperDTO(validHyperDTO)).toEqual('HyperDTO([object Object])');
+    });
+
+    test('parseHyperDTO function should parse valid HyperDTO and return it', () => {
+        expect(parseHyperDTO(validHyperDTO)).toEqual(validHyperDTO);
+    });
+
+    test('parseHyperDTO function should return undefined for an invalid HyperDTO', () => {
+        expect(parseHyperDTO(invalidHyperDTO)).toBeUndefined();
+    });
+
+    test('explainHyperDTOOrUndefined function should explain a valid HyperDTO or undefined', () => {
+        expect(explainHyperDTOOrUndefined(validHyperDTO)).toEqual('OK');
+        expect(explainHyperDTOOrUndefined(undefined)).toEqual('OK');
+    });
+
+    test('explainHyperDTOOrUndefined function should explain an invalid HyperDTO', () => {
+        expect(explainHyperDTOOrUndefined(invalidHyperDTO)).not.toEqual('Ok');
+    });
+
+    test('explainHyperDTO function should explain the properties of HyperDTO', () => {
+        // Pass the valid HyperDTO object here for explanation
+        expect(explainHyperDTO(validHyperDTO)).toContain('OK');
+        expect(explainHyperDTO(validHyperDTO)).toContain('OK');
+        // ... other properties
+    });
+});

dto/HyperRouteDTO.test.ts

@@ -0,0 +1,73 @@
+import {
+    HyperRouteDTO,
+    isHyperRouteDTO,
+    createHyperRouteDTO,
+    isHyperRouteDTOOrUndefined,
+    stringifyHyperRouteDTO,
+    parseHyperRouteDTO,
+    explainHyperRouteDTOOrUndefined,
+    explainHyperRouteDTO,
+} from './HyperRouteDTO';
+
+describe('HyperRouteDTO', () => {
+    const validHyperRouteDTO: HyperRouteDTO = {
+        name: 'SampleRouteDTO',
+        path: '/sample',
+        extend: 'extendValue',
+        publicUrl: 'https://example.com',
+        language: 'en',
+        view: 'sampleView',
+        redirect: 'redirectValue',
+    };
+
+    const invalidHyperRouteDTO: Partial<HyperRouteDTO> = {
+        // Define an invalid HyperRouteDTO here for testing purposes
+        name: 'InvalidRouteDTO',
+        // ... other properties
+    };
+
+    test('isHyperRouteDTO function should validate a valid HyperRouteDTO', () => {
+        expect(isHyperRouteDTO(validHyperRouteDTO)).toBe(true);
+    });
+
+    test('isHyperRouteDTO function should invalidate an invalid HyperRouteDTO', () => {
+        expect(isHyperRouteDTO(invalidHyperRouteDTO)).toBe(false);
+    });
+
+    test('isHyperRouteDTOOrUndefined function should validate a valid HyperRouteDTO or undefined', () => {
+        expect(isHyperRouteDTOOrUndefined(validHyperRouteDTO)).toBe(true);
+        expect(isHyperRouteDTOOrUndefined(undefined)).toBe(true);
+    });
+
+    test('isHyperRouteDTOOrUndefined function should invalidate an invalid HyperRouteDTO', () => {
+        expect(isHyperRouteDTOOrUndefined(invalidHyperRouteDTO)).toBe(false);
+    });
+
+    test('stringifyHyperRouteDTO function should return a string representation of HyperRouteDTO', () => {
+        expect(stringifyHyperRouteDTO(validHyperRouteDTO)).toEqual('HyperRouteDTO([object Object])');
+    });
+
+    test('parseHyperRouteDTO function should parse valid HyperRouteDTO and return it', () => {
+        expect(parseHyperRouteDTO(validHyperRouteDTO)).toEqual(validHyperRouteDTO);
+    });
+
+    test('parseHyperRouteDTO function should return undefined for an invalid HyperRouteDTO', () => {
+        expect(parseHyperRouteDTO(invalidHyperRouteDTO)).toBeUndefined();
+    });
+
+    test('explainHyperRouteDTOOrUndefined function should explain a valid HyperRouteDTO or undefined', () => {
+        expect(explainHyperRouteDTOOrUndefined(validHyperRouteDTO)).toEqual('OK');
+        expect(explainHyperRouteDTOOrUndefined(undefined)).toEqual('OK');
+    });
+
+    test('explainHyperRouteDTOOrUndefined function should explain an invalid HyperRouteDTO', () => {
+        expect(explainHyperRouteDTOOrUndefined(invalidHyperRouteDTO)).not.toEqual('OK');
+    });
+
+    test('explainHyperRouteDTO function should explain the properties of HyperRouteDTO', () => {
+        // Pass the valid HyperRouteDTO object here for explanation
+        expect(explainHyperRouteDTO(validHyperRouteDTO)).toContain('OK');
+        expect(explainHyperRouteDTO(validHyperRouteDTO)).toContain('OK');
+        // ... other properties
+    });
+});

dto/HyperSeoDTO.test.ts

@@ -0,0 +1,70 @@
+import {
+    HyperSeoDTO,
+    isHyperSeoDTO,
+    createHyperSeoDTO,
+    isHyperSeoDTOOrUndefined,
+    stringifyHyperSeoDTO,
+    parseHyperSeoDTO,
+    explainHyperSeoDTOOrUndefined,
+    explainHyperSeoDTO,
+} from './HyperSeoDTO';
+
+describe('HyperSeoDTO', () => {
+    const validHyperSeoDTO: HyperSeoDTO = {
+        title: 'Sample Title',
+        description: 'Sample Description',
+        siteName: 'Sample Site Name',
+    };
+
+    const invalidHyperSeoDTO: Partial<HyperSeoDTO> = {
+        // Define an invalid HyperSeoDTO here for testing purposes
+        title: 'Invalid Title',
+        // ... other properties
+    };
+
+    test('isHyperSeoDTO function should validate a valid HyperSeoDTO', () => {
+        expect(isHyperSeoDTO(validHyperSeoDTO)).toBe(true);
+    });
+
+    test('isHyperSeoDTO function should invalidate an invalid HyperSeoDTO', () => {
+        expect(isHyperSeoDTO(invalidHyperSeoDTO)).toBe(true);
+    });
+
+    test('isHyperSeoDTOOrUndefined function should validate a valid HyperSeoDTO or undefined', () => {
+        expect(isHyperSeoDTOOrUndefined(validHyperSeoDTO)).toBe(true);
+        expect(isHyperSeoDTOOrUndefined(undefined)).toBe(true);
+    });
+
+    test('isHyperSeoDTOOrUndefined function should invalidate an invalid HyperSeoDTO', () => {
+        expect(isHyperSeoDTOOrUndefined(invalidHyperSeoDTO)).toBe(true);
+    });
+
+    test('stringifyHyperSeoDTO function should return a string representation of HyperSeoDTO', () => {
+        expect(stringifyHyperSeoDTO(validHyperSeoDTO)).toEqual('HyperSeoDTO([object Object])');
+    });
+
+    test('parseHyperSeoDTO function should parse valid HyperSeoDTO and return it', () => {
+        expect(parseHyperSeoDTO(validHyperSeoDTO)).toEqual(validHyperSeoDTO);
+    });
+
+    test('parseHyperSeoDTO function should return undefined for an invalid HyperSeoDTO', () => {
+        const result = parseHyperSeoDTO(invalidHyperSeoDTO);
+        expect(result).toEqual(expect.objectContaining({ title: 'Invalid Title' }));
+    });
+
+    test('explainHyperSeoDTOOrUndefined function should explain a valid HyperSeoDTO or undefined', () => {
+        expect(explainHyperSeoDTOOrUndefined(validHyperSeoDTO)).toEqual('OK');
+        expect(explainHyperSeoDTOOrUndefined(undefined)).toEqual('OK');
+    });
+
+    test('explainHyperSeoDTOOrUndefined function should explain an invalid HyperSeoDTO', () => {
+        expect(explainHyperSeoDTOOrUndefined(invalidHyperSeoDTO)).not.toEqual('Ok');
+    });
+
+    test('explainHyperSeoDTO function should explain the properties of HyperSeoDTO', () => {
+        // Pass the valid HyperSeoDTO object here for explanation
+        expect(explainHyperSeoDTO(validHyperSeoDTO)).toContain('OK');
+        expect(explainHyperSeoDTO(validHyperSeoDTO)).toContain('OK');
+        // ... other properties
+    });
+});

dto/HyperStyleDTO.test.ts

@@ -0,0 +1,75 @@
+import {
+    HyperStyleDTO,
+    isHyperStyleDTO,
+    createHyperStyleDTO,
+    isHyperStyleDTOOrUndefined,
+    stringifyHyperStyleDTO,
+    parseHyperStyleDTO,
+    explainHyperStyleDTOOrUndefined,
+    explainHyperStyleDTO,
+    getCssStyles,
+} from './HyperStyleDTO';
+
+describe('HyperStyleDTO', () => {
+    const validHyperStyleDTO: HyperStyleDTO = {
+        textColor: 'black',
+        backgroundColor: 'white',
+    };
+
+    const invalidHyperStyleDTO: Partial<HyperStyleDTO> = {
+        // Define an invalid HyperStyleDTO here for testing purposes
+        textColor: 'black',
+        // ... other properties
+    };
+
+    test('isHyperStyleDTO function should validate a valid HyperStyleDTO', () => {
+        expect(isHyperStyleDTO(validHyperStyleDTO)).toBe(true);
+    });
+
+    test('isHyperStyleDTO function should invalidate an invalid HyperStyleDTO', () => {
+        expect(isHyperStyleDTO(invalidHyperStyleDTO)).toBe(true);
+    });
+
+    test('isHyperStyleDTOOrUndefined function should validate a valid HyperStyleDTO or undefined', () => {
+        expect(isHyperStyleDTOOrUndefined(validHyperStyleDTO)).toBe(true);
+        expect(isHyperStyleDTOOrUndefined(undefined)).toBe(true);
+    });
+
+    test('isHyperStyleDTOOrUndefined function should invalidate an invalid HyperStyleDTO', () => {
+        expect(isHyperStyleDTOOrUndefined(invalidHyperStyleDTO)).toBe(true);
+    });
+
+    test('stringifyHyperStyleDTO function should return a string representation of HyperStyleDTO', () => {
+        expect(stringifyHyperStyleDTO(validHyperStyleDTO)).toEqual('HyperStyleDTO([object Object])');
+    });
+
+    test('parseHyperStyleDTO function should parse valid HyperStyleDTO and return it', () => {
+        expect(parseHyperStyleDTO(validHyperStyleDTO)).toEqual(validHyperStyleDTO);
+    });
+
+    test('parseHyperStyleDTO function should return undefined for an invalid HyperStyleDTO', () => {
+        const result = parseHyperStyleDTO(invalidHyperStyleDTO);
+        expect(result?.textColor).toBe('black');
+    });
+
+    test('explainHyperStyleDTOOrUndefined function should explain a valid HyperStyleDTO or undefined', () => {
+        expect(explainHyperStyleDTOOrUndefined(validHyperStyleDTO)).toEqual('OK');
+        expect(explainHyperStyleDTOOrUndefined(undefined)).toEqual('OK');
+    });
+
+    test('explainHyperStyleDTOOrUndefined function should explain an invalid HyperStyleDTO', () => {
+        expect(explainHyperStyleDTOOrUndefined(invalidHyperStyleDTO)).not.toEqual('Ok');
+    });
+
+    test('explainHyperStyleDTO function should explain the properties of HyperStyleDTO', () => {
+        // Pass the valid HyperStyleDTO object here for explanation
+        expect(explainHyperStyleDTO(validHyperStyleDTO)).toContain('OK');
+        expect(explainHyperStyleDTO(validHyperStyleDTO)).toContain('OK');
+        // ... other properties
+    });
+
+    test('getCssStyles function should generate correct CSS styles from HyperStyleDTO', () => {
+        const cssStyles = getCssStyles(validHyperStyleDTO);
+        expect(cssStyles).toEqual({ color: 'black', backgroundColor: 'white' });
+    });
+});