@squiz/render-runtime-lib 1.73.0 → 1.75.0

package/lib/RenderInputService.spec.js

@@ -0,0 +1,645 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RenderInputService_1 = require("./RenderInputService");
+const component_lib_1 = require("@squiz/component-lib");
+const dx_common_lib_1 = require("@squiz/dx-common-lib");
+const test_1 = require("./test");
+const test_helpers_1 = require("./test-helpers");
+const rootUrl = 'http://localhost:3000';
+const expressRequest = (query = {}) => ({
+    id: 'test-id',
+    app: {
+        locals: {
+            rootUrl: rootUrl,
+        },
+    },
+    query,
+    header: jest.fn(),
+    headers: {},
+});
+describe('RenderInputService', () => {
+    const mockGetContentItem = jest.fn();
+    const apiKeyService = new dx_common_lib_1.DevelopmentApiKeyService();
+    const componentSetService = new test_1.MockedComponentSetServiceForProduction();
+    const componentFunctionService = new component_lib_1.ComponentFunctionService();
+    const manifestService = new component_lib_1.ManifestServiceForProduction(test_helpers_1.TestHelpers.getTestComponentFolder(), test_helpers_1.TestHelpers.testLogger);
+    const contentService = new test_1.MockedContentItemService({
+        createContentItem: jest.fn(),
+        getPaginatedContentItems: jest.fn(),
+        updateContentItem: jest.fn(),
+        getContentItem: mockGetContentItem,
+        deleteContentItemById: jest.fn(),
+    });
+    const getContentItemSpy = jest.spyOn(contentService, 'getContentItem');
+    const rootUrlResolver = jest.fn(() => rootUrl);
+    const renderInputService = new RenderInputService_1.RenderInputService(apiKeyService, componentSetService, manifestService, componentFunctionService, contentService, rootUrlResolver);
+    it(`should return the component root url returned by the root url resolver`, async () => {
+        const request = expressRequest({
+            something: '123',
+            foo: 'foo-val',
+        });
+        const requestInput = {
+            componentSet: 'set',
+            previewKey: undefined,
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-component',
+            version: '1.3.0',
+            expressRequest: request,
+            functionName: 'main',
+        };
+        const componentInput = await renderInputService.resolveInput(requestInput);
+        expect(componentInput.componentRootUrl).toEqual(rootUrl);
+        expect(rootUrlResolver).toHaveBeenCalledWith(request, true);
+    });
+    it('should throw meaningful error when input contains both contentId and previewKey', async () => {
+        const requestInput = {
+            componentSet: 'set',
+            previewKey: 'test-preview-key',
+            contentItemId: 'valid-id',
+            namespace: 'unit-test-components',
+            componentName: 'test-component',
+            version: '1.0.0',
+            expressRequest: expressRequest(),
+            functionName: 'main',
+        };
+        await expect(renderInputService.resolveInput(requestInput)).rejects.toThrowErrorMatchingInlineSnapshot(`"You cannot provide a previewKey and a ContentId as input"`);
+    });
+    it('should throw meaningful error when input contains both componentSet and previewKey', async () => {
+        const requestInput = {
+            componentSet: 'set',
+            previewKey: 'test-preview-key',
+            contentItemId: undefined,
+            namespace: 'test-namespace',
+            componentName: 'test-name',
+            version: '1.0.0',
+            expressRequest: expressRequest(),
+            functionName: 'main',
+        };
+        await expect(renderInputService.resolveInput(requestInput)).rejects.toThrowErrorMatchingInlineSnapshot(`"You cannot provide a previewKey and a componentSet as input"`);
+    });
+    it('should return correct preview render input when preview-key is provided', async () => {
+        const requestInput = {
+            componentSet: undefined,
+            previewKey: 'test-preview',
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-preview-component',
+            version: '1.2.4',
+            expressRequest: expressRequest({
+                something: '123',
+            }),
+            functionName: 'main',
+        };
+        const result = await renderInputService.resolveInput(requestInput);
+        const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.4');
+        const webReadyManifest = componentFunctionService.prepareManifestForWebResponse(manifest, 'set', rootUrl);
+        const expectedResult = {
+            requestId: 'test-id',
+            renderType: 'preview',
+            functionEntryFilePath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-preview-component/1.2.4/main.js`,
+            input: {
+                integerValue: 8,
+                nested: {
+                    content: 'this is nested content',
+                },
+            },
+            headers: {},
+            componentRootUrl: rootUrl,
+            functionName: 'main',
+            manifestForWeb: webReadyManifest,
+            componentFullName: 'unit-test-components/test-preview-component',
+            previewKey: 'test-preview',
+            runtimeSet: {
+                displayName: 'unknown',
+                environment: {},
+                webPath: 'unknown',
+            },
+            componentFunction: manifest.getComponentFunctionByName('main'),
+            manifest: manifest,
+            manifestPath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-preview-component/1.2.4/manifest.json`,
+            queryParameters: {},
+        };
+        expect(result).toEqual(expectedResult);
+    });
+    it('should return the content and set on the input object when contentId and componentSet are provided', async () => {
+        const request = expressRequest({
+            something: '123',
+        });
+        apiKeyService.getInterServiceKeys = jest.fn(() => ['x-inter-service-api-key']);
+        const requestInput = {
+            componentSet: 'set',
+            previewKey: undefined,
+            contentItemId: 'valid-id',
+            namespace: 'unit-test-components',
+            componentName: 'test-component',
+            version: '1.0.0',
+            expressRequest: request,
+            functionName: 'main',
+        };
+        const result = await renderInputService.resolveInput(requestInput);
+        const manifest = await manifestService.loadManifest('unit-test-components', 'test-component', '1.0.0');
+        const webReadyManifest = componentFunctionService.prepareManifestForWebResponse(manifest, 'set', rootUrl);
+        const expectedResult = {
+            requestId: 'test-id',
+            renderType: 'content-item-and-set',
+            functionEntryFilePath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-component/1.0.0/main.js`,
+            input: {
+                something: 'input-from-content-item-service',
+            },
+            headers: {
+                'some-header-name-1': 'mocked-component-set-header-val-1',
+                'some-header-name-2': 'mocked-component-set-header-val-2',
+            },
+            componentRootUrl: rootUrl,
+            dxpApiKey: 'x-inter-service-api-key',
+            functionName: 'main',
+            manifestForWeb: webReadyManifest,
+            componentFullName: 'unit-test-components/test-component',
+            runtimeSet: {
+                displayName: 'set',
+                environment: {},
+                webPath: 'set',
+            },
+            componentFunction: manifest.getComponentFunctionByName('main'),
+            componentSet: await componentSetService.getComponentSet('set'),
+            manifest: manifest,
+            queryParameters: {},
+        };
+        expect(result).toEqual(expectedResult);
+    });
+    it('should use input from the preview data when preview key is provided instead of query parameters', async () => {
+        const requestInput = {
+            componentSet: undefined,
+            previewKey: 'test-preview',
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-component',
+            version: '1.3.0',
+            expressRequest: expressRequest({
+                something: 'something-query-param',
+                foo: 'foo-query-param', // defined as function query parameter in the manifest
+            }),
+            functionName: 'main',
+        };
+        const result = await renderInputService.resolveInput(requestInput);
+        const manifest = await manifestService.loadManifest('unit-test-components', 'test-component', '1.3.0');
+        const webReadyManifest = componentFunctionService.prepareManifestForWebResponse(manifest, 'set', rootUrl);
+        const expectedResult = {
+            requestId: 'test-id',
+            renderType: 'preview',
+            functionEntryFilePath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-component/1.3.0/main.js`,
+            input: {
+                something: 'something-input-val',
+            },
+            headers: {},
+            componentRootUrl: rootUrl,
+            functionName: 'main',
+            manifestForWeb: webReadyManifest,
+            componentFullName: 'unit-test-components/test-component',
+            previewKey: 'test-preview',
+            runtimeSet: {
+                displayName: 'unknown',
+                environment: {},
+                webPath: 'unknown',
+            },
+            componentFunction: manifest.getComponentFunctionByName('main'),
+            manifest: manifest,
+            manifestPath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-component/1.3.0/manifest.json`,
+            queryParameters: {
+                foo: 'foo-query-param',
+            },
+        };
+        expect(result).toEqual(expectedResult);
+    });
+    it('should use input from the content item when using content item ID is provided instead of query parameters', async () => {
+        const request = expressRequest({
+            something: 'something-query-param',
+            foo: 'foo-query-param', // defined as function query parameter in the manifest
+        });
+        apiKeyService.getInterServiceKeys = jest.fn(() => ['x-inter-service-api-key']);
+        const requestInput = {
+            componentSet: 'set',
+            previewKey: undefined,
+            contentItemId: 'valid-id',
+            namespace: 'unit-test-components',
+            componentName: 'test-component',
+            version: '1.3.0',
+            expressRequest: request,
+            functionName: 'main',
+        };
+        const result = await renderInputService.resolveInput(requestInput);
+        const manifest = await manifestService.loadManifest('unit-test-components', 'test-component', '1.3.0');
+        const webReadyManifest = componentFunctionService.prepareManifestForWebResponse(manifest, 'set', rootUrl);
+        const expectedResult = {
+            requestId: 'test-id',
+            renderType: 'content-item-and-set',
+            functionEntryFilePath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-component/1.3.0/main.js`,
+            input: {
+                something: 'input-from-content-item-service',
+            },
+            headers: {
+                'some-header-name-1': 'mocked-component-set-header-val-1',
+                'some-header-name-2': 'mocked-component-set-header-val-2',
+            },
+            componentRootUrl: rootUrl,
+            dxpApiKey: 'x-inter-service-api-key',
+            functionName: 'main',
+            manifestForWeb: webReadyManifest,
+            componentFullName: 'unit-test-components/test-component',
+            runtimeSet: {
+                displayName: 'set',
+                environment: {},
+                webPath: 'set',
+            },
+            componentFunction: manifest.getComponentFunctionByName('main'),
+            componentSet: await componentSetService.getComponentSet('set'),
+            manifest: manifest,
+            queryParameters: {
+                foo: 'foo-query-param',
+            },
+        };
+        expect(result).toEqual(expectedResult);
+    });
+    it('should include the defined query parameters in "queryParameters"', async () => {
+        const request = expressRequest({
+            test: '123',
+            squiz: 'test test',
+            dx: 'team',
+            something: 'some value',
+            foo: 'val1',
+            foo2: 'val2', // defined as function query parameter
+        });
+        const requestInput = {
+            componentSet: 'set',
+            previewKey: undefined,
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-component',
+            version: '1.3.0',
+            expressRequest: request,
+            functionName: 'main',
+        };
+        const result = await renderInputService.resolveInput(requestInput);
+        const manifest = await manifestService.loadManifest('unit-test-components', 'test-component', '1.3.0');
+        const webReadyManifest = componentFunctionService.prepareManifestForWebResponse(manifest, 'set', rootUrl);
+        const expectedResult = {
+            requestId: 'test-id',
+            renderType: 'set-without-content-item',
+            functionEntryFilePath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-component/1.3.0/main.js`,
+            input: {},
+            headers: {
+                'some-header-name-1': 'mocked-component-set-header-val-1',
+                'some-header-name-2': 'mocked-component-set-header-val-2',
+            },
+            componentRootUrl: rootUrl,
+            functionName: 'main',
+            manifestForWeb: webReadyManifest,
+            componentFullName: 'unit-test-components/test-component',
+            runtimeSet: {
+                displayName: 'set',
+                environment: {},
+                webPath: 'set',
+            },
+            dxpApiKey: 'x-inter-service-api-key',
+            componentFunction: manifest.getComponentFunctionByName('main'),
+            componentSet: await componentSetService.getComponentSet('set'),
+            manifest: manifest,
+            queryParameters: {
+                foo: 'val1',
+                foo2: 'val2',
+            },
+        };
+        expect(result).toEqual(expectedResult);
+    });
+    it('should throw error if query parameter defined as required in "queryParameters" is not available', async () => {
+        const request = expressRequest({
+            test: '123',
+            squiz: 'test test',
+            dx: 'team',
+            something: 'some value',
+            foo2: 'val2',
+        });
+        const requestInput = {
+            componentSet: 'set',
+            previewKey: undefined,
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-component',
+            version: '1.3.0',
+            expressRequest: request,
+            functionName: 'main',
+        };
+        await expect(renderInputService.resolveInput(requestInput)).rejects.toMatchInlineSnapshot(`[Error: Required query parameter 'foo' is missing]`);
+    });
+    it('should NOT throw error if query parameter defined as not required in "queryParameters" is not available', async () => {
+        const request = expressRequest({
+            test: '123',
+            squiz: 'test test',
+            dx: 'team',
+            something: 'some value',
+            foo: 'foo-val',
+        });
+        const requestInput = {
+            componentSet: 'set',
+            previewKey: undefined,
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-component',
+            version: '1.3.0',
+            expressRequest: request,
+            functionName: 'main',
+        };
+        await expect(renderInputService.resolveInput(requestInput)).resolves.toBeTruthy();
+    });
+    it('should return with preview input for file data when render type is preview', async () => {
+        const requestInput = {
+            componentSet: undefined,
+            previewKey: 'another-preview',
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-preview-component',
+            version: '1.2.4',
+            expressRequest: expressRequest({
+                'should-not': 'see-this',
+            }),
+            functionName: 'main',
+        };
+        const result = await renderInputService.resolveInput(requestInput);
+        const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.4');
+        const webReadyManifest = componentFunctionService.prepareManifestForWebResponse(manifest, 'set', rootUrl);
+        const expectedResult = {
+            requestId: 'test-id',
+            renderType: 'preview',
+            functionEntryFilePath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-preview-component/1.2.4/main.js`,
+            input: {
+                integerValue: 123,
+                nested: {
+                    content: 'this is also nested content',
+                },
+            },
+            headers: {},
+            componentRootUrl: rootUrl,
+            functionName: 'main',
+            manifestForWeb: webReadyManifest,
+            componentFullName: 'unit-test-components/test-preview-component',
+            previewKey: 'another-preview',
+            runtimeSet: {
+                displayName: 'unknown',
+                environment: {},
+                webPath: 'unknown',
+            },
+            componentFunction: manifest.getComponentFunctionByName('main'),
+            manifest: manifest,
+            manifestPath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-preview-component/1.2.4/manifest.json`,
+            queryParameters: {},
+        };
+        expect(result).toEqual(expectedResult);
+    });
+    it('should return with preview input for inline data when render type is preview', async () => {
+        const requestInput = {
+            componentSet: undefined,
+            previewKey: 'test-preview',
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-preview-component',
+            version: '1.2.4',
+            expressRequest: expressRequest({
+                'should-not': 'see-this',
+            }),
+            functionName: 'main',
+        };
+        const result = await renderInputService.resolveInput(requestInput);
+        const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.4');
+        const webReadyManifest = componentFunctionService.prepareManifestForWebResponse(manifest, 'set', rootUrl);
+        const expectedResult = {
+            requestId: 'test-id',
+            renderType: 'preview',
+            functionEntryFilePath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-preview-component/1.2.4/main.js`,
+            input: {
+                integerValue: 8,
+                nested: {
+                    content: 'this is nested content',
+                },
+            },
+            headers: {},
+            componentRootUrl: rootUrl,
+            functionName: 'main',
+            manifestForWeb: webReadyManifest,
+            componentFullName: 'unit-test-components/test-preview-component',
+            previewKey: 'test-preview',
+            runtimeSet: {
+                displayName: 'unknown',
+                environment: {},
+                webPath: 'unknown',
+            },
+            componentFunction: manifest.getComponentFunctionByName('main'),
+            manifest: manifest,
+            manifestPath: `${test_helpers_1.TestHelpers.getTestComponentFolder()}/unit-test-components/test-preview-component/1.2.4/manifest.json`,
+            queryParameters: {},
+        };
+        expect(result).toEqual(expectedResult);
+    });
+    it('should pass the x-api-key through to the content item service', async () => {
+        const requestInput = {
+            componentSet: 'set',
+            previewKey: undefined,
+            contentItemId: 'valid-id',
+            namespace: 'unit-test-components',
+            componentName: 'test-component',
+            version: '1.0.0',
+            expressRequest: expressRequest(),
+            functionName: 'main',
+        };
+        await renderInputService.resolveInput(requestInput);
+        expect(getContentItemSpy).toHaveBeenCalledWith('valid-id', 'x-inter-service-api-key');
+    });
+    it('should return expected runtime set with env vars', async () => {
+        process.env.M_VAR = 'm-var-val';
+        process.env.M_VAR2 = 'm-var2-val';
+        process.env.NM_VAR = 'nm-var-val';
+        const requestInput = {
+            componentSet: undefined,
+            previewKey: 'my-preview',
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-environment-variables',
+            version: '1.0.4',
+            expressRequest: expressRequest(),
+            functionName: 'main',
+        };
+        const result = await renderInputService.resolveInput(requestInput);
+        expect(result.runtimeSet).toEqual({
+            webPath: 'unknown',
+            displayName: 'unknown',
+            environment: {
+                M_VAR: 'm-var-val',
+                M_VAR2: 'm-var2-val',
+                NM_VAR: 'nm-var-val',
+            },
+        });
+    });
+    it('should return expected runtime set with env vars - non-mandatory var not required', async () => {
+        process.env.M_VAR = 'm-var-val';
+        process.env.M_VAR2 = 'm-var2-val';
+        delete process.env.NM_VAR;
+        const requestInput = {
+            componentSet: undefined,
+            previewKey: 'my-preview',
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-environment-variables',
+            version: '1.0.4',
+            expressRequest: expressRequest(),
+            functionName: 'main',
+        };
+        const result = await renderInputService.resolveInput(requestInput);
+        expect(result.runtimeSet).toEqual({
+            webPath: 'unknown',
+            displayName: 'unknown',
+            environment: {
+                M_VAR: 'm-var-val',
+                M_VAR2: 'm-var2-val',
+            },
+        });
+    });
+    it('should return error if mandatory vars not provided', async () => {
+        delete process.env.M_VAR;
+        delete process.env.M_VAR2;
+        delete process.env.NM_VAR;
+        const requestInput = {
+            componentSet: undefined,
+            previewKey: 'my-preview',
+            contentItemId: undefined,
+            namespace: 'unit-test-components',
+            componentName: 'test-environment-variables',
+            version: '1.0.4',
+            expressRequest: expressRequest(),
+            functionName: 'main',
+        };
+        await expect(renderInputService.resolveInput(requestInput)).rejects.toThrowErrorMatchingInlineSnapshot(`"Missing required environment variables: "M_VAR","M_VAR2""`);
+    });
+    describe('getPreviewRenderInput', () => {
+        it('should not resolve formatted text from the preview data', async () => {
+            const requestInput = {
+                componentSet: undefined,
+                previewKey: 'preview-inline',
+                contentItemId: undefined,
+                namespace: 'unit-test-components',
+                componentName: 'test-preview-component',
+                version: '1.1.0',
+                expressRequest: expressRequest(),
+                functionName: 'main',
+            };
+            await expect(renderInputService.resolveInput(requestInput)).rejects.toThrowError();
+        });
+        it('should not resolve formatted text from the preview file', async () => {
+            const requestInput = {
+                componentSet: undefined,
+                previewKey: 'preview-file',
+                contentItemId: undefined,
+                namespace: 'unit-test-components',
+                componentName: 'test-preview-component',
+                version: '1.1.0',
+                expressRequest: expressRequest(),
+                functionName: 'main',
+            };
+            await expect(renderInputService.resolveInput(requestInput)).rejects.toThrowError();
+        });
+        it('should expect a string for input properties of type FormattedText', async () => {
+            const requestInput = {
+                componentSet: undefined,
+                contentItemId: undefined,
+                previewKey: 'valid-inline-preview',
+                namespace: 'unit-test-components',
+                componentName: 'test-formatted-text',
+                version: '1.0.0',
+                expressRequest: expressRequest(),
+                functionName: 'main',
+            };
+            await expect(renderInputService.resolveInput(requestInput)).resolves.toEqual(expect.objectContaining({ input: { text: expect.any(String) } }));
+        });
+    });
+    describe('getContentItemAndSetInput', () => {
+        it('should resolve formatted text from the a content item', async () => {
+            const requestInput = {
+                componentSet: 'set',
+                previewKey: undefined,
+                contentItemId: 'formatted-text-content-item',
+                namespace: 'unit-test-components',
+                componentName: 'test-formatted-text',
+                version: '2.0.0',
+                expressRequest: expressRequest(),
+                functionName: 'main',
+            };
+            const result = await renderInputService.resolveInput(requestInput);
+            expect(result.input).toEqual({
+                formattedText: '<p>This is a paragraph<span> with a span</span></p>',
+            });
+        });
+    });
+    describe('getQueryParametersFromRequest', () => {
+        const requestInputHelper = (expressRequest, version = '1.0.0') => ({
+            componentSet: 'set',
+            previewKey: undefined,
+            contentItemId: 'valid-id',
+            namespace: 'unit-test-components',
+            componentName: 'test-component-query-parameters',
+            version,
+            expressRequest,
+            functionName: 'main',
+        });
+        it('should return query parameters that are specified within the manifest component function', async () => {
+            const queryParameterToShow = { 'manifest-specified': 'shown' };
+            const queryParameterDontShow = { 'not-in-manifest': 'not shown' };
+            const requestInput = requestInputHelper(expressRequest({
+                ...queryParameterToShow,
+                ...queryParameterDontShow,
+            }));
+            const result = await renderInputService.resolveInput(requestInput);
+            expect(result.queryParameters).toEqual({
+                ...queryParameterToShow,
+            });
+        });
+        it('should throw error if required query parameters that are specified within the manifest component function not provided', async () => {
+            const parameter = 'manifest-specified';
+            const queryParameterDontShow = { 'not-in-manifest': 'not shown' };
+            const requestInput = requestInputHelper(expressRequest({
+                ...queryParameterDontShow,
+            }));
+            await expect(() => renderInputService.resolveInput(requestInput)).rejects.toThrowError(`Required query parameter '${parameter}' is missing`);
+        });
+        it('should throw error if required query parameters that are specified within the manifest component function are not string', async () => {
+            const parameter = 'manifest-specified';
+            const queryParameterToShow = { 'manifest-specified': 123 };
+            const requestInput = requestInputHelper(expressRequest({
+                ...queryParameterToShow,
+            }));
+            await expect(() => renderInputService.resolveInput(requestInput)).rejects.toThrowError(`Value for query parameter '${parameter}' must be a string`);
+        });
+        it('should return query parameters that are whitelisted and not in component function', async () => {
+            const queryParameterToShow = { 'manifest-specified': 'shown' };
+            const queryParameterDontShow = { 'not-in-manifest': 'not shown' };
+            const queryParameterWhitelisted = { _contentContext: 'matrix context' };
+            const requestInput = requestInputHelper(expressRequest({
+                ...queryParameterToShow,
+                ...queryParameterDontShow,
+                ...queryParameterWhitelisted,
+            }));
+            const result = await renderInputService.resolveInput(requestInput);
+            expect(result.queryParameters).toEqual({
+                ...queryParameterToShow,
+                ...queryParameterWhitelisted,
+            });
+        });
+        it('should throw error if whitelisted query parameters that are included are not string', async () => {
+            const parameter = '_contentContext';
+            const queryParameterWhitelisted = { _contentContext: 123 };
+            const requestInput = requestInputHelper(expressRequest({
+                ...queryParameterWhitelisted,
+            }));
+            await expect(() => renderInputService.resolveInput(requestInput)).rejects.toThrowError(`Value for query parameter '${parameter}' must be a string`);
+        });
+    });
+});
+//# sourceMappingURL=RenderInputService.spec.js.map