Add unit tests for CreateWebRtcConnectionRequest and CreateEndpointResponseData; remove redundant tests from existing models

Author: smoghe-bw

test/unit/api/test_endpoints_api.py

@@ -22,8 +22,13 @@
 from bandwidth.api.endpoints_api import EndpointsApi
 from bandwidth.models.create_web_rtc_connection_request import CreateWebRtcConnectionRequest
 from bandwidth.models.create_endpoint_response import CreateEndpointResponse
+from bandwidth.models.create_endpoint_response_data import CreateEndpointResponseData
 from bandwidth.models.endpoint_response import EndpointResponse
+from bandwidth.models.endpoint import Endpoint
+from bandwidth.models.endpoints import Endpoints
 from bandwidth.models.list_endpoints_response import ListEndpointsResponse
+from bandwidth.models.link import Link
+from bandwidth.models.page import Page
 from bandwidth.models.endpoint_type_enum import EndpointTypeEnum
 from bandwidth.models.endpoint_direction_enum import EndpointDirectionEnum
 from bandwidth.models.endpoint_status_enum import EndpointStatusEnum
@@ -66,8 +71,21 @@ def test_create_endpoint(self) -> None:
 
         assert_that(response.status_code, equal_to(201))
         assert_that(response.data, instance_of(CreateEndpointResponse))
+
         assert_that(response.data.links, instance_of(list))
-        assert_that(response.data.data, instance_of(object))
+        assert_that(len(response.data.links), greater_than(0))
+        assert_that(response.data.links[0], instance_of(Link))
+        assert_that(response.data.links[0].href, starts_with('http'))
+        assert_that(response.data.links[0].rel, instance_of(str))
+
+        assert_that(response.data.data, instance_of(CreateEndpointResponseData))
+        assert_that(response.data.data.endpoint_id, instance_of(str))
+        assert_that(response.data.data.type, is_in(EndpointTypeEnum))
+        assert_that(response.data.data.status, is_in(EndpointStatusEnum))
+        assert_that(response.data.data.creation_timestamp, instance_of(datetime))
+        assert_that(response.data.data.expiration_timestamp, instance_of(datetime))
+        assert_that(response.data.data.token, instance_of(str))
+
         assert_that(response.data.errors, instance_of(list))
 
     def test_delete_endpoint(self) -> None:
@@ -94,8 +112,20 @@ def test_get_endpoint(self) -> None:
 
         assert_that(response.status_code, equal_to(200))
         assert_that(response.data, instance_of(EndpointResponse))
+
         assert_that(response.data.links, instance_of(list))
-        assert_that(response.data.data, instance_of(object))
+        assert_that(len(response.data.links), greater_than(0))
+        assert_that(response.data.links[0], instance_of(Link))
+        assert_that(response.data.links[0].href, starts_with('http'))
+        assert_that(response.data.links[0].rel, instance_of(str))
+
+        assert_that(response.data.data, instance_of(Endpoint))
+        assert_that(response.data.data.endpoint_id, instance_of(str))
+        assert_that(response.data.data.type, is_in(EndpointTypeEnum))
+        assert_that(response.data.data.status, is_in(EndpointStatusEnum))
+        assert_that(response.data.data.creation_timestamp, instance_of(datetime))
+        assert_that(response.data.data.expiration_timestamp, instance_of(datetime))
+
         assert_that(response.data.errors, instance_of(list))
 
     def test_list_endpoints(self) -> None:
@@ -109,98 +139,29 @@ def test_list_endpoints(self) -> None:
 
         assert_that(response.status_code, equal_to(200))
         assert_that(response.data, instance_of(ListEndpointsResponse))
-        assert_that(response.data.links, instance_of(list))
-        assert_that(response.data.data, instance_of(list))
-        assert_that(response.data.errors, instance_of(list))
-
-    def test_list_endpoints_with_filters(self) -> None:
-        """Test case for list_endpoints with filters
-
-        List Endpoints with Type and Status Filters
-        """
-        response = self.endpoints_api_instance.list_endpoints_with_http_info(
-            BW_ACCOUNT_ID,
-            type=EndpointTypeEnum.WEBRTC,
-            status=EndpointStatusEnum.CONNECTED,
-            limit=100
-        )
 
