Merge pull request #103 from Bandwidth/DX-2728

DX-2728 Improved Logging

Author: brianluisgomez

.github/workflows/test.yaml

@@ -5,6 +5,15 @@ on:
     - cron: "0 4 * * *"
   pull_request:
   workflow_dispatch:
+    inputs:
+      logLevel:
+        description: Log level
+        required: false
+        default: WARNING
+        type: choice
+        options:
+        - WARNING
+        - DEBUG  
 
 jobs:
   deploy:
@@ -14,6 +23,28 @@ jobs:
       matrix:
         os: [windows-2022, windows-2019, ubuntu-18.04, ubuntu-20.04]
         python-version: [3.7, 3.8, 3.9, "3.10"]
+    env:
+      BW_ACCOUNT_ID: ${{ secrets.BW_ACCOUNT_ID }}
+      BW_USERNAME: ${{ secrets.BW_USERNAME }}
+      BW_PASSWORD: ${{ secrets.BW_PASSWORD }}
+      BW_USERNAME_FORBIDDEN: ${{ secrets.BW_USERNAME_FORBIDDEN }}
+      BW_PASSWORD_FORBIDDEN: ${{ secrets.BW_PASSWORD_FORBIDDEN }}
+      BW_VOICE_APPLICATION_ID: ${{ secrets.BW_VOICE_APPLICATION_ID }}
+      BW_MESSAGING_APPLICATION_ID: ${{ secrets.BW_MESSAGING_APPLICATION_ID }}
+      BW_NUMBER: ${{ secrets.BW_NUMBER }}
+      USER_NUMBER: ${{ secrets.USER_NUMBER }}
+      VZW_NUMBER: ${{ secrets.VZW_NUMBER }}
+      ATT_NUMBER: ${{ secrets.ATT_NUMBER }}
+      T_MOBILE_NUMBER: ${{ secrets.T_MOBILE_NUMBER }}
+      BASE_CALLBACK_URL: ${{ secrets.BASE_CALLBACK_URL }}
+      PYTHON_VERSION: ${{ matrix.python-version }}
+      OPERATING_SYSTEM: ${{ matrix.os }}
+      MANTECA_ACTIVE_NUMBER: ${{ secrets.MANTECA_ACTIVE_NUMBER }}
+      MANTECA_IDLE_NUMBER: ${{ secrets.MANTECA_IDLE_NUMBER }}
+      MANTECA_BASE_URL: ${{ secrets.MANTECA_BASE_URL }}
+      MANTECA_APPLICATION_ID: ${{ secrets.MANTECA_APPLICATION_ID }}
+      BW_NUMBER_PROVIDER: ${{ secrets.BW_NUMBER_PROVIDER }}
+
     steps:
       - name: Checkout
         uses: actions/checkout@v2
@@ -28,28 +59,17 @@ jobs:
           pip install -r requirements.txt
           pip install -r test-requirements.txt
 
-      - name: Test
-        env:
-          BW_ACCOUNT_ID: ${{ secrets.BW_ACCOUNT_ID }}
-          BW_USERNAME: ${{ secrets.BW_USERNAME }}
-          BW_PASSWORD: ${{ secrets.BW_PASSWORD }}
-          BW_USERNAME_FORBIDDEN: ${{ secrets.BW_USERNAME_FORBIDDEN }}
-          BW_PASSWORD_FORBIDDEN: ${{ secrets.BW_PASSWORD_FORBIDDEN }}
-          BW_VOICE_APPLICATION_ID: ${{ secrets.BW_VOICE_APPLICATION_ID }}
-          BW_MESSAGING_APPLICATION_ID: ${{ secrets.BW_MESSAGING_APPLICATION_ID }}
-          BW_NUMBER: ${{ secrets.BW_NUMBER }}
-          USER_NUMBER: ${{ secrets.USER_NUMBER }}
-          VZW_NUMBER: ${{ secrets.VZW_NUMBER }}
-          ATT_NUMBER: ${{ secrets.ATT_NUMBER }}
-          T_MOBILE_NUMBER: ${{ secrets.T_MOBILE_NUMBER }}
-          BASE_CALLBACK_URL: ${{ secrets.BASE_CALLBACK_URL }}
-          PYTHON_VERSION: ${{ matrix.python-version }}
-          OPERATING_SYSTEM: ${{ matrix.os }}
-          MANTECA_ACTIVE_NUMBER: ${{ secrets.MANTECA_ACTIVE_NUMBER }}
-          MANTECA_IDLE_NUMBER: ${{ secrets.MANTECA_IDLE_NUMBER }}
-          MANTECA_BASE_URL: ${{ secrets.MANTECA_BASE_URL }}
-          MANTECA_APPLICATION_ID: ${{ secrets.MANTECA_APPLICATION_ID }}
-        run: pytest
+      - name: Test at Debug Level
+        if: ${{ inputs.logLevel == 'DEBUG' }}
+        run: |
+          echo "Log level: DEBUG"
+          pytest -v --log-cli-level=DEBUG
+
+      - name: Test at Warning Level
+        if: ${{( inputs.logLevel == null) || ( inputs.logLevel  == 'WARNING') }}
+        run: |
+          echo "Log level: WARNING"
+          pytest -v --log-cli-level=WARNING
 
       - name: Notify Slack of Failures
         uses: Bandwidth/[email protected]

