test: migrate endpoints tests to PyHamcrest and add optional param support

Author: smoghe-bw

.claude/worktrees/agent-e0d029b7

@@ -0,0 +1 @@
+Subproject commit f7060abe73e32d3515e6ea9a9808e8038bd7499c

test/unit/api/test_endpoints_api.py

@@ -16,6 +16,7 @@
 import unittest
 from datetime import datetime
 
+from hamcrest import *
 from test.utils.env_variables import *
 from bandwidth import ApiClient, Configuration
 from bandwidth.api.endpoints_api import EndpointsApi
@@ -68,26 +69,25 @@ def test_create_endpoint(self) -> None:
             endpoint_body
         )
 
-        assert response.status_code == 201
-        assert isinstance(response.data, CreateEndpointResponse)
+        assert_that(response.status_code, equal_to(201))
+        assert_that(response.data, instance_of(CreateEndpointResponse))
 
-        assert isinstance(response.data.links, list)
-        assert len(response.data.links) > 0
-        assert isinstance(response.data.links[0], Link)
-        assert response.data.links[0].href.startswith('http')
-        assert response.data.links[0].rel == 'endpoint'
+        assert_that(response.data.links, instance_of(list))
+        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, equal_to('endpoint'))
 
-        assert isinstance(response.data.data, CreateEndpointResponseData)
-        assert response.data.data.endpoint_id == 'e-15ac29a2-1331029c-2cb0-4a07-b215-b22865662d85'
-        assert response.data.data.type == EndpointTypeEnum.WEBRTC
-        assert response.data.data.status == EndpointStatusEnum.CONNECTED
-        assert isinstance(response.data.data.creation_timestamp, datetime)
-        assert isinstance(response.data.data.expiration_timestamp, datetime)
-        assert response.data.data.token == 'xxxxx.yyyyy.zzzzz'
-        assert response.data.data.tag == 'my-tag'
-        assert isinstance(response.data.data.devices, list)
+        assert_that(response.data.data, instance_of(CreateEndpointResponseData))
+        assert_that(response.data.data.endpoint_id, equal_to('e-15ac29a2-1331029c-2cb0-4a07-b215-b22865662d85'))
+        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.data.tag, instance_of(str))
+        assert_that(response.data.data.devices, instance_of(list))
 
-        assert response.data.errors == []
+        assert_that(response.data.errors, instance_of(list))
 
     def test_delete_endpoint(self) -> None:
         """Test case for delete_endpoint
@@ -99,7 +99,7 @@ def test_delete_endpoint(self) -> None:
             "ep-abc123"
         )
 
-        assert response.status_code == 204
+        assert_that(response.status_code, equal_to(204))
 
     def test_get_endpoint(self) -> None:
         """Test case for get_endpoint
@@ -111,25 +111,24 @@ def test_get_endpoint(self) -> None:
             "ep-abc123"
         )
 
-        assert response.status_code == 200
-        assert isinstance(response.data, EndpointResponse)
+        assert_that(response.status_code, equal_to(200))
+        assert_that(response.data, instance_of(EndpointResponse))
 
-        assert isinstance(response.data.links, list)
-        assert len(response.data.links) > 0
-        assert isinstance(response.data.links[0], Link)
-        assert response.data.links[0].href.startswith('http')
-        assert response.data.links[0].rel == 'self'
+        assert_that(response.data.links, instance_of(list))
+        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, equal_to('self'))
 
-        assert isinstance(response.data.data, Endpoint)
-        assert response.data.data.endpoint_id == 'e-15ac29a2-1331029c-2cb0-4a07-b215-b22865662d85'
-        assert response.data.data.type == EndpointTypeEnum.WEBRTC
-        assert response.data.data.status == EndpointStatusEnum.CONNECTED
-        assert isinstance(response.data.data.creation_timestamp, datetime)
-        assert isinstance(response.data.data.expiration_timestamp, datetime)
-        assert response.data.data.tag == 'my-tag'
-        assert response.data.data.devices == []
+        assert_that(response.data.data, instance_of(Endpoint))
+        assert_that(response.data.data.endpoint_id, equal_to('e-15ac29a2-1331029c-2cb0-4a07-b215-b22865662d85'))
+        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.tag, instance_of(str))
+        assert_that(response.data.data.devices, instance_of(list))
 
