@takeshape/schema 11.72.0 → 11.74.1

package/dist/util/__tests__/merge.test.js

@@ -1,1074 +0,0 @@
-import set from 'lodash/fp/set.js';
-import unset from 'lodash/fp/unset.js';
-import { describe, expect, test } from 'vitest';
-import { createMockSchema } from "../../mocks.js";
-import { createShape } from "../../schema-util.js";
-import { mergeDeepObjectSchemas, mergeFormConfigs, mergeObjectSchemas, mergeProjectSchemas } from "../merge.js";
-describe('mergeObjectSchemas', () => {
-    test('it works', () => {
-        const original = {
-            type: 'object',
-            properties: {
-                a: { type: 'string' },
-                b: { type: 'string' }
-            },
-            required: ['a', 'b']
-        };
-        const override = {
-            type: 'object',
-            properties: {
-                c: { type: 'string' }
-            },
-            required: ['c']
-        };
-        expect(mergeObjectSchemas(original, override)).toEqual({
-            type: 'object',
-            properties: {
-                a: { type: 'string' },
-                b: { type: 'string' },
-                c: { type: 'string' }
-            },
-            required: ['a', 'b', 'c']
-        });
-    });
-    test('overrides', () => {
-        const original = {
-            type: 'object',
-            properties: {
-                a: { type: 'string' },
-                b: { type: 'string' }
-            },
-            required: ['a', 'b']
-        };
-        const override = {
-            type: 'object',
-            properties: {
-                b: { type: 'integer' }
-            }
-        };
-        expect(mergeObjectSchemas(original, override)).toEqual({
-            type: 'object',
-            properties: {
-                a: { type: 'string' },
-                b: { type: 'integer' }
-            },
-            required: ['a', 'b']
-        });
-    });
-});
-describe('mergeDeepObjectSchemas', () => {
-    test('deep merge', () => {
-        const original = {
-            type: 'object',
-            properties: {
-                obj: {
-                    type: 'object',
-                    properties: {
-                        a: { type: 'string' },
-                        b: { type: 'string' }
-                    },
-                    required: ['a', 'b']
-                }
-            }
-        };
-        const override = {
-            type: 'object',
-            properties: {
-                obj: {
-                    type: 'object',
-                    properties: {
-                        c: { type: 'string' }
-                    },
-                    required: ['c']
-                }
-            }
-        };
-        expect(mergeDeepObjectSchemas(original, override)).toEqual({
-            type: 'object',
-            properties: {
-                obj: {
-                    type: 'object',
-                    properties: {
-                        a: { type: 'string' },
-                        b: { type: 'string' },
-                        c: { type: 'string' }
-                    },
-                    required: ['a', 'b', 'c']
-                }
-            }
-        });
-    });
-    test('uses allOf merge @ref', () => {
-        const original = {
-            type: 'object',
-            properties: {
-                obj: {
-                    '@ref': 'local:Test'
-                }
-            }
-        };
-        const override = {
-            type: 'object',
-            properties: {
-                obj: {
-                    type: 'object',
-                    properties: {
-                        c: { type: 'string' }
-                    },
-                    required: ['c']
-                }
-            }
-        };
-        expect(mergeDeepObjectSchemas(original, override)).toEqual({
-            type: 'object',
-            properties: {
-                obj: {
-                    allOf: [
-                        { '@ref': 'local:Test' },
-                        {
-                            type: 'object',
-                            properties: {
-                                c: { type: 'string' }
-                            },
-                            required: ['c']
-                        }
-                    ]
-                }
-            }
-        });
-    });
-    test('properly handles duplicate refs', () => {
-        const original = {
-            type: 'object',
-            properties: {
-                a: {
-                    '@ref': 'local:Test'
-                },
-                b: { type: 'string' }
-            }
-        };
-        const override = {
-            type: 'object',
-            properties: {
-                a: {
-                    '@ref': 'local:Test'
-                },
-                c: { type: 'integer' }
-            }
-        };
-        expect(mergeDeepObjectSchemas(original, override)).toEqual({
-            type: 'object',
-            properties: {
-                a: {
-                    '@ref': 'local:Test'
-                },
-                b: {
-                    type: 'string'
-                },
-                c: {
-                    type: 'integer'
-                }
-            }
-        });
-    });
-});
-describe('mergeFormConfigs', () => {
-    test('it works', () => {
-        const primary = {
-            order: ['shapePropertyType', 'name', 'isRequired'],
-            properties: {
-                name: {
-                    widget: 'singleLineText'
-                },
-                isRequired: {
-                    widget: 'checkbox'
-                }
-            }
-        };
-        const l10n = {
-            order: ['enableLocalization'],
-            properties: {
-                widget: 'switch'
-            }
-        };
-        const common = {
-            order: ['name', 'title', 'description', 'instructions', 'widget'],
-            properties: {
-                name: {
-                    widget: 'shapePropertyName'
-                },
-                title: {
-                    widget: 'singleLineText'
-                },
-                description: {
-                    widget: 'singleLineText'
-                },
-                instructions: {
-                    widget: 'singleLineText'
-                },
-                widget: {
-                    properties: {
-                        name: {
-                            widget: 'dropdown',
-                            hiddenValues: ['custom']
-                        }
-                    }
-                }
-            }
-        };
-        expect(mergeFormConfigs(primary, l10n, common)).toEqual({
-            order: [
-                'shapePropertyType',
-                'name',
-                'isRequired',
-                'enableLocalization',
-                'title',
-                'description',
-                'instructions',
-                'widget'
-            ],
-            properties: {
-                description: {
-                    widget: 'singleLineText'
-                },
-                instructions: {
-                    widget: 'singleLineText'
-                },
-                isRequired: {
-                    widget: 'checkbox'
-                },
-                name: {
-                    widget: 'shapePropertyName'
-                },
-                title: {
-                    widget: 'singleLineText'
-                },
-                widget: {
-                    properties: {
-                        name: {
-                            hiddenValues: ['custom'],
-                            widget: 'dropdown'
-                        }
-                    }
-                }
-            }
-        });
-    });
-});
-const emptySchema = createMockSchema('projectId');
-const addedService = {
-    ...emptySchema,
-    queries: {
-        Rick_characters: {
-            resolver: {
-                name: 'graphql:query',
-                service: 'rick',
-                fieldName: 'characters'
-            },
-            args: {
-                type: 'object',
-                properties: {
-                    page: { type: 'integer' },
-                    filter: { '@ref': 'rick:FilterCharacter' }
-                }
-            },
-            shape: 'Rick_Characters'
-        }
-    },
-    services: {
-        rick: {
-            id: 'rick',
-            provider: 'graphql',
-            title: 'Rick',
-            namespace: 'Rick',
-            serviceType: 'graphql',
-            authenticationType: 'none',
-            options: { endpoint: 'https://rickandmortyapi.com/graphql' }
-        }
-    }
-};
-const addedShape = {
-    ...emptySchema,
-    queries: {
-        getHomepage: {
-            shape: 'Homepage',
-            resolver: {
-                name: 'shapedb:get',
-                service: 'shapedb',
-                shapeName: 'Homepage'
-            },
-            description: 'Get a Homepage by ID',
-            args: 'TSGetArgs<Homepage>'
-        }
-    },
-    mutations: {
-        updateHomepage: {
-            shape: 'UpdateResult<Homepage>',
-            resolver: {
-                name: 'shapedb:update',
-                service: 'shapedb',
-                shapeName: 'Homepage'
-            },
-            description: 'Update Homepage',
-            args: 'UpdateArgs<Homepage>'
-        }
-    },
-    shapes: {
-        Homepage: {
-            id: '7fms3CQ6d',
-            name: 'Homepage',
-            title: 'Homepage',
-            model: { type: 'single' },
-            schema: {
-                type: 'object',
-                properties: {
-                    greeting: {
-                        title: 'Greeting',
-                        '@mapping': 'shapedb:Homepage.uq8t3G3O6',
-                        type: 'string'
-                    }
-                }
-            }
-        }
-    },
-    forms: {
-        Homepage: {
-            default: {
-                properties: { greeting: { widget: 'singleLineText' } },
-                order: ['greeting']
-            }
-        }
-    }
-};
-const addedProperty = set('shapes.Homepage.schema.properties.body', {
-    title: 'Body',
-    '@mapping': 'shapedb:Homepage.abcXYZ123',
-    type: 'string'
-}, addedShape);
-describe('mergeProjectSchemas', () => {
-    test('merges when base/parent are the same', () => {
-        const { mergedSchema } = mergeProjectSchemas(emptySchema, emptySchema, addedShape);
-        expect(mergedSchema).toEqual(addedShape);
-    });
-    test('removes sections', () => {
-        const { mergedSchema } = mergeProjectSchemas(addedShape, addedShape, emptySchema);
-        expect(mergedSchema).toEqual(emptySchema);
-    });
-    test('merges unrelated changes', () => {
-        const { mergedSchema } = mergeProjectSchemas(addedShape, emptySchema, addedService);
-        expect(mergedSchema).toMatchObject({
-            shapes: { ...addedShape.shapes, ...addedService.shapes },
-            forms: { ...addedShape.forms, ...addedService.forms },
-            services: { ...addedShape.services, ...addedService.services }
-        });
-    });
-    test('fails on removal conflicts', () => {
-        const { error } = mergeProjectSchemas(addedService, addedShape, addedProperty);
-        expect(error).toEqual('Attempting to update shapes.Homepage which has already been removed');
-    });
-    test('fails on type conflicts', () => {
-        const main = {
-            ...emptySchema,
-            shapes: {
-                Name: createShape('Name', {
-                    type: 'object',
-                    properties: {
-                        name: {
-                            type: 'string'
-                        }
-                    }
-                })
-            }
-        };
-        const branch = {
-            ...emptySchema,
-            shapes: {
-                Name: createShape('Name', {
-                    enum: ['FOO', 'BAR', 'BAZ']
-                })
-            }
-        };
-        const { error } = mergeProjectSchemas(main, emptySchema, branch);
-        expect(error).toEqual('Unable to merge shapes.Name schemas conflict');
-    });
-    test('overwrite shape schema when there is no conflicting change', () => {
-        const parent = {
-            ...emptySchema,
-            shapes: {
-                Name: createShape('Name', {
-                    type: 'object',
-                    properties: {
-                        name: {
-                            type: 'string'
-                        }
-                    }
-                })
-            }
-        };
-        const main = {
-            ...parent,
-            shapes: {
-                ...parent.shapes,
-                TacoBell: createShape('TacoBell', {
-                    type: 'object',
-                    properties: {
-                        bajaBlast: {
-                            type: 'boolean'
-                        }
-                    }
-                })
-            }
-        };
-        const branch = {
-            ...parent,
-            shapes: {
-                ...parent.shapes,
-                Name: createShape('Name', {
-                    enum: ['FOO', 'BAR', 'BAZ']
-                })
-            }
-        };
-        const result = mergeProjectSchemas(main, parent, branch);
-        expect(result.mergedSchema).toEqual({
-            ...main,
-            shapes: {
-                Name: {
-                    id: 'Name',
-                    name: 'Name',
-                    schema: {
-                        enum: ['FOO', 'BAR', 'BAZ']
-                    },
-                    title: 'Name'
-                },
-                TacoBell: {
-                    id: 'TacoBell',
-                    name: 'TacoBell',
-                    schema: {
-                        properties: {
-                            bajaBlast: {
-                                type: 'boolean'
-                            }
-                        },
-                        type: 'object'
-                    },
-                    title: 'TacoBell'
-                }
-            }
-        });
-    });
-    test('merges object properties when both base/parent are equal', () => {
-        const main = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    type: 'object',
-                    properties: {
-                        foo: {
-                            type: 'string'
-                        },
-                        bar: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['foo']
-                })
-            }
-        };
-        const branch = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    type: 'object',
-                    properties: {
-                        foo: {
-                            type: 'string'
-                        },
-                        baz: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['foo', 'baz']
-                })
-            }
-        };
-        const result = mergeProjectSchemas(main, main, branch);
-        expect(result.mergedSchema).toEqual(branch);
-    });
-    test('merges object properties when both base/head add the same shape', () => {
-        const main = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    type: 'object',
-                    properties: {
-                        foo: {
-                            type: 'string'
-                        },
-                        bar: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['foo']
-                })
-            },
-            forms: {
-                Test: {
-                    default: {
-                        order: ['foo', 'bar'],
-                        properties: {
-                            foo: {
-                                widget: 'singleLineText'
-                            },
-                            bar: {
-                                widget: 'singleLineText'
-                            }
-                        }
-                    }
-                }
-            }
-        };
-        const branch = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    type: 'object',
-                    properties: {
-                        foo: {
-                            type: 'string'
-                        },
-                        baz: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['foo', 'baz']
-                })
-            },
-            forms: {
-                Test: {
-                    default: {
-                        order: ['foo', 'baz'],
-                        properties: {
-                            foo: {
-                                widget: 'singleLineText'
-                            },
-                            baz: {
-                                widget: 'singleLineText'
-                            }
-                        }
-                    }
-                }
-            }
-        };
-        const result = mergeProjectSchemas(main, emptySchema, branch);
-        expect(result.mergedSchema).toEqual({
-            ...main,
-            shapes: {
-                Test: createShape('Test', {
-                    type: 'object',
-                    properties: {
-                        foo: {
-                            type: 'string'
-                        },
-                        bar: {
-                            type: 'string'
-                        },
-                        baz: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['foo', 'baz']
-                })
-            },
-            forms: {
-                Test: {
-                    default: {
-                        order: ['foo', 'bar', 'baz'],
-                        properties: {
-                            foo: {
-                                widget: 'singleLineText'
-                            },
-                            bar: {
-                                widget: 'singleLineText'
-                            },
-                            baz: {
-                                widget: 'singleLineText'
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    });
-    test('rebase object properties when both base/head update shape', () => {
-        const parent = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    type: 'object',
-                    properties: {
-                        foo: {
-                            type: 'string'
-                        },
-                        bar: {
-                            type: 'string'
-                        },
-                        huh: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['foo', 'huh']
-                })
-            },
-            forms: {
-                Test: {
-                    default: {
-                        order: ['foo', 'bar', 'huh'],
-                        properties: {
-                            foo: {
-                                widget: 'singleLineText'
-                            },
-                            bar: {
-                                widget: 'singleLineText'
-                            },
-                            huh: {
-                                widget: 'singleLineText'
-                            }
-                        }
-                    }
-                }
-            }
-        };
-        const main = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    type: 'object',
-                    properties: {
-                        foo: {
-                            type: 'string'
-                        },
-                        bar: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['foo']
-                })
-            },
-            forms: {
-                Test: {
-                    default: {
-                        order: ['foo', 'bar'],
-                        properties: {
-                            foo: {
-                                widget: 'singleLineText'
-                            },
-                            bar: {
-                                widget: 'singleLineText'
-                            }
-                        }
-                    }
-                }
-            }
-        };
-        const branch = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    type: 'object',
-                    properties: {
-                        foo: {
-                            type: 'string'
-                        },
-                        bar: {
-                            type: 'string'
-                        },
-                        huh: {
-                            type: 'string'
-                        },
-                        baz: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['foo', 'huh']
-                })
-            },
-            forms: {
-                Test: {
-                    default: {
-                        order: ['foo', 'bar', 'huh', 'baz'],
-                        properties: {
-                            foo: {
-                                widget: 'singleLineText'
-                            },
-                            bar: {
-                                widget: 'singleLineText'
-                            },
-                            huh: {
-                                widget: 'singleLineText'
-                            },
-                            baz: {
-                                widget: 'singleLineText'
-                            }
-                        }
-                    }
-                }
-            }
-        };
-        const result = mergeProjectSchemas(main, parent, branch);
-        expect(result.mergedSchema).toEqual({
-            ...main,
-            shapes: {
-                Test: createShape('Test', {
-                    type: 'object',
-                    properties: {
-                        foo: {
-                            type: 'string'
-                        },
-                        bar: {
-                            type: 'string'
-                        },
-                        baz: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['foo']
-                })
-            },
-            forms: {
-                Test: {
-                    default: {
-                        order: ['foo', 'bar', 'baz'],
-                        properties: {
-                            foo: {
-                                widget: 'singleLineText'
-                            },
-                            bar: {
-                                widget: 'singleLineText'
-                            },
-                            baz: {
-                                widget: 'singleLineText'
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    });
-    test('merge object properties in extends when both base/head update shape', () => {
-        const main = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                bar: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo']
-                        }
-                    ]
-                })
-            }
-        };
-        const branch = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                baz: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo', 'baz']
-                        }
-                    ]
-                })
-            }
-        };
-        const result = mergeProjectSchemas(main, emptySchema, branch);
-        expect(result.mergedSchema).toEqual({
-            ...main,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                bar: {
-                                    type: 'string'
-                                },
-                                baz: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo', 'baz']
-                        }
-                    ]
-                })
-            }
-        });
-    });
-    test('rebase object properties in extends when both base/head update shape', () => {
-        const parent = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        { '@ref': 'local:Parent' },
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                bar: {
-                                    type: 'string'
-                                },
-                                huh: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo', 'huh']
-                        }
-                    ]
-                })
-            }
-        };
-        const main = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        { '@ref': 'local:Parent' },
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                bar: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo']
-                        }
-                    ]
-                })
-            }
-        };
-        const branch = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        { '@ref': 'local:Parent' },
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                bar: {
-                                    type: 'string'
-                                },
-                                huh: {
-                                    type: 'string'
-                                },
-                                baz: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo', 'huh']
-                        }
-                    ]
-                })
-            }
-        };
-        const result = mergeProjectSchemas(main, parent, branch);
-        expect(result.mergedSchema).toEqual({
-            ...main,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        { '@ref': 'local:Parent' },
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                bar: {
-                                    type: 'string'
-                                },
-                                baz: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo']
-                        }
-                    ]
-                })
-            }
-        });
-    });
-    test('Should be able to merge identical changes', () => {
-        const parent = {
-            ...emptySchema
-        };
-        const main = {
-            ...parent,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [{ '@ref': 'local:Parent' }]
-                })
-            }
-        };
-        const branch = {
-            ...parent,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [{ '@ref': 'local:Parent' }]
-                })
-            }
-        };
-        const result = mergeProjectSchemas(main, parent, branch);
-        expect(result.mergedSchema).toEqual(branch);
-    });
-    test('errors when extends do not match in conflicting change', () => {
-        const parent = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        { '@ref': 'local:Parent' },
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                bar: {
-                                    type: 'string'
-                                },
-                                huh: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo', 'huh']
-                        }
-                    ]
-                })
-            }
-        };
-        const main = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        { '@ref': 'local:Parent' },
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                bar: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo']
-                        }
-                    ]
-                })
-            }
-        };
-        const branch = {
-            ...emptySchema,
-            shapes: {
-                Test: createShape('Test', {
-                    extends: [
-                        { '@ref': 'local:OtherParent' },
-                        {
-                            type: 'object',
-                            properties: {
-                                foo: {
-                                    type: 'string'
-                                },
-                                bar: {
-                                    type: 'string'
-                                },
-                                huh: {
-                                    type: 'string'
-                                },
-                                baz: {
-                                    type: 'string'
-                                }
-                            },
-                            required: ['foo', 'huh']
-                        }
-                    ]
-                })
-            }
-        };
-        const result = mergeProjectSchemas(main, parent, branch);
-        expect(result.error).toEqual('Unable to merge shapes.Test schemas conflict');
-    });
-    test('rebase shape level properties', () => {
-        const parent = unset('shapes.Homepage.model', addedShape);
-        const main = addedShape;
-        const branch = set('shapes.Homepage.schema.properties.new', { type: 'string' }, addedShape);
-        const result = mergeProjectSchemas(main, parent, branch);
-        expect(result.mergedSchema?.shapes.Homepage).toEqual({
-            id: '7fms3CQ6d',
-            model: {
-                type: 'single'
-            },
-            name: 'Homepage',
-            schema: {
-                properties: {
-                    greeting: {
-                        '@mapping': 'shapedb:Homepage.uq8t3G3O6',
-                        title: 'Greeting',
-                        type: 'string'
-                    },
-                    new: {
-                        type: 'string'
-                    }
-                },
-                type: 'object'
-            },
-            title: 'Homepage'
-        });
-    });
-    test('non-merged field changed in head', () => {
-        const changedLocales = { ...emptySchema, locales: ['en-us', 'es-es'] };
-        const { mergedSchema } = mergeProjectSchemas(emptySchema, emptySchema, changedLocales);
-        expect(mergedSchema).toEqual(changedLocales);
-    });
-    test('non-merged field changed in base', () => {
-        const changedLocales = { ...emptySchema, locales: ['en-us', 'es-es'] };
-        const { mergedSchema } = mergeProjectSchemas(changedLocales, emptySchema, emptySchema);
-        expect(mergedSchema).toEqual(changedLocales);
-    });
-    test('conflict in non-merged field takes value from head without merge', () => {
-        const changedLocales1 = { ...emptySchema, locales: ['en-us', 'es-es'] };
-        const changedLocales2 = { ...emptySchema, locales: ['en-us', 'de-de'] };
-        const { mergedSchema } = mergeProjectSchemas(changedLocales1, emptySchema, changedLocales2);
-        expect(mergedSchema).toEqual(changedLocales2);
-    });
-});