Address PR review feedback for BRTC endpoints

- Add Connect and Endpoint BXML verb implementations and tests
- Export new verbs from bxml/verbs/index.ts
- Combine model tests into single comprehensive tests per model
- Add Object.values assertions to all enum tests
- Improve date assertions to verify year and specific ISO timestamps
- Use request body variable with CreateWebRtcConnectionRequest type in unit API tests
- Remove toContainKeys assertions from unit API tests
- Rename test descriptions to "should create/list/get/delete endpoint"
- Add missing delete endpoint unit test
- Remove unnecessary filtered-by-type test from smoke tests
- Rename smoke test descriptions for consistency

Generated from Claude9 with Claude Code

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: smoghe-bw

models/bxml/verbs/Connect.ts

@@ -0,0 +1,41 @@
+import { NestableVerb } from '../NestableVerb';
+import { Endpoint } from './Endpoint';
+
+export interface ConnectAttributes {
+    connectCompleteUrl?: string;
+    connectCompleteMethod?: string;
+    connectCompleteFallbackUrl?: string;
+    connectCompleteFallbackMethod?: string;
+    username?: string;
+    password?: string;
+    fallbackUsername?: string;
+    fallbackPassword?: string;
+    tag?: string;
+}
+
+/**
+ * @export
+ * @class Connect
+ * @extends {NestableVerb}
+ * Represents a Connect verb
+ */
+export class Connect extends NestableVerb {
+    attributes: ConnectAttributes;
+
+    /**
+     * Creates an instance of Connect
+     * @param {ConnectAttributes} attributes The attributes to add to the element
+     * @param {Endpoint | Endpoint[]} endpoints The endpoint or endpoints to connect to
+     */
+    constructor(attributes?: ConnectAttributes, endpoints?: Endpoint | Endpoint[]) {
+        super('Connect', undefined, attributes, endpoints);
+    }
+
+    /**
+     * Add an endpoint or endpoints to the connect
+     * @param {Endpoint | Endpoint[]} endpoints The endpoint or endpoints to add
+     */
+    addEndpoints(endpoints: Endpoint | Endpoint[]): void {
+        this.nestedVerbs = this.nestedVerbs.concat(endpoints);
+    }
+}

models/bxml/verbs/Endpoint.ts

@@ -0,0 +1,24 @@
+import { Verb } from '../Verb';
+
+export interface EndpointAttributes {
+    endpointId?: string;
+}
+
+/**
+ * @export
+ * @class Endpoint
+ * @extends {Verb}
+ * Represents an Endpoint verb
+ */
+export class Endpoint extends Verb {
+    attributes: EndpointAttributes;
+
+    /**
+     * Creates an instance of Endpoint
+     * @param {string} endpointId The endpoint ID to connect to
+     * @param {EndpointAttributes} attributes The attributes to add to the element
+     */
+    constructor(endpointId: string, attributes?: EndpointAttributes) {
+        super('Endpoint', endpointId, attributes);
+    }
+}

models/bxml/verbs/index.ts

@@ -1,6 +1,8 @@
 export * from './Bridge';
 export * from './Conference';
+export * from './Connect';
 export * from './CustomParam';
+export * from './Endpoint';
 export * from './Forward';
 export * from './Gather';
 export * from './Hangup';

tests/smoke/endpoints-api.test.ts

