fix: Binary request bodies are inlined as raw binary characters breaking the script (#1120)

Co-authored-by: Cursor Agent <cursoragent@cursor.com>

Author: Llandy3d

src/codegen/codegen.test.ts

@@ -26,6 +26,7 @@ import {
   generateImports,
   generateParameterizationCustomCode,
   generateRequestSnippetsFromSchemas,
+  isBinaryContent,
 } from './codegen'
 
 const fakeDate = new Date('2000-01-01T00:00:00Z')
@@ -183,6 +184,19 @@ describe('Code generation', () => {
         )
       ).toBe(expectedResult)
     })
+
+    it('should generate imports with encoding when hasBinaryContent is true', async () => {
+      const expectedResult = await prettify(`
+        import { group, sleep, check } from 'k6'
+        import http from 'k6/http'
+        import execution from "k6/execution";
+        import encoding from "k6/encoding";
+      `)
+
+      expect(
+        await prettify(generateImports(generator, { hasBinaryContent: true }))
+      ).toBe(expectedResult)
+    })
   })
 
   describe('generateVariableDeclarations', () => {
@@ -728,4 +742,110 @@ describe('Code generation', () => {
       )
     })
   })
+
+  describe('isBinaryContent', () => {
+    it('should return true for content with null bytes', () => {
+      expect(isBinaryContent('hello\x00world')).toBe(true)
+    })
+
+    it('should return true for content with control characters', () => {
+      expect(isBinaryContent('data\x01\x02\x03')).toBe(true)
+    })
+
+    it('should return false for normal text', () => {
+      expect(isBinaryContent('hello world')).toBe(false)
+    })
+
+    it('should return false for text with tabs, newlines, and carriage returns', () => {
+      expect(isBinaryContent('hello\tworld\nfoo\rbar')).toBe(false)
+    })
+
+    it('should return false for empty string', () => {
+      expect(isBinaryContent('')).toBe(false)
+    })
+
+    it('should return false for JSON content', () => {
+      expect(isBinaryContent('{"key": "value"}')).toBe(false)
+    })
+  })
+
+  describe('generateSingleRequestSnippet with binary content', () => {
+    it('should use encoding.b64decode for binary content', () => {
+      const binaryContent = 'hello\x00\x01\x02world'
+      const schema = {
+        data: createProxyData({
+          id: '1',
+          request: createRequest({
+            method: 'POST',
+            url: '/api/v1/upload',
+            content: binaryContent,
+            headers: [['content-type', 'application/octet-stream']],
+          }),
+        }),
+        before: [],
+        after: [],
+        checks: [],
+      }
+
+      const result = generateRequestSnippetsFromSchemas([schema], thinkTime)
+      const snippet = result[0]?.snippet ?? ''
+
+      expect(snippet).toContain("encoding.b64decode('")
+      expect(snippet).not.toContain('`hello')
+    })
+
+    it('should use backtick wrapping for text content', () => {
+      const schema = {
+        data: createProxyData({
+          id: '1',
+          request: createRequest({
+            method: 'POST',
+            url: '/api/v1/users',
+            content: '{"user": "test"}',
+            headers: [['content-type', 'application/json']],
+          }),
+        }),
+        before: [],
+        after: [],
+        checks: [],
+      }
+
+      const result = generateRequestSnippetsFromSchemas([schema], thinkTime)
+      const snippet = result[0]?.snippet ?? ''
+
+      expect(snippet).toContain('`{"user": "test"}`')
+      expect(snippet).not.toContain('encoding.b64decode')
+    })
+
+    it('should base64 encode binary content when btoa cannot handle input', () => {
+      const binaryContent = "\x00\u0100'data"
+      const bytes = new TextEncoder().encode(binaryContent)
+      let utf8Binary = ''
+      for (const byte of bytes) {
+        utf8Binary += String.fromCharCode(byte)
+      }
+      const expectedBase64Content = btoa(utf8Binary)
+      const schema = {
+        data: createProxyData({
+          id: '1',
+          request: createRequest({
+            method: 'POST',
+            url: '/api/v1/upload',
+            content: binaryContent,
+            headers: [['content-type', 'application/octet-stream']],
+          }),
+        }),
+        before: [],
+        after: [],
+        checks: [],
+      }
+
+      const result = generateRequestSnippetsFromSchemas([schema], thinkTime)
+      const snippet = result[0]?.snippet ?? ''
+
+      expect(snippet).toContain(
+        `encoding.b64decode('${expectedBase64Content}')`
+      )
+    })
+  })
 })

src/codegen/codegen.ts

