def __validate_field_definition(self, field_name, field_def_fields,
test_def_metadata_file_path):
self.assertEqual(
TestDefMetadata.REQUIRED in field_def_fields, True,
testing_helper.format_message('WLSDPLY-09844', field_name,
test_def_metadata_file_path,
TestDefMetadata.REQUIRED))
self.assertEqual(
TestDefMetadata.DATA_TYPE in field_def_fields, True,
testing_helper.format_message('WLSDPLY-09844', field_name,
test_def_metadata_file_path,
TestDefMetadata.DATA_TYPE))
def stepRunDiscoverDomainScript(self):
_method_name = 'stepRunDiscoverDomainScript'
self._logger.info('WLSDPLY-09856', self._test_name, self._stage.get_name(),
class_name=_class_name, method_name=_method_name)
self._logger.entering(class_name=_class_name, method_name=_method_name)
settings_1 = self._test_def.get_settings(_SETTINGS_1)
module_to_import = self._stage.get_module_to_import()
if module_to_import is not None:
self.__run_using_module_to_import(module_to_import, settings_1)
else:
script_path = self._stage.get_script_to_run()
if script_path is not None:
self.__run_using_script_to_run(script_path, settings_1)
else:
# Stage didn't contain a script_to_run or module_to_import field, so
# fail stating that
self.fail(testing_helper.format_message('WLSDPLY-09857',
self._stage.get_name(),
TestDefStage.SCRIPT_TO_RUN,
TestDefStage.MODULE_TO_IMPORT))
# archive_file is a required field for discover, but model_file
# is optional.
model_file_name = settings_1.get_model_file_name()
if model_file_name is None:
# There was no model_file field in settings_1, so discoverDomain
# should have just put the generated model in the archive file.
archive_file_name = settings_1.get_archive_file_name()
response = _archive_contains_model_file(archive_file_name, self._logger)
self.assertEqual(response, True, testing_helper.format_message('WLSDPLY-09836',
self._test_name,
self._stage.get_name(),
archive_file_name))
else:
# There was a model_file field in settings_1, so discoverDomain
# should have written the model to the specified file system file.
model_file = settings_1.get_model_file()
self.assertNotEqual(model_file, None, testing_helper.format_message('WLSDPLY-09837',
self._test_name,
self._stage.get_name(),
model_file_name))
self._logger.exiting(class_name=_class_name, method_name=_method_name)
def stepRunCreateDomainScript(self):
_method_name = 'stepRunCreateDomainScript'
self._logger.entering(class_name=_class_name, method_name=_method_name)
settings_0 = self._test_def.get_settings(_SETTINGS_0)
module_to_import = self._stage.get_module_to_import()
if module_to_import is not None:
self.__run_using_module_to_import(module_to_import, settings_0)
else:
script_path = self._stage.get_script_to_run()
if script_path is not None:
self.__run_using_script_to_run(script_path, settings_0)
else:
# Stage didn't contain a script_to_run or module_to_import field, so
# fail stating that
self.fail(
testing_helper.format_message(
'WLSDPLY-09857', self._stage.get_name(),
TestDefStage.SCRIPT_TO_RUN,
TestDefStage.MODULE_TO_IMPORT))
self._logger.exiting(class_name=_class_name, method_name=_method_name)
def __run_using_script_to_run(self, script_path, settings):
script_to_run = testing_helper.verify_file_exists(script_path, self._logger)
env = _populate_env_map(settings)
args = _populate_tool_args([], settings)
script_runner = ScriptRunner(env, self._stage.get_name())
exit_code = script_runner.executeScript(script_to_run, True, None, args)
self.assertEqual(exit_code, 0, testing_helper.format_message('WLSDPLY-09835', script_to_run, exit_code))
def verifyRequiredFieldsArePresent(self):
_method_name = 'verifyRequiredFieldsArePresent'
self._logger.entering(class_name=_class_name, method_name=_method_name)
test_def_metadata_file_path = self._test_def_metadata_file.getAbsolutePath(
)
self.assertEqual(
TestDef.METADATA_FILE in self._test_def_metadata_dict, True,
testing_helper.format_message('WLSDPLY-09843',
test_def_metadata_file_path,
TestDef.METADATA_FILE))
self.assertEqual(
TestDef.TYPE in self._test_def_metadata_dict, True,
testing_helper.format_message('WLSDPLY-09843',
test_def_metadata_file_path,
TestDef.TYPE))
self.assertEqual(
TestDef.NAME in self._test_def_metadata_dict, True,
testing_helper.format_message('WLSDPLY-09843',
test_def_metadata_file_path,
TestDef.NAME))
iterators = [self._test_def_metadata_dict.iteritems()]
while iterators:
current_iterator = iterators.pop()
for field_name, field_value in current_iterator:
if isinstance(field_value, dict):
if field_name in _MANAGED_FIELD_DEF_FIELDS:
self.__validate_field_definition(
field_name, field_value.keys(),
test_def_metadata_file_path)
iterators.append(current_iterator)
iterators.append(field_value.iteritems())
self._logger.exiting(class_name=_class_name, method_name=_method_name)
def get_output_dir_for_test(self, output_base_dir, test_number):
_method_name = 'get_output_dir_for_test'
output_dir = get_canonical_path(
output_base_dir,
testing_helper.format_message(
SystemTestSupport.OUTPUT_DIR_TEMPLATE, test_number))
if not output_dir.exists() and not output_dir.mkdirs():
ex = exception_helper.create_system_test_exception(
'WLSDPLY-09875', output_dir.getPath())
_logger.throwing(ex,
class_name=_class_name,
method_name=_method_name)
raise ex
return output_dir
def get_target_domain_parent_dir_for_test(self, domain_parent_dir,
test_number):
_method_name = 'get_target_domain_parent_dir_for_test'
target_domain_parent_dir = get_canonical_path(
domain_parent_dir,
testing_helper.format_message(
SystemTestSupport.TARGET_DOMAIN_DIR_TEMPLATE, test_number))
if not target_domain_parent_dir.exists(
) and not target_domain_parent_dir.mkdirs():
ex = exception_helper.create_system_test_exception(
'WLSDPLY-09874', target_domain_parent_dir.getPath())
_logger.throwing(ex,
class_name=_class_name,
method_name=_method_name)
raise ex
return target_domain_parent_dir
def __to_string(self, category_name):
tmp = ' "%s": {' % category_name
tmp += '"count": %d, ' % self._result[category_name][TestResult._COUNT]
tmp += '"messages": ['
for message in self._result[category_name][TestResult._MESSAGES]:
tmp += "{"
tmp += '"%s": "%s",' % ('message', testing_helper.format_message(message[_RESOURCE_ID],
list(message[_ARGS])))
if tmp[-1:] == ',':
# Strip off trailing ','
tmp = tmp[:-1]
tmp += "},"
if tmp[-1:] == ',':
# Strip off trailing ','
tmp = tmp[:-1]
# Concatenate closing ']}'
tmp += "]},"
return tmp
def __run_using_module_to_import(self, module_to_import, settings):
tool_module = testing_helper.import_tool_module(module_to_import, self._logger)
args = list()
# args[0] is the file path for the tool_module
args.append('%s/%s.py' % (testing_constants.TOOL_MODULES_PATH, module_to_import))
# Use settings to populate all the other args
args = _populate_tool_args(args, settings)
try:
exit_code = tool_module.main(args)
except DiscoverException, de:
self.fail(testing_helper.format_message('WLSDPLY-09826',
self._test_name,
self._stage.get_module_name(),
self._stage.get_class_name(),
de.getLocalizedMessage()))
def validate_locations_for_webLogic_versions_required(
self, env, versions_required):
_method_name = 'validate_locations_for_webLogic_versions_required'
for version, types in versions_required.iteritems():
requires_jrf = self.__requires_jrf(types)
jrf_variable_name = testing_helper.format_message(
SystemTestSupport.ORACLE_HOME_ENV_VARIABLE_TEMPLATE, 'JRF',
version)
wls_variable_name = testing_helper.format_message(
SystemTestSupport.ORACLE_HOME_ENV_VARIABLE_TEMPLATE, 'WLS',
version)
if jrf_variable_name in os.environ:
oracle_home_to_validate = os.environ[jrf_variable_name]
version_key = '%s%s' % (SystemTestSupport.JRF_TEST_TYPE,
version)
elif not requires_jrf and wls_variable_name in os.environ:
oracle_home_to_validate = os.environ[wls_variable_name]
version_key = '%s%s' % (SystemTestSupport.WLS_TEST_TYPE,
version)
else:
if requires_jrf:
message_id = 'WLSDPLY-09880'
else:
message_id = 'WLSDPLY-09881'
ex = exception_helper.create_system_test_exception(
message_id, version)
_logger.throwing(ex,
class_name=_class_name,
method_name=_method_name)
raise ex
if not self._oracle_homes.__contains__(version_key):
oracle_home = get_canonical_file(oracle_home_to_validate)
if not oracle_home.exists():
if requires_jrf:
message_id = 'WLSDPLY-09882'
else:
message_id = 'WLSDPLY-09883'
ex = exception_helper.create_system_test_exception(
message_id, oracle_home.getPath(), version)
_logger.throwing(ex,
class_name=_class_name,
method_name=_method_name)
raise ex
elif not oracle_home.isDirectory():
if requires_jrf:
message_id = 'WLSDPLY-09884'
else:
message_id = 'WLSDPLY-09885'
ex = exception_helper.create_system_test_exception(
message_id, oracle_home.getPath(), version)
_logger.throwing(ex,
class_name=_class_name,
method_name=_method_name)
raise ex
self._oracle_homes[version_key] = oracle_home
self.__validate_locations_for_java_versions_required(env, version)
# Use settings to populate all the other args
args = _populate_tool_args(args, settings)
try:
exit_code = tool_module.main(args)
except DiscoverException, de:
self.fail(testing_helper.format_message('WLSDPLY-09826',
self._test_name,
self._stage.get_module_name(),
self._stage.get_class_name(),
de.getLocalizedMessage()))
except SystemExit, se:
exit_code = str(se)
self.assertEqual(exit_code, '0', testing_helper.format_message('WLSDPLY-09835', module_to_import, exit_code))
def _populate_env_map(settings):
env = HashMap()
if settings.is_field_set(TestDefSettings.JAVA_HOME):
env.put(testing_constants.JAVA_HOME_ENVVAR, settings.get_java_home())
if settings.is_field_set(TestDefSettings.WLST_PATH):
env.put(testing_constants.WLST_PATH_ENVVAR, settings.get_wlst_path())
return env
def _populate_tool_args(args, settings):
def stepShutdownAdminServer(self):
_method_name = 'stepShutdownAdminServer'
settings_1 = self._test_def.get_settings(_SETTINGS_1)
can_proceed = (settings_1.is_field_set(
TestDefSettings.ADMIN_SERVER_NAME),
settings_1.is_field_set(TestDefSettings.DOMAIN_HOME),
settings_1.is_field_set(TestDefSettings.DOMAIN_NAME))
if 0 in can_proceed:
needed_fields = [
TestDefSettings.ADMIN_SERVER_NAME, TestDefSettings.DOMAIN_HOME,
TestDefSettings.DOMAIN_NAME
]
missing_fields = [
needed_fields[i] for i, x in enumerate(can_proceed) if x == 0
]
self.fail(
testing_helper.format_message('WLSDPLY-09854',
settings_1.get_id(),
', '.join(missing_fields)))
admin_server_name = settings_1.get_admin_server_name()
domain_name = settings_1.get_domain_name()
domain_home = settings_1.get_domain_home()
script_runner = ScriptRunner(HashMap(), admin_server_name)
script_to_run = testing_helper.verify_file_exists(
'%s/%s' % (domain_home, self._stage.get_script_to_run()),
self._logger)
admin_user = settings_1.get_admin_user()
admin_url = settings_1.get_admin_url()
args = list()
args.append('%s' % admin_user)
args.append('%s' % settings_1.get_admin_pass())
args.append('%s' % admin_url)
self._logger.info('WLSDPLY-09846',
admin_server_name,
domain_name,
admin_url,
admin_user,
class_name=_class_name,
method_name=_method_name)
exit_code = script_runner.executeScript(script_to_run, True, None,
args)
self.assertEqual(
exit_code, 0,
testing_helper.format_message('WLSDPLY-09835', script_to_run,
exit_code))
self._logger.info('WLSDPLY-09847',
admin_server_name,
domain_name,
class_name=_class_name,
method_name=_method_name)
return
args = _populate_tool_args(args, settings)
try:
exit_code = tool_module.main(args)
except CreateException, ce:
self.fail(
testing_helper.format_message('WLSDPLY-09826', self._test_name,
self._stage.get_module_name(),
self._stage.get_class_name(),
ce.getLocalizedMessage()))
except SystemExit, se:
exit_code = str(se)
self.assertEqual(
exit_code, None,
testing_helper.format_message('WLSDPLY-09835', module_to_import,
exit_code))
def _populate_env_map(settings):
env = HashMap()
if settings.is_field_set(TestDefSettings.JAVA_HOME):
env.put(testing_constants.JAVA_HOME_ENVVAR, settings.get_java_home())
if settings.is_field_set(TestDefSettings.WLST_PATH):
env.put(testing_constants.WLST_PATH_ENVVAR, settings.get_wlst_path())
return env
def _populate_tool_args(args, settings):
def stepStartAdminServer(self):
_method_name = 'stepStartAdminServer'
self._logger.entering(class_name=_class_name, method_name=_method_name)
settings_1 = self._test_def.get_settings(_SETTINGS_1)
can_proceed = (settings_1.is_field_set(TestDefSettings.ADMIN_URL),
settings_1.is_field_set(
TestDefSettings.ADMIN_SERVER_NAME),
settings_1.is_field_set(TestDefSettings.ADMIN_USER),
settings_1.is_field_set(TestDefSettings.ADMIN_PASS),
settings_1.is_field_set(TestDefSettings.DOMAIN_HOME),
settings_1.is_field_set(TestDefSettings.DOMAIN_NAME))
needed_fields = [
TestDefSettings.ADMIN_URL, TestDefSettings.ADMIN_SERVER_NAME,
TestDefSettings.ADMIN_USER, TestDefSettings.ADMIN_PASS,
TestDefSettings.DOMAIN_HOME, TestDefSettings.DOMAIN_NAME
]
missing_fields = [
needed_fields[i] for i, x in enumerate(can_proceed) if x == 0
]
if missing_fields:
self.fail(
testing_helper.format_message('WLSDPLY-09853',
settings_1.get_id(),
', '.join(missing_fields)))
admin_url = settings_1.get_admin_url()
domain_home = settings_1.get_domain_home()
domain_name = settings_1.get_domain_name()
admin_server_name = settings_1.get_admin_server_name()
admin_user = settings_1.get_admin_user()
admin_pass = settings_1.get_admin_pass()
jvm_args = self._stage.get_field_value(StartAdminServer.JVM_ARGS)
timeout_value = self._stage.get_field_value(StartAdminServer.TIMEOUT,
default=_DEFAULT_TIMEOUT)
stdout_log = '%s/%s.out' % (self._test_def.get_logs_dir(),
admin_server_name)
self._logger.info('WLSDPLY-09838',
admin_server_name,
domain_name,
admin_url,
admin_user,
class_name=_class_name,
method_name=_method_name)
self._logger.info('WLSDPLY-09839',
admin_server_name,
stdout_log,
class_name=_class_name,
method_name=_method_name)
self._logger.info('WLSDPLY-09841',
self._stage.get_class_name(),
'two',
class_name=_class_name,
method_name=_method_name)
self._logger.info('WLSDPLY-09842',
'%s="%s"; %s=%d' %
(StartAdminServer.JVM_ARGS, jvm_args,
StartAdminServer.TIMEOUT, timeout_value),
self._test_def.get_def_file_name(),
class_name=_class_name,
method_name=_method_name)
wlst_wls_id = wlst.startServer(adminServerName=admin_server_name,
username=admin_user,
password=admin_pass,
domainName=domain_name,
domainDir=domain_home,
serverLog=stdout_log,
timeout=timeout_value,
jvmArgs=jvm_args)
self._logger.info('WLSDPLY-09840',
wlst_wls_id,
class_name=_class_name,
method_name=_method_name)
self._logger.exiting(class_name=_class_name, method_name=_method_name)
return