@grafana/openapi-to-k6 0.2.4 → 0.2.6

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

@@ -12,6 +12,7 @@ import {
   it,
 } from 'vitest'
 import { Mode } from '../../src/constants'
+import { NoFilesGeneratedError } from '../../src/errors'
 import generator from '../../src/generator'
 
 const writeFile = promisify(fs.writeFile)
@@ -19,7 +20,7 @@ const readFile = promisify(fs.readFile)
 const mkdtemp = promisify(fs.mkdtemp)
 const rmdir = promisify(fs.rmdir)
 
-const fixturesDir = path.join(__dirname, 'fixtures', 'schemas')
+const fixturesDir = path.join(__dirname, 'fixtures')
 
 const loadFixture = (filename: string) => {
   const filePath = path.join(fixturesDir, filename)
@@ -44,7 +45,7 @@ function replaceSpacesAndNewLineToSingleSpace(input: string): string {
 
 describe('generator', () => {
   let tempDir: string, schemaDirectory: string
-  const allFixtures = fs.readdirSync(fixturesDir)
+  const allFixtures = fs.readdirSync(path.join(fixturesDir, 'schemas'))
 
   beforeAll(async () => {
     tempDir = await mkdtemp(path.join(os.tmpdir(), 'sdk-generator-'))
@@ -57,7 +58,7 @@ describe('generator', () => {
   for (const fixtureName of allFixtures) {
     describe(`test ${fixtureName} OpenAPI schema`, () => {
       let openApiPath: string, generatedSchemaPath: string
-      const fixture = loadFixture(fixtureName)
+      const fixture = loadFixture(path.join('schemas', fixtureName))
 
       beforeEach(async () => {
         schemaDirectory = await mkdtemp(
@@ -160,4 +161,159 @@ describe('generator', () => {
       })
     })
   }
+
+  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
+        []
+      )
+    })
+  })
 })

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
+      }
+    }
+  })
+})