-        assert_that(response.status_code, equal_to(200))
-        assert_that(response.data, instance_of(ListEndpointsResponse))
         assert_that(response.data.links, instance_of(list))
-        assert_that(response.data.data, instance_of(list))
-        assert_that(response.data.errors, instance_of(list))
-        if response.data.page:
-            assert_that(response.data.page, instance_of(object))
-
-    def test_list_endpoints_with_pagination(self) -> None:
-        """Test case for list_endpoints with pagination
+        assert_that(len(response.data.links), greater_than(0))
+        assert_that(response.data.links[0], instance_of(Link))
+        assert_that(response.data.links[0].href, starts_with('http'))
+        assert_that(response.data.links[0].rel, instance_of(str))
 
-        List Endpoints with Pagination
-        """
-        response = self.endpoints_api_instance.list_endpoints_with_http_info(
-            BW_ACCOUNT_ID,
-            after_cursor="cursor-abc123",
-            limit=50
-        )
-
-        assert_that(response.status_code, equal_to(200))
-        assert_that(response.data, instance_of(ListEndpointsResponse))
-        assert_that(response.data.links, instance_of(list))
         assert_that(response.data.data, instance_of(list))
-        assert_that(response.data.errors, instance_of(list))
+        assert_that(len(response.data.data), greater_than(0))
+        assert_that(response.data.data[0], instance_of(Endpoints))
+        assert_that(response.data.data[0].endpoint_id, instance_of(str))
+        assert_that(response.data.data[0].type, is_in(EndpointTypeEnum))
+        assert_that(response.data.data[0].status, is_in(EndpointStatusEnum))
+        assert_that(response.data.data[0].creation_timestamp, instance_of(datetime))
+        assert_that(response.data.data[0].expiration_timestamp, instance_of(datetime))
 
-    # TODO: Endpoint BXML not ready yet - commented out
-    # def test_update_endpoint_bxml(self) -> None:
-    #     """Test case for update_endpoint_bxml
-    #
-    #     Update Endpoint BXML
-    #     """
-    #     update_bxml = '<?xml version="1.0" encoding="UTF-8"?><Bxml><SpeakSentence locale="en_US" gender="female" voice="susan">This is a test bxml response for endpoint</SpeakSentence><Pause duration="3"/></Bxml>'
-    #
-    #     response = self.endpoints_api_instance.update_endpoint_bxml_with_http_info(
-    #         BW_ACCOUNT_ID,
-    #         "ep-abc123",
-    #         update_bxml
-    #     )
-    #
-    #     assert_that(response.status_code, equal_to(204))
-
-    def test_create_endpoint_minimal(self) -> None:
-        """Test case for create_endpoint with minimal required fields
-
-        Create Endpoint with Minimal Fields
-        """
-        endpoint_body = CreateWebRtcConnectionRequest(
-            type=EndpointTypeEnum.WEBRTC,
-            direction=EndpointDirectionEnum.OUTBOUND
-        )
-        response = self.endpoints_api_instance.create_endpoint_with_http_info(
-            BW_ACCOUNT_ID,
-            endpoint_body
-        )
-
-        assert_that(response.status_code, equal_to(201))
-        assert_that(response.data, instance_of(CreateEndpointResponse))
+        if response.data.page:
+            assert_that(response.data.page, instance_of(Page))
+            assert_that(response.data.page.page_size, greater_than_or_equal_to(0))
 
-    def test_create_endpoint_sip(self) -> None:
-        """Test case for create_endpoint with SIP type
+        assert_that(response.data.errors, instance_of(list))
 
-        Create SIP Endpoint
-        """
-        endpoint_body = CreateWebRtcConnectionRequest(
-            type=EndpointTypeEnum.WEBRTC,
-            direction=EndpointDirectionEnum.BIDIRECTIONAL,
-            event_callback_url="https://myServer.com/bandwidth/webhooks/sip-endpoint",
-            tag="sip-test-endpoint"
-        )
-        response = self.endpoints_api_instance.create_endpoint_with_http_info(
-            BW_ACCOUNT_ID,
-            endpoint_body
-        )
 
-        assert_that(response.status_code, equal_to(201))
-        assert_that(response.data, instance_of(CreateEndpointResponse))
 
 
 if __name__ == '__main__':

test/unit/models/test_create_endpoint_request_base.py

