@grafana/openapi-to-k6 0.2.6 → 0.3.1

package/tests/functional-tests/test-generator/fixtures/basic_parameter_in_ref.json

@@ -0,0 +1,59 @@
+{
+  "openapi_schema": {
+    "openapi": "3.0.0",
+    "info": {
+      "title": "Simple API",
+      "version": "1.0.0"
+    },
+    "paths": {
+      "/example": {
+        "get": {
+          "summary": "Retrieve example data",
+          "parameters": [
+            {
+              "$ref": "#/components/parameters/stackId"
+            }
+          ],
+          "responses": {
+            "200": {
+              "description": "Successful response",
+              "content": {
+                "application/json": {
+                  "schema": {
+                    "type": "object",
+                    "properties": {
+                      "message": {
+                        "type": "string",
+                        "example": "Hello, World!"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "components": {
+      "parameters": {
+        "stackId": {
+          "in": "header",
+          "name": "X-Stack-Id",
+          "schema": {
+            "type": "integer"
+          },
+          "required": true
+        }
+      }
+    }
+  },
+  "expected_sdk": {
+    "fileName": "simpleAPI.ts",
+    "expectedSubstrings": [
+      "export class SimpleAPIClient",
+      "export type StackIdParameter = number;",
+      "export type GetExampleHeaders = { \"X-Stack-Id\": StackIdParameter; };"
+    ]
+  }
+}

package/tests/functional-tests/{fixtures/schemas → test-generator/fixtures}/form_data_schema.json

@@ -88,7 +88,7 @@
       "export class FormDataAPIClient",
       "const formData = new FormData(); formData.append(\"file\", postUploadBody.file); if (postUploadBody.description !== undefined) { formData.append(\"description\", postUploadBody.description); } formData.append(\"userId\", postUploadBody.userId);",
       "const url = new URL(this.cleanBaseUrl + `/upload`);",
-      "const response = http.request(\"POST\", url.toString(), formData.body(), { ...mergedRequestParameters, headers: { \"Content-Type\": \"multipart/form-data; boundary=\" + formData.boundary, ...mergedRequestParameters?.headers, }, });"
+      "const response = http.request(\"POST\", url.toString(), formData.body(), { ...mergedRequestParameters, headers: { ...mergedRequestParameters?.headers, \"Content-Type\": \"multipart/form-data; boundary=\" + formData.boundary, }, });"
     ]
   }
 }

package/tests/functional-tests/{fixtures/schemas → test-generator/fixtures}/form_url_encoded_data_schema.json

@@ -87,7 +87,7 @@
     "expectedSubstrings": [
       "export class FormURLEncodedAPIClient",
       "const url = new URL(this.cleanBaseUrl + `/submit-form`);",
-      "const response = http.request( \"POST\", url.toString(), JSON.stringify(postSubmitFormBody), { ...mergedRequestParameters, headers: { \"Content-Type\": \"application/x-www-form-urlencoded\", ...mergedRequestParameters?.headers, }, }, );"
+      "const response = http.request( \"POST\", url.toString(), JSON.stringify(postSubmitFormBody), { ...mergedRequestParameters, headers: { ...mergedRequestParameters?.headers, \"Content-Type\": \"application/x-www-form-urlencoded\", }, }, );"
     ]
   }
 }

package/tests/functional-tests/{fixtures/schemas → test-generator/fixtures}/headers_schema.json

@@ -152,9 +152,9 @@
     "expectedSubstrings": [
       "export class HeaderDemoAPIClient",
       "getExampleGet( headers?: GetExampleGetHeaders, requestParameters?: Params, ): { response: Response; data: GetExampleGet200; }",
-      "response = http.request(\"GET\", url.toString(), undefined, { ...mergedRequestParameters, headers: { // In the schema, headers can be of any type like number but k6 accepts only strings as headers, hence converting all headers to string ...Object.fromEntries( Object.entries(headers || {}).map(([key, value]) => [ key, String(value), ]), ), ...mergedRequestParameters?.headers, }, });",
+      "response = http.request(\"GET\", url.toString(), undefined, { ...mergedRequestParameters, headers: { ...mergedRequestParameters?.headers, // In the schema, headers can be of any type like number but k6 accepts only strings as headers, hence converting all headers to string ...Object.fromEntries( Object.entries(headers || {}).map(([key, value]) => [ key, String(value), ]), ), }, });",
       "postExamplePost( postExamplePostBody: PostExamplePostBody, headers: PostExamplePostHeaders, requestParameters?: Params, ): { response: Response; data: void; }",
-      "response = http.request( \"POST\", url.toString(), JSON.stringify(postExamplePostBody), { ...mergedRequestParameters, headers: { \"Content-Type\": \"application/json\", // In the schema, headers can be of any type like number but k6 accepts only strings as headers, hence converting all headers to string ...Object.fromEntries( Object.entries(headers || {}).map(([key, value]) => [ key, String(value), ]), ), ...mergedRequestParameters?.headers, }, }, );",
+      "response = http.request( \"POST\", url.toString(), JSON.stringify(postExamplePostBody), { ...mergedRequestParameters, headers: { ...mergedRequestParameters?.headers, \"Content-Type\": \"application/json\", // In the schema, headers can be of any type like number but k6 accepts only strings as headers, hence converting all headers to string ...Object.fromEntries( Object.entries(headers || {}).map(([key, value]) => [ key, String(value), ]), ), }, }, );",
       "getExampleResponseHeaders(requestParameters?: Params): { response: Response; data: GetExampleResponseHeaders200; }",
       "response = http.request( \"GET\", url.toString(), undefined, mergedRequestParameters, );"
     ]

package/tests/functional-tests/{fixtures/schemas → test-generator/fixtures}/simple_post_request_schema.json

@@ -124,7 +124,7 @@
       "const url = new URL(this.cleanBaseUrl + `/example`);",
       "JSON.stringify(createExampleDataBody),",
       "POST",
-      "export type CreateExampleData201 = { age?: number; date?: string; /** The unique ID of the created resource */ id?: string; isActive?: boolean; meta?: CreateExampleData201Meta; name?: string; tags?: string[];"
+      "export type CreateExampleData201 = { /** The unique ID of the created resource */ id?: string; name?: string; age?: number; isActive?: boolean; tags?: string[]; date?: string; meta?: CreateExampleData201Meta; };"
     ]
   }
 }

package/tests/functional-tests/test-generator/generator.test.ts

@@ -0,0 +1,154 @@
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+} from 'vitest'
+import { Mode } from '../../../src/constants'
+import generator from '../../../src/generator'
+
+import {
+  loadFixture,
+  mkdtemp,
+  readFile,
+  replaceSpacesAndNewLineToSingleSpace,
+  rmdir,
+  writeFile,
+} from '../helper'
+
+const commonSubstringsForAllSDK = [
+  'Automatically generated by',
+  'Do not edit manually',
+  'Service version',
+  'const mergedRequestParameters = this._mergeRequestParameters( requestParameters || {}, this.commonRequestParameters, );',
+  'try { data = response.json(); } catch { data = response.body; }',
+  'return { response, data, };',
+]
+
+const commonSubstringsForK6SampleScript = [`const baseUrl = "<BASE_URL>";`]
+
+describe('generator', () => {
+  let tempDir: string, schemaDirectory: string
+  const allFixtures = fs.readdirSync(path.join(__dirname, 'fixtures'))
+
+  beforeAll(async () => {
+    tempDir = await mkdtemp(path.join(os.tmpdir(), 'sdk-generator-'))
+  })
+
+  afterAll(async () => {
+    await rmdir(tempDir, { recursive: true })
+  })
+
+  for (const fixtureName of allFixtures) {
+    describe(`test ${fixtureName} OpenAPI schema`, () => {
+      let openApiPath: string, generatedSchemaPath: string
+      const fixture = loadFixture(path.join(__dirname, 'fixtures', fixtureName))
+
+      beforeEach(async () => {
+        schemaDirectory = await mkdtemp(
+          path.join(tempDir, fixtureName.replace('.', '-'))
+        )
+        // Write the OpenAPI schema to a file
+
+        openApiPath = path.join(schemaDirectory, 'openapi-schema.json')
+
+        await writeFile(openApiPath, JSON.stringify(fixture['openapi_schema']))
+
+        generatedSchemaPath = path.join(schemaDirectory, 'generated-schema')
+      })
+
+      afterEach(async () => {
+        await rmdir(schemaDirectory, { recursive: true })
+      })
+
+      it(`should generate SDK client from the OpenAPI schema`, async () => {
+        const expectedGeneratedCode = fixture['expected_sdk']
+
+        await generator({
+          openApiPath,
+          outputDir: generatedSchemaPath,
+          mode: Mode.SINGLE,
+        })
+
+        const generatedFiles = fs.readdirSync(generatedSchemaPath)
+        expect(generatedFiles.length).toBe(1)
+        expect(generatedFiles[0]).toBeDefined()
+        const fileName = path.basename(generatedFiles[0]!)
+        expect(fileName).toBe(expectedGeneratedCode.fileName)
+        const generatedFilePath = path.join(
+          generatedSchemaPath,
+          generatedFiles[0]!
+        )
+        const generatedContent = await readFile(generatedFilePath, 'utf-8')
+
+        for (const expectedString of [
+          ...expectedGeneratedCode['expectedSubstrings'],
+          ...commonSubstringsForAllSDK,
+        ]) {
+          expect(
+            replaceSpacesAndNewLineToSingleSpace(generatedContent)
+          ).toContain(expectedString)
+        }
+      })
+
+      it('should generate a sample K6 script', async () => {
+        await generator({
+          openApiPath,
+          outputDir: generatedSchemaPath,
+          shouldGenerateSampleK6Script: true,
+          mode: Mode.SINGLE,
+        })
+
+        const generatedFiles = fs.readdirSync(generatedSchemaPath)
+        expect(generatedFiles.length).toBe(2)
+        const k6ScriptFile = generatedFiles.find((file) =>
+          file.includes('k6-script')
+        )
+        expect(k6ScriptFile).toBeDefined()
+        expect(k6ScriptFile).toBe('k6-script.sample.ts')
+
+        const generatedFilePath = path.join(generatedSchemaPath, k6ScriptFile!)
+        const generatedContent = await readFile(generatedFilePath, 'utf-8')
+
+        for (const expectedString of [...commonSubstringsForK6SampleScript]) {
+          expect(generatedContent).toContain(expectedString)
+        }
+      })
+
+      it('should not contain types in main file when using split mode', async () => {
+        await generator({
+          openApiPath,
+          outputDir: generatedSchemaPath,
+          shouldGenerateSampleK6Script: true,
+          mode: Mode.SPLIT,
+        })
+        const expectedGeneratedCode = fixture['expected_sdk']
+        const generatedFiles = fs.readdirSync(generatedSchemaPath)
+
+        expect(generatedFiles.length).toBe(3)
+
+        const clientFile = generatedFiles.find((file) =>
+          file.includes(expectedGeneratedCode.fileName)
+        )
+        const schemaFile = generatedFiles.find((file) =>
+          file.includes('.schemas.ts')
+        )
+
+        expect(clientFile).toBeDefined()
+        expect(schemaFile).toBeDefined()
+
+        const generatedFilePath = path.join(generatedSchemaPath, clientFile!)
+        const generatedContent = await readFile(generatedFilePath, 'utf-8')
+
+        expect(generatedContent).not.toContain('export type')
+        expect(generatedContent).not.toContain('export interface')
+      })
+    })
+  }
+})

package/tests/functional-tests/test-sample-k6-scripts/fixtures/schema_using_ref_models.json

@@ -0,0 +1,394 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Comprehensive API",
+    "version": "1.0.0",
+    "description": "API supporting various HTTP methods with query, path parameters, and headers"
+  },
+  "components": {
+    "schemas": {
+      "ItemBase": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "example": "Sample Item"
+          },
+          "description": {
+            "type": "string",
+            "example": "This is a sample description for the item."
+          }
+        }
+      },
+      "ItemId": {
+        "type": "string",
+        "example": "12345-getItemById"
+      },
+      "UpdatedItem": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "example": "Updated Item Name"
+          },
+          "description": {
+            "type": "string",
+            "example": "Updated description for the item."
+          }
+        }
+      },
+      "PatchItem": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "example": "Partially Updated Item Name"
+          }
+        }
+      },
+      "FormUrlEncodedItem": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "example": "Form Encoded Item"
+          },
+          "description": {
+            "type": "string",
+            "example": "Description for form-urlencoded item."
+          }
+        },
+        "required": ["name"]
+      },
+      "FormDataItem": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "example": "Form Data Item"
+          }
+        },
+        "required": ["file", "name"]
+      },
+      "UserPost": {
+        "type": "object",
+        "properties": {
+          "title": {
+            "type": "string"
+          },
+          "content": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "parameters": {
+      "itemIdPath": {
+        "name": "id",
+        "in": "path",
+        "required": true,
+        "description": "ID of the item to retrieve",
+        "schema": {
+          "$ref": "#/components/schemas/ItemId"
+        }
+      },
+      "detailQuery": {
+        "name": "detail",
+        "in": "query",
+        "required": false,
+        "description": "Whether to return detailed information",
+        "schema": {
+          "type": "boolean",
+          "default": false,
+          "example": true
+        }
+      },
+      "userId": {
+        "name": "userId",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string"
+        }
+      },
+      "postId": {
+        "name": "postId",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string"
+        }
+      },
+      "clientIdHeader": {
+        "name": "X-Client-ID",
+        "in": "header",
+        "description": "Client ID for the request",
+        "required": true,
+        "schema": {
+          "type": "string",
+          "example": "client-123"
+        }
+      },
+      "requestIdHeader": {
+        "name": "X-Request-ID",
+        "in": "header",
+        "description": "Unique request identifier",
+        "required": false,
+        "schema": {
+          "type": "string",
+          "example": "req-56789"
+        }
+      },
+      "authTokenHeader": {
+        "name": "X-Auth-Token",
+        "in": "header",
+        "description": "Authentication token",
+        "required": true,
+        "schema": {
+          "type": "string",
+          "example": "Bearer abcdef12345"
+        }
+      },
+      "correlationIdHeader": {
+        "name": "X-Correlation-ID",
+        "in": "header",
+        "description": "Correlation ID for tracking requests",
+        "required": true,
+        "schema": {
+          "type": "string",
+          "example": "correlation-12345"
+        }
+      },
+      "optionalHeader": {
+        "name": "X-Optional-Header",
+        "in": "header",
+        "description": "Optional header",
+        "required": false,
+        "schema": {
+          "type": "string",
+          "example": "optional-header-value"
+        }
+      }
+    }
+  },
+  "paths": {
+    "/items/{id}": {
+      "get": {
+        "tags": ["Items"],
+        "summary": "Get an item by ID",
+        "parameters": [
+          { "$ref": "#/components/parameters/itemIdPath" },
+          { "$ref": "#/components/parameters/detailQuery" }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful response"
+          }
+        }
+      },
+      "post": {
+        "tags": ["Items"],
+        "summary": "Create an item by ID",
+        "parameters": [{ "$ref": "#/components/parameters/itemIdPath" }],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ItemBase"
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Item created successfully"
+          }
+        }
+      },
+      "put": {
+        "tags": ["Items"],
+        "summary": "Update an item by ID",
+        "parameters": [{ "$ref": "#/components/parameters/itemIdPath" }],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdatedItem"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Item updated successfully"
+          }
+        }
+      },
+      "patch": {
+        "tags": ["Items"],
+        "summary": "Partially update an item by ID",
+        "parameters": [{ "$ref": "#/components/parameters/itemIdPath" }],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PatchItem"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Item partially updated"
+          }
+        }
+      },
+      "delete": {
+        "tags": ["Items"],
+        "summary": "Delete an item by ID",
+        "parameters": [{ "$ref": "#/components/parameters/itemIdPath" }],
+        "responses": {
+          "204": {
+            "description": "Item deleted successfully"
+          }
+        }
+      },
+      "head": {
+        "tags": ["Items"],
+        "summary": "Check if item exists",
+        "parameters": [{ "$ref": "#/components/parameters/itemIdPath" }],
+        "responses": {
+          "200": {
+            "description": "Item exists"
+          },
+          "404": {
+            "description": "Item not found"
+          }
+        }
+      }
+    },
+    "/items-form-url-encoded": {
+      "post": {
+        "tags": ["ItemsForm", "Items"],
+        "summary": "Create an item using form-urlencoded data",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/x-www-form-urlencoded": {
+              "schema": {
+                "$ref": "#/components/schemas/FormUrlEncodedItem"
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Item created successfully"
+          }
+        }
+      }
+    },
+    "/items-form-data": {
+      "post": {
+        "tags": ["ItemsForm", "Items"],
+        "summary": "Create an item using form-data",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "multipart/form-data": {
+              "schema": {
+                "$ref": "#/components/schemas/FormDataItem"
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Item created with file upload"
+          }
+        }
+      }
+    },
+    "/items-header": {
+      "get": {
+        "tags": ["ItemsHeader"],
+        "summary": "Get an item with custom headers",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "query",
+            "required": true,
+            "description": "ID of the item to retrieve",
+            "schema": {
+              "type": "string",
+              "example": "123450-getItemByIdWithHeader"
+            }
+          },
+          { "$ref": "#/components/parameters/clientIdHeader" },
+          { "$ref": "#/components/parameters/requestIdHeader" }
+        ],
+        "responses": {
+          "200": {
+            "description": "Item retrieved successfully"
+          }
+        },
+        "requestBody": {
+          "required": false
+        }
+      }
+    },
+    "/users/{userId}/posts/{postId}": {
+      "get": {
+        "operationId": "getUserPost",
+        "parameters": [
+          { "$ref": "#/components/parameters/userId" },
+          { "$ref": "#/components/parameters/postId" }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UserPost"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/items-new-mandatory-headers": {
+      "get": {
+        "tags": ["ItemsHeader"],
+        "summary": "Retrieve a new item with mandatory headers",
+        "parameters": [
+          {
+            "name": "itemId",
+            "in": "query",
+            "required": true,
+            "description": "ID of the item to retrieve",
+            "schema": {
+              "type": "string",
+              "example": "67890"
+            }
+          },
+          { "$ref": "#/components/parameters/authTokenHeader" },
+          { "$ref": "#/components/parameters/correlationIdHeader" },
+          { "$ref": "#/components/parameters/optionalHeader" }
+        ],
+        "responses": {
+          "200": {
+            "description": "New item retrieved successfully"
+          },
+          "400": {
+            "description": "Invalid request"
+          }
+        }
+      }
+    }
+  }
+}