@redocly/openapi-docs 3.24.0-next.9 → 3.24.1

package/lib/services/code-samples/__tests__/get-example-value-by-mime-type.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/code-samples/__tests__/get-example-value-by-mime-type.test.js

@@ -0,0 +1,31 @@
+import { getExampleValueByMimeType } from '../get-example-value-by-mime-type.js';
+describe('getExampleValueByMimeType', () => {
+    it('returns an empty string for undefined values', () => {
+        expect(getExampleValueByMimeType(undefined, 'application/json')).toBe('');
+    });
+    it('pretty-prints objects for json-like media types', () => {
+        expect(getExampleValueByMimeType({ a: 1, b: 'two' }, 'application/json')).toBe('{\n  "a": 1,\n  "b": "two"\n}');
+    });
+    it('parses and pretty-prints JSON provided as a string', () => {
+        expect(getExampleValueByMimeType('{"a":1}', 'application/json')).toBe('{\n  "a": 1\n}');
+    });
+    it('falls back to the raw string when a json-like string is not valid JSON', () => {
+        expect(getExampleValueByMimeType('not json', 'application/json')).toBe('not json');
+    });
+    it('url-encodes objects for application/x-www-form-urlencoded', () => {
+        const result = getExampleValueByMimeType({ a: 'x', b: 'y' }, 'application/x-www-form-urlencoded');
+        expect(result).toContain('a=x');
+        expect(result).toContain('b=y');
+    });
+    it('builds XML for xml-like media types', () => {
+        expect(getExampleValueByMimeType({ name: 'John' }, 'application/xml')).toContain('<name>John</name>');
+    });
+    it('stringifies objects as JSON for non-json, non-xml, non-form media types', () => {
+        expect(getExampleValueByMimeType({ a: 1 }, 'text/plain')).toBe('{\n  "a": 1\n}');
+    });
+    it('stringifies primitive values', () => {
+        expect(getExampleValueByMimeType('hello', 'text/plain')).toBe('hello');
+        expect(getExampleValueByMimeType(42, 'text/plain')).toBe('42');
+    });
+});
+//# sourceMappingURL=get-example-value-by-mime-type.test.js.map

package/lib/services/code-samples/httpsnippet/__tests__/device-authorization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/code-samples/httpsnippet/__tests__/device-authorization.test.js