@@ -58,13 +58,5 @@ def testCreateEndpointRequestBase(self):
         assert instance.event_fallback_url == 'https://example.com/fallback'
         assert instance.tag == 'test-request'
 
-    def testCreateEndpointRequestBaseRequiredOnly(self):
-        """Test CreateEndpointRequestBase with required fields only"""
-        instance = self.make_instance(False)
-        assert instance is not None
-        assert isinstance(instance, CreateEndpointRequestBase)
-        assert instance.type == EndpointTypeEnum.WEBRTC
-        assert instance.direction == EndpointDirectionEnum.BIDIRECTIONAL
-
 if __name__ == '__main__':
     unittest.main()

test/unit/models/test_create_endpoint_response_data.py

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+"""
+    Bandwidth
+
+    Bandwidth's Communication APIs
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: letstalk@bandwidth.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+import unittest
+from datetime import datetime
+
+from bandwidth.models.create_endpoint_response_data import CreateEndpointResponseData
+from bandwidth.models.device import Device
+from bandwidth.models.device_status_enum import DeviceStatusEnum
+from bandwidth.models.endpoint_status_enum import EndpointStatusEnum
+from bandwidth.models.endpoint_type_enum import EndpointTypeEnum
+
+class TestCreateEndpointResponseData(unittest.TestCase):
+    """CreateEndpointResponseData unit test stubs"""
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def make_instance(self, include_optional) -> CreateEndpointResponseData:
+        """Test CreateEndpointResponseData
+            include_optional is a boolean, when False only required
+            params are included, when True both required and
+            optional params are included """
+        if include_optional:
+            return CreateEndpointResponseData(
+                endpoint_id='e-15ac29a2-1331029c-2cb0-4a07-b215-b22865662d85',
+                type=EndpointTypeEnum.WEBRTC,
+                status=EndpointStatusEnum.CONNECTED,
+                creation_timestamp=datetime(2026, 1, 15, 10, 0, 0),
+                expiration_timestamp=datetime(2026, 1, 16, 10, 0, 0),
+                tag='my-tag',
+                devices=[
+                    Device(
+                        device_id='device-456',
+                        device_name='Test Device',
+                        status=DeviceStatusEnum.CONNECTED,
+                        creation_timestamp=datetime(2026, 1, 15, 10, 0, 0)
+                    )
+                ],
+                token='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test.token'
+            )
+        else:
+            return CreateEndpointResponseData(
+                endpoint_id='e-15ac29a2-1331029c-2cb0-4a07-b215-b22865662d85',
+                type=EndpointTypeEnum.WEBRTC,
+                status=EndpointStatusEnum.CONNECTED,
+                creation_timestamp=datetime(2026, 1, 15, 10, 0, 0),
+                expiration_timestamp=datetime(2026, 1, 16, 10, 0, 0),
+                token='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test.token'
+            )
+
+    def testCreateEndpointResponseData(self):
+        """Test CreateEndpointResponseData"""
+        instance = self.make_instance(True)
+        assert instance is not None
+        assert isinstance(instance, CreateEndpointResponseData)
+        assert instance.endpoint_id == 'e-15ac29a2-1331029c-2cb0-4a07-b215-b22865662d85'
+        assert instance.type == EndpointTypeEnum.WEBRTC
+        assert instance.status == EndpointStatusEnum.CONNECTED
+        assert isinstance(instance.creation_timestamp, datetime)
+        assert isinstance(instance.expiration_timestamp, datetime)
+        assert instance.tag == 'my-tag'
+        assert isinstance(instance.devices, list)
+        assert len(instance.devices) == 1
+        assert isinstance(instance.devices[0], Device)
+        assert instance.devices[0].device_id == 'device-456'
+        assert instance.token == 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test.token'
+
+if __name__ == '__main__':
+    unittest.main()

test/unit/models/test_create_web_rtc_connection_request.py

@@ -0,0 +1,69 @@
+# coding: utf-8
+
+"""
+    Bandwidth
+
+    Bandwidth's Communication APIs
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: letstalk@bandwidth.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+import unittest
+
+from bandwidth.models.create_web_rtc_connection_request import CreateWebRtcConnectionRequest
+from bandwidth.models.endpoint_direction_enum import EndpointDirectionEnum
+from bandwidth.models.endpoint_type_enum import EndpointTypeEnum
+
+class TestCreateWebRtcConnectionRequest(unittest.TestCase):
+    """CreateWebRtcConnectionRequest unit test stubs"""
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def make_instance(self, include_optional) -> CreateWebRtcConnectionRequest:
+        """Test CreateWebRtcConnectionRequest
+            include_optional is a boolean, when False only required
+            params are included, when True both required and
+            optional params are included """
+        if include_optional:
+            return CreateWebRtcConnectionRequest(
+                type=EndpointTypeEnum.WEBRTC,
+                direction=EndpointDirectionEnum.BIDIRECTIONAL,
+                event_callback_url='https://example.com/callback',
+                event_fallback_url='https://example.com/fallback',
+                tag='test-webrtc',
+                connection_metadata={
+                    'key1': 'value1',
+                    'key2': 'value2'
+                }
+            )
+        else:
+            return CreateWebRtcConnectionRequest(
+                type=EndpointTypeEnum.WEBRTC,
+                direction=EndpointDirectionEnum.BIDIRECTIONAL
+            )
+
+    def testCreateWebRtcConnectionRequest(self):
+        """Test CreateWebRtcConnectionRequest"""
+        instance = self.make_instance(True)
+        assert instance is not None
+        assert isinstance(instance, CreateWebRtcConnectionRequest)
+        assert instance.type == EndpointTypeEnum.WEBRTC
+        assert instance.direction == EndpointDirectionEnum.BIDIRECTIONAL
+        assert instance.event_callback_url == 'https://example.com/callback'
+        assert instance.event_fallback_url == 'https://example.com/fallback'
+        assert instance.tag == 'test-webrtc'
+        assert isinstance(instance.connection_metadata, dict)
+        assert instance.connection_metadata['key1'] == 'value1'
+        assert instance.connection_metadata['key2'] == 'value2'
+
+if __name__ == '__main__':
+    unittest.main()

