@redocly/openapi-docs 3.24.1 → 3.25.0-next.1

package/lib/services/code-samples/__tests__/generator.test.js

@@ -1,1201 +0,0 @@
-import { SecurityVariablesEnvSuffix } from '@redocly/theme/core/openapi';
-import { getOperation } from '../../../models/index.js';
-import { getCodeSample, getDataRequest } from '../generator.js';
-import { normalizeOptions } from '../../config-options/normalizeOptions.js';
-import { OpenAPIParser } from '../../OpenAPIParser.js';
-// Mock translate function for tests
-const mockTranslate = ((key) => key);
-export const testGetOperation = {
-    summary: 'test',
-    responses: { '200': {} },
-    parameters: [
-        {
-            name: 'id',
-            in: 'path',
-            schema: { type: 'string' },
-        },
-    ],
-    requestBody: {
-        content: {
-            'application/json': {
-                schema: {
-                    type: 'object',
-                    properties: {
-                        a: {
-                            type: 'string',
-                        },
-                        b: {
-                            type: 'string',
-                        },
-                    },
-                },
-            },
-            'application/x-www-form-urlencoded': {
-                schema: {
-                    type: 'object',
-                    properties: {
-                        a: {
-                            type: 'string',
-                        },
-                        b: {
-                            type: 'string',
-                        },
-                    },
-                },
-            },
-            'application/xml': {
-                schema: {
-                    type: 'object',
-                    properties: {
-                        a: {
-                            type: 'string',
-                            example: 'test-value-a',
-                        },
-                        b: {
-                            type: 'object',
-                        },
-                        d: {
-                            type: 'object',
-                        },
-                    },
-                },
-            },
-            'multipart/form-data': {
-                schema: {
-                    type: 'object',
-                    properties: {
-                        a: {
-                            type: 'string',
-                        },
-                        b: {
-                            type: 'object',
-                        },
-                        d: {
-                            type: 'object',
-                        },
-                        g: {
-                            type: 'object',
-                        },
-                    },
-                },
-            },
-        },
-    },
-};
-export const testPostOperation = {
-    summary: 'test',
-    responses: { '200': {} },
-    parameters: [
-        {
-            name: 'session_token',
-            in: 'cookie',
-            schema: { type: 'string' },
-        },
-    ],
-    requestBody: {
-        content: {
-            'application/json': {
-                schema: {
-                    type: 'object',
-                    properties: {
-                        a: {
-                            type: 'string',
-                        },
-                        b: {
-                            type: 'string',
-                        },
-                    },
-                },
-            },
-        },
-    },
-};
-export const testDefinition = {
-    openapi: '3.0.0',
-    info: { version: '1.0', title: 'Foo' },
-    security: [{ testApiKey: [] }, { testBasicAuth: [], testApiKey: [] }],
-    paths: {
-        '/test/{id}': {
-            get: testGetOperation,
-            post: testPostOperation,
-        },
-    },
-    components: {
-        securitySchemes: {
-            testApiKey: { type: 'apiKey', in: 'header', name: 'X-API-Key' },
-            testBasicAuth: { type: 'http', scheme: 'basic' },
-        },
-    },
-};
-describe('getCodeSample', () => {
-    const options = normalizeOptions({});
-    const parser = new OpenAPIParser(testDefinition, undefined, options);
-    const operationStore = {
-        activeServer: {
-            url: 'http://petstore.swagger.io/v2',
-        },
-        requestValues: {},
-    };
-    let operation;
-    beforeEach(() => {
-        operation = getOperation(parser, {
-            pointer: '#/paths/~1test~1{id}/get',
-            pathName: '/test/{id}',
-            httpVerb: 'GET',
-            pathParameters: [],
-            pathServers: [],
-            isWebhook: false,
-            isAdditionalOperation: false,
-            operationId: 'getPet',
-            defaultSampleName: 'defaultSampleName',
-            ...testGetOperation,
-        }, undefined, options, '');
-        vi.resetAllMocks();
-    });
-    it('should  show correct code sample if operation is not visible', () => {
-        const operationNotVisible = getOperation(parser, {
-            pointer: '#/paths/~1test~1{id}/get',
-            pathName: '/test/{id}',
-            httpVerb: 'GET',
-            pathParameters: [],
-            pathServers: [],
-            isWebhook: false,
-            isAdditionalOperation: false,
-            operationId: 'getPet',
-            defaultSampleName: 'defaultSampleName',
-            ...testGetOperation,
-        }, undefined, options, '', { isCallback: false }, undefined);
-        const sample = getCodeSample({
-            lang: 'Node.js',
-            operation: operationNotVisible,
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "import fetch from 'node-fetch';
-
-      async function run() {
-        const id = 'YOUR_id_PARAMETER';
-        const resp = await fetch(
-          \`http://localhost:3000/test/\${id}\`,
-          {
-            method: 'GET',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-API-Key': 'YOUR_API_KEY_HERE'
-            },
-            body: JSON.stringify({
-              a: 'string',
-              b: 'string'
-            })
-          }
-        );
-
-        const data = await resp.json();
-        console.log(data);
-      }
-
-      run();"
-    `);
-    });
-    it('should properly handler query parameters', () => {
-        const queryParameters = [
-            {
-                name: 'q1',
-                in: 'query',
-                schema: {
-                    type: 'string',
-                    rawSchema: { type: 'string' },
-                },
-                style: 'form',
-                required: false,
-                example: '1',
-            },
-            {
-                name: 'q2',
-                in: 'query',
-                schema: {
-                    type: 'string',
-                    rawSchema: { type: 'string' },
-                },
-                style: 'form',
-                required: false,
-                example: '2',
-            },
-        ];
-        const params = {
-            operation: {
-                ...operation,
-                parameters: [...operation.parameters, ...queryParameters],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        };
-        const nodeSample = getCodeSample({
-            lang: 'Node.js',
-            ...params,
-        });
-        const curlSample = getCodeSample({
-            lang: 'curl',
-            ...params,
-        });
-        // no query parameters in the URL because we have a query object
-        expect(nodeSample).toMatchInlineSnapshot(`
-      "import fetch from 'node-fetch';
-
-      async function run() {
-        const query = new URLSearchParams({q1: '1', q2: '2'}).toString();
-
-        const id = 'YOUR_id_PARAMETER';
-        const resp = await fetch(
-          \`http://localhost:3000/test/\${id}?\${query}\`,
-          {
-            method: 'GET',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-API-Key': 'YOUR_API_KEY_HERE'
-            },
-            body: JSON.stringify({
-              a: 'string',
-              b: 'string'
-            })
-          }
-        );
-
-        const data = await resp.json();
-        console.log(data);
-      }
-
-      run();"
-    `);
-        // query parameters in the URL because we don't have a query object
-        expect(curlSample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        'http://localhost:3000/test/{id}?q1=1&q2=2' \\
-        -H 'Content-Type: application/json' \\
-        -H 'X-API-Key: YOUR_API_KEY_HERE' \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should convert operation to proper code sample', () => {
-        const sample = getCodeSample({
-            lang: 'Node.js',
-            operation,
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "import fetch from 'node-fetch';
-
-      async function run() {
-        const id = 'YOUR_id_PARAMETER';
-        const resp = await fetch(
-          \`http://localhost:3000/test/\${id}\`,
-          {
-            method: 'GET',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-API-Key': 'YOUR_API_KEY_HERE'
-            },
-            body: JSON.stringify({
-              a: 'string',
-              b: 'string'
-            })
-          }
-        );
-
-        const data = await resp.json();
-        console.log(data);
-      }
-
-      run();"
-    `);
-    });
-    it('should show correct security type when multiple activeSecuritySchemeIds passed', () => {
-        const operationStoreWithActiveSecurityScheme = {
-            ...operationStore,
-            activeSecuritySchemeIds: ['testBasicAuth', 'testApiKey'],
-        };
-        const sample = getCodeSample({
-            lang: 'Node.js',
-            operation,
-            options: { store: operationStoreWithActiveSecurityScheme },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "import fetch from 'node-fetch';
-
-      async function run() {
-        const id = 'YOUR_id_PARAMETER';
-        const resp = await fetch(
-          \`http://localhost:3000/test/\${id}\`,
-          {
-            method: 'GET',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-API-Key': 'YOUR_API_KEY_HERE',
-              Authorization: 'Basic ' + Buffer.from('<username>:<password>').toString('base64')
-            },
-            body: JSON.stringify({
-              a: 'string',
-              b: 'string'
-            })
-          }
-        );
-
-        const data = await resp.json();
-        console.log(data);
-      }
-
-      run();"
-    `);
-    });
-    it('should show correct security type when single value passed in activeSecuritySchemeIds', () => {
-        const operationStoreWithActiveSecurityScheme = {
-            ...operationStore,
-            activeSecuritySchemeIds: ['testApiKey'],
-        };
-        const sample = getCodeSample({
-            lang: 'Node.js',
-            operation,
-            options: { store: operationStoreWithActiveSecurityScheme },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "import fetch from 'node-fetch';
-
-      async function run() {
-        const id = 'YOUR_id_PARAMETER';
-        const resp = await fetch(
-          \`http://localhost:3000/test/\${id}\`,
-          {
-            method: 'GET',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-API-Key': 'YOUR_API_KEY_HERE'
-            },
-            body: JSON.stringify({
-              a: 'string',
-              b: 'string'
-            })
-          }
-        );
-
-        const data = await resp.json();
-        console.log(data);
-      }
-
-      run();"
-    `);
-    });
-    it('should support custom path parameters values', () => {
-        const sample = getCodeSample({
-            lang: 'Node.js',
-            operation,
-            pathParams: { id: 'test-value' },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "import fetch from 'node-fetch';
-
-      async function run() {
-        const id = 'test-value';
-        const resp = await fetch(
-          \`http://localhost:3000/test/\${id}\`,
-          {
-            method: 'GET',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-API-Key': 'YOUR_API_KEY_HERE'
-            },
-            body: JSON.stringify({
-              a: 'string',
-              b: 'string'
-            })
-          }
-        );
-
-        const data = await resp.json();
-        console.log(data);
-      }
-
-      run();"
-    `);
-    });
-    it('should support custom body properties values', () => {
-        const sample = getCodeSample({
-            lang: 'Node.js',
-            operation,
-            properties: { a: 'test-value' },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "import fetch from 'node-fetch';
-
-      async function run() {
-        const id = 'YOUR_id_PARAMETER';
-        const resp = await fetch(
-          \`http://localhost:3000/test/\${id}\`,
-          {
-            method: 'GET',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-API-Key': 'YOUR_API_KEY_HERE'
-            },
-            body: JSON.stringify({
-              a: 'test-value',
-              b: 'string'
-            })
-          }
-        );
-
-        const data = await resp.json();
-        console.log(data);
-      }
-
-      run();"
-    `);
-    });
-    it('should work properly with form-data and url-encoded', () => {
-        const sample = getCodeSample({
-            lang: 'Node.js',
-            operation,
-            properties: { a: 'test-value' },
-            options: { store: operationStore, activeMimeName: 'application/x-www-form-urlencoded' },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "import fetch from 'node-fetch';
-
-      async function run() {
-        const formData = {
-          a: 'test-value',
-          b: 'string'
-        };
-
-        const id = 'YOUR_id_PARAMETER';
-        const resp = await fetch(
-          \`http://localhost:3000/test/\${id}\`,
-          {
-            method: 'GET',
-            headers: {
-              'Content-Type': 'application/x-www-form-urlencoded',
-              'X-API-Key': 'YOUR_API_KEY_HERE'
-            },
-            body: new URLSearchParams(formData).toString()
-          }
-        );
-
-        const data = await resp.text();
-        console.log(data);
-      }
-
-      run();"
-    `);
-    });
-    it('should work properly with server variables', () => {
-        const operationStore = {
-            activeServer: {
-                url: 'https://api.{environment}',
-            },
-            requestValues: {},
-        };
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: { ...operation, servers: [{ url: 'https://api.{environment}' }] },
-            options: { store: operationStore, activeMimeName: 'multipart/form-data' },
-            environment: {
-                server: 'https://api.{environment}',
-                environment: 'production',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        'https://api.production/test/{id}' \\
-        -H 'Content-Type: multipart/form-data' \\
-        -H 'X-API-Key: YOUR_API_KEY_HERE' \\
-        -F a=string"
-    `);
-    });
-    it('should work properly with multipart/form-data', () => {
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation,
-            properties: {
-                a: 'test-value-a',
-                b: { c: 'test-value-b-c' },
-                d: { e: { f: 'test-value-d-e-f' } },
-                g: { h: ['value 1', 'value 2', 'value 3'] },
-                f: { items: [{ name: 'John Doe', age: 100 }] },
-            },
-            options: { store: operationStore, activeMimeName: 'multipart/form-data' },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        'http://localhost:3000/test/{id}' \\
-        -H 'Content-Type: multipart/form-data' \\
-        -H 'X-API-Key: YOUR_API_KEY_HERE' \\
-        -F a=test-value-a \\
-        -F 'b[c]=test-value-b-c' \\
-        -F 'd[e][f]=test-value-d-e-f' \\
-        -F 'g[h]=value 1' \\
-        -F 'g[h]=value 2' \\
-        -F 'g[h]=value 3' \\
-        -F 'f[items][0][name]=John Doe' \\
-        -F 'f[items][0][age]=100'"
-    `);
-    });
-    it('should work properly with application/xml', () => {
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation,
-            properties: {
-                a: 'test-value-a',
-                b: { c: 'test-value-b-c' },
-                d: { e: ['value 1', 'value 2', 'value 3'] },
-            },
-            options: { store: operationStore, activeMimeName: 'application/xml' },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        'http://localhost:3000/test/{id}' \\
-        -H 'Content-Type: application/xml' \\
-        -H 'X-API-Key: YOUR_API_KEY_HERE' \\
-        -d '<root>
-          <a>test-value-a</a>
-          <b></b>
-          <d></d>
-        </root>
-        '"
-    `);
-    });
-    it('should handle http security type with basic auth', () => {
-        const basicAuth = {
-            type: 'http',
-            scheme: 'basic',
-            id: 'testSchemeId',
-            scopes: [],
-            sectionId: 'sectionId',
-            bearerFormat: '',
-            flows: {},
-        };
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: {
-                ...operation,
-                security: [
-                    {
-                        schemes: [basicAuth],
-                    },
-                ],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-                [basicAuth.id + SecurityVariablesEnvSuffix.Username]: 'test-user',
-                [basicAuth.id + SecurityVariablesEnvSuffix.Password]: '12345',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        -u test-user:12345 \\
-        'http://localhost:3000/test/{id}' \\
-        -H 'Content-Type: application/json' \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should handle http security type with basic auth and no credentials', () => {
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: {
-                ...operation,
-                security: [
-                    {
-                        schemes: [
-                            {
-                                type: 'http',
-                                scheme: 'basic',
-                                id: 'testSchemeId',
-                                sectionId: 'sectionId',
-                                scopes: [],
-                                bearerFormat: '',
-                                flows: {},
-                            },
-                        ],
-                    },
-                ],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        -u <username>:<password> \\
-        'http://localhost:3000/test/{id}' \\
-        -H 'Content-Type: application/json' \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should handle http security type with bearer auth', () => {
-        const bearerAuth = {
-            type: 'http',
-            scheme: 'bearer',
-            id: 'testSchemeId',
-            scopes: [],
-            sectionId: 'sectionId',
-            bearerFormat: '',
-            flows: {},
-        };
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: {
-                ...operation,
-                security: [
-                    {
-                        schemes: [bearerAuth],
-                    },
-                ],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-                [bearerAuth.id + SecurityVariablesEnvSuffix.Token]: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6Ikpva',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        'http://localhost:3000/test/{id}' \\
-        -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6Ikpva' \\
-        -H 'Content-Type: application/json' \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should handle http security type with bearer auth and no token provided', () => {
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: {
-                ...operation,
-                security: [
-                    {
-                        schemes: [
-                            {
-                                type: 'http',
-                                scheme: 'bearer',
-                                id: 'testSchemeId',
-                                sectionId: 'sectionId',
-                                scopes: [],
-                                bearerFormat: '',
-                                flows: {},
-                            },
-                        ],
-                    },
-                ],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        'http://localhost:3000/test/{id}' \\
-        -H 'Authorization: Bearer <YOUR_TOKEN_HERE>' \\
-        -H 'Content-Type: application/json' \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should handle basic auth with server specific credentials', () => {
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: {
-                ...operation,
-                security: [
-                    {
-                        schemes: [
-                            {
-                                type: 'http',
-                                scheme: 'basic',
-                                id: 'testSchemeId',
-                                sectionId: 'sectionId',
-                                scopes: [],
-                                bearerFormat: '',
-                                flows: {},
-                                serverValues: {
-                                    'http://petstore.swagger.io/v2': {
-                                        'x-defaultUsername': 'test-user',
-                                        'x-defaultPassword': '12345',
-                                    },
-                                    'http://dev-petstore.swagger.io/v2': {
-                                        'x-defaultUsername': 'test-user-dev',
-                                        'x-defaultPassword': '12345-dev',
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                ],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        -u test-user:12345 \\
-        'http://localhost:3000/test/{id}' \\
-        -H 'Content-Type: application/json' \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should handle server specific path parameter', () => {
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: {
-                ...operation,
-                parameters: [
-                    {
-                        name: 'id',
-                        in: 'path',
-                        example: 'test-value',
-                        serverValues: {
-                            'http://petstore.swagger.io/v2': {
-                                example: 'test-value-env',
-                            },
-                        },
-                    },
-                ],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        http://localhost:3000/test/test-value-env \\
-        -H 'Content-Type: application/json' \\
-        -H 'X-API-Key: YOUR_API_KEY_HERE' \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should handle server specific query parameter', () => {
-        const queryParameter = {
-            name: 'page',
-            in: 'query',
-            schema: {
-                type: 'string',
-                rawSchema: { type: 'string' },
-            },
-            style: 'form',
-            required: false,
-            example: '2',
-            serverValues: {
-                'http://petstore.swagger.io/v2': {
-                    example: '10',
-                },
-            },
-        };
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: {
-                ...operation,
-                parameters: [...operation.parameters, queryParameter],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X GET \\
-        'http://localhost:3000/test/{id}?page=10' \\
-        -H 'Content-Type: application/json' \\
-        -H 'X-API-Key: YOUR_API_KEY_HERE' \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should handle server specific cookie parameters', () => {
-        const postOperation = getOperation(parser, {
-            pointer: '#/paths/~1test~1{id}/post',
-            pathName: '/test/{id}',
-            httpVerb: 'POST',
-            pathParameters: [],
-            pathServers: [],
-            isWebhook: false,
-            isAdditionalOperation: false,
-            operationId: 'addPet',
-            defaultSampleName: 'defaultSampleName',
-            ...testPostOperation,
-        }, undefined, options, '', { isCallback: false }, undefined);
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: {
-                ...postOperation,
-                parameters: [
-                    {
-                        name: 'session_token',
-                        in: 'cookie',
-                        example: 'test-value',
-                        style: 'form',
-                        serverValues: {
-                            'http://petstore.swagger.io/v2': {
-                                example: 'test-value-env',
-                            },
-                        },
-                    },
-                ],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X POST \\
-        'http://localhost:3000/test/{id}' \\
-        -H 'Content-Type: application/json' \\
-        -H 'X-API-Key: YOUR_API_KEY_HERE' \\
-        -b session_token=test-value-env \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should handle server specific header parameters', () => {
-        const postOperation = getOperation(parser, {
-            pointer: '#/paths/~1test~1{id}/post',
-            pathName: '/test/{id}',
-            httpVerb: 'POST',
-            pathParameters: [],
-            pathServers: [],
-            isWebhook: false,
-            isAdditionalOperation: false,
-            operationId: 'addPet',
-            defaultSampleName: 'defaultSampleName',
-            ...testPostOperation,
-        }, undefined, options, '', { isCallback: false }, undefined);
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: {
-                ...postOperation,
-                parameters: [
-                    {
-                        name: 'User-Agent',
-                        in: 'header',
-                        example: 'test-value',
-                        style: 'form',
-                        serverValues: {
-                            'http://petstore.swagger.io/v2': {
-                                example: 'test-value-env',
-                            },
-                        },
-                    },
-                ],
-            },
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toMatchInlineSnapshot(`
-      "curl -i -X POST \\
-        'http://localhost:3000/test/{id}' \\
-        -H 'Content-Type: application/json' \\
-        -H 'User-Agent: test-value-env' \\
-        -H 'X-API-Key: YOUR_API_KEY_HERE' \\
-        -d '{
-          "a": "string",
-          "b": "string"
-        }'"
-    `);
-    });
-    it('should handle variable interpolation', () => {
-        const operationStoreWithNestedVars = {
-            activeServer: {
-                url: 'https://api.{domain}',
-            },
-            requestValues: {},
-        };
-        const testParams = {
-            operation,
-            pathParams: { id: 'test-value' },
-            options: { store: operationStoreWithNestedVars },
-            environment: {
-                server: 'https://api.{domain}',
-                domain: 'example.hxrenew.com',
-                oauth2_base: 'https://accounts.{domain}/oauth2',
-            },
-            translate: mockTranslate,
-        };
-        const jsSample = getCodeSample({
-            lang: 'JavaScript',
-            ...testParams,
-        });
-        expect(jsSample).toMatchInlineSnapshot(`
-      "const id = 'test-value';
-      const domain = 'example.hxrenew.com';
-      const oauth2Base = \`https://accounts.\${domain}/oauth2\`;
-      const resp = await fetch(
-        \`http://localhost:3000/test/\${id}\`,
-        {
-          method: 'GET',
-          headers: {
-            'Content-Type': 'application/json',
-            'X-API-Key': 'YOUR_API_KEY_HERE'
-          },
-          body: JSON.stringify({
-            a: 'string',
-            b: 'string'
-          })
-        }
-      );
-
-      const data = await resp.json();
-      console.log(data);"
-    `);
-        const pythonSample = getCodeSample({
-            lang: 'Python',
-            ...testParams,
-        });
-        expect(pythonSample).toMatchInlineSnapshot(`
-      "import requests
-
-      id = "test-value"
-      domain = "example.hxrenew.com"
-      oauth_2_base = "https://accounts." + domain + "/oauth2"
-      url = "http://localhost:3000/test/" + id
-
-      payload = {
-        "a": "string",
-        "b": "string"
-      }
-
-      headers = {
-        "Content-Type": "application/json",
-        "X-API-Key": "YOUR_API_KEY_HERE"
-      }
-
-      response = requests.get(url, json=payload, headers=headers)
-
-      data = response.json()
-      print(data)"
-    `);
-        const phpSample = getCodeSample({
-            lang: 'PHP',
-            ...testParams,
-        });
-        expect(phpSample).toMatchInlineSnapshot(`
-      "/**
-       * Requires libcurl
-       */
-
-      const id = "test-value";
-      const domain = "example.hxrenew.com";
-      const oauth2Base = "https://accounts." . domain . "/oauth2";
-      $curl = curl_init();
-
-      $payload = array(
-        "a" => "string",
-        "b" => "string"
-      );
-
-      curl_setopt_array($curl, [
-        CURLOPT_HTTPHEADER => [
-          "Content-Type: application/json",
-          "X-API-Key: YOUR_API_KEY_HERE"
-        ],
-        CURLOPT_POSTFIELDS => json_encode($payload),
-        CURLOPT_PORT => "3000",
-        CURLOPT_URL => "http://localhost:3000/test/" . id,
-        CURLOPT_RETURNTRANSFER => true,
-        CURLOPT_CUSTOMREQUEST => "GET",
-      ]);
-
-      $response = curl_exec($curl);
-      $error = curl_error($curl);
-
-      curl_close($curl);
-
-      if ($error) {
-        echo "cURL Error #:" . $error;
-      } else {
-        echo $response;
-      }"
-    `);
-    });
-    it('should handle querystring parameter with form-urlencoded content and object value', () => {
-        const querystringParameter = {
-            name: 'filter',
-            in: 'querystring',
-            content: {
-                'application/x-www-form-urlencoded': {
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' },
-                            age: { type: 'number' },
-                        },
-                        rawSchema: {
-                            type: 'object',
-                            properties: {
-                                name: { type: 'string' },
-                                age: { type: 'number' },
-                            },
-                        },
-                    },
-                },
-            },
-            required: false,
-        };
-        const parser = new OpenAPIParser({
-            openapi: '3.2.0',
-            info: { title: 'Test', version: '1.0' },
-            paths: {
-                '/test': {
-                    get: {
-                        summary: 'test',
-                        responses: { '200': {} },
-                        parameters: [querystringParameter],
-                    },
-                },
-            },
-        }, undefined, options);
-        const testOperation = getOperation(parser, {
-            pointer: '#/paths/~1test/get',
-            pathName: '/test',
-            httpVerb: 'GET',
-            pathParameters: [],
-            pathServers: [],
-            isWebhook: false,
-            isAdditionalOperation: false,
-            operationId: 'testQuerystring',
-            defaultSampleName: 'defaultSampleName',
-            summary: 'test',
-            responses: { '200': {} },
-            parameters: [querystringParameter],
-        }, undefined, options, '');
-        const sample = getCodeSample({
-            lang: 'curl',
-            operation: testOperation,
-            options: { store: operationStore },
-            environment: {
-                server: 'http://petstore.swagger.io/v2',
-            },
-            translate: mockTranslate,
-        });
-        expect(sample).toContain('name=');
-        expect(sample).toContain('age=');
-    });
-});
-describe('getDataRequest', () => {
-    it('should return false when exampleValue is falsy', () => {
-        expect(getDataRequest(null, {})).toBe(false);
-        expect(getDataRequest(undefined, {})).toBe(false);
-        expect(getDataRequest('', {})).toBe(false);
-    });
-    it('should return exampleValue when it is an object with properties and empty properties param', () => {
-        const example = { foo: 'bar' };
-        expect(getDataRequest(example, {})).toEqual(example);
-    });
-    it('should merge exampleValue object with properties', () => {
-        const example = { foo: 'bar' };
-        const props = { baz: 'qux' };
-        expect(getDataRequest(example, props)).toEqual({
-            foo: 'bar',
-            baz: 'qux',
-        });
-    });
-    it('should parse JSON string and merge with properties', () => {
-        const example = '{"foo":"bar"}';
-        const props = { baz: 'qux' };
-        expect(getDataRequest(example, props)).toEqual({
-            foo: 'bar',
-            baz: 'qux',
-        });
-    });
-    it('should return false when JSON parsing fails', () => {
-        const example = 'invalid json';
-        const props = { baz: 'qux' };
-        expect(getDataRequest(example, props)).toBe(false);
-    });
-    it('should merge arrays using arrayMergeStrategy', () => {
-        const example = { arr: [1, 2] };
-        const props = { arr: [3, 4] };
-        expect(getDataRequest(example, props)).toEqual({
-            arr: [3, 4], //it is correct, because arrayMergeStrategy returns second array
-        });
-    });
-});
-//# sourceMappingURL=generator.test.js.map