test: add tests for RestTransportHandler (#280)

# Description

Thank you for opening a Pull Request!
Before submitting your PR, there are a few things you can do to make
sure it goes smoothly:

- [x] Follow the [`CONTRIBUTING`
Guide](https://github.com/google-a2a/a2a-js/blob/main/CONTRIBUTING.md).
- [x] Make your Pull Request title in the
<https://www.conventionalcommits.org/> specification.
- Important Prefixes for
[release-please](https://github.com/googleapis/release-please):
- `fix:` which represents bug fixes, and correlates to a
[SemVer](https://semver.org/) patch.
- `feat:` represents a new feature, and correlates to a SemVer minor.
- `feat!:`, or `fix!:`, `refactor!:`, etc., which represent a breaking
change (indicated by the `!`) and will result in a SemVer major.
- [x] Ensure the tests and linter pass
- [ ] Appropriate docs were updated (if necessary)

Fixes #278 🦕

Co-authored-by: Ivan Shymko <[email protected]>

Author: tchapacan

test/server/a2a_express_app.spec.ts …t/server/express/a2a_express_app.spec.tstest/server/a2a_express_app.spec.ts renamed to test/server/express/a2a_express_app.spec.ts test/server/a2a_express_app.spec.ts renamed to test/server/express/a2a_express_app.spec.ts

@@ -12,14 +12,14 @@ import {
 import express, { Express, NextFunction, Request, Response } from 'express';
 import request from 'supertest';
 
-import { A2AExpressApp } from '../../src/server/express/a2a_express_app.js';
-import { A2ARequestHandler } from '../../src/server/request_handler/a2a_request_handler.js';
-import { JsonRpcTransportHandler } from '../../src/server/transports/jsonrpc/jsonrpc_transport_handler.js';
-import { AgentCard, JSONRPCSuccessResponse, JSONRPCErrorResponse } from '../../src/index.js';
-import { AGENT_CARD_PATH, HTTP_EXTENSION_HEADER } from '../../src/constants.js';
-import { A2AError } from '../../src/server/error.js';
-import { ServerCallContext } from '../../src/server/context.js';
-import { User, UnauthenticatedUser } from '../../src/server/authentication/user.js';
+import { A2AExpressApp } from '../../../src/server/express/a2a_express_app.js';
+import { A2ARequestHandler } from '../../../src/server/request_handler/a2a_request_handler.js';
+import { JsonRpcTransportHandler } from '../../../src/server/transports/jsonrpc/jsonrpc_transport_handler.js';
+import { AgentCard, JSONRPCSuccessResponse, JSONRPCErrorResponse } from '../../../src/index.js';
+import { AGENT_CARD_PATH, HTTP_EXTENSION_HEADER } from '../../../src/constants.js';
+import { A2AError } from '../../../src/server/error.js';
+import { ServerCallContext } from '../../../src/server/context.js';
+import { User, UnauthenticatedUser } from '../../../src/server/authentication/user.js';
 
 describe('A2AExpressApp', () => {
   let mockRequestHandler: A2ARequestHandler;

test/server/rest_handler.spec.ts test/server/express/rest_handler.spec.tstest/server/rest_handler.spec.ts renamed to test/server/express/rest_handler.spec.ts

@@ -2,10 +2,10 @@ import { describe, it, beforeEach, afterEach, assert, expect, vi, Mock } from 'v
 import express, { Express } from 'express';
 import request from 'supertest';
 
-import { restHandler, UserBuilder } from '../../src/server/express/index.js';
-import { A2ARequestHandler } from '../../src/server/request_handler/a2a_request_handler.js';
-import { AgentCard, Task, Message } from '../../src/types.js';
-import { A2AError } from '../../src/server/error.js';
+import { restHandler, UserBuilder } from '../../../src/server/express/index.js';
+import { A2ARequestHandler } from '../../../src/server/request_handler/a2a_request_handler.js';
+import { AgentCard, Task, Message } from '../../../src/types.js';
+import { A2AError } from '../../../src/server/error.js';
 
 /**
  * Test suite for restHandler - HTTP+JSON/REST transport implementation
@@ -113,25 +113,13 @@ describe('restHandler', () => {
   });
 
   describe('POST /v1/message:send', () => {
-    it('should accept camelCase message and return 201 with Task', async () => {
+    it.each([
+      { name: 'camelCase', message: testMessage },
+      { name: 'snake_case', message: snakeCaseMessage },
+    ])('should accept $name message and return 201 with Task', async ({ message }) => {
       (mockRequestHandler.sendMessage as Mock).mockResolvedValue(testTask);
 
-      const response = await request(app)
-        .post('/v1/message:send')
-        .send({ message: testMessage })
-        .expect(201);
-
-      assert.deepEqual(response.body.id, testTask.id);
-      assert.deepEqual(response.body.kind, 'task');
-    });
-
-    it('should accept snake_case message and return 201 with Task', async () => {
-      (mockRequestHandler.sendMessage as Mock).mockResolvedValue(testTask);
-
-      const response = await request(app)
-        .post('/v1/message:send')
-        .send({ message: snakeCaseMessage })
-        .expect(201);
+      const response = await request(app).post('/v1/message:send').send({ message }).expect(201);
 
       assert.deepEqual(response.body.id, testTask.id);
       assert.deepEqual(response.body.kind, 'task');
@@ -160,31 +148,17 @@ describe('restHandler', () => {
   });
 
   describe('POST /v1/message:stream', () => {
-    it('should accept camelCase message and stream via SSE', async () => {
+    it.each([
+      { name: 'camelCase', message: testMessage },
+      { name: 'snake_case', message: snakeCaseMessage },
+    ])('should accept $name message and stream via SSE', async ({ message }) => {
       async function* mockStream() {
         yield testMessage;
         yield testTask;
       }
       (mockRequestHandler.sendMessageStream as Mock).mockResolvedValue(mockStream());
 
-      const response = await request(app)
-        .post('/v1/message:stream')
-        .send({ message: testMessage })
-        .expect(200);
-
-      assert.equal(response.headers['content-type'], 'text/event-stream');
-    });
-
-    it('should accept snake_case message and stream via SSE', async () => {
-      async function* mockStream() {
-        yield testMessage;
-      }
-      (mockRequestHandler.sendMessageStream as Mock).mockResolvedValue(mockStream());
-
-      const response = await request(app)
-        .post('/v1/message:stream')
-        .send({ message: snakeCaseMessage })
-        .expect(200);
+      const response = await request(app).post('/v1/message:stream').send({ message }).expect(200);
 
       assert.equal(response.headers['content-type'], 'text/event-stream');
     });
@@ -341,33 +315,25 @@ describe('restHandler', () => {
     };
 
     describe('POST /v1/tasks/:taskId/pushNotificationConfigs', () => {
-      it('should accept camelCase pushNotificationConfig and return 201', async () => {
-        (mockRequestHandler.setTaskPushNotificationConfig as Mock).mockResolvedValue(mockConfig);
-
-        const response = await request(app)
-          .post('/v1/tasks/task-1/pushNotificationConfigs')
-          .send({
-            pushNotificationConfig: {
-              id: 'config-1',
-              url: 'https://example.com/webhook',
-            },
-          })
-          .expect(201);
-
-        assert.deepEqual(response.body.taskId, mockConfig.taskId);
-      });
-
-      it('should accept snake_case push_notification_config and return 201', async () => {
+      it.each([
+        {
+          name: 'camelCase',
+          payload: {
+            pushNotificationConfig: { id: 'config-1', url: 'https://example.com/webhook' },
+          },
+        },
+        {
+          name: 'snake_case',
+          payload: {
+            push_notification_config: { id: 'config-1', url: 'https://example.com/webhook' },
+          },
+        },
+      ])('should accept $name config and return 201', async ({ payload }) => {
         (mockRequestHandler.setTaskPushNotificationConfig as Mock).mockResolvedValue(mockConfig);
 
         const response = await request(app)
           .post('/v1/tasks/task-1/pushNotificationConfigs')
-          .send({
-            push_notification_config: {
-              id: 'config-1',
-              url: 'https://example.com/webhook',
-            },
-          })
+          .send(payload)
           .expect(201);
 
         assert.deepEqual(response.body.taskId, mockConfig.taskId);
@@ -494,89 +460,73 @@ describe('restHandler', () => {
    * File Parts Format Tests
    */
   describe('File parts format acceptance', () => {
-    it('should accept camelCase mimeType in file parts', async () => {
-      (mockRequestHandler.sendMessage as Mock).mockResolvedValue(testTask);
-
-      await request(app)
-        .post('/v1/message:send')
-        .send({
-          message: {
-            messageId: 'msg-file',
-            role: 'user',
-            kind: 'message',
-            parts: [
-              {
-                kind: 'file',
-                file: {
-                  uri: 'https://example.com/file.pdf',
-                  mimeType: 'application/pdf',
-                  name: 'document.pdf',
-                },
+    it.each([
+      {
+        name: 'camelCase',
+        message: {
+          messageId: 'msg-file',
+          role: 'user',
+          kind: 'message',
+          parts: [
+            {
+              kind: 'file',
+              file: {
+                uri: 'https://example.com/file.pdf',
+                mimeType: 'application/pdf',
+                name: 'document.pdf',
               },
-            ],
-          },
-        })
-        .expect(201);
-    });
-
-    it('should accept snake_case mime_type in file parts', async () => {
+            },
+          ],
+        },
+      },
+      {
+        name: 'snake_case',
+        message: {
+          message_id: 'msg-file',
+          role: 'user',
+          kind: 'message',
+          parts: [
+            {
+              kind: 'file',
+              file: {
+                uri: 'https://example.com/file.pdf',
+                mime_type: 'application/pdf',
+                name: 'document.pdf',
+              },
+            },
+          ],
+        },
+      },
+    ])('should accept $name file parts', async ({ message }) => {
       (mockRequestHandler.sendMessage as Mock).mockResolvedValue(testTask);
 
-      await request(app)
-        .post('/v1/message:send')
-        .send({
-          message: {
-            message_id: 'msg-file',
-            role: 'user',
-            kind: 'message',
-            parts: [
-              {
-                kind: 'file',
-                file: {
-                  uri: 'https://example.com/file.pdf',
-                  mime_type: 'application/pdf',
-                  name: 'document.pdf',
-                },
-              },
-            ],
-          },
-        })
-        .expect(201);
+      await request(app).post('/v1/message:send').send({ message }).expect(201);
     });
   });
 
   /**
    * Configuration Format Tests
    */
   describe('Configuration format acceptance', () => {
-    it('should accept camelCase configuration fields', async () => {
-      (mockRequestHandler.sendMessage as Mock).mockResolvedValue(testTask);
-
-      await request(app)
-        .post('/v1/message:send')
-        .send({
+    it.each([
+      {
+        name: 'camelCase',
+        payload: {
           message: testMessage,
-          configuration: {
-            acceptedOutputModes: ['text/plain'],
-            historyLength: 5,
-          },
-        })
-        .expect(201);
-    });
-
-    it('should accept snake_case configuration fields', async () => {
+          configuration: { acceptedOutputModes: ['text/plain'], historyLength: 5 },
+        },
+      },
+      {
+        name: 'snake_case',
+        payload: {
+          message: snakeCaseMessage,
+          configuration: { accepted_output_modes: ['text/plain'], history_length: 5 },
+        },
+      },
+    ])('should accept $name configuration fields', async ({ payload }) => {
       (mockRequestHandler.sendMessage as Mock).mockResolvedValue(testTask);
 
-      await request(app)
-        .post('/v1/message:send')
-        .send({
-          message: snakeCaseMessage,
-          configuration: {
-            accepted_output_modes: ['text/plain'],
-            history_length: 5,
-          },
-        })
-        .expect(201);
+      await request(app).post('/v1/message:send').send(payload).expect(201);
     });
   });