Merge pull request #3 from edx/mushtaq/test-generate-token

Add unit tests for generate_apitoken.py and config.py

.travis.yml

@@ -18,5 +18,7 @@ script:
  - python tests/test_api_connect.py
  - python tests/test_build.py
  - nosetests video_worker/tests/test_api_communicate.py
+ - nosetests video_worker/tests/test_generate_token.py
+ - nosetests video_worker/tests/test_config.py
  - nosetests video_worker/tests/test_video_images.py
  - pep8

video_worker/config.py

@@ -4,10 +4,12 @@ based on variables within
 
 """
 
+import logging
 import os
 import sys
 import yaml
-from reporting import ErrorObject
+
+logger = logging.getLogger(__name__)
 
 
 class WorkerSetup:
@@ -47,21 +49,15 @@ class WorkerSetup:
         Read Extant Settings or Generate New Ones
         """
         if not os.path.exists(self.instance_yaml):
-            ErrorObject.print_error(
-                message='Not Configured'
-            )
-            return None
+            logger.error('Not Configured')
+            return
 
         with open(self.instance_yaml, 'r') as stream:
             try:
                 self.settings_dict = yaml.load(stream)
-
             except yaml.YAMLError as exc:
-                ErrorObject.print_error(
-                    message='Config YAML read error'
-                )
-
-                return None
+                logger.error('Config YAML read error')
+                return
 
     def _CONFIGURE(self):
         """
@@ -71,10 +67,8 @@ class WorkerSetup:
             try:
                 config_dict = yaml.load(stream)
             except yaml.YAMLError as exc:
-                ErrorObject.print_error(
-                    message='default YAML read error'
-                )
-                return None
+                logger.error('default YAML read error')
+                return
 
         output_dict = {}
 
@@ -97,15 +91,3 @@ class WorkerSetup:
             )
 
         self.settings_dict = output_dict
-
-
-def main():
-    """
-    For example
-    """
-    V = WorkerSetup()
-    V.run()
-
-
-if __name__ == '__main__':
-    sys.exit(main())

video_worker/generate_apitoken.py

 """
-Simple set of token creators for attached APIs
+Generates authorized Video Pipeline and VAL token.
 
 """
 
 import ast
+import logging
 import os
 import requests
-import sys
 
-from reporting import ErrorObject
 from config import WorkerSetup
 
 """Disable insecure warning for requests lib"""
@@ -20,13 +19,16 @@ if os.path.exists(WS.instance_yaml):
 settings = WS.settings_dict
 
 
+logger = logging.getLogger(__name__)
+
+
 def veda_tokengen():
     """
     Gen and authorize a VEDA API token
     """
     # Generate Token
     payload = {'grant_type': 'client_credentials'}
-    r = requests.post(
+    veda_token_response = requests.post(
         settings['veda_token_url'] + '/',
         params=payload,
         auth=(
@@ -35,13 +37,12 @@ def veda_tokengen():
         ),
         timeout=20
     )
-    if r.status_code == 200:
-        veda_token = ast.literal_eval(r.text)['access_token']
-    else:
-        ErrorObject().print_error(
-            message='VEDA Token Generate',
-        )
-        return None
+
+    if veda_token_response.status_code != 200:
+        logger.error('VEDA Token Generate')
+        return
+
+    veda_token = ast.literal_eval(veda_token_response.text)['access_token']
 
     # Authorize token
     """