@@ -7,6 +7,7 @@ import { CustomCodeValue, ParameterizationRule, TestRule } from '@/types/rules'
 import { DataFile, Variable } from '@/types/testData'
 import { ThinkTime } from '@/types/testOptions'
 import { getFileNameWithoutExtension } from '@/utils/file'
+import { safeBtoa } from '@/utils/format'
 import { groupProxyData } from '@/utils/groups'
 import { getContentTypeWithCharsetHeader } from '@/utils/headers'
 import { exhaustive } from '@/utils/typescript'
@@ -29,10 +30,14 @@ export function generateScript({
   recording,
   generator,
 }: GenerateScriptParams): string {
+  const hasBinaryContent = recording.some(
+    ({ request }) => request.content != null && isBinaryContent(request.content)
+  )
+
   return `
     // ${generateScriptHeader()}
 
-    ${generateImports(generator)}
+    ${generateImports(generator, { hasBinaryContent })}
 
     export const options = ${generateOptions(generator.options)}
 
@@ -46,7 +51,14 @@ export function generateScript({
   `
 }
 
-export function generateImports(generator: GeneratorFileData): string {
+interface GenerateImportsOptions {
+  hasBinaryContent?: boolean
+}
+
+export function generateImports(
+  generator: GeneratorFileData,
+  options: GenerateImportsOptions = {}
+): string {
   const hasCSVDataFiles = generator.testData.files.some(({ name }) =>
     name.toLowerCase().endsWith('csv')
   )
@@ -61,6 +73,8 @@ export function generateImports(generator: GeneratorFileData): string {
     ...(hasCSVDataFiles
       ? [K6_EXPORTS['k6/experimental/csv'], K6_EXPORTS['k6/experimental/fs']]
       : []),
+    // Import k6/encoding for binary content
+    ...(options.hasBinaryContent ? [K6_EXPORTS['k6/encoding']] : []),
   ]
 
   return imports.map(generateImportStatement).join('\n')
@@ -230,19 +244,24 @@ export function generateSingleRequestSnippet(
 
   try {
     if (request.content) {
-      const escapedContent = escapeBackticks(request.content)
-      content = `\`${escapedContent}\``
-
-      // if we have postData parameters we need to pass an object to the k6 post function because if it receives
-      // a stringified json it won't correctly post the data.
-      const contentTypeHeader =
-        getContentTypeWithCharsetHeader(request.headers) ?? ''
-      if (contentTypeHeader.includes('application/x-www-form-urlencoded')) {
-        content = `JSON.parse(\`${escapedContent}\`)`
-      }
-
-      if (contentTypeHeader.includes('multipart/form-data')) {
-        content = `\`${escapedContent.replace(/(?:\r\n|\r|\n)/g, '\\r\\n')}\``
+      if (isBinaryContent(request.content)) {
+        const base64Content = safeBtoa(request.content)
+        content = `encoding.b64decode('${base64Content}')`
+      } else {
+        const escapedContent = escapeBackticks(request.content)
+        content = `\`${escapedContent}\``
+
+        // if we have postData parameters we need to pass an object to the k6 post function because if it receives
+        // a stringified json it won't correctly post the data.
+        const contentTypeHeader =
+          getContentTypeWithCharsetHeader(request.headers) ?? ''
+        if (contentTypeHeader.includes('application/x-www-form-urlencoded')) {
+          content = `JSON.parse(\`${escapedContent}\`)`
+        }
+
+        if (contentTypeHeader.includes('multipart/form-data')) {
+          content = `\`${escapedContent.replace(/(?:\r\n|\r|\n)/g, '\\r\\n')}\``
+        }
       }
     }
   } catch (error) {
@@ -316,6 +335,17 @@ export function generateParameterizationCustomCode(
     .join('\n')
 }
 
+export function isBinaryContent(content: string): boolean {
+  for (let i = 0; i < content.length; i++) {
+    const code = content.charCodeAt(i)
+    // Null byte or control character that isn't whitespace (tab, newline, carriage return)
+    if (code === 0 || (code < 32 && code !== 9 && code !== 10 && code !== 13)) {
+      return true
+    }
+  }
+  return false
+}
+
 function escapeBackticks(content: string): string {
   return content.replace(/`/g, '\\`')
 }

src/utils/format.ts

@@ -38,7 +38,14 @@ export function safeBtoa(content: string) {
   try {
     return btoa(content)
   } catch {
-    return content
+    const bytes = new TextEncoder().encode(content)
+    let binary = ''
+
+    for (const byte of bytes) {
+      binary += String.fromCharCode(byte)
+    }
+
+    return btoa(binary)
   }
 }