@contentful/field-editor-reference 5.9.0 → 5.11.0

package/dist/cjs/resources/MultipleResourceReferenceEditor.spec.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = _interop_require_wildcard(require("react"));
+require("@testing-library/jest-dom/extend-expect");
+const _react1 = require("@testing-library/react");
+const _EntityStore = require("../common/EntityStore");
+const _MultipleResourceReferenceEditor = require("./MultipleResourceReferenceEditor");
+const _resourceEditorHelpers = require("./testHelpers/resourceEditorHelpers");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let mockedResources = {};
+jest.mock('../common/EntityStore', ()=>{
+    const module = jest.requireActual('../common/EntityStore');
+    return {
+        ...module,
+        useResource: jest.fn((linkType, urn, apiUrl)=>({
+                data: mockedResources[`${linkType}.${urn}`],
+                status: 'success',
+                apiUrl
+            }))
+    };
+});
+jest.mock('react-intersection-observer', ()=>{
+    const module = jest.requireActual('react-intersection-observer');
+    return {
+        ...module,
+        useInView: ()=>({
+                inView: true
+            })
+    };
+});
+const fieldDefinition = {
+    type: 'Array',
+    items: {
+        type: 'ResourceLink'
+    },
+    id: 'foo',
+    name: 'Foo',
+    allowedResources: [
+        {
+            source: 'foo',
+            contentTypes: [
+                'bar'
+            ]
+        }
+    ],
+    required: true,
+    validations: []
+};
+describe('Multiple resource editor', ()=>{
+    it('renders the action button when no value is set', async ()=>{
+        const sdk = (0, _resourceEditorHelpers.mockSdkForField)(fieldDefinition);
+        (0, _react1.render)(_react.createElement(_MultipleResourceReferenceEditor.MultipleResourceReferenceEditor, {
+            isInitiallyDisabled: false,
+            sdk: sdk,
+            hasCardEditActions: true,
+            viewType: "card",
+            parameters: {}
+        }));
+        const button = await _react1.screen.findByText('Add existing content');
+        expect(button).toBeDefined();
+        _react1.fireEvent.click(button);
+        const dialogFn = sdk.dialogs.selectMultipleResourceEntries;
+        expect(dialogFn).toHaveBeenCalledTimes(1);
+        const options = dialogFn.mock.calls[0][0];
+        expect(options).toEqual({
+            allowedResources: fieldDefinition.allowedResources
+        });
+    });
+    it('renders custom actions when passed', async ()=>{
+        const sdk = (0, _resourceEditorHelpers.mockSdkForField)(fieldDefinition);
+        (0, _react1.render)(_react.createElement(_MultipleResourceReferenceEditor.MultipleResourceReferenceEditor, {
+            isInitiallyDisabled: false,
+            sdk: sdk,
+            hasCardEditActions: true,
+            viewType: "card",
+            parameters: {},
+            renderCustomActions: ()=>_react.createElement("div", {
+                    "data-testid": "custom-actions"
+                })
+        }));
+        const customActions = await _react1.screen.findByTestId('custom-actions');
+        expect(customActions).toBeDefined();
+    });
+    describe('with value', ()=>{
+        it('renders the cards', async ()=>{
+            const { entryLinks , entryInfos  } = generateMultipleTestResources();
+            mockedResources = {};
+            for (const [spaceId, link] of Object.entries(entryLinks)){
+                mockedResources[`${link.sys.linkType}.${link.sys.urn}`] = entryInfos[spaceId];
+            }
+            const sdk = (0, _resourceEditorHelpers.mockSdkForField)(fieldDefinition, Object.values(entryLinks));
+            (0, _react1.render)(_react.createElement(_MultipleResourceReferenceEditor.MultipleResourceReferenceEditor, {
+                isInitiallyDisabled: false,
+                sdk: sdk,
+                hasCardEditActions: true,
+                viewType: "card",
+                apiUrl: "test-contentful",
+                getEntryRouteHref: ()=>'',
+                parameters: {}
+            }));
+            expect(_EntityStore.useResource).toHaveBeenCalledTimes(Object.values(entryInfos).length);
+            const cards = [];
+            const entriesArray = Object.values(entryInfos);
+            for (const info of Array.from(entriesArray.values())){
+                const entryTitle = info.resource.fields.title[info.defaultLocaleCode];
+                const spaceName = info.space.name;
+                const card = await expectEntryCard(entryTitle, spaceName);
+                cards.push(card);
+            }
+        });
+        describe('card actions', ()=>{
+            it('should have a move to top button', async ()=>{
+                const { entryLinks , entryInfos  } = generateMultipleTestResources();
+                mockedResources = {};
+                for (const [spaceId, link] of Object.entries(entryLinks)){
+                    mockedResources[`${link.sys.linkType}.${link.sys.urn}`] = entryInfos[spaceId];
+                }
+                const sdk = (0, _resourceEditorHelpers.mockSdkForField)(fieldDefinition, Object.values(entryLinks));
+                (0, _react1.render)(_react.createElement(_MultipleResourceReferenceEditor.MultipleResourceReferenceEditor, {
+                    isInitiallyDisabled: false,
+                    sdk: sdk,
+                    hasCardEditActions: true,
+                    viewType: "card",
+                    apiUrl: "test-contentful",
+                    getEntryRouteHref: ()=>'',
+                    parameters: {}
+                }));
+                const linkExistingBtn = _react1.screen.queryByText('Add existing content');
+                expect(linkExistingBtn).toBeInTheDocument();
+                const entriesArray = Object.values(entryInfos);
+                const firstItem = entriesArray[0];
+                await expectToNotHaveMoveButton(firstItem, 'Move to top');
+                const allButFirst = entriesArray.slice(1);
+                for (const info of allButFirst){
+                    await expectToHaveMoveButton(info, 'Move to top');
+                }
+            });
+            it('should have a move to bottom button', async ()=>{
+                const { entryLinks , entryInfos  } = generateMultipleTestResources();
+                mockedResources = {};
+                for (const [spaceId, link] of Object.entries(entryLinks)){
+                    mockedResources[`${link.sys.linkType}.${link.sys.urn}`] = entryInfos[spaceId];
+                }
+                const sdk = (0, _resourceEditorHelpers.mockSdkForField)(fieldDefinition, Object.values(entryLinks));
+                (0, _react1.render)(_react.createElement(_MultipleResourceReferenceEditor.MultipleResourceReferenceEditor, {
+                    isInitiallyDisabled: false,
+                    sdk: sdk,
+                    hasCardEditActions: true,
+                    viewType: "card",
+                    apiUrl: "test-contentful",
+                    getEntryRouteHref: ()=>'',
+                    parameters: {}
+                }));
+                const linkExistingBtn = _react1.screen.queryByText('Add existing content');
+                expect(linkExistingBtn).toBeInTheDocument();
+                const entriesArray = Object.values(entryInfos);
+                const lastItem = entriesArray[entriesArray.length - 1];
+                await expectToNotHaveMoveButton(lastItem, 'Move to bottom');
+                const allButLast = entriesArray.slice(0, -1);
+                for (const info of allButLast){
+                    await expectToHaveMoveButton(info, 'Move to bottom');
+                }
+            });
+            it('works when using remove action', async ()=>{
+                const { entryLinks , entryInfos  } = generateMultipleTestResources();
+                mockedResources = {};
+                for (const [spaceId, link] of Object.entries(entryLinks)){
+                    mockedResources[`${link.sys.linkType}.${link.sys.urn}`] = entryInfos[spaceId];
+                }
+                const sdk = (0, _resourceEditorHelpers.mockSdkForField)(fieldDefinition, Object.values(entryLinks));
+                (0, _react1.render)(_react.createElement(_MultipleResourceReferenceEditor.MultipleResourceReferenceEditor, {
+                    isInitiallyDisabled: false,
+                    sdk: sdk,
+                    hasCardEditActions: true,
+                    viewType: "card",
+                    apiUrl: "test-contentful",
+                    getEntryRouteHref: ()=>'',
+                    parameters: {}
+                }));
+                const linkExistingBtn = _react1.screen.queryByText('Add existing content');
+                expect(linkExistingBtn).toBeInTheDocument();
+                const entriesArray = Object.values(entryInfos);
+                for (const info of entriesArray){
+                    await clickCardActionsButton(info);
+                    const removeBtn = await _react1.screen.findByText('Remove', {
+                        selector: '[role="menuitem"]'
+                    });
+                    _react1.fireEvent.click(removeBtn);
+                }
+                expect(sdk.field.setValue).toHaveBeenCalledTimes(3);
+                expect(sdk.field.setValue).toHaveBeenCalledWith([]);
+            });
+        });
+    });
+});
+async function expectToHaveMoveButton(info, buttonString) {
+    await clickCardActionsButton(info);
+    await _react1.screen.findByText(buttonString, {
+        selector: '[role="menuitem"]'
+    });
+}
+async function expectToNotHaveMoveButton(info, buttonString) {
+    await clickCardActionsButton(info);
+    expect(_react1.screen.queryByText(buttonString, {
+        selector: '[role="menuitem"]'
+    })).toBeNull();
+}
+async function clickCardActionsButton(info) {
+    _react1.fireEvent.click(document.body);
+    const entryTitle = info.resource.fields.title[info.defaultLocaleCode];
+    const spaceName = info.space.name;
+    const card = await expectEntryCard(entryTitle, spaceName);
+    const actionsBtn = card.querySelector('[data-test-id="cf-ui-card-actions"]');
+    expect(actionsBtn).toBeInTheDocument();
+    _react1.fireEvent.click(actionsBtn);
+}
+async function expectEntryCard(entryTitle, spaceName) {
+    const title = await _react1.screen.findByText(entryTitle);
+    await _react1.screen.findByText(spaceName);
+    const theCard = title.closest('[data-test-id="cf-ui-entry-card"]');
+    expect(theCard).toBeDefined();
+    const actionsBtn = theCard?.querySelector('[data-test-id="cf-ui-card-actions"]');
+    expect(actionsBtn).toBeDefined();
+    return theCard;
+}
+function generateMultipleTestResources() {
+    return [
+        'Space A',
+        'Space B',
+        'Space C'
+    ].reduce((acc, spaceName)=>{
+        const spaceId = spaceName.toLowerCase().replace(' ', '-');
+        const entryInfo = {
+            title: `An entry in ${spaceName}`,
+            id: `linkedEntryId`
+        };
+        acc.entryLinks[spaceId] = {
+            sys: {
+                type: 'ResourceLink',
+                linkType: 'Contentful:Entry',
+                urn: `crn:test:::content:spaces/${spaceId}/entries/${entryInfo.id}`
+            }
+        };
+        acc.entryInfos[spaceId] = (0, _resourceEditorHelpers.createFakeEntryResource)({
+            title: entryInfo.title,
+            id: entryInfo.id,
+            space: {
+                id: spaceId,
+                name: spaceName
+            }
+        });
+        return acc;
+    }, {
+        entryLinks: {},
+        entryInfos: {}
+    });
+}