@@ -53,17 +54,16 @@ def veda_tokengen():
     **it's shit, and needs a rewrite. see api.py in veda-django
     """
     payload = {'data': veda_token}
-    t = requests.post(
+    veda_auth_response = requests.post(
         settings['veda_auth_url'] + '/',
         data=payload
     )
-    if t.status_code == 200:
-        return t.text.strip()
-    else:
-        ErrorObject().print_error(
-            message='VEDA Token Authorization',
-        )
-        return None
+
+    if veda_auth_response.status_code != 200:
+        logger.error('VEDA Token Authorization')
+        return
+
+    return veda_auth_response.text.strip()
 
 
 def val_tokengen():
@@ -78,13 +78,10 @@ def val_tokengen():
         'password': settings['val_password']
     }
 
-    r = requests.post(settings['val_token_url'] + '/', data=payload, timeout=20)
+    response = requests.post(settings['val_token_url'] + '/', data=payload, timeout=20)
 
-    if r.status_code != 200:
-        ErrorObject().print_error(
-            message='Token Gen Fail: VAL\nCheck VAL Config'
-        )
-        return None
+    if response.status_code != 200:
+        logger.error('Token Gen Fail: VAL - Check VAL Config')
+        return
 
-    val_token = ast.literal_eval(r.text)['access_token']
-    return val_token
+    return ast.literal_eval(response.text)['access_token']

video_worker/tests/test_api_communicate.py

@@ -11,14 +11,11 @@ from mock import Mock, patch
 
 from video_worker.abstractions import Video
 from video_worker.api_communicate import UpdateAPIStatus
-from video_worker.config import WorkerSetup
 
+from utils import create_worker_setup
 
-TEST_INSTANCE_YAML = os.path.join(
-    os.path.dirname(os.path.abspath(__file__)),
-    'test_instance_config.yaml'
-)
-WS = WorkerSetup(**{'instance_yaml': TEST_INSTANCE_YAML})
+
+WS = create_worker_setup()
 WS.run()
 
 

video_worker/tests/test_config.py

+"""
+This file tests configuration settings for worker setup.
+"""
+
+import os
+import unittest
+import yaml
+
+from ddt import ddt, data, unpack
+from mock import Mock, patch, mock_open
+
+from utils import create_worker_setup, TEST_INSTANCE_YAML, DUMMY_INSTANCE_YAML
+
+
+@ddt
+class ConfigTest(unittest.TestCase):
+    """
+    Config test class.
+    """
+
+    @data(
+        (True, TEST_INSTANCE_YAML),
+        (False, TEST_INSTANCE_YAML),
+        (False, '/dummy-instance-config-path'),
+        (True, '/dummy-instance-config-path')
+    )
+    @unpack
+    @patch('video_worker.config.WorkerSetup._READ_SETTINGS')
+    @patch('video_worker.config.WorkerSetup._CONFIGURE')
+    def test_run(self, setup, instance_yaml, mock_configure, mock_read_settings):
+        """
+        Tests that correct method is called based on worker setup configuration
+        """
+        WS = create_worker_setup({
+            'instance_yaml': instance_yaml,
+            'setup': setup
+        })
+        WS.run()
+
+        instance_yaml_exists = os.path.exists(WS.instance_yaml)
+        self.assertEqual(mock_configure.called, setup or not instance_yaml_exists)
+        self.assertEqual(mock_read_settings.called, not setup and instance_yaml_exists)
+
+    @data(
+        ('/dummy-instance-config-path', 'Not Configured'),
+        (TEST_INSTANCE_YAML, '')
+    )
+    @unpack
+    @patch('video_worker.config.logger')
+    def test_read_settings(self, instance_yaml, error_message, mock_logger):
+        """
+        Tests that `_READ_SETTINGS` method works correctly.
+        """
+        WS = create_worker_setup({
+            'instance_yaml': instance_yaml
+        })
+        self.assertEqual(WS.settings_dict, {})
+        WS._READ_SETTINGS()
+
+        if error_message:
+            self.assertFalse(len(WS.settings_dict))
+            mock_logger.error.assert_called_with(error_message)
+        else:
+            self.assertNotEqual(WS.settings_dict, {})
+            self.assertTrue(len(WS.settings_dict))
+
+    @patch('video_worker.config.raw_input', create=True)
+    @patch('video_worker.config.yaml.load')
+    def test_configure(self, yaml_load, mock_raw_input):
+        """
+        Tests that `_CONFIGURE` method works correctly.
+        """
+        with open(DUMMY_INSTANCE_YAML, 'w+') as file:
+            mock_raw_input.return_value = 'dummy-value'
+            yaml_load.return_value = {
+                'dummy_key': 'dummy-value',
+                'empty_value_key': ''
+            }
+            WS = create_worker_setup({
+                'instance_yaml': DUMMY_INSTANCE_YAML
+            })
+            self.assertEqual(WS.settings_dict, {})
+
+            WS._CONFIGURE()
+            self.assertNotEqual(WS.settings_dict, {})
+            self.assertTrue(len(WS.settings_dict))
+
+        # Close and delete the file after used
+        file.close()
+        os.remove(DUMMY_INSTANCE_YAML)
+
+    @patch('video_worker.config.logger')
+    @patch('video_worker.config.yaml.load')
+    def test_read_settings_load_error(self, yaml_load, mock_logger):
+        """
+        Tests that `_READ_SETTINGS` method raises correct log in case of yaml load error.
+        """
+        error_message = 'Config YAML read error'
+        yaml_load.side_effect = yaml.YAMLError(error_message)
+        WS = create_worker_setup()
+        self.assertEqual(WS.settings_dict, {})
+        WS._READ_SETTINGS()
+        mock_logger.error.assert_called_with(error_message)
+        self.assertEqual(WS.settings_dict, {})
+
+    @patch('video_worker.config.logger')
+    @patch('video_worker.config.yaml.load')
+    def test_configure_load_error(self, yaml_load, mock_logger):
+        """
+        Tests that `_CONFIGURE` method raises correct log in case of yaml load error.
+        """
+        error_message = 'default YAML read error'
+        yaml_load.side_effect = yaml.YAMLError(error_message)
+        WS = create_worker_setup()
+        self.assertEqual(WS.settings_dict, {})
+        WS._CONFIGURE()
+        mock_logger.error.assert_called_with(error_message)
+        self.assertEqual(WS.settings_dict, {})

video_worker/tests/test_generate_token.py

+"""
+This file tests token generation for val and veda APIs.
+"""
+
+import json
+import unittest
+
+from ddt import ddt, data, unpack
+from mock import Mock, patch
+
+from video_worker.generate_apitoken import val_tokengen, veda_tokengen
+
+from utils import create_worker_setup
+
+
+WS = create_worker_setup()
+WS.run()
+
+
+@ddt
+@patch('video_worker.generate_apitoken.settings', WS.settings_dict)
+class GenerateApiTokenTest(unittest.TestCase):
+    """
+    GenerateApiToken test class.
+    """
+
+    @patch('video_worker.generate_apitoken.requests.post')
+    @patch('video_worker.generate_apitoken.logger')
+    def test_veda_tokengen_fail(self, mock_logger, mock_post):
+        """
+        Tests `veda_tokengen` method logs correct error message.
+        """
+        mock_post.return_value = Mock(status_code=400, text='', content={})
+        response = veda_tokengen()
+        self.assertFalse(response)
+        mock_logger.error.assert_called_with('VEDA Token Generate')
+
+    @patch('video_worker.generate_apitoken.requests.post')
+    @patch('video_worker.generate_apitoken.logger')
+    def test_veda_tokengen_auth_fail(self, mock_logger, mock_post):
+        """
+        Tests `veda_tokengen` method logs correct error message when authorization fails.
+        """
+        access_token = 'dummy-val-token'
+        response_data = json.dumps({
+            'access_token': access_token
+        })
+        # Mock request multiple times with different responses.
+        mock_post.side_effect = [
+            Mock(status_code=200, text=response_data, content=response_data),
+            Mock(status_code=400, text='', content={})
+        ]
+        response = veda_tokengen()
+        self.assertFalse(response)
+        mock_logger.error.assert_called_with('VEDA Token Authorization')
+
+    @patch('video_worker.generate_apitoken.requests.post')
+    def test_veda_tokengen(self, mock_post):
+        """
+        Tests `veda_tokengen` method works correctly.
+        """
+        access_token = 'dummy-val-token'
+        response_data = json.dumps({
+            'access_token': access_token
+        })
+        mock_post.return_value = Mock(status_code=200, text=response_data, content=response_data)
+        response = veda_tokengen()
+        response = json.loads(response)
+        self.assertEqual(response['access_token'], access_token)
+
+    @patch('video_worker.generate_apitoken.requests.post')
+    @patch('video_worker.generate_apitoken.logger')
+    def test_val_tokengen_fail(self, mock_logger, mock_post):
+        """
+        Tests `val_tokengen` method logs correct error message.
+        """
+        mock_post.return_value = Mock(status_code=400, text='', content={})
+        response = val_tokengen()
+        self.assertFalse(response)
+        mock_logger.error.assert_called_with('Token Gen Fail: VAL - Check VAL Config')
+
+    @patch('video_worker.generate_apitoken.requests.post')
+    def test_val_tokengen(self, mock_post):
+        """
+        Tests `val_tokengen` method works correctly.
+        """
+        access_token = 'dummy-val-token'
+        response_data = json.dumps({
+            'access_token': access_token
+        })
+        mock_post.return_value = Mock(status_code=200, text=response_data, content=response_data)
+        response = val_tokengen()
+        self.assertEqual(response, access_token)

video_worker/tests/utils.py

+"""
+Adds util classes and methods for tests.
+"""
+import os
+
+from video_worker.config import WorkerSetup
+
+
+TEST_INSTANCE_YAML = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)),
+    'test_instance_config.yaml'
+)
+
+DUMMY_INSTANCE_YAML = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)),
+    'dummy_instance_config.yaml'
+)
+
+
+def create_worker_setup(kwargs={}):
+    """
+    Returns a worker setup object for tests.
+    """
+    kwargs['instance_yaml'] = kwargs.get('instance_yaml', TEST_INSTANCE_YAML)
+    kwargs['setup'] = kwargs.get('setup', False)
+    return WorkerSetup(**kwargs)