@@ -13,7 +13,7 @@ describe('EndpointsApi', () => {
     let endpointId: string;
 
     describe('endpoint lifecycle', () => {
-        test('should create a new endpoint', async () => {
+        test('should create endpoint', async () => {
             const endpointBody: CreateWebRtcConnectionRequest = {
                 type: EndpointTypeEnum.Webrtc,
                 direction: EndpointDirectionEnum.Bidirectional
@@ -42,7 +42,7 @@ describe('EndpointsApi', () => {
             endpointId = data.data.endpointId;
         });
 
-        test('should list endpoints for the account', async () => {
+        test('should list endpoints', async () => {
             const { status, data } = await endpointsApi.listEndpoints(BW_ACCOUNT_ID);
 
             expect(status).toEqual(200);
@@ -61,18 +61,7 @@ describe('EndpointsApi', () => {
             expect(createdEndpoint!.expirationTimestamp).toBeDateString();
         });
 
-        test('should list endpoints filtered by type', async () => {
-            const { status, data } = await endpointsApi.listEndpoints(BW_ACCOUNT_ID, EndpointTypeEnum.Webrtc);
-
-            expect(status).toEqual(200);
-            expect(data.data).toBeInstanceOf(Array);
-            expect(data.errors).toBeInstanceOf(Array);
-            if (data.data.length > 0) {
-                expect(data.data.every((item) => item.type === EndpointTypeEnum.Webrtc)).toEqual(true);
-            }
-        });
-
-        test('should retrieve details of a specific endpoint', async () => {
+        test('should get endpoint', async () => {
             const { status, data } = await endpointsApi.getEndpoint(BW_ACCOUNT_ID, endpointId);
 
             expect(status).toEqual(200);

tests/unit/api/endpoints-api.test.ts

@@ -1,7 +1,7 @@
 //@ts-nocheck
 import { EndpointsApi } from '../../../api';
 import { Configuration } from '../../../configuration';
-import { EndpointDirectionEnum, EndpointStatusEnum, EndpointTypeEnum } from '../../../models';
+import { CreateWebRtcConnectionRequest, EndpointDirectionEnum, EndpointStatusEnum, EndpointTypeEnum } from '../../../models';
 
 describe('EndpointsApi', () => {
     const config = new Configuration({
@@ -15,27 +15,20 @@ describe('EndpointsApi', () => {
     const endpointId = 'ep-123456';
 
     describe('createEndpoint', () => {
-        test('should create endpoint and return full response shape', async () => {
-            const { status, data } = await endpointsApi.createEndpoint(accountId, {
+        test('should create endpoint', async () => {
+            const createEndpointBody: CreateWebRtcConnectionRequest = {
                 type: EndpointTypeEnum.Webrtc,
                 direction: EndpointDirectionEnum.Bidirectional
-            });
+            };
+
+            const { status, data } = await endpointsApi.createEndpoint(accountId, createEndpointBody);
 
             expect(status).toEqual(201);
             expect(data.links).toBeInstanceOf(Array);
             expect(data.links.length).toBeGreaterThan(0);
-            expect(data.links[0]).toContainKeys(['rel', 'href']);
             expect(data.links[0].rel).toBeString();
             expect(data.links[0].href).toBeString();
 
-            expect(data.data).toContainKeys([
-                'endpointId',
-                'type',
-                'status',
-                'creationTimestamp',
-                'expirationTimestamp',
-                'token'
-            ]);
             expect(data.data.endpointId).toBeString();
             expect(data.data.type).toBeOneOf(Object.values(EndpointTypeEnum));
             expect(data.data.status).toBeOneOf(Object.values(EndpointStatusEnum));
@@ -49,30 +42,23 @@ describe('EndpointsApi', () => {
     });
 
     describe('listEndpoints', () => {
-        test('should list endpoints and include links, page, data, and errors', async () => {
+        test('should list endpoints', async () => {
             const { status, data } = await endpointsApi.listEndpoints(accountId, EndpointTypeEnum.Webrtc, EndpointStatusEnum.Connected, undefined, 10);
 
             expect(status).toEqual(200);
             expect(data.links).toBeInstanceOf(Array);
             expect(data.links.length).toBeGreaterThan(0);
-            expect(data.links[0]).toContainKeys(['rel', 'href']);
+            expect(data.links[0].rel).toBeString();
+            expect(data.links[0].href).toBeString();
             expect(data.data).toBeInstanceOf(Array);
             expect(data.page).toBeDefined();
-            expect(data.page).toContainKeys(['pageSize', 'pageNumber', 'totalPages', 'totalElements']);
             expect(data.page.pageSize).toBeNumber();
             expect(data.page.pageNumber).toBeNumber();
             expect(data.page.totalPages).toBeNumber();
             expect(data.page.totalElements).toBeNumber();
             expect(data.errors).toBeInstanceOf(Array);
 
             if (data.data.length > 0) {
-                expect(data.data[0]).toContainKeys([
-                    'endpointId',
-                    'type',
-                    'status',
-                    'creationTimestamp',
-                    'expirationTimestamp'
-                ]);
                 expect(data.data[0].endpointId).toBeString();
                 expect(data.data[0].type).toBeOneOf(Object.values(EndpointTypeEnum));
                 expect(data.data[0].status).toBeOneOf(Object.values(EndpointStatusEnum));
@@ -83,21 +69,15 @@ describe('EndpointsApi', () => {
     });
 
     describe('getEndpoint', () => {
-        test('should get endpoint and return full response shape', async () => {
+        test('should get endpoint', async () => {
             const { status, data } = await endpointsApi.getEndpoint(accountId, endpointId);
 
             expect(status).toEqual(200);
             expect(data.links).toBeInstanceOf(Array);
             expect(data.links.length).toBeGreaterThan(0);
-            expect(data.links[0]).toContainKeys(['rel', 'href']);
-
-            expect(data.data).toContainKeys([
-                'endpointId',
-                'type',
-                'status',
-                'creationTimestamp',
-                'expirationTimestamp'
-            ]);
+            expect(data.links[0].rel).toBeString();
+            expect(data.links[0].href).toBeString();
+
             expect(data.data.endpointId).toBeString();
             expect(data.data.type).toBeOneOf(Object.values(EndpointTypeEnum));
             expect(data.data.status).toBeOneOf(Object.values(EndpointStatusEnum));
@@ -108,4 +88,12 @@ describe('EndpointsApi', () => {
             expect(data.errors).toHaveLength(0);
         });
     });
+
+    describe('deleteEndpoint', () => {
+        test('should delete endpoint', async () => {
+            const { status } = await endpointsApi.deleteEndpoint(accountId, endpointId);
+
+            expect(status).toEqual(204);
+        });
+    });
 });

tests/unit/models/bxml/verbs/Connect.test.ts

@@ -0,0 +1,55 @@
+import { Verb } from '../../../../../models/bxml/Verb';
+import { Connect, ConnectAttributes } from '../../../../../models/bxml/verbs/Connect';
+import { Endpoint } from '../../../../../models/bxml/verbs/Endpoint';
+
+describe('Connect', () => {
+    const attributes: ConnectAttributes = {
+        connectCompleteUrl: 'https://initial.com',
+        connectCompleteMethod: 'POST',
+        connectCompleteFallbackUrl: 'https://initial.com',
+        connectCompleteFallbackMethod: 'POST',
+        username: 'initialUsername',
+        password: 'initialPassword',
+        fallbackUsername: 'initialFallbackUsername',
+        fallbackPassword: 'initialFallbackPassword',
+        tag: 'initialTag'
+    };
+
+    const endpoint = new Endpoint('ep-123456');
+
+    test('should create a Connect Verb', () => {
+        const connect = new Connect(attributes);
+        const expected = '<Connect connectCompleteUrl="https://initial.com" connectCompleteMethod="POST" connectCompleteFallbackUrl="https://initial.com" connectCompleteFallbackMethod="POST" username="initialUsername" password="initialPassword" fallbackUsername="initialFallbackUsername" fallbackPassword="initialFallbackPassword" tag="initialTag"/>';
+
+        expect(connect).toBeInstanceOf(Connect);
+        expect(connect).toBeInstanceOf(Verb);
+        expect(connect.toBxml()).toBe(expected);
+    });
+
+    test('should create a Connect Verb with nested Endpoint', () => {
+        const connect = new Connect(attributes, endpoint);
+        const expected = '<Connect connectCompleteUrl="https://initial.com" connectCompleteMethod="POST" connectCompleteFallbackUrl="https://initial.com" connectCompleteFallbackMethod="POST" username="initialUsername" password="initialPassword" fallbackUsername="initialFallbackUsername" fallbackPassword="initialFallbackPassword" tag="initialTag"><Endpoint>ep-123456</Endpoint></Connect>';
+
+        expect(connect).toBeInstanceOf(Connect);
+        expect(connect).toBeInstanceOf(Verb);
+        expect(connect.toBxml()).toBe(expected);
+    });
+
+    test('should create a Connect Verb with multiple nested Endpoints', () => {
+        const endpoint2 = new Endpoint('ep-789012');
+        const connect = new Connect(attributes, [endpoint, endpoint2]);
+        const expected = '<Connect connectCompleteUrl="https://initial.com" connectCompleteMethod="POST" connectCompleteFallbackUrl="https://initial.com" connectCompleteFallbackMethod="POST" username="initialUsername" password="initialPassword" fallbackUsername="initialFallbackUsername" fallbackPassword="initialFallbackPassword" tag="initialTag"><Endpoint>ep-123456</Endpoint><Endpoint>ep-789012</Endpoint></Connect>';
+
+        expect(connect).toBeInstanceOf(Connect);
+        expect(connect).toBeInstanceOf(Verb);
+        expect(connect.toBxml()).toBe(expected);
+    });
+
+    test('should test the addEndpoints method when no verbs are initially nested', () => {
+        const connect = new Connect(attributes);
+        const expected = '<Connect connectCompleteUrl="https://initial.com" connectCompleteMethod="POST" connectCompleteFallbackUrl="https://initial.com" connectCompleteFallbackMethod="POST" username="initialUsername" password="initialPassword" fallbackUsername="initialFallbackUsername" fallbackPassword="initialFallbackPassword" tag="initialTag"><Endpoint>ep-123456</Endpoint></Connect>';
+
+        connect.addEndpoints(endpoint);
+        expect(connect.toBxml()).toBe(expected);
+    });
+});

tests/unit/models/bxml/verbs/Endpoint.test.ts

@@ -0,0 +1,27 @@
+import { Verb } from '../../../../../models/bxml/Verb';
+import { Endpoint, EndpointAttributes } from '../../../../../models/bxml/verbs/Endpoint';
+
+describe('Endpoint', () => {
+    const attributes: EndpointAttributes = {
+        endpointId: 'ep-123456'
+    };
+
+    const expected = '<Endpoint endpointId="ep-123456">ep-123456</Endpoint>';
+    const expectedNoAttributes = '<Endpoint>ep-123456</Endpoint>';
+
+    test('should create an Endpoint Verb with attributes', () => {
+        const endpoint = new Endpoint('ep-123456', attributes);
+
+        expect(endpoint).toBeInstanceOf(Endpoint);
+        expect(endpoint).toBeInstanceOf(Verb);
+        expect(endpoint.toBxml()).toBe(expected);
+    });
+
+    test('should create an Endpoint Verb without attributes', () => {
+        const endpoint = new Endpoint('ep-123456');
+
+        expect(endpoint).toBeInstanceOf(Endpoint);
+        expect(endpoint).toBeInstanceOf(Verb);
+        expect(endpoint.toBxml()).toBe(expectedNoAttributes);
+    });
+});

tests/unit/models/create-endpoint-response-data.test.ts

@@ -3,7 +3,7 @@ import { EndpointStatusEnum } from '../../../models/endpoint-status-enum';
 import { EndpointTypeEnum } from '../../../models/endpoint-type-enum';
 
 describe('CreateEndpointResponseData', () => {
-    test('should include endpoint fields and token', () => {
+    test('should include all endpoint fields and token', () => {
         const responseData: CreateEndpointResponseData = {
             endpointId: 'ep-123456',
             type: EndpointTypeEnum.Webrtc,
@@ -17,8 +17,10 @@ describe('CreateEndpointResponseData', () => {
         expect(responseData.endpointId).toBe('ep-123456');
         expect(responseData.type).toBe(EndpointTypeEnum.Webrtc);
         expect(responseData.status).toBe(EndpointStatusEnum.Connected);
-        expect(new Date(responseData.creationTimestamp).toString()).not.toBe('Invalid Date');
-        expect(new Date(responseData.expirationTimestamp).toString()).not.toBe('Invalid Date');
+        expect(new Date(responseData.creationTimestamp).getFullYear()).toBe(2024);
+        expect(new Date(responseData.creationTimestamp).toISOString()).toBe('2024-02-18T10:30:00.000Z');
+        expect(new Date(responseData.expirationTimestamp).getFullYear()).toBe(2024);
+        expect(new Date(responseData.expirationTimestamp).toISOString()).toBe('2024-02-19T10:30:00.000Z');
         expect(responseData.token).toBe('xxxxx.yyyyy.zzzzz');
         expect(responseData.tag).toBe('endpoint-tag');
     });

tests/unit/models/create-endpoint-response.test.ts

@@ -6,7 +6,7 @@ import { Link } from '../../../models/link';
 import { ModelError } from '../../../models/model-error';
 
 describe('CreateEndpointResponse', () => {
-    test('should create an endpoint response with successful data', () => {
+    test('should create an endpoint response with all fields', () => {
         const link: Link = {
             rel: 'self',
             href: 'http://api.example.com/endpoints/ep-123456'
@@ -22,35 +22,6 @@ describe('CreateEndpointResponse', () => {
             tag: 'webrtc-endpoint'
         };
 
-        const response: CreateEndpointResponse = {
-            links: [link],
-            data: responseData,
-            errors: []
-        };
-
-        expect(response.links).toHaveLength(1);
-        expect(response.data.endpointId).toBe('ep-123456');
-        expect(response.data.type).toBe('WEBRTC');
-        expect(response.data.status).toBe('CONNECTED');
-        expect(response.data.token).toBe('xxxxx.yyyyy.zzzzz');
-        expect(response.errors).toHaveLength(0);
-    });
-
-    test('should create an endpoint response with error', () => {
-        const link: Link = {
-            rel: 'documentation',
-            href: 'http://api.example.com/docs/endpoints'
-        };
-
-        const responseData: CreateEndpointResponseData = {
-            endpointId: '',
-            type: EndpointTypeEnum.Webrtc,
-            status: EndpointStatusEnum.Disconnected,
-            creationTimestamp: '2024-02-18T10:30:00Z',
-            expirationTimestamp: '2024-02-19T10:30:00Z',
-            token: 'invalid.token.value'
-        };
-
         const error: ModelError = {
             code: 400,
             description: 'Missing required field: endpointId'
@@ -62,7 +33,18 @@ describe('CreateEndpointResponse', () => {
             errors: [error]
         };
 
+        expect(response.links).toHaveLength(1);
+        expect(response.links[0].rel).toBe('self');
+        expect(response.links[0].href).toBe('http://api.example.com/endpoints/ep-123456');
+        expect(response.data.endpointId).toBe('ep-123456');
+        expect(response.data.type).toBe('WEBRTC');
+        expect(response.data.status).toBe('CONNECTED');
+        expect(response.data.token).toBe('xxxxx.yyyyy.zzzzz');
+        expect(response.data.tag).toBe('webrtc-endpoint');
+        expect(new Date(response.data.creationTimestamp).getFullYear()).toBe(2024);
+        expect(new Date(response.data.expirationTimestamp).getFullYear()).toBe(2024);
         expect(response.errors).toHaveLength(1);
+        expect(response.errors[0].code).toBe(400);
         expect(response.errors[0].description).toContain('endpointId');
     });
 });