-        assert response.data.errors == []
+        assert_that(response.data.errors, instance_of(list))
 
     def test_list_endpoints(self) -> None:
         """Test case for list_endpoints
@@ -140,33 +139,32 @@ def test_list_endpoints(self) -> None:
             BW_ACCOUNT_ID
         )
 
-        assert response.status_code == 200
-        assert isinstance(response.data, ListEndpointsResponse)
-
-        assert isinstance(response.data.links, list)
-        assert len(response.data.links) > 0
-        assert isinstance(response.data.links[0], Link)
-        assert response.data.links[0].href.startswith('http')
-        assert response.data.links[0].rel == 'self'
-
-        assert response.data.page.page_size == 2
-        assert response.data.page.total_elements == 10
-        assert response.data.page.total_pages == 5
-        assert response.data.page.page_number == 0
-
-        assert isinstance(response.data.data, list)
-        assert len(response.data.data) == 2
-        assert isinstance(response.data.data[0], Endpoints)
-        assert response.data.data[0].endpoint_id == 'e-15ac29a2-1331029c-2cb0-4a07-b215-b22865662d85'
-        assert response.data.data[0].type == EndpointTypeEnum.WEBRTC
-        assert response.data.data[0].status == EndpointStatusEnum.CONNECTED
-        assert response.data.data[0].tag == 'my-tag'
-        assert isinstance(response.data.data[0].creation_timestamp, datetime)
-        assert isinstance(response.data.data[0].expiration_timestamp, datetime)
-        assert response.data.data[1].endpoint_id == 'e-2cb0-4a07-b215-b22865662d85-15ac29a2-1331029c'
-        assert response.data.data[1].tag == 'my-tag'
-
-        assert response.data.errors == []
+        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.links[0], instance_of(Link))
+        assert_that(response.data.links[0].href, starts_with('http'))
+        assert_that(response.data.links[0].rel, equal_to('self'))
+
+        assert_that(response.data.page, instance_of(Page))
+        assert_that(response.data.page.page_size, equal_to(2))
+        assert_that(response.data.page.total_elements, equal_to(10))
+        assert_that(response.data.page.total_pages, equal_to(5))
+        assert_that(response.data.page.page_number, equal_to(0))
+
+        assert_that(response.data.data, instance_of(list))
+        assert_that(response.data.data[0], instance_of(Endpoints))
+        assert_that(response.data.data[0].endpoint_id, equal_to('e-15ac29a2-1331029c-2cb0-4a07-b215-b22865662d85'))
+        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].tag, instance_of(str))
+        assert_that(response.data.data[0].creation_timestamp, instance_of(datetime))
+        assert_that(response.data.data[0].expiration_timestamp, instance_of(datetime))
+        assert_that(response.data.data[1].endpoint_id, equal_to('e-2cb0-4a07-b215-b22865662d85-15ac29a2-1331029c'))
+        assert_that(response.data.data[1].tag, instance_of(str))
+
+        assert_that(response.data.errors, instance_of(list))
 
 
 if __name__ == '__main__':

test/unit/models/test_create_endpoint_request_base.py

@@ -28,19 +28,26 @@ def setUp(self):
     def tearDown(self):
         pass
 
-    def make_instance(self) -> CreateEndpointRequestBase:
-        """Test CreateEndpointRequestBase"""
-        return CreateEndpointRequestBase(
-            type=EndpointTypeEnum.WEBRTC,
-            direction=EndpointDirectionEnum.BIDIRECTIONAL,
-            event_callback_url='https://example.com/callback',
-            event_fallback_url='https://example.com/fallback',
-            tag='test-request'
+    def make_instance(self, include_optional) -> CreateEndpointRequestBase:
+        """Test CreateEndpointRequestBase
+            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 CreateEndpointRequestBase(
+                type=EndpointTypeEnum.WEBRTC,
+                direction=EndpointDirectionEnum.BIDIRECTIONAL,
+                event_callback_url='https://example.com/callback',
+                event_fallback_url='https://example.com/fallback',
+                tag='test-request'
+            )
+        else:
+            return CreateEndpointRequestBase(
         )
 
     def testCreateEndpointRequestBase(self):
         """Test CreateEndpointRequestBase"""
