@grafana/openapi-to-k6 0.2.5 → 0.3.0

package/tests/functional-tests/test-tags-filtering/fixtures/tags_filtering.json

@@ -0,0 +1,141 @@
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "Sample API",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/users": {
+      "get": {
+        "tags": ["users"],
+        "responses": {
+          "200": {
+            "description": "Success"
+          }
+        }
+      }
+    },
+    "/user-profiles": {
+      "get": {
+        "tags": ["userProfiles"],
+        "responses": {
+          "200": {
+            "description": "Success"
+          }
+        }
+      }
+    },
+    "/pets": {
+      "get": {
+        "tags": ["pets"],
+        "responses": {
+          "200": {
+            "description": "Success"
+          }
+        }
+      }
+    },
+    "/auth": {
+      "post": {
+        "tags": ["auth"],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/AuthRequest"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Success"
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "AuthRequest": {
+        "type": "object",
+        "properties": {
+          "username": {
+            "type": "string",
+            "example": "user123"
+          },
+          "password": {
+            "type": "string",
+            "format": "password",
+            "example": "mypassword"
+          }
+        },
+        "required": ["username", "password"]
+      },
+      "User": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "example": "abc123"
+          },
+          "name": {
+            "type": "string",
+            "example": "John Doe"
+          },
+          "email": {
+            "type": "string",
+            "format": "email",
+            "example": "john.doe@example.com"
+          }
+        },
+        "required": ["id", "name", "email"]
+      },
+      "UserProfile": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "example": "profile123"
+          },
+          "userId": {
+            "type": "string",
+            "example": "abc123"
+          },
+          "bio": {
+            "type": "string",
+            "example": "Software developer with 10 years of experience"
+          },
+          "avatarUrl": {
+            "type": "string",
+            "format": "uri",
+            "example": "https://example.com/avatar.jpg"
+          }
+        },
+        "required": ["id", "userId", "bio"]
+      },
+      "Pet": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "example": "pet123"
+          },
+          "name": {
+            "type": "string",
+            "example": "Buddy"
+          },
+          "species": {
+            "type": "string",
+            "example": "Dog"
+          },
+          "age": {
+            "type": "integer",
+            "example": 3
+          }
+        },
+        "required": ["id", "name", "species"]
+      }
+    }
+  }
+}

package/tests/functional-tests/test-tags-filtering/tagsFiltering.test.ts