package/dist/cjs/resources/SingleResourceReferenceEditor.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SingleResourceReferenceEditor", {
+    enumerable: true,
+    get: function() {
+        return SingleResourceReferenceEditor;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _fieldeditorshared = require("@contentful/field-editor-shared");
+const _deepequal = _interop_require_default(require("deep-equal"));
+const _EntityStore = require("../common/EntityStore");
+const _LinkEntityActions = require("../components/LinkActions/LinkEntityActions");
+const _ResourceCard = require("./Cards/ResourceCard");
+const _useResourceLinkActions = require("./useResourceLinkActions");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function SingleResourceReferenceEditor(props) {
+    const { dialogs , field  } = props.sdk;
+    const linkActionsProps = (0, _useResourceLinkActions.useResourceLinkActions)({
+        dialogs,
+        field,
+        apiUrl: props.apiUrl
+    });
+    return _react.createElement(_EntityStore.EntityProvider, {
+        sdk: props.sdk
+    }, _react.createElement(_fieldeditorshared.FieldConnector, {
+        throttle: 0,
+        field: props.sdk.field,
+        isInitiallyDisabled: props.isInitiallyDisabled,
+        isEqualValues: _deepequal.default
+    }, ({ value , disabled  })=>{
+        return value ? _react.createElement(_ResourceCard.ResourceCard, {
+            onRemove: ()=>props.sdk.field.removeValue(),
+            resourceLink: value,
+            isDisabled: disabled,
+            getEntryRouteHref: props.getEntryRouteHref
+        }) : _react.createElement(_LinkEntityActions.CombinedLinkEntityActions, {
+            ...linkActionsProps,
+            renderCustomActions: props.renderCustomActions
+        });
+    }));
+}

package/dist/cjs/resources/SingleResourceReferenceEditor.spec.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = _interop_require_wildcard(require("react"));
+require("@testing-library/jest-dom/extend-expect");
+const _react1 = require("@testing-library/react");
+const _EntityStore = require("../common/EntityStore");
+const _SingleResourceReferenceEditor = require("./SingleResourceReferenceEditor");
+const _resourceEditorHelpers = require("./testHelpers/resourceEditorHelpers");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const mockedResources = {};
+jest.mock('../common/EntityStore', ()=>{
+    const module = jest.requireActual('../common/EntityStore');
+    return {
+        ...module,
+        useResource: jest.fn((linkType, urn)=>({
+                data: mockedResources[`${linkType}.${urn}`],
+                status: 'success'
+            }))
+    };
+});
+jest.mock('react-intersection-observer', ()=>{
+    const module = jest.requireActual('react-intersection-observer');
+    return {
+        ...module,
+        useInView: ()=>({
+                inView: true
+            })
+    };
+});
+const fieldDefinition = {
+    type: 'ResourceLink',
+    id: 'foo',
+    name: 'Foo',
+    allowedResources: [
+        {
+            source: 'foo',
+            contentTypes: [
+                'bar'
+            ]
+        }
+    ],
+    required: true,
+    validations: []
+};
+describe('Single resource editor', ()=>{
+    it('renders the action button when no value is set', async ()=>{
+        const sdk = (0, _resourceEditorHelpers.mockSdkForField)(fieldDefinition);
+        (0, _react1.render)(_react.createElement(_SingleResourceReferenceEditor.SingleResourceReferenceEditor, {
+            isInitiallyDisabled: false,
+            sdk: sdk,
+            hasCardEditActions: true,
+            viewType: "card",
+            parameters: {}
+        }));
+        const button = await _react1.screen.findByText('Add existing content');
+        expect(button).toBeDefined();
+        _react1.fireEvent.click(button);
+        const dialogFn = sdk.dialogs.selectSingleResourceEntry;
+        expect(dialogFn).toHaveBeenCalledTimes(1);
+        const options = dialogFn.mock.calls[0][0];
+        expect(options).toEqual({
+            allowedResources: fieldDefinition.allowedResources
+        });
+    });
+    it('renders custom actions when passed', async ()=>{
+        const sdk = (0, _resourceEditorHelpers.mockSdkForField)(fieldDefinition);
+        (0, _react1.render)(_react.createElement(_SingleResourceReferenceEditor.SingleResourceReferenceEditor, {
+            isInitiallyDisabled: false,
+            sdk: sdk,
+            hasCardEditActions: true,
+            viewType: "card",
+            parameters: {},
+            renderCustomActions: ()=>_react.createElement("div", {
+                    "data-testid": "custom-actions"
+                })
+        }));
+        const customActions = await _react1.screen.findByTestId('custom-actions');
+        expect(customActions).toBeDefined();
+    });
+    it('renders the card button when the value is set', async ()=>{
+        const sdk = (0, _resourceEditorHelpers.mockSdkForField)(fieldDefinition, {
+            sys: {
+                type: 'Link',
+                linkType: 'Contentful:Entry',
+                urn: 'crn:test:::content:spaces/x-space/entries/linkedEntryId'
+            }
+        });
+        const info = (0, _resourceEditorHelpers.createFakeEntryResource)({
+            title: 'Title of linked entry',
+            id: 'linkedEntryId',
+            space: {
+                id: 'x-space',
+                name: 'X Space'
+            }
+        });
+        mockedResources[`Contentful:Entry.crn:test:::content:spaces/x-space/entries/linkedEntryId`] = info;
+        (0, _react1.render)(_react.createElement(_SingleResourceReferenceEditor.SingleResourceReferenceEditor, {
+            isInitiallyDisabled: false,
+            sdk: sdk,
+            hasCardEditActions: true,
+            viewType: "card",
+            apiUrl: "test-contentful",
+            getEntryRouteHref: jest.fn(),
+            parameters: {}
+        }));
+        expect(_EntityStore.useResource).toHaveBeenCalled();
+        const title = await _react1.screen.findByText('Title of linked entry');
+        await _react1.screen.findByText('X Space');
+        const theCard = title.closest('[data-test-id="cf-ui-entry-card"]');
+        const actionsBtn = theCard?.querySelector('[data-test-id="cf-ui-card-actions"]');
+        expect(actionsBtn).toBeDefined();
+        _react1.fireEvent.click(actionsBtn);
+        const removeBtn = await _react1.screen.findByText('Remove', {
+            selector: '[role="menuitem"]'
+        });
+        _react1.fireEvent.click(removeBtn);
+        expect(sdk.field.removeValue).toHaveBeenCalledWith();
+        const linkExistingBtn = _react1.screen.queryByText('Add existing content');
+        expect(linkExistingBtn).not.toBeInTheDocument();
+    });
+});

package/dist/cjs/resources/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./MultipleResourceReferenceEditor"), exports);
+_export_star(require("./SingleResourceReferenceEditor"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/cjs/resources/testHelpers/resourceEditorHelpers.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    mockSdkForField: function() {
+        return mockSdkForField;
+    },
+    createFakeEntryResource: function() {
+        return createFakeEntryResource;
+    }
+});
+function mockSdkForField(fieldDefinition, fieldValue) {
+    return {
+        field: {
+            getValue: jest.fn(()=>fieldValue),
+            setValue: jest.fn(()=>Promise.resolve(undefined)),
+            removeValue: jest.fn(),
+            onSchemaErrorsChanged: ()=>{},
+            onIsDisabledChanged: ()=>{},
+            onValueChanged: ()=>{},
+            ...fieldDefinition,
+            locale: 'en'
+        },
+        dialogs: {
+            selectSingleResourceEntry: jest.fn().mockResolvedValue({
+                sys: {
+                    type: 'Entry',
+                    id: 'linkedEntryId',
+                    space: {
+                        sys: {
+                            type: 'Link',
+                            linkType: 'Space',
+                            id: 'x-space'
+                        }
+                    }
+                }
+            }),
+            selectMultipleResourceEntries: jest.fn().mockResolvedValue([
+                {
+                    sys: {
+                        type: 'Entry',
+                        id: 'linkedEntryId',
+                        space: {
+                            sys: {
+                                type: 'Link',
+                                linkType: 'Space',
+                                id: 'x-space'
+                            }
+                        }
+                    }
+                }
+            ])
+        },
+        ids: {
+            space: 'myTestSpace',
+            environment: 'master',
+            organization: 'acme',
+            user: 'norris_chuck',
+            field: fieldDefinition.id,
+            entry: 'testEntry',
+            contentType: 'testCT'
+        },
+        space: {
+            onEntityChanged: ()=>{}
+        },
+        navigator: {
+            onSlideInNavigation: ()=>()=>({})
+        }
+    };
+}
+const createFakeEntryResource = ({ title , id , space  })=>{
+    const { id: spaceId , name: spaceName  } = space;
+    return {
+        resource: {
+            sys: {
+                id,
+                type: 'Entry',
+                space: {
+                    sys: {
+                        id: spaceId
+                    }
+                },
+                environment: {
+                    sys: {
+                        id: `${spaceId}-environment`
+                    }
+                }
+            },
+            fields: {
+                title: {
+                    en: title
+                }
+            }
+        },
+        contentType: {
+            sys: {
+                id: 'xTestCT'
+            },
+            displayField: 'title',
+            fields: [
+                {
+                    type: 'Symbol',
+                    id: 'title',
+                    name: 'The title'
+                }
+            ]
+        },
+        localeCode: 'en',
+        defaultLocaleCode: 'en',
+        space: {
+            name: spaceName
+        }
+    };
+};