test/unit/models/test_device.py

@@ -57,13 +57,5 @@ def testDevice(self):
         assert instance.status == DeviceStatusEnum.CONNECTED
         assert isinstance(instance.creation_timestamp, datetime)
 
-    def testDeviceRequiredOnly(self):
-        """Test Device with required fields only"""
-        instance = self.make_instance(False)
-        assert instance is not None
-        assert isinstance(instance, Device)
-        assert instance.device_id == 'device-abc-123'
-        assert instance.status == DeviceStatusEnum.CONNECTED
-
 if __name__ == '__main__':
     unittest.main()

test/unit/models/test_endpoint.py

@@ -77,14 +77,5 @@ def testEndpoint(self):
         assert len(instance.devices) == 1
         assert isinstance(instance.devices[0], Device)
 
-    def testEndpointRequiredOnly(self):
-        """Test Endpoint with required fields only"""
-        instance = self.make_instance(False)
-        assert instance is not None
-        assert isinstance(instance, Endpoint)
-        assert instance.endpoint_id == 'endpoint-123'
-        assert instance.type == EndpointTypeEnum.WEBRTC
-        assert instance.status == EndpointStatusEnum.CONNECTED
-
 if __name__ == '__main__':
     unittest.main()

test/unit/models/test_endpoint_event.py

@@ -81,14 +81,5 @@ def testEndpointEvent(self):
         assert isinstance(instance.device, Device)
         assert instance.device.device_id == 'device-event-456'
 
-    def testEndpointEventRequiredOnly(self):
-        """Test EndpointEvent with required fields only"""
-        instance = self.make_instance(False)
-        assert instance is not None
-        assert isinstance(instance, EndpointEvent)
-        assert instance.endpoint_id == 'endpoint-event-123'
-        assert isinstance(instance.event_time, datetime)
-        assert instance.event_type == EndpointEventTypeEnum.DEVICE_CONNECTED
-
 if __name__ == '__main__':
     unittest.main()

test/unit/models/test_endpoints.py

@@ -64,12 +64,5 @@ def testEndpoints(self):
         assert isinstance(instance.expiration_timestamp, datetime)
         assert instance.tag == 'list-endpoint'
 
-    def testEndpointsRequiredOnly(self):
-        """Test Endpoints with required fields only"""
-        instance = self.make_instance(False)
-        assert instance is not None
-        assert isinstance(instance, Endpoints)
-        assert instance.endpoint_id == 'endpoint-789'
-
 if __name__ == '__main__':
     unittest.main()