.gitignore

@@ -13,6 +13,7 @@ __pycache__/
 .Python
 env/
 build/
+logs/
 develop-eggs/
 dist/
 downloads/

setup.cfg

@@ -1,2 +1,5 @@
 [flake8]
 max-line-length=99
+[tool:pytest]
+log_cli = True
+junit_logging = system-out

test/integration/bwmatchers/one_of_string.py

@@ -0,0 +1,33 @@
+from typing import Any
+
+from hamcrest.core.base_matcher import BaseMatcher
+from hamcrest.core.description import Description
+from hamcrest.core.matcher import Matcher
+
+
+class IsOneOfString(BaseMatcher[Any]):
+    def __init__(self, equalsAnyString: Any) -> None:
+        self.object = equalsAnyString
+
+    def _matches(self, item: Any) -> bool:
+        if isinstance(self.object, list):
+            return  item in self.object
+        return False
+
+    def describe_to(self, description: Description) -> None:
+        nested_matcher = isinstance(self.object, Matcher)
+        description.append_description_of("one of ")
+        if nested_matcher:
+            description.append_text("<")
+        description.append_description_of(self.object)
+        if nested_matcher:
+            description.append_text(">")
+
+
+def is_one_of_string(obj: Any) -> Matcher[Any]:
+    """Matches expected string is in a given list.
+
+    :param obj: The object to compare against as the expected value.
+
+    This matcher compares the evaluated object to ``obj`` for a match."""
+    return IsOneOfString(obj)

test/integration/test_calls.py

@@ -7,6 +7,7 @@
 import time
 import unittest
 import datetime
+
 from hamcrest import assert_that, has_properties, not_none, instance_of
 
 import bandwidth

test/integration/test_media_api.py

@@ -2,15 +2,16 @@
 Integration test for Bandwidth's Media API
 """
 
-import os
 import uuid
 import filecmp
 import unittest
+import logging
 
 import bandwidth
 from bandwidth.api import media_api
 from bandwidth.model.media import Media
 from bandwidth.exceptions import ApiException, NotFoundException
+from test.utils.env_variables import *
 
 
 class TestMedia(unittest.TestCase):
@@ -19,17 +20,16 @@ class TestMedia(unittest.TestCase):
 
     def setUp(self) -> None:
         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 = media_api.MediaApi(api_client)
-        self.account_id = os.environ['BW_ACCOUNT_ID']
+        self.api_client = bandwidth.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 = os.environ['PYTHON_VERSION'] + "_" + os.environ['RUNNER_OS'] + "_" + str(uuid.uuid4()) + "_" + self.media_file
+        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")
 
     def uploadMedia(self) -> None:
@@ -48,6 +48,7 @@ def uploadMedia(self) -> None:
             _return_http_data_only=False
         )
 
+        logging.debug(api_response_with_http_info)
         self.assertEqual(api_response_with_http_info[1], 204)
 
         # reopen the media file
@@ -73,6 +74,7 @@ def listMedia(self) -> None:
         self.assertEqual(api_response_with_http_info[1], 200)
 
         api_response = self.api_instance.list_media(self.account_id)
+        logging.debug("List Media" + str(api_response))
 
         self.assertIs(type(api_response[0]), Media)
         pass
@@ -83,6 +85,7 @@ def getMedia(self) -> None:
         api_response_with_http_info = self.api_instance.get_media(
             self.account_id, self.media_id, _return_http_data_only=False)
 
+        logging.debug(api_response_with_http_info)
         self.assertEqual(api_response_with_http_info[1], 200)
 
         api_response = self.api_instance.get_media(
@@ -100,7 +103,8 @@ def deleteMedia(self) -> None:
         """
         api_response_with_http_info = self.api_instance.delete_media(
             self.account_id, self.media_id, _return_http_data_only=False)
-
+        
+        logging.debug(api_response_with_http_info)
         self.assertEqual(api_response_with_http_info[1], 204)
 
         # returns void
@@ -114,6 +118,7 @@ def _steps(self) -> None:
     def test_steps(self) -> None:
         """Test each function from _steps.call_order in specified order
         """
+        
         for name, step in self._steps():
             step()
 

test/integration/test_multi_factor_authentication.py

@@ -5,6 +5,7 @@
 import os
 import time
 import unittest
+import logging
 from random import randint
 
 import bandwidth
@@ -16,6 +17,9 @@
 from bandwidth.model.voice_code_response import VoiceCodeResponse
 from bandwidth.exceptions import ApiException, UnauthorizedException, ForbiddenException
 