@@ -0,0 +1,222 @@
+import { HTTPSnippet } from '../index.js';
+describe('Device Authorization Flow', () => {
+    // Base HAR request for device authorization
+    const baseDeviceAuthHAR = {
+        method: 'POST',
+        url: 'https://petstore.swagger.io/v2/pet',
+        httpVersion: 'HTTP/1.1',
+        headers: [
+            { name: 'Content-Type', value: 'application/json' },
+            { name: 'Authorization', value: 'Bearer <YOUR_TOKEN_HERE>' },
+        ],
+        queryString: [],
+        postData: {
+            mimeType: 'application/json',
+            text: JSON.stringify({ name: 'Fluffy', status: 'available' }),
+            params: [],
+        },
+        cookies: [],
+        headersSize: -1,
+        bodySize: -1,
+        securityOAuth2ExtraCalls: [
+            {
+                method: 'POST',
+                url: 'http://petstore.swagger.io/api/oauth/device',
+                httpVersion: 'HTTP/1.1',
+                headers: [
+                    { name: 'Content-Type', value: 'application/x-www-form-urlencoded' },
+                    { name: 'Accept', value: 'application/json' },
+                ],
+                queryString: [],
+                postData: {
+                    mimeType: 'application/x-www-form-urlencoded',
+                    text: '',
+                    params: [
+                        { name: 'client_id', value: 'test-client-id' },
+                        { name: 'scope', value: 'write:pets read:pets' },
+                    ],
+                },
+                cookies: [],
+                headersSize: -1,
+                bodySize: -1,
+                flowType: 'deviceAuthorization',
+                tokenUrl: 'http://petstore.swagger.io/api/oauth/token',
+                clientId: 'test-client-id',
+                securityOAuth2ExtraCalls: [],
+            },
+        ],
+    };
+    describe('Node.js', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('node', 'fetch', {});
+            expect(code).toContain('device_code');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/token');
+            expect(code).toContain('while (Date.now() < deadline)');
+            expect(code).toContain('urn:ietf:params:oauth:grant-type:device_code');
+            expect(code).toContain('accessToken');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('JavaScript', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('javascript', 'fetch', {});
+            expect(code).toContain('device_code');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('while (Date.now() < deadline)');
+            expect(code).toContain('accessToken');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('Python', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('python', 'requests', {});
+            expect(code).toContain('time.time()');
+            expect(code).toContain('device_code');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('while time.time() < deadline:');
+            expect(code).toContain('access_token');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('PHP', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('php', 'curl', {});
+            expect(code).toContain('device_code');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('while (time() < $deadline)');
+            expect(code).toContain('usleep');
+            expect(code).toContain('$accessToken');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('Go', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('go', 'native', {});
+            expect(code).toContain('"time"');
+            expect(code).toContain('Device_code');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('for time.Now().Unix() < deadline');
+            expect(code).toContain('time.Sleep');
+            expect(code).toContain('accessToken');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('C#', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('csharp', 'httpclient', {});
+            expect(code).toContain('using System.Text.Json');
+            expect(code).toContain('deviceCode');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('while (DateTime.UtcNow < deadline)');
+            expect(code).toContain('await Task.Delay');
+            expect(code).toContain('accessToken');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('C# + Newtonsoft', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('csharpNewtonsoft', 'httpclient', {});
+            expect(code).toContain('using Newtonsoft.Json.Linq');
+            expect(code).toContain('deviceCode');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('while (DateTime.UtcNow < deadline)');
+            expect(code).toContain('JObject');
+            expect(code).toContain('accessToken');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('Java', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('java', 'httpclient', {});
+            expect(code).toContain('JSONObject');
+            expect(code).toContain('deviceCode');
+            expect(code).toContain('/api/oauth/device');
+            expect(code).toContain('/api/oauth/token');
+            expect(code).toContain('while (System.currentTimeMillis() < deadline)');
+            expect(code).toContain('Thread.sleep');
+            expect(code).toContain('accessToken');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('Java8+Apache', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('java8', 'apachehttp', {});
+            expect(code).toContain('JSONObject');
+            expect(code).toContain('deviceCode');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('while (System.currentTimeMillis() < deadline)');
+            expect(code).toContain('Thread.sleep');
+            expect(code).toContain('accessToken');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('R', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('r', 'httr', {});
+            expect(code).toContain('library(httr)');
+            expect(code).toContain('device_code');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('while (as.numeric(Sys.time()) < deadline)');
+            expect(code).toContain('Sys.sleep');
+            expect(code).toContain('access_token');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('Ruby', () => {
+        it('should generate device authorization flow code', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('ruby', 'native', {});
+            expect(code).toContain("require 'json'");
+            expect(code).toContain('device_code');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('while Time.now.to_i < deadline');
+            expect(code).toContain('sleep');
+            expect(code).toContain('access_token');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('curl', () => {
+        it('should generate device authorization flow script', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('shell', 'curl', {});
+            expect(code).toContain('DEVICE_CODE=');
+            expect(code).toContain('http://petstore.swagger.io/api/oauth/device');
+            expect(code).toContain('while [ $(date +%s) -lt $DEADLINE ]');
+            expect(code).toContain('jq -r');
+            expect(code).toContain('ACCESS_TOKEN');
+            expect(code).toMatchSnapshot();
+        });
+    });
+    describe('Error handling', () => {
+        it('should handle slow_down error', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const code = snippet.convert('node', 'fetch', {});
+            expect(code).toContain('slow_down');
+            expect(code).toContain('intervalMs');
+        });
+        it('should handle access_denied and expired_token errors', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const pythonCode = snippet.convert('python', 'requests', {});
+            expect(pythonCode).toContain('access_denied');
+            expect(pythonCode).toContain('expired_token');
+            expect(pythonCode).toContain('Device flow failed');
+        });
+        it('should handle timeout', () => {
+            const snippet = new HTTPSnippet(baseDeviceAuthHAR);
+            const goCode = snippet.convert('go', 'native', {});
+            expect(goCode).toContain('Timed out waiting for authorization');
+        });
+    });
+});
+//# sourceMappingURL=device-authorization.test.js.map

package/lib/services/code-samples/httpsnippet/helpers/__tests__/code-helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/code-samples/httpsnippet/helpers/__tests__/code-helpers.test.js

@@ -0,0 +1,129 @@
+import { buildUrlExpression, parseUrlIntoOperands, printUrlVariablesDeclarations, } from '../code-helpers.js';
+import { Lang } from '../constants.js';
+import { CodeBuilder } from '../code-builder.js';
+import { buildUrlExpressionData, commonVariablesInput, printUrlVariablesDeclarationsOutput, } from '../mocks/code-helpers-mock.js';
+describe('parseUrlIntoOperands', () => {
+    it('should correctly parse string without path parameters', () => {
+        expect(parseUrlIntoOperands('/v1/test', {})).toEqual([{ type: 'string', value: '/v1/test' }]);
+    });
+    it('should correctly parse string with single known parameter in the end', () => {
+        expect(parseUrlIntoOperands('/v1/{test}', { test: '1' })).toEqual([
+            { type: 'string', value: '/v1/' },
+            { type: 'variable', name: 'test' },
+        ]);
+    });
+    it('should correctly parse string with single known parameter in the middle', () => {
+        expect(parseUrlIntoOperands('/v1/{test}/test', { test: '1' })).toEqual([
+            { type: 'string', value: '/v1/' },
+            { type: 'variable', name: 'test' },
+            { type: 'string', value: '/test' },
+        ]);
+    });
+    it('should correctly parse string with single known parameter and trailing slash', () => {
+        expect(parseUrlIntoOperands('/v1/{test}/', { test: '1' })).toEqual([
+            { type: 'string', value: '/v1/' },
+            { type: 'variable', name: 'test' },
+            { type: 'string', value: '/' },
+        ]);
+    });
+    it('should correctly parse string with multiple known parameters', () => {
+        expect(parseUrlIntoOperands('/v1/{test2}/{test}', { test: '1', test2: '1' })).toEqual([
+            { type: 'string', value: '/v1/' },
+            { type: 'variable', name: 'test2' },
+            { type: 'string', value: '/' },
+            { type: 'variable', name: 'test' },
+        ]);
+    });
+});
+describe('printUrlVariablesDeclarations', () => {
+    it('should print empty string on empty pathParameters/serverVariables', () => {
+        const variablesPrefix = 'variablesPrefix';
+        const snippetRequest = { pathParameters: {}, serverVariables: {} };
+        for (const key in Lang) {
+            const code = new CodeBuilder({
+                indentation: '',
+                variablesPrefix,
+                lang: Lang[key],
+                lineJoin: '\n',
+            });
+            printUrlVariablesDeclarations(snippetRequest, code);
+            expect(code.join()).toEqual('');
+        }
+    });
+    it('should declare variable presented in pathParameters/serverVariables for given lang', () => {
+        const variablesPrefix = 'variablesPrefix';
+        for (const key in Lang) {
+            const lang = Lang[key];
+            const output = printUrlVariablesDeclarationsOutput[lang];
+            const code = new CodeBuilder({
+                indentation: '',
+                variablesPrefix,
+                lang,
+                lineJoin: '\n',
+            });
+            printUrlVariablesDeclarations(commonVariablesInput, code);
+            try {
+                expect(code.join()).toEqual(output);
+            }
+            catch (e) {
+                throw new Error(`${lang} is broken ${e}`);
+            }
+        }
+    });
+});
+describe('buildUrlExpression', () => {
+    it('should not change url if variables are empty', () => {
+        const variablesPrefix = 'variablesPrefix';
+        const url = 'http://acme.com';
+        const input = {
+            pathParameters: {},
+            serverVariables: {},
+            url,
+            fullUrl: url,
+            pathname: url,
+        };
+        for (const key in Lang) {
+            const lang = Lang[key];
+            const code = new CodeBuilder({
+                indentation: '',
+                variablesPrefix,
+                lang,
+                lineJoin: '\n',
+            });
+            const res = buildUrlExpression(input, code).replace(/["']/g, '');
+            try {
+                expect(res).toEqual('http://acme.com');
+            }
+            catch (e) {
+                throw new Error(`${lang} is broken ${e}`);
+            }
+        }
+    });
+    it('should work with given input', () => {
+        const variablesPrefix = 'variablesPrefix';
+        const url = 'http://acme.com/{pathParam1}/{pathParam2}/{pathParam3}/{pathParam4}/{serverVariable1}/{serverVariable2}';
+        const input = {
+            ...commonVariablesInput,
+            url,
+            fullUrl: url,
+            pathname: url,
+        };
+        for (const key in Lang) {
+            const lang = Lang[key];
+            const code = new CodeBuilder({
+                indentation: '',
+                variablesPrefix,
+                lang,
+                lineJoin: '\n',
+            });
+            const res = buildUrlExpression(input, code);
+            try {
+                expect(res).toEqual(buildUrlExpressionData[lang]);
+            }
+            catch (e) {
+                throw new Error(`${lang} is broken ${e}`);
+            }
+        }
+    });
+});
+//# sourceMappingURL=code-helpers.test.js.map

package/lib/services/code-samples/httpsnippet/helpers/__tests__/string-utility.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/code-samples/httpsnippet/helpers/__tests__/string-utility.test.js

@@ -0,0 +1,49 @@
+import StringUtility from '../string-utility.js';
+describe('StringUtility', () => {
+    const testStrings = [
+        'lives-Down_by-the.River',
+        'Lives`Down,by~the RIVER',
+        'LivesDownBY  the RIVER',
+    ];
+    describe('toCamelCase', () => {
+        it('returns camelCase string', () => {
+            const expectedResult = 'livesDownByTheRiver';
+            testStrings.forEach((str) => {
+                expect(StringUtility.toCamelCase(str)).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('toTitleCase', () => {
+        it('returns Title Case string', () => {
+            const expectedResult = 'Lives Down By The River';
+            testStrings.forEach((str) => {
+                expect(StringUtility.toTitleCase(str)).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('toPascalCase', () => {
+        it('returns PascalCase string', () => {
+            const expectedResult = 'LivesDownByTheRiver';
+            testStrings.forEach((str) => {
+                expect(StringUtility.toPascalCase(str)).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('toLowerCase', () => {
+        it('returns lowercase string', () => {
+            const expectedResult = 'livesdownbytheriver';
+            testStrings.forEach((str) => {
+                expect(StringUtility.toLowerCase(str)).toEqual(expectedResult);
+            });
+        });
+    });
+    describe('toSnakeCase', () => {
+        it('returns snake_case string', () => {
+            const expectedResult = 'lives_down_by_the_river';
+            testStrings.forEach((str) => {
+                expect(StringUtility.toSnakeCase(str)).toEqual(expectedResult);
+            });
+        });
+    });
+});
+//# sourceMappingURL=string-utility.test.js.map

package/lib/services/code-samples/httpsnippet/targets/csharp/__tests__/httpclient.test.d.ts

@@ -0,0 +1 @@
+export { HTTPSnippet } from '../../../index.js';

package/lib/services/code-samples/httpsnippet/targets/csharp/__tests__/httpclient.test.js

@@ -0,0 +1,172 @@
+export { HTTPSnippet } from '../../../index.js'; // we need to reexport it before to prevent circular ref issue
+import httpclient from '../httpclient.js';
+import { originalOptions, serverVariablesOptions, source } from '../../__mocks__/mock.js';
+describe('#code-samples C#', () => {
+    describe('handler', () => {
+        it('returns code API PUT /pet', () => {
+            const result = httpclient(source['PUT http://petstore.swagger.io/v2/pet'], originalOptions, {
+                target: 'csharp',
+                client: 'httpclient',
+            });
+            expect(result).toMatchSnapshot();
+        });
+        it('returns code with path parameters reserved (data) and not (petId) /pet/{petId}/uploadImage/{data}', () => {
+            const result = httpclient(source['POST http://petstore.swagger.io/v2/pet/{petId}/uploadImage/{data}'], originalOptions, { target: 'csharp', client: 'httpclient' });
+            expect(result).toMatchSnapshot();
+        });
+        it('returns code with one path parameter inside url /pet/{petId}/uploadImage', () => {
+            const result = httpclient(source['POST http://petstore.swagger.io/v2/pet/{petId}/uploadImage'], originalOptions, { target: 'csharp', client: 'httpclient' });
+            expect(result).toMatchSnapshot();
+        });
+        it('returns code with path parameter and query /pet/findByStatus/{id}?status=...', () => {
+            const result = httpclient(source['GET http://petstore.swagger.io/v2/pet/findByStatus/{id}'], originalOptions, { target: 'csharp', client: 'httpclient' });
+            expect(result).toMatchSnapshot();
+        });
+        it('should generate code with server variables', () => {
+            const result = httpclient(source['POST https://{customerId}.saas-app.com:{port}/v2'], serverVariablesOptions, {
+                target: 'csharp',
+                client: 'httpclient',
+            });
+            expect(result).toMatchSnapshot();
+        });
+        it('should generate code with basic auth', () => {
+            const result = httpclient(source['POST http://petstore.swagger.io/login'], serverVariablesOptions, {
+                target: 'csharp',
+                client: 'httpclient',
+            });
+            expect(result).toMatchSnapshot();
+        });
+        it('should handle URL_ENCODED with text but no params (serializedValue case)', () => {
+            const sourceWithUrlEncodedText = {
+                method: 'post',
+                url: 'http://petstore.swagger.io/v2/pet',
+                httpVersion: 'HTTP/1.1',
+                cookies: [],
+                headers: [{ name: 'Content-Type', value: 'application/x-www-form-urlencoded' }],
+                queryString: [],
+                postData: {
+                    mimeType: 'application/x-www-form-urlencoded',
+                    text: 'name=Museum+Visitor&value=premium&count=5',
+                    params: [],
+                },
+                headersSize: 0,
+                bodySize: 0,
+                securityOAuth2ExtraCalls: [],
+                pathParameters: {},
+                serverVariables: {},
+                queryObj: {},
+                headersObj: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                cookiesObj: {},
+                allHeaders: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                uriObj: {
+                    protocol: 'http:',
+                    slashes: true,
+                    auth: null,
+                    host: 'petstore.swagger.io',
+                    port: null,
+                    hostname: 'petstore.swagger.io',
+                    hash: null,
+                    search: '',
+                    query: {},
+                    pathname: '/v2/pet',
+                    path: '/v2/pet',
+                    href: 'http://petstore.swagger.io/v2/pet',
+                },
+                fullUrl: 'http://petstore.swagger.io/v2/pet',
+            };
+            const result = httpclient(sourceWithUrlEncodedText, originalOptions, {
+                target: 'csharp',
+                client: 'httpclient',
+            });
+            expect(result).toMatchSnapshot();
+        });
+        it('should handle MULTIPART with text but no params (serializedValue case)', () => {
+            const sourceWithMultipartText = {
+                method: 'post',
+                url: 'http://petstore.swagger.io/v2/pet',
+                httpVersion: 'HTTP/1.1',
+                cookies: [],
+                headers: [{ name: 'Content-Type', value: 'multipart/form-data' }],
+                queryString: [],
+                postData: {
+                    mimeType: 'multipart/form-data',
+                    text: '--boundary123\r\nContent-Disposition: form-data; name="field1"\r\n\r\nvalue1\r\n--boundary123\r\nContent-Disposition: form-data; name="field2"\r\n\r\nvalue2\r\n--boundary123--',
+                    params: [],
+                },
+                headersSize: 0,
+                bodySize: 0,
+                securityOAuth2ExtraCalls: [],
+                pathParameters: {},
+                serverVariables: {},
+                queryObj: {},
+                headersObj: { 'Content-Type': 'multipart/form-data' },
+                cookiesObj: {},
+                allHeaders: { 'Content-Type': 'multipart/form-data' },
+                uriObj: {
+                    protocol: 'http:',
+                    slashes: true,
+                    auth: null,
+                    host: 'petstore.swagger.io',
+                    port: null,
+                    hostname: 'petstore.swagger.io',
+                    hash: null,
+                    search: '',
+                    query: {},
+                    pathname: '/v2/pet',
+                    path: '/v2/pet',
+                    href: 'http://petstore.swagger.io/v2/pet',
+                },
+                fullUrl: 'http://petstore.swagger.io/v2/pet',
+            };
+            const result = httpclient(sourceWithMultipartText, originalOptions, {
+                target: 'csharp',
+                client: 'httpclient',
+            });
+            expect(result).toMatchSnapshot();
+        });
+        it('should handle OCTET_STREAM with text (binary data case)', () => {
+            const sourceWithOctetStream = {
+                method: 'post',
+                url: 'http://petstore.swagger.io/v2/upload',
+                httpVersion: 'HTTP/1.1',
+                cookies: [],
+                headers: [{ name: 'Content-Type', value: 'application/octet-stream' }],
+                queryString: [],
+                postData: {
+                    mimeType: 'application/octet-stream',
+                    text: 'SGVsbG8gV29ybGQ=',
+                },
+                headersSize: 0,
+                bodySize: 0,
+                securityOAuth2ExtraCalls: [],
+                pathParameters: {},
+                serverVariables: {},
+                queryObj: {},
+                headersObj: { 'Content-Type': 'application/octet-stream' },
+                cookiesObj: {},
+                allHeaders: { 'Content-Type': 'application/octet-stream' },
+                uriObj: {
+                    protocol: 'http:',
+                    slashes: true,
+                    auth: null,
+                    host: 'petstore.swagger.io',
+                    port: null,
+                    hostname: 'petstore.swagger.io',
+                    hash: null,
+                    search: '',
+                    query: {},
+                    pathname: '/v2/upload',
+                    path: '/v2/upload',
+                    href: 'http://petstore.swagger.io/v2/upload',
+                },
+                fullUrl: 'http://petstore.swagger.io/v2/upload',
+            };
+            const result = httpclient(sourceWithOctetStream, originalOptions, {
+                target: 'csharp',
+                client: 'httpclient',
+            });
+            expect(result).toMatchSnapshot();
+        });
+    });
+});
+//# sourceMappingURL=httpclient.test.js.map

package/lib/services/code-samples/httpsnippet/targets/csharpNewtonsoft/__tests__/httpclient.test.d.ts

@@ -0,0 +1 @@
+export { HTTPSnippet } from '../../../index.js';