frontend: Add test for '@apidevtools/swagger-parser'

Signed-off-by: adwait-godbole <adwaitngodbole@gmail.com>

Author: adwait-godbole

frontend/src/components/common/Resource/DocsViewer.tsx

@@ -6,7 +6,7 @@ import { TreeView } from '@mui/x-tree-view/TreeView';
 // import * as buffer from 'buffer';
 import React from 'react';
 import { useTranslation } from 'react-i18next';
-import getDocDefinitions from '../../../lib/docs';
+import { getDocDefinitions } from '../../../lib/docs';
 import Empty from '../EmptyContent';
 import Loader from '../Loader';
 

frontend/src/lib/docs.test.ts

@@ -0,0 +1,130 @@
+import Swagger from '@apidevtools/swagger-parser';
+import { Mock, vi } from 'vitest';
+import { getDocDefinitions, getDocs } from './docs';
+import { request } from './k8s/apiProxy';
+
+vi.mock('@apidevtools/swagger-parser', () => ({
+  default: { dereference: vi.fn() },
+}));
+
+vi.mock('./k8s/apiProxy', () => ({
+  request: vi.fn(),
+}));
+
+describe('getDocs', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should fetch and dereference the OpenAPI docs', async () => {
+    const mockDocs = { definitions: {} };
+    (request as Mock).mockResolvedValue(mockDocs);
+    (Swagger.dereference as Mock).mockResolvedValue(mockDocs);
+
+    const result = await getDocs();
+
+    expect(request).toHaveBeenCalledWith('/openapi/v2');
+    expect(Swagger.dereference).toHaveBeenCalledWith(mockDocs);
+    expect(result).toEqual(mockDocs);
+  });
+
+  it('should handle API request errors', async () => {
+    (request as Mock).mockRejectedValue(new Error('API request failed'));
+
+    await expect(getDocs()).rejects.toThrow('API request failed');
+  });
+
+  it('should handle Swagger parser errors', async () => {
+    const mockDocs = { definitions: {} };
+    (request as Mock).mockResolvedValue(mockDocs);
+    (Swagger.dereference as Mock).mockRejectedValue(new Error('Swagger parsing failed'));
+
+    await expect(getDocs()).rejects.toThrow('Swagger parsing failed');
+  });
+});
+
+describe('getDocDefinitions', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should return the correct definition for given API version and kind', async () => {
+    const mockDocs = {
+      definitions: {
+        PlaceholderKey: {
+          'x-kubernetes-group-version-kind': [
+            { group: 'apps', version: 'v1', kind: 'ExampleKind' },
+          ],
+        },
+      },
+    };
+    (request as Mock).mockResolvedValue(mockDocs);
+    (Swagger.dereference as Mock).mockResolvedValue(mockDocs);
+
+    const result = await getDocDefinitions('apps/v1', 'ExampleKind');
+
+    expect(result).toBeDefined();
+    expect(result).toEqual(mockDocs.definitions.PlaceholderKey);
+  });
+
+  it('should correctly parse API version when group is missing', async () => {
+    const mockDocs = {
+      definitions: {
+        PlaceholderKey: {
+          'x-kubernetes-group-version-kind': [{ group: '', version: 'v1', kind: 'ExampleKind' }],
+        },
+      },
+    };
+    (request as Mock).mockResolvedValue(mockDocs);
+    (Swagger.dereference as Mock).mockResolvedValue(mockDocs);
+
+    const result = await getDocDefinitions('v1', 'ExampleKind');
+
+    expect(result).toBeDefined();
+    expect(result).toEqual(mockDocs.definitions.PlaceholderKey);
+  });
+
+  it('should return undefined when no matching definition is found', async () => {
+    const mockDocs = {
+      definitions: {
+        PlaceholderKey: {
+          'x-kubernetes-group-version-kind': [
+            { group: 'apps', version: 'v1', kind: 'ExampleKind' },
+          ],
+        },
+      },
+    };
+    (request as Mock).mockResolvedValue(mockDocs);
+    (Swagger.dereference as Mock).mockResolvedValue(mockDocs);
+
+    const result = await getDocDefinitions('apps/v1', 'NonExistentKind');
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should handle cases where definitions are missing', async () => {
+    const mockDocs = { definitions: {} };
+    (request as Mock).mockResolvedValue(mockDocs);
+    (Swagger.dereference as Mock).mockResolvedValue(mockDocs);
+
+    const result = await getDocDefinitions('apps/v1', 'ExampleKind');
+
+    expect(result).toBeUndefined();
+  });
+
+  it("should handle missing key 'x-kubernetes-group-version-kind'", async () => {
+    const mockDocs = {
+      definitions: {
+        PlaceholderKey: {
+          someOtherProperty: 'value',
+        },
+      },
+    };
+    (request as Mock).mockResolvedValue(mockDocs);
+    (Swagger.dereference as Mock).mockResolvedValue(mockDocs);
+
+    const result = await getDocDefinitions('apps/v1', 'ExampleKind');
+
+    expect(result).toBeUndefined();
+  });
+});

frontend/src/lib/docs.ts

@@ -6,19 +6,14 @@ import Swagger from '@apidevtools/swagger-parser';
 import { OpenAPIV2 } from 'openapi-types';
 import { request } from './k8s/apiProxy';
 
-let docsPromise: ReturnType<typeof getDocs>;
-
-async function getDocs() {
+export async function getDocs() {
   const docs = await request('/openapi/v2');
   return Swagger.dereference(docs);
 }
 
-export default async function getDocDefinitions(apiVersion: string, kind: string) {
-  if (!docsPromise) {
-    docsPromise = getDocs(); // Don't wait here. Just kick off the request
-  }
-
-  const { definitions = {} } = (await docsPromise) as OpenAPIV2.Document;
+export async function getDocDefinitions(apiVersion: string, kind: string) {
+  // We want a fresh call to getDocs() each time to ensure we get the latest mock data during testing
+  const { definitions = {} } = (await getDocs()) as OpenAPIV2.Document;
 
   let [group, version] = apiVersion.split('/');
   if (!version) {