@wise/dynamic-flow-client 3.5.0-experimental-b041af5 → 3.5.0-experimental-63c768d

package/build/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/repeatableSchema/utils/summary-utils.spec.js

@@ -0,0 +1,909 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { getItemSummaryFromSchema } from './summary-utils';
+describe('getItemSummaryFromSchema', function () {
+    describe('titles', function () {
+        var defaultTitle = 'default title';
+        describe('const schemas', function () {
+            var constSchema = {
+                "const": 'const'
+            };
+            var constSchemaWithTitle = __assign(__assign({}, constSchema), { summary: {
+                    providesTitle: true
+                } });
+            var constSchemaWithTitleProp = __assign(__assign({}, constSchemaWithTitle), { title: 'title' });
+            it('should return the default if the schema does not provide a title', function () {
+                expect(getItemSummaryFromSchema(constSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+                expect(getItemSummaryFromSchema(constSchema, 'const', { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the const if the schema provides a title', function () {
+                expect(getItemSummaryFromSchema(constSchemaWithTitle, null, { defaultTitle: defaultTitle }).title).toBe('const');
+                expect(getItemSummaryFromSchema(constSchemaWithTitle, 'const', { defaultTitle: defaultTitle }).title).toBe('const');
+            });
+            it('should prefer the title prop over the const value', function () {
+                expect(getItemSummaryFromSchema(constSchemaWithTitleProp, 'const', { defaultTitle: defaultTitle }).title).toBe('title');
+            });
+        });
+        describe('basic schemas', function () {
+            var basicSchema = {
+                type: 'string',
+                title: 'basic schema'
+            };
+            var basicSchemaWithTitle = __assign(__assign({}, basicSchema), { summary: {
+                    providesTitle: true
+                } });
+            it('should return the default if the schema does not provide a title', function () {
+                expect(getItemSummaryFromSchema(basicSchema, 'value', { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+                expect(getItemSummaryFromSchema(basicSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the default if the schema provides a title but the model is null', function () {
+                expect(getItemSummaryFromSchema(basicSchemaWithTitle, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the model if the schema provides a title and the model is valued', function () {
+                expect(getItemSummaryFromSchema(basicSchemaWithTitle, 'value', { defaultTitle: defaultTitle }).title).toBe('value');
+            });
+        });
+        describe('object schemas', function () {
+            var objectSchema = {
+                type: 'object',
+                displayOrder: ['name'],
+                properties: {
+                    name: {
+                        title: 'Name',
+                        type: 'string'
+                    }
+                }
+            };
+            var objectSchemaWithTitle = __assign(__assign({}, objectSchema), { summary: {
+                    providesTitle: true
+                } });
+            var objectSchemaWithTitleInChild = {
+                type: 'object',
+                displayOrder: ['age', 'name'],
+                properties: {
+                    name: {
+                        title: 'Name',
+                        type: 'string',
+                        summary: {
+                            providesTitle: true
+                        }
+                    },
+                    age: {
+                        title: 'Age',
+                        type: 'string'
+                    }
+                }
+            };
+            it('should return the default if the schema does not provide a title', function () {
+                expect(getItemSummaryFromSchema(objectSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+                expect(getItemSummaryFromSchema(objectSchema, { name: 'name' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the default if schema provides a title but the model is not a string', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithTitle, { name: 'name' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the default if a child schema provides a title but the model is null', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithTitleInChild, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the model if a child schema provides a title and the model is valued', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithTitleInChild, { name: 'name' }, { defaultTitle: defaultTitle })
+                    .title).toBe('name');
+            });
+        });
+        describe('oneOf schemas', function () {
+            var oneOfSchema = {
+                oneOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            var oneOfSchemaWithTitle = __assign(__assign({}, oneOfSchema), { summary: {
+                    providesTitle: true
+                } });
+            var oneOfSchemaWithTitleOnChildSchema = {
+                oneOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string',
+                                summary: {
+                                    providesTitle: true
+                                }
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            it('should return the default if the schema does not provide a title', function () {
+                expect(getItemSummaryFromSchema(oneOfSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the default if the schema does not provide a title, even if the model is valued', function () {
+                expect(getItemSummaryFromSchema(oneOfSchema, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the default if a child schema provides a title but the model is null', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithTitleOnChildSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the model if a child schema provides a title and the model is valued', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithTitleOnChildSchema, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe('iban');
+            });
+            it('should return the default if schema provides a title but the model is not a string', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithTitle, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+        });
+        describe('allOf schemas', function () {
+            var allOfSchema = {
+                allOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            var allOfSchemaWithTitle = __assign(__assign({}, allOfSchema), { summary: {
+                    providesTitle: true
+                } });
+            var allOfSchemaWithTitleOnChild = {
+                allOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string',
+                                summary: {
+                                    providesTitle: true
+                                }
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            it('should return the default if the schema does not provide a title', function () {
+                expect(getItemSummaryFromSchema(allOfSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+                expect(getItemSummaryFromSchema(allOfSchema, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the default if schema provides a title but the model is not a string', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithTitle, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the default if a child schema provides a title but the model is null', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithTitleOnChild, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
+            });
+            it('should return the model if a child schema provides a title and the model is valued', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithTitleOnChild, { iban: 'iban' }, { defaultTitle: defaultTitle })
+                    .title).toBe('iban');
+            });
+        });
+    });
+    describe('descriptions', function () {
+        var defaultDescription = 'default description';
+        describe('const schemas', function () {
+            var constSchema = {
+                "const": 'const'
+            };
+            var constSchemaWithDescription = __assign(__assign({}, constSchema), { summary: {
+                    providesDescription: true
+                } });
+            var constSchemaWithDescriptionProp = __assign(__assign({}, constSchemaWithDescription), { title: 'title' });
+            it('should return the default if the schema does not provide a description', function () {
+                expect(getItemSummaryFromSchema(constSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+                expect(getItemSummaryFromSchema(constSchema, 'const', { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+            });
+            it('should return the const if the schema provides a description', function () {
+                expect(getItemSummaryFromSchema(constSchemaWithDescription, null, { defaultDescription: defaultDescription })
+                    .description).toBe('const');
+                expect(getItemSummaryFromSchema(constSchemaWithDescription, 'const', { defaultDescription: defaultDescription })
+                    .description).toBe('const');
+            });
+            it('should prefer the title prop over the const value', function () {
+                expect(getItemSummaryFromSchema(constSchemaWithDescriptionProp, 'const', { defaultDescription: defaultDescription })
+                    .description).toBe('title');
+            });
+        });
+        describe('basic schemas', function () {
+            var basicSchema = {
+                type: 'string',
+                title: 'basic schema'
+            };
+            var basicSchemaWithDescription = __assign(__assign({}, basicSchema), { summary: {
+                    providesDescription: true
+                } });
+            it('should return the default if the schema does not provide a description', function () {
+                expect(getItemSummaryFromSchema(basicSchema, 'value', { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+                expect(getItemSummaryFromSchema(basicSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+            });
+            it('should return the default if the schema provides a description but the model is null', function () {
+                expect(getItemSummaryFromSchema(basicSchemaWithDescription, null, { defaultDescription: defaultDescription })
+                    .description).toBe(defaultDescription);
+            });
+            it('should return the model if the schema provides a description and the model is valued', function () {
+                expect(getItemSummaryFromSchema(basicSchemaWithDescription, 'value', { defaultDescription: defaultDescription })
+                    .description).toBe('value');
+            });
+        });
+        describe('object schemas', function () {
+            var objectSchema = {
+                type: 'object',
+                displayOrder: ['name'],
+                properties: {
+                    name: {
+                        title: 'Name',
+                        type: 'string'
+                    }
+                }
+            };
+            var objectSchemaWithDescription = __assign(__assign({}, objectSchema), { summary: {
+                    providesDescription: true
+                } });
+            var objectSchemaWithDescriptionInChild = {
+                type: 'object',
+                displayOrder: ['age', 'name'],
+                properties: {
+                    name: {
+                        title: 'Name',
+                        type: 'string',
+                        summary: {
+                            providesDescription: true
+                        }
+                    },
+                    age: {
+                        title: 'Age',
+                        type: 'string'
+                    }
+                }
+            };
+            it('should return the default if the schema does not provide a description', function () {
+                expect(getItemSummaryFromSchema(objectSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+                expect(getItemSummaryFromSchema(objectSchema, { name: 'name' }, { defaultDescription: defaultDescription })
+                    .description).toBe(defaultDescription);
+            });
+            it('should return the default if schema provides a description but the model is not a string', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithDescription, { name: 'name' }, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+            });
+            it('should return the default if a child schema provides a description but the model is null', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithDescriptionInChild, null, { defaultDescription: defaultDescription })
+                    .description).toBe(defaultDescription);
+            });
+            it('should return the model if a child schema provides a description and the model is valued', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithDescriptionInChild, { name: 'name' })
+                    .description).toBe('name');
+            });
+        });
+        describe('oneOf schemas', function () {
+            var oneOfSchema = {
+                oneOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            var oneOfSchemaWithDescription = __assign(__assign({}, oneOfSchema), { summary: {
+                    providesDescription: true
+                } });
+            var oneOfSchemaWithDescriptionOnChildSchema = {
+                oneOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string',
+                                summary: {
+                                    providesDescription: true
+                                }
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            it('should return the default if the schema does not provide a description', function () {
+                expect(getItemSummaryFromSchema(oneOfSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+            });
+            it('should return the default if the schema does not provide a description, even if the model is valued', function () {
+                expect(getItemSummaryFromSchema(oneOfSchema, { iban: 'iban' }, { defaultDescription: defaultDescription })
+                    .description).toBe(defaultDescription);
+            });
+            it('should return the default if a child schema provides a description but the model is null', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithDescriptionOnChildSchema, null, {
+                    defaultDescription: defaultDescription
+                }).description).toBe(defaultDescription);
+            });
+            it('should return the model if a child schema provides a description and the model is valued', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithDescriptionOnChildSchema, {
+                    iban: 'iban'
+                }, { defaultDescription: defaultDescription }).description).toBe('iban');
+            });
+            it('should return the default if schema provides a description but the model is not a string', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithDescription, { iban: 'iban' }, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+            });
+        });
+        describe('allOf schemas', function () {
+            var allOfSchema = {
+                allOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            var allOfSchemaWithDescription = __assign(__assign({}, allOfSchema), { summary: {
+                    providesDescription: true
+                } });
+            var allOfSchemaWithDescriptionOnChild = {
+                allOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string',
+                                summary: {
+                                    providesDescription: true
+                                }
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            it('should return the default if the schema does not provide a description', function () {
+                expect(getItemSummaryFromSchema(allOfSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+                expect(getItemSummaryFromSchema(allOfSchema, { iban: 'iban' }, { defaultDescription: defaultDescription })
+                    .description).toBe(defaultDescription);
+            });
+            it('should return the default if schema provides a description but the model is not a string', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithDescription, { iban: 'iban' }, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
+            });
+            it('should return the default if a child schema provides a description but the model is null', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithDescriptionOnChild, null, { defaultDescription: defaultDescription })
+                    .description).toBe(defaultDescription);
+            });
+            it('should return the model if a child schema provides a description and the model is valued', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithDescriptionOnChild, { iban: 'iban' }, { defaultDescription: defaultDescription }).description).toBe('iban');
+            });
+        });
+    });
+    describe('icons', function () {
+        var icon = {
+            name: 'plus'
+        };
+        var defaultIcon = {
+            name: 'default'
+        };
+        describe('const schemas', function () {
+            var constSchema = {
+                "const": 'const'
+            };
+            var constSchemaWithIcon = __assign(__assign({}, constSchema), { icon: icon, summary: {
+                    providesIcon: true
+                } });
+            it('should return the default if the schema does not provide an icon', function () {
+                expect(getItemSummaryFromSchema(constSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+            });
+            it('should return icon if the schema provides an icon', function () {
+                expect(getItemSummaryFromSchema(constSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
+                expect(getItemSummaryFromSchema(constSchemaWithIcon, 'const', { defaultIcon: defaultIcon }).icon).toBe(icon);
+            });
+        });
+        describe('basic schemas', function () {
+            var basicSchema = {
+                type: 'string',
+                title: 'basic schema'
+            };
+            var basicSchemaWithIcon = __assign(__assign({}, basicSchema), { icon: icon, summary: {
+                    providesIcon: true
+                } });
+            it('should return the default if the schema does not provide an icon', function () {
+                expect(getItemSummaryFromSchema(basicSchema, 'value', { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+                expect(getItemSummaryFromSchema(basicSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+            });
+            it('should return icon if the schema provides an icon', function () {
+                expect(getItemSummaryFromSchema(basicSchemaWithIcon, 'value', { defaultIcon: defaultIcon }).icon).toBe(icon);
+                expect(getItemSummaryFromSchema(basicSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
+            });
+        });
+        describe('object schemas', function () {
+            var objectSchema = {
+                type: 'object',
+                displayOrder: ['name'],
+                properties: {
+                    name: {
+                        title: 'Name',
+                        type: 'string'
+                    }
+                }
+            };
+            var objectSchemaWithIcon = __assign(__assign({}, objectSchema), { icon: icon, summary: {
+                    providesIcon: true
+                } });
+            var objectSchemaWithIconInChild = {
+                type: 'object',
+                displayOrder: ['age', 'name'],
+                properties: {
+                    name: {
+                        title: 'Name',
+                        type: 'string',
+                        icon: icon,
+                        summary: {
+                            providesIcon: true
+                        }
+                    },
+                    age: {
+                        title: 'Age',
+                        type: 'string'
+                    }
+                }
+            };
+            it('should return the default if the schema does not provide an icon', function () {
+                expect(getItemSummaryFromSchema(objectSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+                expect(getItemSummaryFromSchema(objectSchema, { name: 'name' }, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+            });
+            it('should return icon if schema provides an icon', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithIcon, { name: 'name' }, { defaultIcon: defaultIcon }).icon).toBe(icon);
+                expect(getItemSummaryFromSchema(objectSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
+            });
+            it('should return icon if a child schema provides an icon', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithIconInChild, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
+                expect(getItemSummaryFromSchema(objectSchemaWithIconInChild, { name: 'name' }, { defaultIcon: defaultIcon })
+                    .icon).toBe(icon);
+            });
+        });
+        describe('oneOf schemas', function () {
+            var oneOfSchema = {
+                oneOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            var oneOfSchemaWithIcon = __assign(__assign({}, oneOfSchema), { icon: icon, summary: {
+                    providesIcon: true
+                } });
+            var oneOfSchemaWithIconOnChildSchema = {
+                oneOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string',
+                                icon: icon,
+                                summary: {
+                                    providesIcon: true
+                                }
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            it('should return the default if the schema does not provide an icon', function () {
+                expect(getItemSummaryFromSchema(oneOfSchema, { iban: 'iban' }, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+                expect(getItemSummaryFromSchema(oneOfSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+            });
+            it('should return icon schema provides an icon', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
+            });
+            it('should return icon if active child schema provides an icon', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithIconOnChildSchema, {
+                    iban: 'iban'
+                }, { defaultIcon: defaultIcon }).icon).toBe(icon);
+            });
+            it('should return the default if non-active child schema provides an icon', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithIconOnChildSchema, {
+                    accountNumber: 'accountNumber'
+                }, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+            });
+        });
+        describe('allOf schemas', function () {
+            var allOfSchema = {
+                allOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            var allOfSchemaWithIcon = __assign(__assign({}, allOfSchema), { icon: icon, summary: {
+                    providesIcon: true
+                } });
+            var allOfSchemaWithIconOnChild = {
+                allOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string',
+                                icon: icon,
+                                summary: {
+                                    providesIcon: true
+                                }
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            it('should return the default if the schema does not provide an icon', function () {
+                expect(getItemSummaryFromSchema(allOfSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+                expect(getItemSummaryFromSchema(allOfSchema, { iban: 'iban' }, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
+            });
+            it('should icon if schema provides an icon', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
+            });
+            it('should return icon if a child schema provides an icon', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithIconOnChild, { iban: 'iban' }, { defaultIcon: defaultIcon })
+                    .icon).toBe(icon);
+            });
+        });
+    });
+    describe('images', function () {
+        var image = {
+            url: '/cat.jpg'
+        };
+        var defaultImage = {
+            url: '/default.jpg'
+        };
+        describe('const schemas', function () {
+            var constSchema = {
+                "const": 'const'
+            };
+            var constSchemaWithImage = __assign(__assign({}, constSchema), { image: image, summary: {
+                    providesImage: true
+                } });
+            it('should return the default if the schema does not provide an image', function () {
+                expect(getItemSummaryFromSchema(constSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
+            });
+            it('should return image if the schema provides an image', function () {
+                expect(getItemSummaryFromSchema(constSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
+                expect(getItemSummaryFromSchema(constSchemaWithImage, 'const', { defaultImage: defaultImage }).image).toBe(image);
+            });
+        });
+        describe('basic schemas', function () {
+            var basicSchema = {
+                type: 'string',
+                title: 'basic schema'
+            };
+            var basicSchemaWithImage = __assign(__assign({}, basicSchema), { image: image, summary: {
+                    providesImage: true
+                } });
+            it('should return the default if the schema does not provide an image', function () {
+                expect(getItemSummaryFromSchema(basicSchema, 'value', { defaultImage: defaultImage }).image).toBe(defaultImage);
+                expect(getItemSummaryFromSchema(basicSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
+            });
+            it('should return image if the schema provides an image', function () {
+                expect(getItemSummaryFromSchema(basicSchemaWithImage, 'value', { defaultImage: defaultImage }).image).toBe(image);
+                expect(getItemSummaryFromSchema(basicSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
+            });
+        });
+        describe('object schemas', function () {
+            var objectSchema = {
+                type: 'object',
+                displayOrder: ['name'],
+                properties: {
+                    name: {
+                        title: 'Name',
+                        type: 'string'
+                    }
+                }
+            };
+            var objectSchemaWithImage = __assign(__assign({}, objectSchema), { image: image, summary: {
+                    providesImage: true
+                } });
+            var objectSchemaWithImageInChild = {
+                type: 'object',
+                displayOrder: ['age', 'name'],
+                properties: {
+                    name: {
+                        title: 'Name',
+                        type: 'string',
+                        image: image,
+                        summary: {
+                            providesImage: true
+                        }
+                    },
+                    age: {
+                        title: 'Age',
+                        type: 'string'
+                    }
+                }
+            };
+            it('should return the default if the schema does not provide an image', function () {
+                expect(getItemSummaryFromSchema(objectSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
+                expect(getItemSummaryFromSchema(objectSchema, { name: 'name' }, { defaultImage: defaultImage }).image).toBe(defaultImage);
+            });
+            it('should return image if schema provides an image', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithImage, { name: 'name' }, { defaultImage: defaultImage }).image).toBe(image);
+                expect(getItemSummaryFromSchema(objectSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
+            });
+            it('should return image if a child schema provides an image', function () {
+                expect(getItemSummaryFromSchema(objectSchemaWithImageInChild, null, { defaultImage: defaultImage }).image).toBe(image);
+                expect(getItemSummaryFromSchema(objectSchemaWithImageInChild, { name: 'name' }, { defaultImage: defaultImage })
+                    .image).toBe(image);
+            });
+        });
+        describe('oneOf schemas', function () {
+            var oneOfSchema = {
+                oneOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            var oneOfSchemaWithImage = __assign(__assign({}, oneOfSchema), { image: image, summary: {
+                    providesImage: true
+                } });
+            var oneOfSchemaWithImageOnChildSchema = {
+                oneOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string',
+                                image: image,
+                                summary: {
+                                    providesImage: true
+                                }
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            it('should return the default if the schema does not provide an image', function () {
+                expect(getItemSummaryFromSchema(oneOfSchema, { iban: 'iban' }, { defaultImage: defaultImage }).image).toBe(defaultImage);
+                expect(getItemSummaryFromSchema(oneOfSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
+            });
+            it('should return image schema provides an image', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
+            });
+            it('should return image if active child schema provides an image', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithImageOnChildSchema, {
+                    iban: 'iban'
+                }, { defaultImage: defaultImage }).image).toBe(image);
+            });
+            it('should return the default if non-active child schema provides an image', function () {
+                expect(getItemSummaryFromSchema(oneOfSchemaWithImageOnChildSchema, {
+                    accountNumber: 'accountNumber'
+                }, { defaultImage: defaultImage }).image).toBe(defaultImage);
+            });
+        });
+        describe('allOf schemas', function () {
+            var allOfSchema = {
+                allOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            var allOfSchemaWithImage = __assign(__assign({}, allOfSchema), { image: image, summary: {
+                    providesImage: true
+                } });
+            var allOfSchemaWithImageOnChild = {
+                allOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            accountNumber: {
+                                type: 'string'
+                            }
+                        },
+                        displayOrder: ['accountNumber']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            iban: {
+                                type: 'string',
+                                image: image,
+                                summary: {
+                                    providesImage: true
+                                }
+                            }
+                        },
+                        displayOrder: ['iban']
+                    },
+                ]
+            };
+            it('should return the default if the schema does not provide an image', function () {
+                expect(getItemSummaryFromSchema(allOfSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
+                expect(getItemSummaryFromSchema(allOfSchema, { iban: 'iban' }, { defaultImage: defaultImage }).image).toBe(defaultImage);
+            });
+            it('should image if schema provides an image', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
+            });
+            it('should return image if a child schema provides an image', function () {
+                expect(getItemSummaryFromSchema(allOfSchemaWithImageOnChild, { iban: 'iban' }, { defaultImage: defaultImage })
+                    .image).toBe(image);
+            });
+        });
+    });
+});