+import hamcrest
+from hamcrest.core import *
+from hamcrest.library import *
 
 class TestMultiFactorAuthentication(unittest.TestCase):
     """Multi-Factor Authentication API integration Test
@@ -66,6 +70,14 @@ def assertAuthException(self, context: ApiException, expectedException: ApiExcep
         self.assertEqual(context.exception.status, expected_status_code)
         self.assertIs(type(context.exception.body), str)
 
+        # alternate option using hamcrest mathcers - reads like normal sentence, easy to read/speak & less brain overload
+        assert_that(context.exception, is_(expectedException))
+
+        assert_that(context.exception, has_properties(
+            'status', equal_to(expected_status_code),
+            'body', not_none())
+        )
+
     def testSuccessfulMfaGenerateMessagingCodeRequest(self) -> None:
         """Test a successful MFA messaging code request 
         """
@@ -114,6 +126,9 @@ def testSuccessfulMfaGVerifyCodeRequest(self) -> None:
         self.assertEqual(type(api_response.valid), bool)
         self.assertIs(api_response.valid, False)
 
+        # can be simplified
+        assert_that(api_response, has_property('valid', False))
+
     def testBadRequest(self) -> None:
         """Validates a bad (400) request
         """
@@ -162,13 +177,17 @@ def testRateLimit(self) -> None:
             expiration_time_in_minutes=3.0,
             code="123456",
         )
+        call_count = 1
         while True:
             try:
+                logging.debug('Testing rate limit, attempt #'+ str(call_count))
                 api_response_with_http_info = self.api_instance.verify_code(
                     self.account_id, verify_code_request
                 )
+                call_count += 1
             except ApiException as e:
                 if e.status == 429:
+                    logging.debug('Got rate limit error')
                     time.sleep(35)
                     api_response_with_http_info = self.api_instance.verify_code(
                         self.account_id, verify_code_request,
@@ -178,3 +197,6 @@ def testRateLimit(self) -> None:
                     break
                 else:
                     raise e
+            except:
+                logging.error("Unexpected error while testing rate limit!")
+                raise e  

test/integration/test_phone_number_lookup.py

@@ -17,6 +17,11 @@
 from bandwidth.model.tn_lookup_request_error import TnLookupRequestError
 from bandwidth.exceptions import ApiException, UnauthorizedException, ForbiddenException
 
+from hamcrest.core import *
+from hamcrest.library import *
+
+from .bwmatchers.one_of_string import is_one_of_string
+
 
 class TestPhoneNumberLookupIntegration(unittest.TestCase):
     """Phone Number Lookup API integration test
@@ -39,19 +44,21 @@ def validateResult(self, result: LookupResult, e_164_format: str, line_provider:
             e_164_format (str): Phone number in e164 format ex: +19195551234
             line_provider (str): Line service provider ex: Verizon
         """
-        self.assertEqual(result.response_code, 0)
-        self.assertIs(type(result.message), str)
-        self.assertEqual(result.e_164_format, e_164_format)
-        self.assertIs(type(result.formatted), str)
-        self.assertTrue(result.country == "US" or result.country == "Canada")
-        self.assertTrue(result.line_type == "Mobile" or result.line_type == "Fixed")
-        self.assertIn(line_provider, result.line_provider)
 
         # if result has 1 of these attributes it should have the other
         if result.get('mobile_country_code') or result.get('mobile_network_code'):
             self.assertIs(type(result.mobile_country_code), str)
             self.assertIs(type(result.mobile_network_code), str)
 
+        assert_that(result, has_properties(
+            'response_code', 0,
+            'e_164_format', e_164_format,
+            'line_provider', contains_string(line_provider),
+            'country', is_one_of_string(["US", "Canada"]),
+            'line_type', is_one_of_string(["Mobile", "Fixed"])
+            )
+        )
+
     def pollLookupStatus(self, request_id: str) -> LookupStatus:
         """Poll LookupRequest for 'COMPLETE' status
 
@@ -109,6 +116,7 @@ def testSuccessfulPhoneNumberLookup(self) -> None:
         # Create the lookup request and validate the response
         create_lookup_response: CreateLookupResponse = self.api_instance.create_lookup(
             self.account_id, lookup_request, _return_http_data_only=False)
+                
         self.assertEqual(create_lookup_response[1], 202)
         self.assertIs(type(create_lookup_response[0].status), LookupStatusEnum)
         self.assertEqual(create_lookup_response[0].status, LookupStatusEnum("IN_PROGRESS"))
@@ -135,7 +143,7 @@ def testSuccessfulPhoneNumberLookup(self) -> None:
 
         # Check the information for a Bandwidth TN
         bw_lookup_result: LookupResult = get_lookup_status_response.result[0]
-        self.validateResult(bw_lookup_result, os.environ['BW_NUMBER'], "Bandwidth")
+        self.validateResult(bw_lookup_result, os.environ['BW_NUMBER'], os.environ['BW_NUMBER_PROVIDER'])
 
         # Check the information for a Verizon TN
         vzw_lookup_result = get_lookup_status_response.result[1]

test/utils/env_variables.py

@@ -17,6 +17,7 @@
     MANTECA_APPLICATION_ID = os.environ["MANTECA_APPLICATION_ID"]
     PYTHON_VERSION = os.environ["PYTHON_VERSION"]
     OPERATING_SYSTEM = os.environ["OPERATING_SYSTEM"]
+    RUNNER_OS = os.environ['RUNNER_OS']
 
 except KeyError as e:
     raise Exception("Environmental variables not found")