-        instance = self.make_instance()
+        instance = self.make_instance(True)
         assert instance is not None
         assert isinstance(instance, CreateEndpointRequestBase)
         assert instance.type == EndpointTypeEnum.WEBRTC

test/unit/models/test_create_endpoint_response.py

@@ -32,26 +32,33 @@ def setUp(self):
     def tearDown(self):
         pass
 
-    def make_instance(self) -> CreateEndpointResponse:
-        """Test CreateEndpointResponse"""
-        return CreateEndpointResponse(
-            links=[
-                Link(href='https://api.bandwidth.com/endpoint-123', rel='self')
-            ],
-            data=CreateEndpointResponseData(
-                endpoint_id='endpoint-123',
-                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'
-            ),
-            errors=[]
+    def make_instance(self, include_optional) -> CreateEndpointResponse:
+        """Test CreateEndpointResponse
+            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 CreateEndpointResponse(
+                links=[
+                    Link(href='https://api.bandwidth.com/endpoint-123', rel='self')
+                ],
+                data=CreateEndpointResponseData(
+                    endpoint_id='endpoint-123',
+                    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'
+                ),
+                errors=[]
+            )
+        else:
+            return CreateEndpointResponse(
         )
 
     def testCreateEndpointResponse(self):
         """Test CreateEndpointResponse"""
-        instance = self.make_instance()
+        instance = self.make_instance(True)
         assert instance is not None
         assert isinstance(instance, CreateEndpointResponse)
         assert isinstance(instance.links, list)

test/unit/models/test_create_endpoint_response_data.py

@@ -31,29 +31,36 @@ def setUp(self):
     def tearDown(self):
         pass
 
-    def make_instance(self) -> CreateEndpointResponseData:
-        """Test CreateEndpointResponseData"""
-        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'
+    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(
         )
 
     def testCreateEndpointResponseData(self):
         """Test CreateEndpointResponseData"""
-        instance = self.make_instance()
+        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'

test/unit/models/test_create_web_rtc_connection_request.py

@@ -28,23 +28,30 @@ def setUp(self):
     def tearDown(self):
         pass
 
-    def make_instance(self) -> CreateWebRtcConnectionRequest:
-        """Test CreateWebRtcConnectionRequest"""
-        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'
-            }
+    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(
         )
 
     def testCreateWebRtcConnectionRequest(self):
         """Test CreateWebRtcConnectionRequest"""
-        instance = self.make_instance()
+        instance = self.make_instance(True)
         assert instance is not None
         assert isinstance(instance, CreateWebRtcConnectionRequest)
         assert instance.type == EndpointTypeEnum.WEBRTC

test/unit/models/test_device.py

@@ -28,18 +28,25 @@ def setUp(self):
     def tearDown(self):
         pass
 
-    def make_instance(self) -> Device:
-        """Test Device"""
-        return Device(
-            device_id='device-abc-123',
-            device_name='My Test Device',
-            status=DeviceStatusEnum.CONNECTED,
-            creation_timestamp=datetime(2026, 1, 15, 10, 0, 0)
+    def make_instance(self, include_optional) -> Device:
+        """Test Device
+            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 Device(
+                device_id='device-abc-123',
+                device_name='My Test Device',
+                status=DeviceStatusEnum.CONNECTED,
+                creation_timestamp=datetime(2026, 1, 15, 10, 0, 0)
+            )
+        else:
+            return Device(
         )
 
     def testDevice(self):
         """Test Device"""
-        instance = self.make_instance()
+        instance = self.make_instance(True)
         assert instance is not None
         assert isinstance(instance, Device)
         assert instance.device_id == 'device-abc-123'