def test_celery_status_connection_reset(self, mock_celery): """Test that the status retrys on connection reset.""" mock_celery.control.inspect.side_effect = ConnectionResetError stat = ApplicationStatus() result = stat._check_celery_status() self.assertIn('Error', result) result = stat.celery_status self.assertIn('Error', result)
def test_startup_without_modules(self, mock_mods): """Test the startup method without a module list.""" mock_mods.return_value = {} expected = 'INFO:masu.api.status:Modules: None' with self.assertLogs('masu.api.status', level='INFO') as logger: ApplicationStatus().startup() self.assertIn(expected, logger.output)
def test_modules(self, mock_modules): """Test the modules method.""" expected = {"module1": "version1", "module2": "version2"} mod1 = Mock(__version__="version1") mod2 = Mock(__version__="version2") mock_modules.items.return_value = (("module1", mod1), ("module2", mod2)) result = ApplicationStatus().modules self.assertEqual(result, expected)
def test_platform_info(self, mock_platform): """Test the platform_info method.""" platform_record = namedtuple("Platform", ["os", "version"]) a_plat = platform_record("Red Hat", "7.4") mock_platform.return_value = a_plat result = ApplicationStatus().platform_info self.assertEqual(result["os"], "Red Hat") self.assertEqual(result["version"], "7.4")
def test_celery_status_no_stats(self, mock_celery): """Test that an error status is returned when Celery is down.""" mock_control = mock_celery.control mock_control.inspect.return_value.stats.return_value = None expected_status = {'Error': CELERY_WORKER_NOT_FOUND} status = ApplicationStatus().celery_status self.assertEqual(status, expected_status)
def test_celery_status(self, mock_celery): """Test that an error status is returned when Celery is down.""" expected_status = {'Status': 'OK'} mock_control = mock_celery.control mock_control.inspect.return_value.stats.return_value = expected_status status = ApplicationStatus().celery_status self.assertEqual(status, expected_status)
def test_celery_heartbeat_failure(self, mock_celery): """Test that heartbeat failure logs connection to broker issue.""" mock_conn = mock_celery.connection.return_value mock_conn.heartbeat_check.side_effect = ConnectionRefusedError expected_status = {'Error': BROKER_CONNECTION_ERROR} status = ApplicationStatus().celery_status self.assertEqual(status, expected_status)
def test_platform_info(self, mock_platform): """Test the platform_info method.""" platform_record = namedtuple('Platform', ['os', 'version']) a_plat = platform_record('Red Hat', '7.4') mock_platform.return_value = a_plat result = ApplicationStatus().platform_info self.assertEqual(result['os'], 'Red Hat') self.assertEqual(result['version'], '7.4')
def test_get_datetime(self, mock_date, mock_celery): """Test the startup method for datetime.""" mock_date_string = "2018-07-25 10:41:59.993536" mock_date_obj = datetime.strptime(mock_date_string, "%Y-%m-%d %H:%M:%S.%f") mock_date.return_value = mock_date_obj expected = f"INFO:masu.api.status:Current Date: {mock_date.return_value}" with self.assertLogs("masu.api.status", level="INFO") as logger: ApplicationStatus().startup() self.assertIn(str(expected), logger.output)
def test_database_status_fail(self): """test that fetching database handles errors.""" expected = 'WARNING:masu.api.status:Unable to connect to DB: ' with patch('django.db.backends.utils.CursorWrapper') as mock_cursor: mock_cursor = mock_cursor.return_value.__enter__.return_value mock_cursor.execute.side_effect = InterfaceError() with self.assertLogs('masu.api.status', level='INFO') as logger: ApplicationStatus().startup() self.assertIn(expected, logger.output)
def test_get_celery_queue_data_error(self, mock_celery): """Test that queue results are returned.""" mock_inspect = mock_celery.control.inspect.return_value mock_inspect.scheduled.side_effect = ConnectionResetError stat = ApplicationStatus() result = stat.celery_task_status self.assertIn("Error", result)
def test_modules(self, mock_modules): """Test the modules method.""" expected = {'module1': 'version1', 'module2': 'version2'} mod1 = Mock(__version__='version1') mod2 = Mock(__version__='version2') mock_modules.items.return_value = (('module1', mod1), ('module2', mod2)) result = ApplicationStatus().modules self.assertEqual(result, expected)
def test_commit_with_subprocess_nostdout(self, mock_os, mock_subprocess): """Test the commit method via subprocess when stdout is none.""" args = {"args": ["git", "describe", "--always"], "returncode": 0, "stdout": None} mock_subprocess.return_value = Mock(spec=CompletedProcess, **args) result = ApplicationStatus().commit mock_os.assert_called_with("OPENSHIFT_BUILD_COMMIT", None) mock_subprocess.assert_called_with(args["args"], stdout=PIPE) self.assertIsNone(result.stdout)
def test_database_status(self, mock_celery): """Test that fetching database status works.""" expected = re.compile(r"INFO:masu.api.status:Database: \[{.*postgres.*}\]") with self.assertLogs("masu.api.status", level="INFO") as logger: ApplicationStatus().startup() results = None for line in logger.output: if not results: results = expected.search(line) self.assertIsNotNone(results)
def test_startup_has_celery_status(self, mock_celery): """Test celery status is in startup() output.""" expected_status = {"Status": "OK"} expected = f"INFO:masu.api.status:Celery Status: {expected_status}" mock_control = mock_celery.control mock_control.inspect.return_value.stats.return_value = expected_status with self.assertLogs("masu.api.status", level="INFO") as logger: ApplicationStatus().startup() self.assertIn(expected, logger.output)
def test_startup_has_celery_status(self, mock_celery): """test celery status is in startup() output.""" expected_status = {'Status': 'OK'} expected = f'INFO:masu.api.status:Celery Status: {expected_status}' mock_control = mock_celery.control mock_control.inspect.return_value.stats.return_value = expected_status with self.assertLogs('masu.api.status', level='INFO') as logger: ApplicationStatus().startup() self.assertIn(expected, logger.output)
def test_get_datetime(self, mock_date): """Test the startup method for datetime.""" mock_date_string = '2018-07-25 10:41:59.993536' mock_date_obj = datetime.strptime(mock_date_string, '%Y-%m-%d %H:%M:%S.%f') mock_date.return_value = mock_date_obj expected = 'INFO:masu.api.status:Current Date: {}'.format( mock_date.return_value) with self.assertLogs('masu.api.status', level='INFO') as logger: ApplicationStatus().startup() self.assertIn(str(expected), logger.output)
def test_commit_with_subprocess(self, mock_os, mock_subprocess): """Test the commit method via subprocess.""" expected = "buildnum" args = {"args": ["git", "describe", "--always"], "returncode": 0, "stdout": bytes(expected, encoding="UTF-8")} mock_subprocess.return_value = Mock(spec=CompletedProcess, **args) result = ApplicationStatus().commit mock_os.assert_called_with("OPENSHIFT_BUILD_COMMIT", None) mock_subprocess.assert_called_with(args["args"], stdout=PIPE) self.assertEqual(result, expected)
def test_commit_with_subprocess_nostdout(self, mock_os, mock_subprocess): """Test the commit method via subprocess when stdout is none.""" args = { 'args': ['git', 'describe', '--always'], 'returncode': 0, 'stdout': None, } mock_subprocess.return_value = Mock(spec=CompletedProcess, **args) result = ApplicationStatus().commit mock_os.assert_called_with('OPENSHIFT_BUILD_COMMIT', None) mock_subprocess.assert_called_with(args['args'], stdout=PIPE) self.assertIsNone(result.stdout)
def test_commit_with_subprocess(self, mock_os, mock_subprocess): """Test the commit method via subprocess.""" expected = 'buildnum' args = { 'args': ['git', 'describe', '--always'], 'returncode': 0, 'stdout': bytes(expected, encoding='UTF-8'), } mock_subprocess.return_value = Mock(spec=CompletedProcess, **args) result = ApplicationStatus().commit mock_os.assert_called_with('OPENSHIFT_BUILD_COMMIT', None) mock_subprocess.assert_called_with(args['args'], stdout=PIPE) self.assertEqual(result, expected)
def create_app(test_config=None): """ App factory for Flask application. Args: test_config (dict): A mapping of configurations used for testing Returns: flask.app.Flask: The configured Flask application """ app = Flask(__name__, instance_relative_config=True) # Load configs if test_config: app.config.from_mapping(test_config) # disable log messages less than CRITICAL when running unit tests. logging.disable(logging.CRITICAL) else: app.config.from_object('masu.config.Config') # Logging setup_cloudwatch_logging(logger) logger.setLevel(app.config.get('LOG_LEVEL', 'WARNING')) if not test_config and (sys.argv and 'celery' not in sys.argv[0]): ApplicationStatus().startup() try: os.makedirs(app.instance_path) if not test_config: metrics.init_app(app) # pylint: disable=invalid-name except OSError as e: # ignore "File exists" if e.errno != errno.EEXIST: logger.warning(e) # Add application config to Celery update_celery_config(celery_app, app) # Blueprints app.register_blueprint(api_v1) return app
def test_get_celery_queue_data(self, mock_celery): """Test that queue results are returned.""" scheduled_tasks = [1, 2, 3] reserved_tasks = [3] active_tasks = [] scheduled = {"task": scheduled_tasks} reserved = {"task": reserved_tasks} active = {"task": active_tasks} mock_inspect = mock_celery.control.inspect.return_value mock_inspect.scheduled.return_value = scheduled mock_inspect.reserved.return_value = reserved mock_inspect.active.return_value = active stat = ApplicationStatus() result = stat.celery_task_status self.assertIn("scheduled_count", result) self.assertIn("reserved_count", result) self.assertIn("active_count", result) self.assertEqual(result["scheduled_count"], len(scheduled_tasks)) self.assertEqual(result["reserved_count"], len(reserved_tasks)) self.assertEqual(result["active_count"], len(active_tasks))
def test_commit_with_env(self): """Test the commit method via environment.""" result = ApplicationStatus().commit self.assertEqual(result, 'fake_commit_hash')
def test_database_status_fail(self, mock_psql): """test that fetching database handles errors.""" expected = 'WARNING:masu.api.status:Unable to connect to DB: ' with self.assertLogs('masu.api.status', level='INFO') as logger: ApplicationStatus().startup() self.assertIn(expected, logger.output)
def test_get_debug(self, mock_celery): """Test the startup method for debug state.""" expected = "INFO:masu.api.status:DEBUG enabled: {}".format(str(False)) with self.assertLogs("masu.api.status", level="INFO") as logger: ApplicationStatus().startup() self.assertIn(str(expected), logger.output)
def test_commit(self): """Test the commit method via django settings.""" expected = "buildnum" result = ApplicationStatus().commit self.assertEqual(result, expected)
def test_python_version(self, mock_sys_ver): """Test the python_version method.""" expected = 'Python 3.6' mock_sys_ver.replace.return_value = expected result = ApplicationStatus().python_version self.assertEqual(result, expected)
def test_startup_with_modules(self, mock_logger): """Test the startup method with a module list.""" ApplicationStatus().startup() mock_logger.assert_called_with(ANY, ANY)
def test_get_debug(self): """Test the startup method for debug state.""" expected = 'INFO:masu.api.status:DEBUG enabled: {}'.format(str(False)) with self.assertLogs('masu.api.status', level='INFO') as logger: ApplicationStatus().startup() self.assertIn(str(expected), logger.output)