fix: fixing tests for validating images and router

Signed-off-by: Lucas <lyoon@redhat.com>

Author: JslYoon

workspaces/lightspeed/plugins/lightspeed-backend/src/service/router.test.ts

@@ -1149,16 +1149,8 @@ describe('lightspeed router tests', () => {
 
     it('returns true when model supports vision', async () => {
       rcs.use(
-        http.get(`${LOCAL_LCS_ADDR}/v1/models`, () => {
-          return HttpResponse.json({
-            models: [
-              {
-                identifier: 'gpt-4o',
-                provider_resource_id: 'gpt-4o',
-                supports_vision: true,
-              },
-            ],
-          });
+        http.post(`${LOCAL_LCS_ADDR}/v1/responses`, () => {
+          return HttpResponse.json({ output: 'hi' });
         }),
       );
 
@@ -1168,21 +1160,19 @@ describe('lightspeed router tests', () => {
         .send({ model: 'gpt-4o', provider: 'test-server' });
 
       expect(response.statusCode).toEqual(200);
-      expect(response.body).toEqual({ supports_vision: true });
+      expect(response.body).toEqual({
+        model: 'gpt-4o',
+        supportsVision: true,
+      });
     });
 
     it('returns false when model lacks vision', async () => {
       rcs.use(
-        http.get(`${LOCAL_LCS_ADDR}/v1/models`, () => {
-          return HttpResponse.json({
-            models: [
-              {
-                identifier: 'gpt-3.5-turbo',
-                provider_resource_id: 'gpt-3.5-turbo',
-                supports_vision: false,
-              },
-            ],
-          });
+        http.post(`${LOCAL_LCS_ADDR}/v1/responses`, () => {
+          return HttpResponse.json(
+            { error: 'model does not support images' },
+            { status: 400 },
+          );
         }),
       );
 
@@ -1192,24 +1182,24 @@ describe('lightspeed router tests', () => {
         .send({ model: 'gpt-3.5-turbo', provider: 'test-server' });
 
       expect(response.statusCode).toEqual(200);
-      expect(response.body).toEqual({ supports_vision: false });
+      expect(response.body).toEqual({
+        model: 'gpt-3.5-turbo',
+        supportsVision: false,
+      });
     });
 
-    it('returns 400 when model is not found', async () => {
-      rcs.use(
-        http.get(`${LOCAL_LCS_ADDR}/v1/models`, () => {
-          return HttpResponse.json({ models: [] });
-        }),
-      );
+    it('returns cached result on subsequent calls', async () => {
+      ModelCapabilitiesCache.set('gpt-4o', true);
 
       const backendServer = await startBackendServer();
       const response = await request(backendServer)
         .post('/api/lightspeed/v1/validate-model-vision')
-        .send({ model: 'unknown-model', provider: 'test-server' });
+        .send({ model: 'gpt-4o', provider: 'test-server' });
 
-      expect(response.statusCode).toEqual(400);
+      expect(response.statusCode).toEqual(200);
       expect(response.body).toEqual({
-        error: 'Model unknown-model not found',
+        model: 'gpt-4o',
+        supportsVision: true,
       });
     });
   });
@@ -1220,19 +1210,7 @@ describe('lightspeed router tests', () => {
     });
 
     it('rejects attachments when model lacks vision', async () => {
-      rcs.use(
-        http.get(`${LOCAL_LCS_ADDR}/v1/models`, () => {
-          return HttpResponse.json({
-            models: [
-              {
-                identifier: 'gpt-3.5-turbo',
-                provider_resource_id: 'gpt-3.5-turbo',
-                supports_vision: false,
-              },
-            ],
-          });
-        }),
-      );
+      ModelCapabilitiesCache.set('gpt-3.5-turbo', false);
 
       const backendServer = await startBackendServer();
       const response = await request(backendServer)
@@ -1252,24 +1230,12 @@ describe('lightspeed router tests', () => {
 
       expect(response.statusCode).toEqual(400);
       expect(response.body.error).toContain(
-        'Model gpt-3.5-turbo does not support image attachments',
+        'This model does not support JPEG images',
       );
     });
 
     it('accepts attachments when model supports vision', async () => {
-      rcs.use(
-        http.get(`${LOCAL_LCS_ADDR}/v1/models`, () => {
-          return HttpResponse.json({
-            models: [
-              {
-                identifier: 'gpt-4o',
-                provider_resource_id: 'gpt-4o',
-                supports_vision: true,
-              },
-            ],
-          });
-        }),
-      );
+      ModelCapabilitiesCache.set('gpt-4o', true);
 
       const backendServer = await startBackendServer();
       const response = await request(backendServer)

workspaces/lightspeed/plugins/lightspeed-backend/src/service/validation.test.ts

@@ -21,7 +21,10 @@ import {
   MAX_QUERY_LENGTH,
   MAX_TOTAL_ATTACHMENTS_SIZE_BYTES,
 } from './constant';
-import { validateCompletionsRequest } from './validation';
+import {
+  validateAttachmentsForModel,
+  validateCompletionsRequest,
+} from './validation';
 
 describe('validateCompletionsRequest', () => {
   let mockReq: Partial<Request>;
@@ -142,7 +145,7 @@ describe('validateCompletionsRequest', () => {
     });
   });
 
-  describe('attachment validation', () => {
+  describe('attachment passthrough', () => {
     it('should pass with no attachments', () => {
       mockReq.body = {
         model: 'gpt-4',
@@ -156,14 +159,17 @@ describe('validateCompletionsRequest', () => {
       expect(statusMock).not.toHaveBeenCalled();
     });
 
-    it('should pass with valid small attachments', () => {
+    it('should pass with attachments (size validation is in validateAttachmentsForModel)', () => {
       mockReq.body = {
         model: 'gpt-4',
         provider: 'openai',
         query: 'test query',
         attachments: [
-          { name: 'file1.txt', content: 'small content' },
-          { name: 'file2.txt', content: 'another small content' },
+          {
+            attachment_type: 'dom',
+            content_type: 'text/html',
+            content: 'small content',
+          },
         ],
       };
 
@@ -172,82 +178,113 @@ describe('validateCompletionsRequest', () => {
       expect(mockNext).toHaveBeenCalled();
       expect(statusMock).not.toHaveBeenCalled();
     });
+  });
+});
 
-    it('should reject attachment exceeding MAX_ATTACHMENT_SIZE_BYTES', () => {
-      // Create content that exceeds the limit (20MB)
-      const largeContent = 'a'.repeat(MAX_ATTACHMENT_SIZE_BYTES + 1);
-      mockReq.body = {
-        model: 'gpt-4',
-        provider: 'openai',
-        query: 'test query',
-        attachments: [{ name: 'large-file.txt', content: largeContent }],
-      };
+describe('validateAttachmentsForModel', () => {
+  let mockReq: Partial<Request>;
+  let mockRes: Partial<Response>;
+  let mockNext: NextFunction;
+  let statusMock: jest.Mock;
+  let jsonMock: jest.Mock;
 
-      callValidate();
+  beforeEach(() => {
+    jsonMock = jest.fn();
+    statusMock = jest.fn().mockReturnValue({ json: jsonMock });
+    mockReq = { body: {} };
+    mockRes = { status: statusMock } as unknown as Partial<Response>;
+    mockNext = jest.fn();
+  });
 
-      expect(statusMock).toHaveBeenCalledWith(400);
-      expect(jsonMock).toHaveBeenCalledWith({
-        error: `Attachment "large-file.txt" exceeds maximum size of ${MAX_ATTACHMENT_SIZE_BYTES / (1024 * 1024)}MB`,
-      });
-      expect(mockNext).not.toHaveBeenCalled();
-    });
+  function callValidate() {
+    validateAttachmentsForModel(
+      mockReq as Request,
+      mockRes as Response,
+      mockNext,
+    );
+  }
 
-    it('should reject total attachments exceeding MAX_TOTAL_ATTACHMENTS_SIZE_BYTES', () => {
-      // Create multiple attachments that individually pass but together exceed total limit
-      const attachmentSize = 18 * 1024 * 1024; // 18MB each
-      const content1 = 'a'.repeat(attachmentSize);
-      const content2 = 'b'.repeat(attachmentSize);
-      const content3 = 'c'.repeat(attachmentSize);
+  it('should pass with no attachments', () => {
+    mockReq.body = { model: 'gpt-4' };
+    callValidate();
+    expect(mockNext).toHaveBeenCalled();
+  });
 
-      mockReq.body = {
-        model: 'gpt-4',
-        provider: 'openai',
-        query: 'test query',
-        attachments: [
-          { name: 'file1.txt', content: content1 },
-          { name: 'file2.txt', content: content2 },
-          { name: 'file3.txt', content: content3 },
-        ],
-      };
+  it('should pass with empty attachments', () => {
+    mockReq.body = { model: 'gpt-4', attachments: [] };
+    callValidate();
+    expect(mockNext).toHaveBeenCalled();
+  });
 
-      callValidate();
+  it('should reject attachment exceeding MAX_ATTACHMENT_SIZE_BYTES', () => {
+    const largeContent = 'a'.repeat(MAX_ATTACHMENT_SIZE_BYTES + 1);
+    mockReq.body = {
+      model: 'gpt-4',
+      attachments: [
+        {
+          attachment_type: 'dom',
+          content_type: 'text/html',
+          content: largeContent,
+        },
+      ],
+    };
 
-      expect(statusMock).toHaveBeenCalledWith(400);
-      expect(jsonMock).toHaveBeenCalledWith({
-        error: `Total attachments size exceeds maximum of ${MAX_TOTAL_ATTACHMENTS_SIZE_BYTES / (1024 * 1024)}MB`,
-      });
-      expect(mockNext).not.toHaveBeenCalled();
+    callValidate();
+
+    expect(statusMock).toHaveBeenCalledWith(400);
+    expect(jsonMock).toHaveBeenCalledWith({
+      error: `Attachment with type "dom" exceeds maximum size of ${MAX_ATTACHMENT_SIZE_BYTES / (1024 * 1024)}MB`,
     });
+    expect(mockNext).not.toHaveBeenCalled();
+  });
 
-    it('should handle attachments with empty content', () => {
-      mockReq.body = {
-        model: 'gpt-4',
-        provider: 'openai',
-        query: 'test query',
-        attachments: [
-          { name: 'empty.txt', content: '' },
-          { name: 'file.txt', content: 'some content' },
-        ],
-      };
+  it('should reject total attachments exceeding MAX_TOTAL_ATTACHMENTS_SIZE_BYTES', () => {
+    const attachmentSize = 18 * 1024 * 1024;
+    const content1 = 'a'.repeat(attachmentSize);
+    const content2 = 'b'.repeat(attachmentSize);
+    const content3 = 'c'.repeat(attachmentSize);
+
+    mockReq.body = {
+      model: 'gpt-4',
+      attachments: [
+        {
+          attachment_type: 'dom',
+          content_type: 'text/html',
+          content: content1,
+        },
+        {
+          attachment_type: 'dom',
+          content_type: 'text/html',
+          content: content2,
+        },
+        {
+          attachment_type: 'dom',
+          content_type: 'text/html',
+          content: content3,
+        },
+      ],
+    };
 
-      callValidate();
+    callValidate();
 
-      expect(mockNext).toHaveBeenCalled();
-      expect(statusMock).not.toHaveBeenCalled();
+    expect(statusMock).toHaveBeenCalledWith(400);
+    expect(jsonMock).toHaveBeenCalledWith({
+      error: `Total attachments size exceeds maximum of ${MAX_TOTAL_ATTACHMENTS_SIZE_BYTES / (1024 * 1024)}MB`,
     });
+    expect(mockNext).not.toHaveBeenCalled();
+  });
 
-    it('should handle attachments without content field', () => {
-      mockReq.body = {
-        model: 'gpt-4',
-        provider: 'openai',
-        query: 'test query',
-        attachments: [{ name: 'file.txt' }],
-      };
+  it('should handle attachments with empty content', () => {
+    mockReq.body = {
+      model: 'gpt-4',
+      attachments: [
+        { attachment_type: 'dom', content_type: 'text/html', content: '' },
+      ],
+    };
 
-      callValidate();
+    callValidate();
 
-      expect(mockNext).toHaveBeenCalled();
-      expect(statusMock).not.toHaveBeenCalled();
-    });
+    expect(mockNext).toHaveBeenCalled();
+    expect(statusMock).not.toHaveBeenCalled();
   });
 });