def testValues(self):
my_ordered_dict = OrderedDict()
my_ordered_dict['nba_player'] = 'Steph Curry'
my_ordered_dict['nba_mvp_count'] = 1
my_ordered_dict['is_retired'] = False
my_ordered_dict['nba_finals_years'] = ['2015', '2016', '2017']
expected_values = ['Steph Curry', 1, False, ['2015', '2016', '2017']]
values = my_ordered_dict.values()
self.assertEqual(len(expected_values), len(values),
'expected the ordered dict values to be the same length as the expected values')
for i, value in enumerate(values):
self.assertEqual(value, expected_values[i],
'expected value at position %s to be %s' % (str(i), str(expected_values[i])))
def testOrderedDictSort(self):
dict1 = OrderedDict()
dict1['SecurityConfig.myrealm.IoT-IDCS-Authenticator.ClientSecretEncrypted'] = ''
dict1['AdminUserName'] = ''
dict1['ServerTemp.ms-template.SSL.ListenPort'] = '8100'
dict1['AdminPassword'] = ''
dict1['JDBC.IoTServerDS.user.Value'] = 'admin'
dict1['SecurityConfig.CredentialEncrypted'] = ''
dict1['JDBC.IoTServerDS.PasswordEncrypted'] = ''
dict1['SecurityConfig.NodeManagerUsername'] = '******'
sorted_dict = OrderedDict()
sorted_keys = dict1.keys()
sorted_keys.sort()
for key in sorted_keys:
sorted_dict[key] = dict1[key]
self.assertEqual(sorted_dict.values()[-1], '8100',
'expected dictionary to be sorted by name')
class TestResults(object):
"""
Class for logging and printing out test results
"""
_class_name = 'TestResults'
_ERRORS_COUNT = 'errors_count'
_WARNINGS_COUNT = 'warnings_count'
_INFOS_COUNT = 'infos_count'
def __init__(self):
self._test_result_dict = PyOrderedDict()
def __str__(self):
return self.__to_string()
def set_test_result(self, test_result):
self._test_result_dict[test_result.get_test_area()] = test_result
def get_errors_count(self):
"""
:return:
"""
results_summary = self.__get_summary()
return results_summary[TestResults._ERRORS_COUNT]
def get_warnings_count(self):
"""
:return:
"""
results_summary = self.__get_summary()
return results_summary[TestResults._WARNINGS_COUNT]
def get_infos_count(self):
"""
:return:
"""
results_summary = self.__get_summary()
return results_summary[TestResults._INFOS_COUNT]
def log_results(self, logger):
"""
:param logger:
:return:
"""
_method_name = 'log_results'
if logger is not None:
# Get counts for all the TestResult objects
# in this TestResults object
results_summary = self.__get_summary()
jlogger = JLogger.getLogger(logger.get_name(), logger.resource_bundle_name)
jlogger.setLevel(JLevel.INFO)
# Determine what the severity level is going to be for the
# summary log message. Needs to be set in accordance with
# what the severest test message was.
if results_summary[TestResults._INFOS_COUNT] > 0:
jlogger.setLevel(JLevel.INFO)
if results_summary[TestResults._WARNINGS_COUNT] > 0:
jlogger.setLevel(JLevel.WARNING)
if results_summary[TestResults._ERRORS_COUNT] > 0:
jlogger.setLevel(JLevel.SEVERE)
total_messages_count = \
int(results_summary[TestResults._ERRORS_COUNT]) + int(results_summary[TestResults._WARNINGS_COUNT]) + \
int(results_summary[TestResults._INFOS_COUNT])
logger.log(jlogger.getLevel(),
'WLSDPLY-09810',
results_summary[TestResults._ERRORS_COUNT],
results_summary[TestResults._WARNINGS_COUNT],
results_summary[TestResults._INFOS_COUNT],
class_name=self._class_name, method_name=_method_name)
if total_messages_count > 0:
logger.log(jlogger.getLevel(), 'WLSDPLY-09811', total_messages_count,
class_name=self._class_name, method_name=_method_name)
for test_result in self._test_result_dict.values():
if test_result.get_infos_count() > 0:
jlogger.setLevel(JLevel.INFO)
self.__log_results_category_details(test_result.get_infos_messages(), _method_name, jlogger)
for test_result in self._test_result_dict.values():
if test_result.get_warnings_count() > 0:
jlogger.setLevel(JLevel.WARNING)
self.__log_results_category_details(test_result.get_warnings_messages(), _method_name, jlogger)
for test_result in self._test_result_dict.values():
if test_result.get_errors_count() > 0:
jlogger.setLevel(JLevel.SEVERE)
self.__log_results_category_details(test_result.get_errors_messages(), _method_name, jlogger)
jlogger.setLevel(JLevel.INFO)
return
def __log_results_category_details(self, category_messages, method_name, jlogger):
"""
:param category_messages:
:param method_name:
:param jlogger:
:return:
"""
for i in range(len(category_messages)):
messages = category_messages[i]
_log_category_message(jlogger, messages[_RESOURCE_ID], messages[_ARGS],
class_name=self._class_name, method_name=method_name)
def __get_summary(self):
"""
:return:
"""
results_summary = {
TestResults._ERRORS_COUNT: 0,
TestResults._WARNINGS_COUNT: 0,
TestResults._INFOS_COUNT: 0
}
for test_result in self._test_result_dict.values():
if test_result is not None:
results_summary[TestResults._ERRORS_COUNT] += test_result.get_errors_count()
results_summary[TestResults._WARNINGS_COUNT] += test_result.get_warnings_count()
results_summary[TestResults._INFOS_COUNT] += test_result.get_infos_count()
return results_summary
def __to_string(self):
"""
:return:
"""
tmp = ''
for test_result in self._test_result_dict.values():
if test_result.get_errors_count() > 0 \
or test_result.get_warnings_count() > 0 \
or test_result.get_infos_count():
tmp += str(test_result)
tmp += ','
if tmp[-1:] == ',':
# Strip off trailing ','
tmp = tmp[:-1]
return '[%s]' % tmp