@redocly/openapi-docs 3.24.0 → 3.24.1

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

@@ -0,0 +1,1201 @@
+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