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)
