update tests

ckoegel · ckoegel · commit 20b967b0ca85 · 2025-12-05T17:32:53.000-05:00
diff --git a/test/smoke/test_calls_api.py b/test/smoke/test_calls_api.py
@@ -27,13 +27,14 @@
 class CallsIntegration(unittest.TestCase):
     """Voice Calls API integration test"""
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         configuration = Configuration(
             client_id=BW_CLIENT_ID,
             client_secret=BW_CLIENT_SECRET
         )
         api_client = ApiClient(configuration)
-        self.calls_api_instance = calls_api.CallsApi(api_client)
+        cls.calls_api_instance = calls_api.CallsApi(api_client)
 
         # Unauthorized API Client
 
@@ -42,7 +43,7 @@ def setUp(self):
              password='bad_password'
         )
         unauthorized_api_client = ApiClient(unauthorizedConfiguration)
-        self.unauthorized_api_instance = calls_api.CallsApi(unauthorized_api_client)
+        cls.unauthorized_api_instance = calls_api.CallsApi(unauthorized_api_client)
 
         # Forbidden API Client
 
@@ -51,9 +52,9 @@ def setUp(self):
             password=FORBIDDEN_PASSWORD
         )
         forbidden_api_client = ApiClient(forbiddenConfiguration)
-        self.forbidden_api_instance = calls_api.CallsApi(forbidden_api_client)
-        self.account_id = BW_ACCOUNT_ID
-        self.createCallBody = CreateCall(
+        cls.forbidden_api_instance = calls_api.CallsApi(forbidden_api_client)
+        cls.account_id = BW_ACCOUNT_ID
+        cls.createCallBody = CreateCall(
             to=USER_NUMBER,
             var_from=BW_NUMBER,
             privacy=True,
@@ -91,17 +92,18 @@ def setUp(self):
             priority=5,
             tag="tag_example",
         )
-        self.testCallBody = CreateCall(to=USER_NUMBER, var_from=BW_NUMBER, application_id=BW_VOICE_APPLICATION_ID, answer_url=BASE_CALLBACK_URL)
-        self.testMantecaCallBody = CreateCall(to=MANTECA_IDLE_NUMBER, var_from=MANTECA_ACTIVE_NUMBER, application_id=MANTECA_APPLICATION_ID, answer_url=MANTECA_BASE_URL + "/bxml/pause")
-        self.updateStateCompleted = UpdateCall(state=CallStateEnum("completed"))
-        self.testCallId = "Call-Id"
-        self.testBxmlBody = '<?xml version="1.0" encoding="UTF-8"?><Bxml><SpeakSentence locale="en_US" gender="female" voice="susan">This is a test bxml response</SpeakSentence><Pause duration="3"/></Bxml>'
-        self.callIdArray = []
-        self.TEST_SLEEP = 5
-        self.TEST_SLEEP_LONG = 15
-
-    def tearDown(self):
-        callCleanup(self)
+        cls.testCallBody = CreateCall(to=USER_NUMBER, var_from=BW_NUMBER, application_id=BW_VOICE_APPLICATION_ID, answer_url=BASE_CALLBACK_URL)
+        cls.testMantecaCallBody = CreateCall(to=MANTECA_IDLE_NUMBER, var_from=MANTECA_ACTIVE_NUMBER, application_id=MANTECA_APPLICATION_ID, answer_url=MANTECA_BASE_URL + "/bxml/pause")
+        cls.updateStateCompleted = UpdateCall(state=CallStateEnum("completed"))
+        cls.testCallId = "Call-Id"
+        cls.testBxmlBody = '<?xml version="1.0" encoding="UTF-8"?><Bxml><SpeakSentence locale="en_US" gender="female" voice="susan">This is a test bxml response</SpeakSentence><Pause duration="3"/></Bxml>'
+        cls.callIdArray = []
+        cls.TEST_SLEEP = 5
+        cls.TEST_SLEEP_LONG = 15
+
+    @classmethod
+    def tearDownClass(cls):
+        callCleanup(cls)
 
     def assertApiException(self, context: ApiException, expectedException: ApiException, expected_status_code: int):
         """Validates that common API exceptions, (401, 403, and 404) are properly formatted
diff --git a/test/smoke/test_conferences_api.py b/test/smoke/test_conferences_api.py
@@ -33,7 +33,8 @@ class ConferencesIntegration(unittest.TestCase):
     Voice Conferences API integration test
     """
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """
         Set up for our tests by creating the CallsApi and ConferencesApi instances
         for testing as well as the unauthorized and forbidden credentials for the 4xx tests.
@@ -44,33 +45,33 @@ def setUp(self):
         )
         api_client = ApiClient(configuration)
 
-        self.calls_api_instance = calls_api.CallsApi(api_client)
-        self.conference_api_instance = conferences_api.ConferencesApi(api_client)
+        cls.calls_api_instance = calls_api.CallsApi(api_client)
+        cls.conference_api_instance = conferences_api.ConferencesApi(api_client)
 
         unauthorizedConfiguration = Configuration(
             username='bad_username',
             password='bad_password'
         )
         unauthorized_api_client = ApiClient(unauthorizedConfiguration)
-        self.unauthorized_api_instance = conferences_api.ConferencesApi(unauthorized_api_client)
+        cls.unauthorized_api_instance = conferences_api.ConferencesApi(unauthorized_api_client)
 
         forbiddenConfiguration = Configuration(
             username=FORBIDDEN_USERNAME,
             password=FORBIDDEN_PASSWORD
         )
         forbidden_api_client = ApiClient(forbiddenConfiguration)
-        self.forbidden_api_instance = conferences_api.ConferencesApi(forbidden_api_client)
+        cls.forbidden_api_instance = conferences_api.ConferencesApi(forbidden_api_client)
 
         # Rest client for interacting with Manteca
-        self.rest_client = RESTClientObject(Configuration.get_default_copy())
+        cls.rest_client = RESTClientObject(Configuration.get_default_copy())
         configuration = Configuration(
             username=BW_USERNAME,
             password=BW_PASSWORD,
         )
 
-        self.account_id = BW_ACCOUNT_ID
-        self.callIdArray = []
-        self.testUpdateConf = UpdateConference(
+        cls.account_id = BW_ACCOUNT_ID
+        cls.callIdArray = []
+        cls.testUpdateConf = UpdateConference(
             state=ConferenceStateEnum("active"),
             redirect_url=MANTECA_BASE_URL + "/bxml/pause",
             redirect_method=RedirectMethodEnum("POST"),
@@ -82,17 +83,18 @@ def setUp(self):
             fallback_password="mySecretPassword1!",
             tag="My Custom Tag",
         )
-        self.testUpdateBxml = '<?xml version="1.0" encoding="UTF-8"?><Bxml><SpeakSentence locale="en_US" gender="female" voice="susan">This is test BXML.</SpeakSentence></Bxml>'
-        self.testUpdateMember = UpdateConferenceMember(mute=False)
-        self.testConfId = "Conf-id"
-        self.testMemberId = "Member-Id"
-        self.testRecordId = "Recording-Id"
-        self.TEST_SLEEP = 3
-        self.TEST_SLEEP_LONG = 10
-        self.MAX_RETRIES = 40
-
-    def tearDown(self):
-        callCleanup(self)
+        cls.testUpdateBxml = '<?xml version="1.0" encoding="UTF-8"?><Bxml><SpeakSentence locale="en_US" gender="female" voice="susan">This is test BXML.</SpeakSentence></Bxml>'
+        cls.testUpdateMember = UpdateConferenceMember(mute=False)
+        cls.testConfId = "Conf-id"
+        cls.testMemberId = "Member-Id"
+        cls.testRecordId = "Recording-Id"
+        cls.TEST_SLEEP = 3
+        cls.TEST_SLEEP_LONG = 10
+        cls.MAX_RETRIES = 40
+
+    @classmethod
+    def tearDownClass(cls):
+        callCleanup(cls)
 
     def assertApiException(self, context: ApiException, expectedException: ApiException, expected_status_code: int):
         """Validates that common API exceptions, (401, 403, and 404) are properly formatted
diff --git a/test/smoke/test_media_api.py b/test/smoke/test_media_api.py
@@ -21,19 +21,20 @@ class TestMedia(unittest.TestCase):
     """Media API integration Test
     """
 
-    def setUp(self) -> None:
+    @classmethod
+    def setUpClass(cls) -> None:
         configuration = Configuration(
             username=BW_USERNAME,
             password=BW_PASSWORD
         )
-        self.api_client = ApiClient(configuration)
-        self.api_instance = media_api.MediaApi(self.api_client)
-        self.account_id = BW_ACCOUNT_ID
-        self.media_path = "./test/fixtures/"
-        self.media_file = "python_cat.jpeg"
-        self.media_id = PYTHON_VERSION + "_" + RUNNER_OS + "_" + str(uuid.uuid4()) + "_" + self.media_file
-        self.download_file_path = "cat_download.jpeg"
-        self.original_file = open(self.media_path + self.media_file, "rb")
+        cls.api_client = ApiClient(configuration)
+        cls.api_instance = media_api.MediaApi(cls.api_client)
+        cls.account_id = BW_ACCOUNT_ID
+        cls.media_path = "./test/fixtures/"
+        cls.media_file = "python_cat.jpeg"
+        cls.media_id = PYTHON_VERSION + "_" + RUNNER_OS + "_" + str(uuid.uuid4()) + "_" + cls.media_file
+        cls.download_file_path = "cat_download.jpeg"
+        cls.original_file = open(cls.media_path + cls.media_file, "rb")
 
     def uploadMedia(self) -> None:
         """Test uploading media
diff --git a/test/smoke/test_messages_api.py b/test/smoke/test_messages_api.py
@@ -27,43 +27,44 @@
 class TestMessagesApi(unittest.TestCase):
     """MessagesApi unit test stubs"""
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         # API Client
         configuration = Configuration(
             client_id=BW_CLIENT_ID,
             client_secret=BW_CLIENT_SECRET
         )
         api_client = ApiClient(configuration)
-        self.api_instance = messages_api.MessagesApi(api_client)
-        self.account_id = BW_ACCOUNT_ID
+        cls.api_instance = messages_api.MessagesApi(api_client)
+        cls.account_id = BW_ACCOUNT_ID
 
         # Unauthorized API Client
-        self.unauthorized_api_client = ApiClient()
-        self.unauthorized_api_instance = messages_api.MessagesApi(self.unauthorized_api_client)
+        cls.unauthorized_api_client = ApiClient()
+        cls.unauthorized_api_instance = messages_api.MessagesApi(cls.unauthorized_api_client)
 
         # Message Properties
-        self.application_id = BW_MESSAGING_APPLICATION_ID
-        self.to_number = [USER_NUMBER]
-        self.from_number = BW_NUMBER
-        self.text = 'python integration'
-        self.media = ['https://cdn2.thecatapi.com/images/MTY3ODIyMQ.jpg']
-        self.tag = 'python integration tag'
-        self.priority = PriorityEnum("default")
+        cls.application_id = BW_MESSAGING_APPLICATION_ID
+        cls.to_number = [USER_NUMBER]
+        cls.from_number = BW_NUMBER
+        cls.text = 'python integration'
+        cls.media = ['https://cdn2.thecatapi.com/images/MTY3ODIyMQ.jpg']
+        cls.tag = 'python integration tag'
+        cls.priority = PriorityEnum("default")
 
         # Message Request
-        self.message_request = MessageRequest(
-            application_id=self.application_id,
-            to=self.to_number,
-            var_from=self.from_number,
-            text=self.text,
-            media=self.media,
-            tag=self.tag,
-            priority=self.priority,
+        cls.message_request = MessageRequest(
+            application_id=cls.application_id,
+            to=cls.to_number,
+            var_from=cls.from_number,
+            text=cls.text,
+            media=cls.media,
+            tag=cls.tag,
+            priority=cls.priority,
         )
 
         # Invalid Message Request
-        self.invalid_message_request = MessageRequest(
-            application_id=self.application_id,
+        cls.invalid_message_request = MessageRequest(
+            application_id=cls.application_id,
             to=['+invalid'],
             var_from='+invalid',
             text='',
diff --git a/test/smoke/test_mfa_api.py b/test/smoke/test_mfa_api.py
@@ -25,31 +25,32 @@ class TestMultiFactorAuthentication(unittest.TestCase):
     """Multi-Factor Authentication API integration Test
     """
 
-    def setUp(self) -> None:
+    @classmethod
+    def setUpClass(cls) -> None:
         configuration = Configuration(
             username=BW_USERNAME,
             password=BW_PASSWORD
         )
         api_client = ApiClient(configuration)
-        self.api_instance = mfa_api.MFAApi(api_client)
-        self.account_id = BW_ACCOUNT_ID
-        self.messaging_code_request = CodeRequest(
+        cls.api_instance = mfa_api.MFAApi(api_client)
+        cls.account_id = BW_ACCOUNT_ID
+        cls.messaging_code_request = CodeRequest(
             to=USER_NUMBER,
             var_from=BW_NUMBER,
             application_id=BW_MESSAGING_APPLICATION_ID,
             scope="scope",
             message="Your temporary {NAME} {SCOPE} code is {CODE}",
             digits=6,
         )
-        self.voice_code_request = CodeRequest(
+        cls.voice_code_request = CodeRequest(
             to=USER_NUMBER,
             var_from=BW_NUMBER,
             application_id=BW_VOICE_APPLICATION_ID,
             scope="scope",
             message="Your temporary {NAME} {SCOPE} code is {CODE}",
             digits=6,
         )
-        self.bad_code_request = CodeRequest(
+        cls.bad_code_request = CodeRequest(
             to=USER_NUMBER,
             var_from=BW_NUMBER,
             application_id='not_an_application_id',
diff --git a/test/smoke/test_multi_channel_api.py b/test/smoke/test_multi_channel_api.py
@@ -44,15 +44,16 @@
 class TestMultiChannelApi(unittest.TestCase):
     """MultiChannelApi unit test stubs"""
 
-    def setUp(self) -> None:
+    @classmethod
+    def setUpClass(cls) -> None:
         configuration = Configuration(
             username=BW_USERNAME,
             password=BW_PASSWORD,
         )
         api_client = ApiClient(configuration)
-        self.multi_channel_api_instance = MultiChannelApi(api_client)
+        cls.multi_channel_api_instance = MultiChannelApi(api_client)
 
-        self.expiration = datetime.now(ZoneInfo('America/New_York')) + timedelta(minutes=1)
+        cls.expiration = datetime.now(ZoneInfo('America/New_York')) + timedelta(minutes=1)
 
     def test_create_multi_channel_sms_message(self) -> None:
         """Test case for create_multi_channel_message
diff --git a/test/smoke/test_phone_number_lookup_api.py b/test/smoke/test_phone_number_lookup_api.py
@@ -38,18 +38,16 @@
 class TestPhoneNumberLookupApi(unittest.TestCase):
     """PhoneNumberLookupApi unit test stubs"""
 
-    def setUp(self) -> None:
+    @classmethod
+    def setUpClass(cls) -> None:
         configuration = Configuration(
             client_id=BW_CLIENT_ID,
             client_secret=BW_CLIENT_SECRET
         )
         api_client = ApiClient(configuration)
-        self.api = PhoneNumberLookupApi(api_client)
+        cls.api = PhoneNumberLookupApi(api_client)
 
-        self.phone_numbers = [BW_NUMBER, USER_NUMBER]
-
-    def tearDown(self) -> None:
-        pass
+        cls.phone_numbers = [BW_NUMBER, USER_NUMBER]
 
     def test_create_get_async_bulk_lookup(self) -> None:
         """Test case for create_async_bulk_lookup
diff --git a/test/smoke/test_recordings_api.py b/test/smoke/test_recordings_api.py
@@ -60,7 +60,8 @@ class TestRecordings(unittest.TestCase):
     Integration tests for the Recordings API.
     """
 
-    def setUp(self) -> None:
+    @classmethod
+    def setUpClass(cls) -> None:
         """
         Set up for our tests by creating the CallsApi and RecordingsApi instances
         for testing.
@@ -72,22 +73,23 @@ def setUp(self) -> None:
         api_client = ApiClient(configuration)
 
         # Two Valid API Clients
-        self.calls_api_instance = CallsApi(api_client)
-        self.recordings_api_instance = RecordingsApi(api_client)
+        cls.calls_api_instance = CallsApi(api_client)
+        cls.recordings_api_instance = RecordingsApi(api_client)
 
         # Unauthorized Recordings API Client
-        self.unauthorized_recordings_api_instance = RecordingsApi(
+        cls.unauthorized_recordings_api_instance = RecordingsApi(
             api_client=ApiClient(Configuration.get_default_copy())
         )
 
         # Rest client for interacting with Manteca
-        self.rest_client = RESTClientObject(Configuration.get_default_copy())
+        cls.rest_client = RESTClientObject(Configuration.get_default_copy())
 
         # Call ID Array
-        self.callIdArray = []
+        cls.callIdArray = []
 
-    def tearDown(self):
-        callCleanup(self)
+    @classmethod
+    def tearDownClass(cls):
+        callCleanup(cls)
 
     def create_and_validate_call(self, answer_url: str) -> Tuple[str, str]:
         """
diff --git a/test/smoke/test_statistics_api.py b/test/smoke/test_statistics_api.py
@@ -15,14 +15,15 @@ class TestStatisticsApi(unittest.TestCase):
     """StatisticsApi integration Test
     """
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         configuration = Configuration(
             client_id=BW_CLIENT_ID,
             client_secret=BW_CLIENT_SECRET
         )
-        self.api_client = ApiClient(configuration)
-        self.api_instance = StatisticsApi(self.api_client)
-        self.account_id = BW_ACCOUNT_ID
+        cls.api_client = ApiClient(configuration)
+        cls.api_instance = StatisticsApi(cls.api_client)
+        cls.account_id = BW_ACCOUNT_ID
 
     def test_get_statistics(self):
         api_response_with_http_info = self.api_instance.get_statistics_with_http_info(self.account_id)
diff --git a/test/smoke/test_toll_free_verification_api.py b/test/smoke/test_toll_free_verification_api.py
diff --git a/test/smoke/test_transcriptions_api.py b/test/smoke/test_transcriptions_api.py
