DX-2684 Calls API Integration Tests

Author: brianluisgomez

test/integration/test_calls.py

@@ -37,12 +37,12 @@ class CallsIntegration(unittest.TestCase):
 
     def setUp(self):
         configuration = bandwidth.Configuration(
-            username = os.environ['BW_USERNAME'],
-            password = os.environ['BW_PASSWORD'],
+            username = BW_USERNAME,
+            password = BW_PASSWORD,
         )
         api_client = bandwidth.ApiClient(configuration)
         self.api_instance = calls_api.CallsApi(api_client)
-        self.account_id = os.environ['BW_ACCOUNT_ID']
+        self.account_id = BW_ACCOUNT_ID
 
     def tearDown(self):
         pass
@@ -55,7 +55,7 @@ def testSuccessfulCalls(self):
 
 
         # Creating the call
-        create_call_response: CreateCallResponse = self.calls_api_instance.create_call(BW_ACCOUNT_ID, call_body)
+        create_call_response: CreateCallResponse = self.api_instance.create_call(BW_ACCOUNT_ID, call_body)
 
         # Response Verification
         assert len(create_call_response.call_id) == 47    # assert request created and id matches expected length (47)
@@ -68,14 +68,14 @@ def testSuccessfulCalls(self):
 
         call_id = create_call_response.call_id
 
-        time.sleep(30)
+      #  time.sleep(30)
 
         #GET call state information
 
-        get_call_response: CallState(BW_ACCOUNT_ID, call_id)
+      #  get_call_response: CallState(BW_ACCOUNT_ID, call_id)
 
         #Verification of Call State
-        assert len(get_call_response.call_id) == 47 # assert request created and id matches expected length (47)
+       # assert len(get_call_response.call_id) == 47 # assert request created and id matches expected length (47)
 
         #GET call state information on bad callID to test error
 
@@ -89,39 +89,23 @@ def testSuccessfulCalls(self):
 
         #retry Create Call with the wrong Account ID
 
-    def testFailedCall(self):
-        """Calls API with bad data to force an error"""
-        with self.assertRaises(bandwidth.ApiException) as context:
-            lookup_request = LookupRequest(
-                tns=[
-                    'not a number',
-                ],
-            )
-            self.api_instance.create_lookup(self.account_id, lookup_request)
 
-        self.assertIs(type(context.exception.status), int)
-        self.assertIs(type(context.exception.body), str)
-
-        # initialize TnLookupRequestError model 
-        error = TnLookupRequestError(message=(json.loads(context.exception.body))['message'])
-        self.assertIs(type(error), TnLookupRequestError)
-
-
-    def testUnauthorizedRequest(self):
+    """ def testUnauthorizedRequest(self):
         configuration = bandwidth.Configuration(
             username = 'bad_username',
             password = 'bad_password'
         )
         unauthorized_api_client = bandwidth.ApiClient(configuration)
-        unauthorized_api_instance = phone_number_lookup_api.PhoneNumberLookupApi(unauthorized_api_client)
-        lookup_request = LookupRequest(
-            tns=[
-                os.environ['BW_NUMBER']
-            ],
-        )
+        self.unauthorized_api_instance = calls_api.CallsApi(unauthorized_api_client)
+        self.account_id = BW_ACCOUNT_ID
+        answer_url = BASE_CALLBACK_URL
+        call_body = CreateCall(to=USER_NUMBER, _from=BW_NUMBER, application_id=BW_VOICE_APPLICATION_ID, answer_url=answer_url)
+
+        create_unauthorized_call_response: CreateCallResponse = self.unauthorized_api_instance.create_call(BW_ACCOUNT_ID, call_body)
+
 
         with self.assertRaises(UnauthorizedException) as context:
-            unauthorized_api_instance.create_lookup(self.account_id, lookup_request)
+            unauthorized_api_instance.create_unauthorized_call_response(self.account_id, call_request)
 
         self.assertIs(type(context.exception), UnauthorizedException)
         self.assertIs(type(context.exception.status), int)
@@ -139,9 +123,9 @@ def testForbiddenRequest(self):
             tns=[
                 os.environ['BW_NUMBER']
             ],
-        )
+        ) """
 
-        # This API throws a 401 when a user provides valid credentials with the `TN Lookup` role disabled
+"""         # This API throws a 401 when a user provides valid credentials with the `TN Lookup` role disabled
         # with self.assertRaises(ForbiddenException) as context:
         with self.assertRaises(UnauthorizedException) as context:
             forbidden_api_instance.create_lookup(self.account_id, lookup_request)
@@ -151,7 +135,7 @@ def testForbiddenRequest(self):
         self.assertIs(type(context.exception), UnauthorizedException)
         self.assertIs(type(context.exception.status), int)
         self.assertEqual(context.exception.status, 401)
-        self.assertIs(type(context.exception.body), str)
+        self.assertIs(type(context.exception.body), str) """
 
 
 if __name__ == '__main__':