@grafana/openapi-to-k6 0.2.6 → 0.3.1

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/{vite.config.js → vite.config.mjs}

@@ -1,8 +1,12 @@
 import { defineConfig } from 'vite'
+import tsconfigPaths from 'vite-tsconfig-paths'
 
 export default defineConfig({
+  plugins: [tsconfigPaths()],
   test: {
     environment: 'node',
+    globals: true,
+    include: ['tests/**/*.test.ts'],
     coverage: {
       reporter: ['json', 'text', 'lcov'],
       reportsDirectory: 'coverage',

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

@@ -1,319 +0,0 @@
-import fs from 'fs'
-import os from 'os'
-import path from 'path'
-import { promisify } from 'util'
-import {
-  afterAll,
-  afterEach,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  it,
-} from 'vitest'
-import { Mode } from '../../src/constants'
-import { NoFilesGeneratedError } from '../../src/errors'
-import generator from '../../src/generator'
-
-const writeFile = promisify(fs.writeFile)
-const readFile = promisify(fs.readFile)
-const mkdtemp = promisify(fs.mkdtemp)
-const rmdir = promisify(fs.rmdir)
-
-const fixturesDir = path.join(__dirname, 'fixtures')
-
-const loadFixture = (filename: string) => {
-  const filePath = path.join(fixturesDir, filename)
-  const data = fs.readFileSync(filePath, 'utf-8')
-  return JSON.parse(data)
-}
-
-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>";`]
-
-function replaceSpacesAndNewLineToSingleSpace(input: string): string {
-  return input.replace(/\s+/g, ' ')
-}
-
-describe('generator', () => {
-  let tempDir: string, schemaDirectory: string
-  const allFixtures = fs.readdirSync(path.join(fixturesDir, 'schemas'))
-
-  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('schemas', 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')
-      })
-    })
-  }
-
-  describe('validate tags filtering', () => {
-    let tempDir: string, openApiPath: string
-    const tagsFilteringSchema = loadFixture('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
-        []
-      )
-    })
-  })
-})