def test_get_build_data_config_error(self):
# Recreate the esl to validate parameters aren't set
with unittest.mock.patch.dict(
'os.environ', {'JENKINS_URL': 'jenkins_url', 'JENKINS_USER': '******',
'JENKINS_PASSWORD': '******', 'ES_JOB_NAME': 'es_job_name',
'ES_BUILD_NUMBER': '2', 'GATHER_BUILD_DATA': 'dummy'}):
self.esl = es_logger.EsLogger(1000, ['dummy'])
self.esl.es_build_number = '2'
with unittest.mock.patch('stevedore.driver.DriverManager') as mock_driver_mgr, \
unittest.mock.patch('jenkins.Jenkins.get_build_info') as mock_build_info, \
unittest.mock.patch('jenkins.Jenkins.get_build_env_vars') as mock_env_vars, \
unittest.mock.patch('jenkins.Jenkins.get_build_console_output') as mock_console, \
unittest.mock.patch('jenkins.Jenkins.get_job_config') as mock_config:
mock_env_vars.return_value = {'envMap': {'BUILD_NUMBER': '1',
'JOB_NAME': 'job_name',
'BUILD_URL': 'url',
'dummy': 'dummy'}}
mock_build_info.return_value = {
'description': 'description',
'number': '1',
'url': 'url',
'actions': [{'_class': 'hudson.model.ParametersAction',
'parameters': [{'name': 'param', 'value': 'value'}]},
{'_class': 'hudson.plugins.git.util.BuildData',
'buildsByBranchName': {'b1': {'buildNumber': '1'},
'b2': {'buildNumber': '2'}},
'remoteUrls': ["repoURL"]}]}
mock_console.return_value = 'log'
mock_config.side_effect = JenkinsException("Error from Jenkins Api")
self.esl.get_build_data()
mock_driver_mgr.assert_called_once()
# Job Config recorded
expetected_error_msg = "Unable to retrieve config.xml."
nose.tools.ok_(self.esl.es_info['job_config_info'] == expetected_error_msg,
"'job_config_info' value {} not '{}'".format(
self.esl.es_info['job_config_info'],
expetected_error_msg))
# Console log recorded
nose.tools.ok_(self.esl.es_info['console_log'] == 'log',
"console_log not 'log': {}".format(self.esl.es_info))
# Parameters pulled out
nose.tools.ok_(self.esl.es_info['parameters'].get('param') == 'value',
"Parameter 'param' not 'value': {}".format(self.esl.es_info))
# Prevent ES field explosion through rewrite of builds by branch name
nose.tools.ok_(
self.esl.es_info['build_info']['actions'][1]['buildsByBranchName'] ==
'Removed by es-logger',
"buildsByBranchName not removed by es-logger: {}".format(self.esl.es_info))
# Make sure the gather of the gather_build_data plugins was called
nose.tools.ok_('dummy' in self.esl.es_info['build_data'].keys(),
"dummy not in build_data keys: {}".format(
self.esl.es_info))
# SCM correctly processed
nose.tools.ok_('repoURL' in self.esl.es_info['build_data'].keys(),
"repoURL not in build_data keys: {}".format(
self.esl.es_info['build_data']))
def test_get_es_build_number_default(self):
# Recreate the esl to validate parameters aren't set and default is 0
self.esl = es_logger.EsLogger(1000, ['dummy'])
nose.tools.ok_(
self.esl.es_build_number == '0',
"self.esl.es_build_number not 0: {} ({})".format(
self.esl.es_build_number, type(self.esl.es_build_number)))
def main():
args = parse_args()
configure_logging(args)
if args.list_plugins:
es_logger.EsLogger.list_plugins()
sys.exit(0)
esl = es_logger.EsLogger(console_length=args.console_length,
targets=args.target)
esl.gather_all()
status = 0
# Loop over all of the events to send,
# main job in es_info, then events generated from plugins
process_events = [esl.es_info] if not args.events_only else []
process_events += esl.events
for e in process_events:
if not args.no_dump:
esl.dump(e)
if not args.no_post:
status += esl.post(e)
if not args.no_post:
status += esl.finish()
sys.exit(status)
def test_get_es_build_number(self):
# Recreate the esl to validate parameters aren't set
self.esl = es_logger.EsLogger(1000, ['dummy'])
nose.tools.ok_(self.esl.es_build_number == 0,
"self.esl.es_build_number not 0: {}".format(self.esl.es_build_number))
with unittest.mock.patch.dict('os.environ', {'ES_BUILD_NUMBER': '1000'}):
self.esl.es_build_number = self.esl.get_es_build_number()
nose.tools.ok_(self.esl.get_es_build_number() == 1000,
"{} not returning {}".format(self.esl.get_es_build_number, 1000))
def test_get(self, param):
# Recreate the esl to validate parameters aren't set
self.esl = es_logger.EsLogger(1000, ['dummy'])
nose.tools.ok_(getattr(self.esl, param) is None,
"{} not None: {}".format(param, getattr(self.esl, param)))
getter = getattr(self.esl, 'get_' + param)
with unittest.mock.patch.dict('os.environ', {param.upper(): param}):
setattr(self.esl, param, getter())
nose.tools.ok_(getter() == param,
"{} returned {} not {}".format(getter.__name__, getter(), param))
def setup(self):
dep = pkg_resources.EntryPoint.parse(
'dummy = test.test_plugins:DummyEventTarget')
d = pkg_resources.Distribution()
d._ep_map = {'es_logger.plugins.event_target': {'dummy': dep}}
pkg_resources.working_set.add(d, 'dummy')
ExtensionManager.ENTRY_POINT_CACHE = {}
self.esl = es_logger.EsLogger(1000, ['dummy'])
self.urls = {
'get_build_env_vars': 'jenkins_url/job/job_name/1/injectedEnvVars/api/json?depth=1',
'get_build_test_report': 'jenkins_url/job/job_name/1/testReport/api/json?depth=1'}
def setup(self):
dummy_ep = importlib.metadata.EntryPoint(
'dummy', 'test.test_plugins:DummyEventTarget',
'es_logger.plugins.event_target')
ExtensionManager.ENTRY_POINT_CACHE = {
'es_logger.plugins.event_target': [dummy_ep]
}
self.esl = es_logger.EsLogger(1000, ['dummy'])
self.urls = {
'get_build_artifact': 'jenkins_url/job/job_name/1/artifact/1',
'get_build_stages': 'jenkins_url/job/job_name/1/wfapi/describe/'
}
def test_empty_plugin_vars(self):
dummy_ep = importlib.metadata.EntryPoint(
'dummy', 'test.test_plugins:DummyEventTarget',
'es_logger.plugins.event_target')
ExtensionManager.ENTRY_POINT_CACHE = {
'es_logger.plugins.event_target': [dummy_ep]
}
esl = es_logger.EsLogger(1000, ['dummy'])
nose.tools.ok_(
esl.process_console_logs == [],
"process_console_logs {}".format(esl.process_console_logs))
nose.tools.ok_(esl.gather_build_data == [],
"gather_build_data {}".format(esl.gather_build_data))
nose.tools.ok_(esl.generate_events == ['commit'],
"generate_events {}".format(esl.generate_events))
def test_get_plugin(self, param):
if param == 'generate_events':
base = ['commit']
else:
base = []
# Recreate the esl to validate parameters aren't set
self.esl = es_logger.EsLogger(1000, ['dummy'])
nose.tools.ok_(getattr(self.esl, param) == base,
"{} not []: {}".format(param, getattr(self.esl, param)))
setattr(self.esl, param, None)
getter = getattr(self.esl, 'get_' + param)
with unittest.mock.patch.dict('os.environ',
{param.upper(): "{}1 {}2 {}3".format(param, param, param)}):
plugins = getter()
expected = [param + '1', param + '2', param + '3'] + base
nose.tools.ok_(plugins == expected,
"{} returned {} not {}".format(getter.__name__, getter(), expected))
def test_get_es_build_number(self):
es_build_number = '999'
# Validate correct value from env
with unittest.mock.patch.dict('os.environ',
{'ES_BUILD_NUMBER': es_build_number}):
self.esl = es_logger.EsLogger(1000, ['dummy'])
nose.tools.ok_(
self.esl.get_es_build_number() == es_build_number,
"{} not returning {}, types: {} {}".format(
self.esl.es_build_number, es_build_number,
type(self.esl.es_build_number), type(es_build_number)))
# Validate env change doesn't change our object
with unittest.mock.patch.dict('os.environ',
{'ES_BUILD_NUMBER': '1000'}):
nose.tools.ok_(
self.esl.get_es_build_number() == es_build_number,
"{} not returning {}, types: {} {}".format(
self.esl.es_build_number, es_build_number,
type(self.esl.es_build_number), type(es_build_number)))
def es_logger_task(self, msg):
var = json.loads(''.join(msg[0].decode("utf-8").split()[1:]))
phase = var['build'].get('phase')
if phase == 'FINISHED':
job = self.get_project_name(var['url'])
number = var['build'].get('number')
logging.info("Process {} number {} on {}".format(
job, number, self.jenkins_url))
# Create and configure the ES-Logger instance
esl = es_logger.EsLogger(console_length=32500,
targets=['logstash'])
esl.es_job_name = job
esl.es_build_number = int(number)
esl.gather_all()
status = esl.post_all()
logging.info("{} number {} status {}".format(job, number, status))
else:
logging.debug('Not collecting from job in phase {}'.format(phase))
status = None
return status
def test_get_build_data(self):
# Recreate the esl to validate parameters aren't set
with unittest.mock.patch.dict(
'os.environ', {
'JENKINS_URL': 'jenkins_url',
'JENKINS_USER': '******',
'JENKINS_PASSWORD': '******',
'ES_JOB_NAME': 'es_job_name',
'ES_BUILD_NUMBER': '2',
'GATHER_BUILD_DATA': 'dummy'
}):
self.esl = es_logger.EsLogger(1000, ['dummy'])
self.esl.es_build_number = '2/label=matrix'
with unittest.mock.patch('stevedore.driver.DriverManager') as mock_driver_mgr, \
unittest.mock.patch('jenkins.Jenkins.get_build_info') as mock_build_info, \
unittest.mock.patch('jenkins.Jenkins.get_build_env_vars') as mock_env_vars, \
unittest.mock.patch('jenkins.Jenkins.get_build_console_output') as mock_console, \
unittest.mock.patch('jenkins.Jenkins.get_job_config') as mock_config:
mock_env_vars.return_value = {
'envMap': {
'BUILD_NUMBER': '1',
'JOB_NAME': 'job_name',
'BUILD_URL': 'url',
'dummy': 'dummy'
}
}
mock_build_info.return_value = {
'description':
'description',
'number':
'1',
'url':
'url',
'actions': [{
'_class': 'hudson.model.ParametersAction',
'parameters': [{
'name': 'param',
'value': 'value'
}]
}, {
'_class': 'hudson.plugins.git.util.BuildData',
'buildsByBranchName': {
'b1': {
'buildNumber': '1'
},
'b2': {
'buildNumber': '2'
}
},
'remoteUrls': ["repoURL"]
}]
}
mock_console.return_value = 'log'
config_xml = "<project></project>"
mock_config.return_value = config_xml
self.esl.get_build_data()
mock_driver_mgr.assert_called_once()
# Job Config recorded
nose.tools.ok_(
self.esl.es_info['job_config_info'].get("is_pipeline_job") is
False, "is_pipeline_job not '{}': {}".format(
False,
self.esl.es_info["job_config_info"]["is_pipeline_job"]))
# The job_config is on of length 1.
nose.tools.ok_(
len(self.esl.es_info['job_config_info']) == 1,
"job_config_info len isn't '1': {}".format(
self.esl.es_info["job_config_info"]))
# Console log recorded
nose.tools.ok_(
self.esl.es_info['console_log'] == 'log',
"console_log not 'log': {}".format(self.esl.es_info))
# Console log length recorded
nose.tools.ok_(
self.esl.es_info['console_log_length'] == 3,
"console_log length not 3: {}".format(self.esl.es_info))
# ID info pulled into eslogger namespace
eslogger_vars = {
'job_name': 'es_job_name',
'jenkins_url': 'jenkins_url',
'build_number': 2,
'build_label': 'label=matrix',
'es_build_number': '2/label=matrix'
}
for k, v in eslogger_vars.items():
nose.tools.ok_(self.esl.es_info['eslogger'][k] == v,
"{} not {}: {}".format(k, v, self.esl.es_info))
# Parameters pulled out
nose.tools.ok_(
self.esl.es_info['parameters'].get('param') == 'value',
"Parameter 'param' not 'value': {}".format(self.esl.es_info))
# Prevent ES field explosion through rewrite of builds by branch name
nose.tools.ok_(
self.esl.es_info['build_info']['actions'][1]
['buildsByBranchName'] == 'Removed by es-logger',
"buildsByBranchName not removed by es-logger: {}".format(
self.esl.es_info))
# Make sure the gather of the gather_build_data plugins was called
nose.tools.ok_(
'dummy' in self.esl.es_info['build_data'].keys(),
"dummy not in build_data keys: {}".format(self.esl.es_info))
# SCM correctly processed
nose.tools.ok_(
len(self.esl.es_info['build_data']['scm_data']) == 1,
"Wrong number of elements in scm_data: {}".format(
len(self.esl.es_info['build_data']['scm_data'])))
nose.tools.ok_(
self.esl.es_info['build_data']['scm_data'][0]['name'] ==
"repoURL",
"Wrong name for scm_data first element: {} not repoURL".format(
self.esl.es_info['build_data']['scm_data'][0]['name']))