@@ -0,0 +1,166 @@
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { Mode } from '../../../src/constants'
+import { NoFilesGeneratedError } from '../../../src/errors'
+import generator from '../../../src/generator'
+
+import { loadFixture, mkdtemp, readFile, rmdir, writeFile } from '../helper'
+
+describe('validate tags filtering', () => {
+  let tempDir: string, openApiPath: string
+  const tagsFilteringSchema = loadFixture(
+    path.join(__dirname, 'fixtures', 'tags_filtering.json')
+  )
+
+  beforeAll(async () => {
+    tempDir = await mkdtemp(path.join(os.tmpdir(), 'tags-filtering-test-'))
+    openApiPath = path.join(tempDir, 'openapi-schema.json')
+    await writeFile(openApiPath, JSON.stringify(tagsFilteringSchema))
+  })
+
+  afterAll(async () => {
+    await rmdir(tempDir, { recursive: true })
+  })
+
+  const generateAndTest = async (
+    mode: Mode,
+    tags: string[],
+    expectedFiles: string[],
+    expectedContents: string[],
+    unexpectedContents: string[]
+  ) => {
+    const generatedSchemaPath = path.join(
+      tempDir,
+      `generated-schema-${mode}-${tags.join('-')}`
+    )
+    await generator({
+      openApiPath,
+      outputDir: generatedSchemaPath,
+      tags,
+      mode,
+    })
+
+    const generatedFiles = fs.readdirSync(generatedSchemaPath)
+    expect(generatedFiles).to.have.members(expectedFiles)
+
+    for (const file of expectedFiles) {
+      if (file.includes('.schemas.ts')) {
+        // Skip schemas file
+        continue
+      }
+      const generatedFilePath = path.join(generatedSchemaPath, file)
+      const generatedContent = await readFile(generatedFilePath, 'utf-8')
+
+      for (const content of expectedContents) {
+        expect(generatedContent).to.contain(content)
+      }
+
+      for (const content of unexpectedContents) {
+        expect(generatedContent).not.to.contain(content)
+      }
+    }
+  }
+
+  it('should generate only endpoints with specified tags in single mode', async () => {
+    await generateAndTest(
+      Mode.SINGLE,
+      ['users'],
+      ['sampleAPI.ts'],
+      ['/users'],
+      ['/user-profiles', '/pets', '/auth']
+    )
+
+    await generateAndTest(
+      Mode.SINGLE,
+      ['users', 'userProfiles'],
+      ['sampleAPI.ts'],
+      ['/users', '/user-profiles'],
+      ['/pets', '/auth']
+    )
+
+    // Invalid tag should not generate any endpoints
+    await generateAndTest(
+      Mode.SINGLE,
+      ['invalid-tag'],
+      ['sampleAPI.ts'],
+      [],
+      ['/users', '/user-profiles', '/pets', '/auth']
+    )
+
+    // Empty tags should generate all endpoints
+    await generateAndTest(
+      Mode.SINGLE,
+      [],
+      ['sampleAPI.ts'],
+      ['/users', '/user-profiles', '/pets', '/auth'],
+      []
+    )
+  })
+
+  it('should generate only endpoints with specified tags in split mode', async () => {
+    await generateAndTest(
+      Mode.SPLIT,
+      ['users'],
+      ['sampleAPI.ts', 'sampleAPI.schemas.ts'],
+      ['/users'],
+      ['/user-profiles', '/pets', '/auth']
+    )
+
+    // Test empty tags
+    await generateAndTest(
+      Mode.SPLIT,
+      [],
+      ['sampleAPI.ts', 'sampleAPI.schemas.ts'],
+      ['/users', '/user-profiles', '/pets', '/auth'],
+      []
+    )
+
+    // Invalid tag should not generate any endpoints
+    // In the single mode it will create the client file which will have only the schemas
+    await expect(
+      generateAndTest(
+        Mode.SPLIT,
+        ['invalid-tag'],
+        [],
+        [],
+        ['/users', '/user-profiles', '/pets', '/auth']
+      )
+    ).rejects.toThrow(NoFilesGeneratedError)
+
+    // Empty tags should generate all endpoints
+    await generateAndTest(
+      Mode.SPLIT,
+      [],
+      ['sampleAPI.ts', 'sampleAPI.schemas.ts'],
+      ['/users', '/user-profiles', '/pets', '/auth'],
+      []
+    )
+  })
+
+  it('should generate only endpoints with specified tags in tags mode', async () => {
+    await generateAndTest(
+      Mode.TAGS,
+      ['users'],
+      ['users.ts', 'sampleAPI.schemas.ts'],
+      ['/users'],
+      ['/user-profiles', '/pets', '/auth']
+    )
+
+    // Empty tags should generate all endpoints
+    await generateAndTest(
+      Mode.TAGS,
+      [],
+      [
+        'users.ts',
+        'sampleAPI.schemas.ts',
+        'auth.ts',
+        'pets.ts',
+        'user-profiles.ts',
+      ],
+      [], // Skipping test for content
+      []
+    )
+  })
+})

package/tests/helper.test.ts

@@ -157,3 +157,62 @@ describe('getDirectoryForPath', () => {
     expect(directory).toEqual(expectedDirectory)
   })
 })
+
+describe('hasOnlyComments', () => {
+  it('should return true if the file has only comments', () => {
+    const expectedResultsAndData = [
+      {
+        fileContent: '// This is a comment',
+        expectedResult: true,
+      },
+      {
+        fileContent: '/* This is a comment */',
+        expectedResult: true,
+      },
+      {
+        fileContent: '// This is a comment\nconst x = 1',
+        expectedResult: false,
+      },
+      {
+        fileContent: '/* This is a comment */\nconst x = 1',
+        expectedResult: false,
+      },
+      {
+        fileContent: 'const x = 1',
+        expectedResult: false,
+      },
+      {
+        fileContent: '',
+        expectedResult: true,
+      },
+      {
+        fileContent: '// This is a comment\n// This is another comment',
+        expectedResult: true,
+      },
+      {
+        fileContent: '/* This is a comment */\n/* This is another comment */',
+        expectedResult: true,
+      },
+      {
+        fileContent: '// This is a comment\n/* This is another comment */',
+        expectedResult: true,
+      },
+      {
+        fileContent: `/**
+ * This is a comment
+ */
+`,
+        expectedResult: true,
+      },
+    ]
+    for (const { fileContent, expectedResult } of expectedResultsAndData) {
+      const result = helper.hasOnlyComments(fileContent)
+      try {
+        expect(result).toBe(expectedResult)
+      } catch (error) {
+        console.log(`Expected ${expectedResult} for content:\n${fileContent}`)
+        throw error
+      }
+    }
+  })
+})