libtaskotron/directives/koji_directive.py
72–74	Ugh, can we just use two lines here?
libtaskotron/logger.py
65–68	Let's use just two lines here.
73–75	Let's use just two lines here.
libtaskotron/python_utils.py
16–17	Let's use just two lines here.
libtaskotron/runner.py
135–139	Doesn't this add a lots of whitespace to the help message? I assume we don't want that.
libtaskotron/tap.py
26 ↗	(On Diff #73)	I'm not sure if you don't break pylint directives here. Let's not modify this file at all, we plan to get rid of it in T101 anyway.
libtaskotron/yamlish.py
119 ↗	(On Diff #73)	Let's not modify this file at all, we plan to get rid of it in T101 anyway.
testing/test_check.py
151–155 ↗	(On Diff #73)	There are the cases where I think that some PEP8 guidelines don't make much sense ;) Unless you want to have as many source code lines as possible, of course. The original code was fine.
testing/test_koji_directive.py
29–31	Personally, I would use self.ref_url = ('http://downloads.example.com/builds/%s.noarch.rpm' % self.ref_nvr) The URL seems to be more readable this way.
testing/test_koji_utils.py
15–29	Ditto.
testing/test_runner.py
295–297	This is actually longer than 80 chars.

			Path
M			libtaskotron/directives/createrepo_directive.py (4 lines)
M			libtaskotron/directives/dummy_directive.py (3 lines)
M			libtaskotron/directives/koji_directive.py (37 lines)
M			libtaskotron/directives/python_directive.py (37 lines)
M			libtaskotron/file_utils.py (7 lines)
M			libtaskotron/koji_utils.py (10 lines)
M			libtaskotron/logger.py (12 lines)
M			libtaskotron/python_utils.py (2 lines)
M			libtaskotron/runner.py (34 lines)
M			setup.py (4 lines)
M			testing/conftest.py (3 lines)
M			testing/functest_python_directive.py (15 lines)
M			testing/test_koji_directive.py (34 lines)
M			testing/test_koji_utils.py (34 lines)
M			testing/test_python_directive.py (40 lines)
M			testing/test_python_utils.py (2 lines)
M			testing/test_runner.py (13 lines)

Diff	ID	Base	Description	Created	Lint	Unit
Base			Base
Diff 1	73	bc3b5b6		Mar 14 2014, 12:29 PM	★	★
Diff 2	80	bc3b5b6	- reformated all lines to 80 column	Mar 25 2014, 12:13 PM	★	★
Diff 3	81	bc3b5b6	- remaining pyflakes/pylint changes	Mar 25 2014, 12:48 PM	★	★
Diff 4	83	bc3b5b6	- another set of changes	Mar 25 2014, 1:35 PM	★	★
Diff 5	84	23d387a	Commit rLTRNd8e3675cefdc20a227a0c2351eb7664cea26787f	Mar 25 2014, 2:05 PM	★	★

Commit	Tree	Parents	Author	Summary	Date
fad933fb1f91	b56e7de1b787	26e8dbce18da	Garret Raziel	another set of changes	Mar 25 2014, 1:33 PM
26e8dbce18da	d9c6f35c64d7	e48aa13cdbde	Garret Raziel	remaining pyflakes/pylint changes	Mar 25 2014, 12:46 PM
e48aa13cdbde	afec29edafea	abc15b5de01f	Garret Raziel	reformated all lines to 80 column	Mar 25 2014, 12:12 PM
abc15b5de01f	70cfc9c1f46f	bc3b5b6e3cb6	Garret Raziel	aligned to 80 column (Show More…)	Mar 20 2014, 11:02 AM

Diff 84

libtaskotron/directives/createrepo_directive.py

1	import subprocess as sub	1	import subprocess as sub
2	from libtaskotron.directives import BaseDirective	2	from libtaskotron.directives import BaseDirective
3	from libtaskotron.logger import log	3	from libtaskotron.logger import log
4	from libtaskotron.exceptions import TaskotronDirectiveError	4	from libtaskotron.exceptions import TaskotronDirectiveError
5		5
6	directive_class = 'CreaterepoDirective'	6	directive_class = 'CreaterepoDirective'
7		7
8		8
9	class CreaterepoDirective(BaseDirective):	9	class CreaterepoDirective(BaseDirective):
10	def process(self, input_data, env_data):	10	def process(self, input_data, env_data):
11	"""For the createrepo directive, we're expecting a yaml declaration of the form	11	"""For the createrepo directive, we're expecting a yaml declaration of
12	"createrepo: repodir=/path/to/some/dir"	12	the form "createrepo: repodir=/path/to/some/dir"
13	"""	13	"""
14		14
15	repodir = input_data['repodir']	15	repodir = input_data['repodir']
16		16
17	log.info('running createrepo on %s', repodir)	17	log.info('running createrepo on %s', repodir)
18		18
19	p = sub.Popen(['createrepo', repodir], stdout=sub.PIPE, stderr=sub.PIPE)	19	p = sub.Popen(['createrepo', repodir], stdout=sub.PIPE, stderr=sub.PIPE)
20		20
21	output, errors = p.communicate()	21	output, errors = p.communicate()
22		22
23	if p.returncode:	23	if p.returncode:
24	raise TaskotronDirectiveError(errors)	24	raise TaskotronDirectiveError(errors)
25		25
26	log.debug(output)	26	log.debug(output)
27		27
28	return output	28	return output

View Options

libtaskotron/directives/dummy_directive.py

Show All 15 Lines		14	format:
16	required params: result	16		required params: result
17	optional params: msg	17		optional params: msg
18	"""	18		"""
19		19
20	def process(self, input_data, env_data):	20		def process(self, input_data, env_data):
21	expected_result = input_data['result']	21		expected_result = input_data['result']
22		22
23	if expected_result.lower() == 'fail':	23		if expected_result.lower() == 'fail':
24	raise TaskotronDirectiveError("This is a dummy directive and configured to fail")	24		raise TaskotronDirectiveError("This is a dummy directive and "
		25		"configured to fail")
25		26
26	if 'msg' in input_data:	27		if 'msg' in input_data:
27	return input_data['msg']	28		return input_data['msg']

View Options

libtaskotron/directives/koji_directive.py

1	from libtaskotron.koji_utils import KojiClient	1		from libtaskotron.koji_utils import KojiClient
2	from libtaskotron.logger import log	2		from libtaskotron.logger import log
3	from libtaskotron.directives import BaseDirective	3		from libtaskotron.directives import BaseDirective
4	from libtaskotron.exceptions import TaskotronDirectiveError	4		from libtaskotron.exceptions import TaskotronDirectiveError
5		5
6	directive_class = 'KojiDirective'	6		directive_class = 'KojiDirective'
7		7
8	class KojiDirective(BaseDirective):	8		class KojiDirective(BaseDirective):
9	"""The koji directive interfaces with Koji to facilitate various koji actions.	9		"""The koji directive interfaces with Koji to facilitate various koji
		10		actions.
10		11
11	format: "koji: command=[download] <command args>	12		format: "koji: command=[download] <command args>
12		13
13	Valid Commands:	14		Valid Commands:
14		15
15	download	16		download
16	Downloads the envr specified as "envr"	17		Downloads the envr specified as "envr"
17	format: "koji: command=download envr=<envr to download> arch=<desired arch>	18		format:
		19		"koji: command=download envr=<envr to download> arch=<desired arch>
18	download_tag	20		download_tag
19	Downloads rpms tagged by "tag"	21		Downloads rpms tagged by "tag"
20	format: "koji: command=download_tag tag=<tag to download> arch=<desired arch>	22		format:
		23		"koji: command=download_tag tag=<tag to download> arch=<desired arch>
21	"""	24		"""
22		25
23	def __init__(self, koji_session=None):	26		def __init__(self, koji_session=None):
24	if koji_session == None:	27		super(KojiDirective, self).__init__()
		28		if koji_session is None:
25	self.koji = KojiClient(koji_session)	29		self.koji = KojiClient(koji_session)
26	else:	30		else:
27	self.koji = koji_session	31		self.koji = koji_session
28		32
29	def process(self, input_data, env_data):	33		def process(self, input_data, env_data):
30	valid_actions = ['download', 'download_tag']	34		valid_actions = ['download', 'download_tag']
31		35
32	output_data = {}	36		output_data = {}
33		37
34	action = input_data['action']	38		action = input_data['action']
35		39
36	if not action in valid_actions:	40		if not action in valid_actions:
37	raise TaskotronDirectiveError('%s is not a valid command for koji helper' % action)	41		raise TaskotronDirectiveError('%s is not a valid command for koji '
		42		'helper' % action)
38		43
39	if action == 'download':	44		if action == 'download':
40	if 'envr' not in input_data or 'arch' not in input_data:	45		if 'envr' not in input_data or 'arch' not in input_data:
41	detected_args = ', '.join(input_data.keys())	46		detected_args = ', '.join(input_data.keys())
42	raise TaskotronDirectiveError("The koji directive requires both 'envr' and \	47		raise TaskotronDirectiveError(
43	'arch' arguments. Detected arguments: %s" % detected_args)	48		"The koji directive requires both 'envr' and 'arch'"
		49		"arguments. Detected arguments: %s" % detected_args)
44		50
45	tmpdir = env_data['workdir']	51		tmpdir = env_data['workdir']
46	envr = input_data['envr']	52		envr = input_data['envr']
47	arches = [input_data['arch']]	53		arches = [input_data['arch']]
48		54
49	log.info("getting koji builds for %s (%s) and downloading to %s", envr, arches, tmpdir)	55		log.info("getting koji builds for %s (%s) and downloading to %s",
		56		envr, arches, tmpdir)
50	output_data['downloaded_rpms'] = self.koji.get_nvr_rpms(envr,	57		output_data['downloaded_rpms'] = self.koji.get_nvr_rpms(envr,
51	tmpdir,	58		tmpdir, arches)
52	arches)
53	elif action == 'download_tag':	59		elif action == 'download_tag':
54	if 'tag' not in input_data or 'arch' not in input_data:	60		if 'tag' not in input_data or 'arch' not in input_data:
55	detected_args = ', '.join(input_data.keys())	61		detected_args = ', '.join(input_data.keys())
56	raise TaskotronDirectiveError("The koji directive requires both 'tag' and \	62		raise TaskotronDirectiveError(
57	'arch' arguments. Detected arguments: %s" % detected_args)	63		"The koji directive requires both 'tag' and 'arch' "
		64		"arguments. Detected arguments: %s" % detected_args)
58		65
59	tmpdir = env_data['workdir']	66		tmpdir = env_data['workdir']
60	tag = input_data['tag']	67		tag = input_data['tag']
61	arches = [input_data['arch']]	68		arches = [input_data['arch']]
62		69
63	log.info("getting koji builds for tag %s and downloading to %s", tag, tmpdir)	70		log.info("getting koji builds for tag %s and downloading to %s",
64	output_data['downloaded_rpms'] = self.koji.get_tagged_rpms(tag, tmpdir, arches)	71		tag, tmpdir)
		72		output_data['downloaded_rpms'] = self.koji.get_tagged_rpms(tag,
		73		tmpdir, arches)
65		74
			kparalUnsubmitted Not Done Ugh, can we just use two lines here?
66	return output_data	75		return output_data

View Options

libtaskotron/directives/python_directive.py

1	import imp	1		import imp
2	import os	2		import os
3		3
4	from libtaskotron.directives import BaseDirective	4		from libtaskotron.directives import BaseDirective
5	from libtaskotron.exceptions import TaskotronDirectiveError	5		from libtaskotron.exceptions import TaskotronDirectiveError
6		6
7	directive_class = 'PythonDirective'	7		directive_class = 'PythonDirective'
8		8
9		9
10	class PythonDirective(BaseDirective):	10		class PythonDirective(BaseDirective):
11	"""The python directive is designed to execute a piece of python code as part	11		"""The python directive is designed to execute a piece of python code as
12	of task execution. Given a callable name 'dothis_thing', possible implementations	12		part of task execution. Given a callable name 'dothis_thing', possible
13	in the loaded code could include:	13		implementations in the loaded code could include:
14		14
15	class TaskClass(object):	15		class TaskClass(object):
16	def my_task(self):	16		def my_task(self):
17	return "I'm a task class method!"	17		return "I'm a task class method!"
18		18
19	_instantiated_class = TaskClass()	19		_instantiated_class = TaskClass()
20		20
21	task_class_target = _instantiated_class.my_task	21		task_class_target = _instantiated_class.my_task
Show All 9 Lines
31	In this case, you could pass in 'embedded_task_target' as the callable arg	31		In this case, you could pass in 'embedded_task_target' as the callable arg
32		32
33	def task_method():	33		def task_method():
34	return "I'm a task method!"	34		return "I'm a task method!"
35		35
36	And in this third case, you would pass in 'task_method' as the callable arg	36		And in this third case, you would pass in 'task_method' as the callable arg
37		37
38	format:	38		format:
39	python: file=<python filename> callable=<method name> [<kwargname>=<kwargvalue>'	39		python:
		40		file=<python filename> callable=<method name> [<kwargname>=<kwargvalue>'
40	required params: <python filename>, callable	41		required params: <python filename>, callable
41	optional params: farther key/value pairs, to be passed into the callable as kwargs	42		optional params: farther key/value pairs, to be passed into the callable
		43		as kwargs
42	"""	44		"""
43		45
44	def _do_getattr(self, module, name):	46		def _do_getattr(self, module, name):
45	"""Isolation of getattr to make the code more easily testable	47		"""Isolation of getattr to make the code more easily testable
46		48
47	@param module module from which to getattr from	49		@param module module from which to getattr from
48	@param name name of object to getattr	50		@param name name of object to getattr
49	@returns object retrieved from module	51		@returns object retrieved from module
Show All 17 Lines		56	def execute(self, task_module, method_name, kwargs):
67	return output	69		return output
68		70
69	def load_pyfile(self, filename):	71		def load_pyfile(self, filename):
70	"""Import python code specified	72		"""Import python code specified
71		73
72	@param filename absolute path to the python file	74		@param filename absolute path to the python file
73	"""	75		"""
74		76
75	task_importname = 'runtask_%s' % os.path.basename(filename).rstrip('.py')	77		task_importname = 'runtask_%s' % os.path.basename(filename).rstrip(
		78		'.py')
76	task = imp.load_source(task_importname, filename)	79		task = imp.load_source(task_importname, filename)
77		80
78	return task_importname, task	81		return task_importname, task
79		82
80	def checkfile(self, filename):	83		def checkfile(self, filename):
81	"""Check to see if the file exists	84		"""Check to see if the file exists
82		85
83	@param filename abspath to the filename	86		@param filename abspath to the filename
84	@throws TaskotronDirectiveError if the file does not exist	87		@throws TaskotronDirectiveError if the file does not exist
85	"""	88		"""
86		89
87	if not os.path.exists(filename):	90		if not os.path.exists(filename):
88	raise TaskotronDirectiveError("The file %s does not exist!" % filename)	91		raise TaskotronDirectiveError("The file %s does not exist!"
		92		% filename)
89		93
90	def process(self, input_data, env_data):	94		def process(self, input_data, env_data):
91	"""For the python directive, we're expecting a yaml declaration of the form	95		"""For the python directive, we're expecting a yaml declaration of the
92	"python: file=<python file> callable=<method name> [kwarg1=something ...]"	96		form
		97		"python:
		98		file=<python file> callable=<method name> [kwarg1=something ...]"
93		99
94	@param input_data dictionary of all kwargs from yaml declaration, including callable and file	100		@param input_data dictionary of all kwargs from yaml declaration,
		101		including callable and file
95	@param env_data information on the environment in which we're running	102		@param env_data information on the environment in which we're running
96	@return output from the method specified, this is expected to be TAP output	103		@return output from the method specified, this is expected to be TAP
		104		output
97	"""	105		"""
98		106
99	if 'callable' not in input_data or 'file' not in input_data:	107		if 'callable' not in input_data or 'file' not in input_data:
100	detected_args = ', '.join(input_data.keys())	108		detected_args = ', '.join(input_data.keys())
101	raise TaskotronDirectiveError("The python directive requires both 'callable' and \	109		raise TaskotronDirectiveError(
102	'file' arguments. Detected arguments: %s" % detected_args)	110		"The python directive requires both 'callable' and 'file' "
		111		"arguments. Detected arguments: %s" % detected_args)
103		112
104	method_name = input_data.pop('callable')	113		method_name = input_data.pop('callable')
105	basedir = os.path.dirname(env_data['taskfile'])	114		basedir = os.path.dirname(env_data['taskfile'])
106		115
107	pyfile = os.path.join(basedir, input_data.pop('file'))	116		pyfile = os.path.join(basedir, input_data.pop('file'))
108		117
109	self.checkfile(pyfile)	118		self.checkfile(pyfile)
110		119
111	task_name, task = self.load_pyfile(pyfile)	120		_, task = self.load_pyfile(pyfile)
112		121
113	output = self.execute(task, method_name, input_data)	122		output = self.execute(task, method_name, input_data)
114		123
115	return output	124		return output

View Options

libtaskotron/file_utils.py

1	import os	1		import os
2	import sys	2		import sys
3	import urlgrabber.grabber, urlgrabber.progress	3		import urlgrabber.grabber
		4		import urlgrabber.progress
4	from libtaskotron.logger import log	5		from libtaskotron.logger import log
5	from exceptions import TaskotronRemoteError	6		from libtaskotron.exceptions import TaskotronRemoteError
6		7
7		8
8	def makedirs(fullpath):	9		def makedirs(fullpath):
9	'''This is the same as @method os.makedirs(), but does not throw an	10		'''This is the same as @method os.makedirs(), but does not throw an
10	exception when the destination directory already exists.	11		exception when the destination directory already exists.
11	@raise OSError if directory can't be created	12		@raise OSError if directory can't be created
12	'''	13		'''
13	try:	14		try:
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Line(s)		50	def download(url, dest, overwrite=False, grabber=None):
68		69
69	# get destination file, create dirs if needed	70		# get destination file, create dirs if needed
70	if os.path.isdir(dest):	71		if os.path.isdir(dest):
71	dest = os.path.join(dest, os.path.basename(url))	72		dest = os.path.join(dest, os.path.basename(url))
72	else:	73		else:
73	try:	74		try:
74	makedirs(os.path.dirname(dest))	75		makedirs(os.path.dirname(dest))
75	except OSError, e:	76		except OSError, e:
76	log.exception("Can't create directory: %s" % dest)	77		log.exception("Can't create directory: %s", dest)
77	raise TaskotronRemoteError(e)	78		raise TaskotronRemoteError(e)
78		79
79	# overwrite?	80		# overwrite?
80	if os.path.exists(dest):	81		if os.path.exists(dest):
81	if overwrite:	82		if overwrite:
82	os.remove(dest)	83		os.remove(dest)
83	else:	84		else:
84	log.debug('Already downloaded: %s', os.path.basename(dest))	85		log.debug('Already downloaded: %s', os.path.basename(dest))
Show All 17 Lines

View Options

libtaskotron/koji_utils.py

1	import koji	1		import koji
2		2
3	from libtaskotron import file_utils	3		from libtaskotron import file_utils
4	from libtaskotron.logger import log	4		from libtaskotron.logger import log
5	from libtaskotron.exceptions import TaskotronRemoteError	5		from libtaskotron.exceptions import TaskotronRemoteError
6		6
7	KOJI_URL = 'http://koji.fedoraproject.org/kojihub'	7		KOJI_URL = 'http://koji.fedoraproject.org/kojihub'
8	PKG_URL = 'http://kojipkgs.fedoraproject.org/packages'	8		PKG_URL = 'http://kojipkgs.fedoraproject.org/packages'
9		9
10	class KojiClient(object):	10		class KojiClient(object):
11	def __init__(self, koji_session=None):	11		def __init__(self, koji_session=None):
12	self.session = koji_session	12		self.session = koji_session
13		13
14	def get_koji_session(self):	14		def get_koji_session(self):
15	if self.session == None:	15		if self.session is None:
16	self.session = koji.ClientSession(KOJI_URL)	16		self.session = koji.ClientSession(KOJI_URL)
17		17
18	return self.session	18		return self.session
19		19
20	def nvr_to_urls(self, nvr, arches=None, debuginfo=False, src=True):	20		def nvr_to_urls(self, nvr, arches=None, debuginfo=False, src=True):
21	'''Get list of URLs for RPMs corresponding to a build.	21		'''Get list of URLs for RPMs corresponding to a build.
22	@param nvr build NVR	22		@param nvr build NVR
23	@param arches restrict the arches of builds to provide URLs for. If	23		@param arches restrict the arches of builds to provide URLs for. If
24	basearch i386 is in the list, i686 arch is automatically	24		basearch i386 is in the list, i686 arch is automatically
25	added (since that's the arch Koji API uses).	25		added (since that's the arch Koji API uses).
26	'''	26		'''
27		27
28	log.info('Querying Koji for a list of RPMS for: %s', nvr)	28		log.info('Querying Koji for a list of RPMS for: %s', nvr)
29		29
30	ksession = self.get_koji_session()	30		ksession = self.get_koji_session()
31		31
32	# add i686 arch if i386 is present in arches	32		# add i686 arch if i386 is present in arches
33	if arches and 'i386' in arches and 'i686' not in arches:	33		if arches and 'i386' in arches and 'i686' not in arches:
34	arches.append('i686')	34		arches.append('i686')
35		35
36	info = ksession.getBuild(nvr)	36		info = ksession.getBuild(nvr)
37	if info is None:	37		if info is None:
38	raise TaskotronRemoteError("No build information found for %s" % nvr)	38		raise TaskotronRemoteError(
		39		"No build information found for %s" % nvr)
39		40
40	baseurl = '/'.join((PKG_URL, info['package_name'],	41		baseurl = '/'.join((PKG_URL, info['package_name'],
41	info['version'], info['release']))	42		info['version'], info['release']))
42		43
43	rpms = ksession.listRPMs(buildID=info['id'], arches=arches)	44		rpms = ksession.listRPMs(buildID=info['id'], arches=arches)
44	if not debuginfo:	45		if not debuginfo:
45	rpms = [r for r in rpms if not r['name'].endswith('-debuginfo')]	46		rpms = [r for r in rpms if not r['name'].endswith('-debuginfo')]
46	if not src:	47		if not src:
47	rpms = [r for r in rpms if not r['arch'] == 'src']	48		rpms = [r for r in rpms if not r['arch'] == 'src']
48		49
49	urls = ['%s/%s' % (baseurl, koji.pathinfo.rpm(r)) for r in rpms]	50		urls = ['%s/%s' % (baseurl, koji.pathinfo.rpm(r)) for r in rpms]
50	if len(urls) == 0:	51		if len(urls) == 0:
51	raise TaskotronRemoteError('No RPMs found for %s' % nvr)	52		raise TaskotronRemoteError('No RPMs found for %s' % nvr)
52		53
53	return sorted(urls)	54		return sorted(urls)
54		55
55	def get_nvr_rpms(self, nvr, rpm_dir, arches=None, debuginfo=False, src=False):	56		def get_nvr_rpms(self, nvr, rpm_dir, arches=None, debuginfo=False,
		57		src=False):
56	'''Retrieve the RPMs associated with a build NVR into the specified	58		'''Retrieve the RPMs associated with a build NVR into the specified
57	directory.	59		directory.
58		60
59	@param nvr build NVR	61		@param nvr build NVR
60	@param rpm_dir location where to store the RPMs	62		@param rpm_dir location where to store the RPMs
61	@return list of local filenames of the grabbed RPMs	63		@return list of local filenames of the grabbed RPMs
62	@raise TaskotronRemoteError if downloading failed	64		@raise TaskotronRemoteError if downloading failed
63	'''	65		'''
Show All 21 Lines		81	def get_tagged_rpms(self, tag, dest, arches):
85	ksession = self.get_koji_session()	87		ksession = self.get_koji_session()
86	opts = {}	88		opts = {}
87	tag_data = ksession.listTagged(tag, **opts)	89		tag_data = ksession.listTagged(tag, **opts)
88		90
89	nvrs = ["%(nvr)s" % x for x in tag_data]	91		nvrs = ["%(nvr)s" % x for x in tag_data]
90	rpms = []	92		rpms = []
91	for nvr in nvrs:	93		for nvr in nvrs:
92	rpms.append(self.get_nvr_rpms(nvr, dest, arches))	94		rpms.append(self.get_nvr_rpms(nvr, dest, arches))
93	return rpms	95		return rpms
94	No newline at end of file

View Options

libtaskotron/logger.py

Show All 28 Lines
29	log.addHandler(logging.NullHandler())	29		log.addHandler(logging.NullHandler())
30		30
31		31
32	def _log_excepthook(*exc_info):	32		def _log_excepthook(*exc_info):
33	'''Called when an exception is not caught'''	33		'''Called when an exception is not caught'''
34	log.critical(''.join(traceback.format_exception(*exc_info)))	34		log.critical(''.join(traceback.format_exception(*exc_info)))
35		35
36		36
37	def init(name='libtaskotron', level=logging.INFO, stream=True, syslog=False, filelog=None):	37		def init(name='libtaskotron', level=logging.INFO, stream=True, syslog=False,
		38		filelog=None):
38	"""Setup a logger	39		"""Setup a logger
39	@param name name of the logger, 'libtaskotron' is default	40		@param name name of the logger, 'libtaskotron' is default
40	@param level level of logging	41		@param level level of logging
41	@param stream enables logging to stderr	42		@param stream enables logging to stderr
42	@param syslog enables logging to syslog	43		@param syslog enables logging to syslog
43	@param filelog enables logging to a file, the value is the file name	44		@param filelog enables logging to a file, the value is the file name
44	"""	45		"""
45		46
46	# overwrite default except hook	47		# overwrite default except hook
47	sys.excepthook = _log_excepthook	48		sys.excepthook = _log_excepthook
48		49
49	logger = logging.getLogger(name)	50		logger = logging.getLogger(name)
50	logger.setLevel(level)	51		logger.setLevel(level)
51	logger.addHandler(logging.NullHandler())	52		logger.addHandler(logging.NullHandler())
52		53
53	fmt = '[%(name)s:%(filename)s:%(lineno)d] %(asctime)s %(levelname)-7s %(message)s'	54		fmt = '[%(name)s:%(filename)s:%(lineno)d] '\
		55		'%(asctime)s %(levelname)-7s %(message)s'
54	datefmt = '%Y-%m-%d %H:%M:%S'	56		datefmt = '%Y-%m-%d %H:%M:%S'
55	formatter = logging.Formatter(fmt=fmt, datefmt=datefmt)	57		formatter = logging.Formatter(fmt=fmt, datefmt=datefmt)
56		58
57	if stream:	59		if stream:
58	stream_handler = logging.StreamHandler()	60		stream_handler = logging.StreamHandler()
59	stream_handler.setFormatter(formatter)	61		stream_handler.setFormatter(formatter)
60	logger.addHandler(stream_handler)	62		logger.addHandler(stream_handler)
61	logger.debug("doing stream logging")	63		logger.debug("doing stream logging")
62		64
63	if syslog:	65		if syslog:
64	syslog_handler = logging.handlers.SysLogHandler(	66		syslog_handler = logging.handlers.SysLogHandler(address='/dev/log',
65	address='/dev/log', facility=logging.handlers.SysLogHandler.LOG_LOCAL4)	67		facility=logging.handlers.SysLogHandler.LOG_LOCAL4)
66	syslog_handler.setFormatter(formatter)	68		syslog_handler.setFormatter(formatter)
			kparalUnsubmitted Not Done Let's use just two lines here.
67	logger.addHandler(syslog_handler)	69		logger.addHandler(syslog_handler)
68	logger.debug("doing syslog logging")	70		logger.debug("doing syslog logging")
69		71
70	if filelog:	72		if filelog:
71	file_handler = logging.handlers.RotatingFileHandler(filelog,	73		file_handler = logging.handlers.RotatingFileHandler(filelog,
72	maxBytes=500000, backupCount=5)	74		maxBytes=500000, backupCount=5)
73	file_handler.setFormatter(formatter)	75		file_handler.setFormatter(formatter)
			kparalUnsubmitted Not Done Let's use just two lines here.
74	logger.addHandler(file_handler)	76		logger.addHandler(file_handler)
75	logger.debug('doing file logging to %s' % filelog)	77		logger.debug('doing file logging to %s', filelog)
76		78
77	return logger	79		return logger

View Options

libtaskotron/python_utils.py

1	# -- coding: utf-8 --	1		# -- coding: utf-8 --
2	# Copyright 2014, Red Hat, Inc.	2		# Copyright 2014, Red Hat, Inc.
3	# License: GNU General Public License version 2 or later	3		# License: GNU General Public License version 2 or later
4		4
5	'''A collection of convenience methods related to Python base libraries.'''	5		'''A collection of convenience methods related to Python base libraries.'''
6		6
7	import collections	7		import collections
8		8
9		9
10	def listlike(obj):	10		def listlike(obj):
11	'''Return whether the object is iterable (list, tuple, set, etc), but not	11		'''Return whether the object is iterable (list, tuple, set, etc), but not
12	string (which is iterable, but we don't often want to consider it as such).	12		string (which is iterable, but we don't often want to consider it as such).
13	This method is useful e.g. if you want to check that a variable contains	13		This method is useful e.g. if you want to check that a variable contains
14	a list/set/etc of strings.	14		a list/set/etc of strings.
15	'''	15		'''
16	return isinstance(obj, collections.Iterable) and not isinstance(obj,	16		return isinstance(obj, collections.Iterable) and not isinstance(obj,
17	(str, unicode))	17		basestring)
			kparalUnsubmitted Not Done Let's use just two lines here.

View Options

libtaskotron/runner.py

1	import logging	1		import logging
2	import tempfile	2		import tempfile
3	import os.path	3		import os.path
4	import argparse	4		import argparse
5	import imp	5		import imp
6	from jinja2 import Template, Environment	6		from jinja2 import Environment
7	import copy	7		import copy
8		8
9	from libtaskotron import taskyaml	9		from libtaskotron import taskyaml
10	from libtaskotron import logger	10		from libtaskotron import logger
11	from libtaskotron.logger import log	11		from libtaskotron.logger import log
12	from libtaskotron.exceptions import TaskotronYamlError	12		from libtaskotron.exceptions import TaskotronYamlError
13		13
14		14		class Runner(object):
15	class Runner:
16	def __init__(self, taskdata, argdata, workdir=None):	15		def __init__(self, taskdata, argdata, workdir=None):
17	self.taskdata = taskdata	16		self.taskdata = taskdata
18	self.envdata = argdata	17		self.envdata = argdata
19	self.working_data = {}	18		self.working_data = {}
20	self.directives = {}	19		self.directives = {}
21	self.jinja_env = None	20		self.jinja_env = None
22		21
23	if workdir is None:	22		if workdir is None:
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Line(s)		65	for keyval in action_line:
71	rendered_action[action_key][keyval] = rendered_line	70		rendered_action[action_key][keyval] = rendered_line
72		71
73	return rendered_action	72		return rendered_action
74		73
75	def _extract_directive_from_action(self, action):	74		def _extract_directive_from_action(self, action):
76	for key in action:	75		for key in action:
77	if key not in ['name', 'export']:	76		if key not in ['name', 'export']:
78	return key	77		return key
79	raise TaskotronYamlError('no directive found in action %s' % str(action))	78		raise TaskotronYamlError('no directive found in action %s' %
		79		str(action))
80		80
81	def do_single_action(self, action):	81		def do_single_action(self, action):
82	directive_name = self._extract_directive_from_action(action)	82		directive_name = self._extract_directive_from_action(action)
83		83
84	rendered_action = self._render_action(action)	84		rendered_action = self._render_action(action)
85		85
86	self._load_directive(directive_name)	86		self._load_directive(directive_name)
87		87
88	directive_object = self.directives[directive_name]	88		directive_object = self.directives[directive_name]
89	directive_classname = directive_object.directive_class	89		directive_classname = directive_object.directive_class
90		90
91	directive_callable = getattr(directive_object, directive_classname)()	91		directive_callable = getattr(directive_object, directive_classname)()
92		92
93	output = directive_callable.process(rendered_action[directive_name],	93		output = directive_callable.process(rendered_action[directive_name],
94	self.envdata)	94		self.envdata)
95		95
96	if 'export' in action:	96		if 'export' in action:
97	self.working_data[action['export']] = output	97		self.working_data[action['export']] = output
98		98
99	def do_actions(self):	99		def do_actions(self):
100	if 'task' not in self.taskdata or not self.taskdata['task']:	100		if 'task' not in self.taskdata or not self.taskdata['task']:
101	raise TaskotronYamlError("At least one task should be specified in input yaml file")	101		raise TaskotronYamlError("At least one task should be specified"
		102		" in input yaml file")
102		103
103	for action in self.taskdata['task']:	104		for action in self.taskdata['task']:
104	self.do_single_action(action)	105		self.do_single_action(action)
105		106
106	def _validate_input(self):	107		def _validate_input(self):
107	if 'input' not in self.taskdata:	108		if 'input' not in self.taskdata:
108	return	109		return
109		110
110	if not isinstance(self.taskdata['input'], dict):	111		if not isinstance(self.taskdata['input'], dict):
111	raise TaskotronYamlError("Input yaml should contain correct 'input' section")	112		raise TaskotronYamlError("Input yaml should contain correct"
		113		" 'input' section")
112		114
113	if ('args' not in self.taskdata['input']) or not isinstance(self.taskdata['input']['args'], str):	115		if ('args' not in self.taskdata['input']) or not isinstance(
114	raise TaskotronYamlError("Input yaml should contain correct 'args' section")	116		self.taskdata['input']['args'], str):
		117		raise TaskotronYamlError("Input yaml should contain correct"
		118		" 'args' section")
115		119
116	required_input = self.taskdata['input']['args'].split(',')	120		required_input = self.taskdata['input']['args'].split(',')
117		121
118	for arg in required_input:	122		for arg in required_input:
119	if not arg in self.envdata:	123		if not arg in self.envdata:
120	raise TaskotronYamlError('Required input arg %s was not defined' % arg)	124		raise TaskotronYamlError('Required input arg %s '
		125		'was not defined' % arg)
121		126
122	def _validate_env(self):	127		def _validate_env(self):
123	raise NotImplementedError("Environment validation is not yet implemented")	128		raise NotImplementedError("Environment validation is not"
		129		" yet implemented")
124		130
125		131
126	def get_argparser():	132		def get_argparser():
127	parser = argparse.ArgumentParser()	133		parser = argparse.ArgumentParser()
128	parser.add_argument("task", nargs=1, help="task to run")	134		parser.add_argument("task", nargs=1, help="task to run")
129	parser.add_argument("-a", "--arch", choices=["i386", "x86_64", "armhfp", "noarch"], help="""	135		parser.add_argument("-a", "--arch",
130	Architecture to be used; support arches are x86, x86_64, and armhfp.	136		choices=["i386", "x86_64", "armhfp", "noarch"], help=""
131	If omitted, defaults to noarch.	137		"Architecture to be used; support arches are x86,\n"
132	""")	138		"x86_64, and armhfp.\nIf omitted, defaults to noarch.")
133	parser.add_argument("-e", "--envr", help="envr to be used as input")	139		parser.add_argument("-e", "--envr", help="envr to be used as input")
			kparalUnsubmitted Not Done Doesn't this add a lots of whitespace to the help message? I assume we don't want that.
134	parser.add_argument("-t", "--tag", help="koji tag to be used as input")	140		parser.add_argument("-t", "--tag", help="koji tag to be used as input")
135	return parser	141		return parser
136		142
137		143
138	def main():	144		def main():
139	parser = get_argparser()	145		parser = get_argparser()
140	args = parser.parse_args()	146		args = parser.parse_args()
141		147
Show All 15 Lines

View Options

setup.py

Show All 11 Lines		7	setup(name='libtaskotron',
12	license='GPLv2+',	12		license='GPLv2+',
13	url='https://bitbucket.org/fedoraqa/libtaskotron-demo',	13		url='https://bitbucket.org/fedoraqa/libtaskotron-demo',
14	packages=['libtaskotron'],	14		packages=['libtaskotron'],
15	package_dir={'libtaskotron':'libtaskotron'},	15		package_dir={'libtaskotron':'libtaskotron'},
16	include_package_data=True,	16		include_package_data=True,
17	entry_points=dict(console_scripts=['runtask=libtaskotron.runner:main']),	17		entry_points=dict(console_scripts=['runtask=libtaskotron.runner:main']),
18	install_requires = [	18		install_requires = [
19	'PyYAML',	19		'PyYAML',
20	]	20		]
21	)	21		)

View Options

testing/conftest.py

Show All 13 Lines
14	# GNU General Public License for more details.	14	# GNU General Public License for more details.
15	#	15	#
16	# You should have received a copy of the GNU General Public License along	16	# You should have received a copy of the GNU General Public License along
17	# with this program; if not, write to the Free Software Foundation, Inc.,	17	# with this program; if not, write to the Free Software Foundation, Inc.,
18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.	18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19	#	19	#
20	# Author: Tim Flink <tflink@redhat.com>	20	# Author: Tim Flink <tflink@redhat.com>
21		21
22	import pytest
23	import re
24
25		22
26	def pytest_addoption(parser):	23	def pytest_addoption(parser):
27	"""	24	"""
28	Add an option to the py.test parser to detect when the functional tests	25	Add an option to the py.test parser to detect when the functional tests
29	should be detected and run	26	should be detected and run
30	"""	27	"""
31		28
32	parser.addoption('--functional', action='store_true', default=False,	29	parser.addoption('--functional', action='store_true', default=False,
Show All 21 Lines

View Options

testing/functest_python_directive.py

1	import os	1	import os
2	import copy	2	import copy
3	from libtaskotron.directives import python_directive	3	from libtaskotron.directives import python_directive
4		4
5		5
6	class TestTaskMethod(object):	6	class TestTaskMethod(object):
7	def setup_method(self, method):	7	def setup_method(self, method):
8	self.ref_taskyaml = 'footask.yml'	8	self.ref_taskyaml = 'footask.yml'
9	self.ref_pyfile = 'some_loadable_test.py'	9	self.ref_pyfile = 'some_loadable_test.py'
10	self.ref_env = {'taskfile': os.path.join(os.path.dirname(os.path.abspath(__file__)), self.ref_taskyaml)}	10	self.ref_env = {'taskfile': os.path.join(os.path.dirname(
		11	os.path.abspath(__file__)), self.ref_taskyaml)}
11	self.test_directive = python_directive.PythonDirective()	12	self.test_directive = python_directive.PythonDirective()
12		13
13	def testfunc_task_method(self):	14	def testfunc_task_method(self):
14	ref_input = {'file': self.ref_pyfile, 'callable': 'task_method'}	15	ref_input = {'file': self.ref_pyfile, 'callable': 'task_method'}
15		16
16	test_output = self.test_directive.process(copy.copy(ref_input), self.ref_env)	17	test_output = self.test_directive.process(copy.copy(ref_input),
		18	self.ref_env)
17		19
18	assert test_output == "I'm a task method!"	20	assert test_output == "I'm a task method!"
19		21
20	def testfunc_class_embedded_call(self):	22	def testfunc_class_embedded_call(self):
21	ref_input = {'file': self.ref_pyfile, 'callable': 'embedded_task_target'}	23	ref_input = {'file': self.ref_pyfile,
		24	'callable': 'embedded_task_target'}
22		25
23	test_output = self.test_directive.process(copy.copy(ref_input), self.ref_env)	26	test_output = self.test_directive.process(copy.copy(ref_input),
		27	self.ref_env)
24		28
25	assert test_output == "I'm a __call__ method in a class!"	29	assert test_output == "I'm a __call__ method in a class!"
26		30
27	def testfunc_class_target(self):	31	def testfunc_class_target(self):
28	ref_input = {'file': self.ref_pyfile, 'callable': 'task_class_target'}	32	ref_input = {'file': self.ref_pyfile, 'callable': 'task_class_target'}
29		33
30	test_output = self.test_directive.process(copy.copy(ref_input), self.ref_env)	34	test_output = self.test_directive.process(copy.copy(ref_input),
		35	self.ref_env)
31		36
32	assert test_output == "I'm a task class method!"	37	assert test_output == "I'm a task class method!"

View Options

testing/test_koji_directive.py

1	import pytest
2	from dingus import Dingus	1		from dingus import Dingus
3		2
4	from libtaskotron.directives import koji_directive	3		from libtaskotron.directives import koji_directive
5		4
6	class TestKojiDirective():	5		class TestKojiDirective():
7	def setup_method(self, method):	6		def setup_method(self, method):
8	self.ref_nvr = 'foo-1.2-3.fc99'	7		self.ref_nvr = 'foo-1.2-3.fc99'
9	self.ref_arch = 'noarch'	8		self.ref_arch = 'noarch'
10	self.ref_tag = 'tagfoo'	9		self.ref_tag = 'tagfoo'
11	self.ref_name = 'foo'	10		self.ref_name = 'foo'
12	self.ref_version = '1.2'	11		self.ref_version = '1.2'
13	self.ref_release = '3.fc99'	12		self.ref_release = '3.fc99'
14	self.ref_buildid = 123456	13		self.ref_buildid = 123456
15		14
16	self.ref_build = {'package_name':self.ref_name, 'version':self.ref_version,	15		self.ref_build = {'package_name': self.ref_name,
17	'release':self.ref_release, 'id': self.ref_buildid}	16		'version': self.ref_version,
		17		'release': self.ref_release,
		18		'id': self.ref_buildid}
18		19
19	self.ref_rpms = [{'name':self.ref_name, 'version':self.ref_version, 'release':self.ref_release, 'nvr':self.ref_nvr, 'arch':self.ref_arch},	20		self.ref_rpms = [{'name': self.ref_name, 'version': self.ref_version,
20	{'name':self.ref_name, 'version':self.ref_version, 'release':self.ref_release, 'nvr':self.ref_nvr, 'arch':'src'}]	21		'release': self.ref_release, 'nvr': self.ref_nvr,
		22		'arch': self.ref_arch},
		23		{'name': self.ref_name, 'version': self.ref_version,
		24		'release': self.ref_release, 'nvr': self.ref_nvr,
		25		'arch': 'src'}]
21		26
22	self.ref_tagged = [{'nvr': self.ref_nvr}]	27		self.ref_tagged = [{'nvr': self.ref_nvr}]
23		28
24	self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm' % self.ref_nvr	29		self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm'\
		30		% self.ref_nvr
25	self.helper = koji_directive.KojiDirective()	31		self.helper = koji_directive.KojiDirective()
			kparalUnsubmitted Not Done Personally, I would use self.ref_url = ('http://downloads.example.com/builds/%s.noarch.rpm' % self.ref_nvr) The URL seems to be more readable this way.
26		32
27	def test_parse_download_command(self):	33		def test_parse_download_command(self):
28	self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm' % (self.ref_nvr, self.ref_arch)]	34		self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm'
		35		% (self.ref_nvr, self.ref_arch)]
29		36
30	ref_input = {'action': 'download', 'arch': self.ref_arch, 'envr': self.ref_nvr}	37		ref_input = {'action': 'download', 'arch': self.ref_arch,
31	ref_envdata = {'workdir':'/var/tmp/foo'}	38		'envr': self.ref_nvr}
		39		ref_envdata = {'workdir': '/var/tmp/foo'}
32		40
33	stub_koji = Dingus(get_nvr_rpms__returns = self.ref_rpms)	41		stub_koji = Dingus(get_nvr_rpms__returns = self.ref_rpms)
34		42
35	test_helper = koji_directive.KojiDirective(stub_koji)	43		test_helper = koji_directive.KojiDirective(stub_koji)
36		44
37	test_helper.process(ref_input, ref_envdata)	45		test_helper.process(ref_input, ref_envdata)
38		46
39	getrpm_calls = stub_koji.calls()	47		getrpm_calls = stub_koji.calls()
40	requested_nvr = getrpm_calls[0][1][0]	48		requested_nvr = getrpm_calls[0][1][0]
41		49
42	assert len(getrpm_calls) == 1	50		assert len(getrpm_calls) == 1
43	assert requested_nvr == self.ref_nvr	51		assert requested_nvr == self.ref_nvr
44		52
45	def test_parse_download_tag_command(self):	53		def test_parse_download_tag_command(self):
46	self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm' % (self.ref_nvr, self.ref_arch)]	54		self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm'
		55		% (self.ref_nvr, self.ref_arch)]
47		56
48	ref_input = {'action': 'download_tag', 'arch': self.ref_arch, 'tag': self.ref_tag}	57		ref_input = {'action': 'download_tag', 'arch': self.ref_arch,
49	ref_envdata = {'workdir':'/var/tmp/foo'}	58		'tag': self.ref_tag}
		59		ref_envdata = {'workdir': '/var/tmp/foo'}
50		60
51	stub_koji = Dingus(get_tagged_rpms__returns=self.ref_rpms)	61		stub_koji = Dingus(get_tagged_rpms__returns=self.ref_rpms)
52		62
53	test_helper = koji_directive.KojiDirective(stub_koji)	63		test_helper = koji_directive.KojiDirective(stub_koji)
54		64
55	test_helper.process(ref_input, ref_envdata)	65		test_helper.process(ref_input, ref_envdata)
56		66
57	getrpm_calls = stub_koji.calls()	67		getrpm_calls = stub_koji.calls()
58	requested_tag = getrpm_calls[0][1][0]	68		requested_tag = getrpm_calls[0][1][0]
59		69
60	assert len(getrpm_calls) == 1	70		assert len(getrpm_calls) == 1
61	assert requested_tag == self.ref_tag	71		assert requested_tag == self.ref_tag

View Options

testing/test_koji_utils.py

1	import pytest	1		import pytest
2	from dingus import Dingus	2		from dingus import Dingus
3		3
4	from libtaskotron import koji_utils	4		from libtaskotron import koji_utils
5		5
6	class TestKojiClient():	6		class TestKojiClient():
7	def setup_method(self, method):	7		def setup_method(self, method):
8	self.ref_nvr = 'foo-1.2-3.fc99'	8		self.ref_nvr = 'foo-1.2-3.fc99'
9	self.ref_arch = 'noarch'	9		self.ref_arch = 'noarch'
10	self.ref_name = 'foo'	10		self.ref_name = 'foo'
11	self.ref_version = '1.2'	11		self.ref_version = '1.2'
12	self.ref_release = '3.fc99'	12		self.ref_release = '3.fc99'
13	self.ref_buildid = 123456	13		self.ref_buildid = 123456
14		14
15	self.ref_build = {'package_name':self.ref_name, 'version':self.ref_version,	15		self.ref_build = {'package_name': self.ref_name,
16	'release':self.ref_release, 'id': self.ref_buildid}	16		'version': self.ref_version,
17		17		'release': self.ref_release,
18	self.ref_rpms = [{'name':self.ref_name, 'version':self.ref_version, 'release':self.ref_release, 'nvr':self.ref_nvr, 'arch':self.ref_arch},	18		'id': self.ref_buildid}
19	{'name':self.ref_name, 'version':self.ref_version, 'release':self.ref_release, 'nvr':self.ref_nvr, 'arch':'src'}]	19
20		20		self.ref_rpms = [{'name': self.ref_name, 'version': self.ref_version,
21	self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm' % self.ref_nvr	21		'release': self.ref_release, 'nvr': self.ref_nvr,
		22		'arch': self.ref_arch},
		23		{'name': self.ref_name, 'version': self.ref_version,
		24		'release': self.ref_release, 'nvr': self.ref_nvr,
		25		'arch': 'src'}]
		26
		27		self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm' \
		28		% self.ref_nvr
22	self.helper = koji_utils.KojiClient()	29		self.helper = koji_utils.KojiClient()
			kparalUnsubmitted Not Done Ditto.
23		30
24	def test_get_noarch_rpmurls_from_nvr(self):	31		def test_get_noarch_rpmurls_from_nvr(self):
25	stub_koji = Dingus(getBuild__returns = self.ref_build, listRPMs__returns = self.ref_rpms)	32		stub_koji = Dingus(getBuild__returns = self.ref_build,
		33		listRPMs__returns = self.ref_rpms)
26		34
27	test_koji = koji_utils.KojiClient(stub_koji)	35		test_koji = koji_utils.KojiClient(stub_koji)
28		36
29	test_urls = test_koji.nvr_to_urls(self.ref_nvr)	37		test_urls = test_koji.nvr_to_urls(self.ref_nvr)
30		38
31	koji_baseurl = koji_utils.PKG_URL	39		koji_baseurl = koji_utils.PKG_URL
32	ref_urls = ['%s/%s/%s/%s/%s/%s.%s.rpm' % (koji_baseurl, self.ref_name, self.ref_version, self.ref_release, self.ref_arch, self.ref_nvr, self.ref_arch),	40		ref_urls = ['%s/%s/%s/%s/%s/%s.%s.rpm' % (koji_baseurl, self.ref_name,
33	'%s/%s/%s/%s/src/%s.src.rpm' % (koji_baseurl, self.ref_name, self.ref_version, self.ref_release, self.ref_nvr),	41		self.ref_version, self.ref_release, self.ref_arch,
		42		self.ref_nvr, self.ref_arch),
		43		'%s/%s/%s/%s/src/%s.src.rpm' % (koji_baseurl, self.ref_name,
		44		self.ref_version, self.ref_release, self.ref_nvr),
34	]	45		]
35		46
36	assert test_urls == ref_urls	47		assert test_urls == ref_urls
37		48
38	def should_i386_rpmurls_query_i686(self):	49		def should_i386_rpmurls_query_i686(self):
39	self.ref_arch = 'i386'	50		self.ref_arch = 'i386'
40		51
41	stub_koji = Dingus(getBuild__returns = self.ref_build)	52		stub_koji = Dingus(getBuild__returns = self.ref_build)
42		53
43	test_koji = koji_utils.KojiClient(stub_koji)	54		test_koji = koji_utils.KojiClient(stub_koji)
44		55
45	# this isn't setup to actually return urls since we don't care about that for this test	56		# this isn't setup to actually return urls since we don't care about
		57		# that for this test
46	# it should throw an exception in this case.	58		# it should throw an exception in this case.
47	try:	59		try:
48	test_koji.nvr_to_urls(self.ref_nvr, arches = [self.ref_arch])	60		test_koji.nvr_to_urls(self.ref_nvr, arches = [self.ref_arch])
49	except Exception:	61		except Exception:
50	pass	62		pass
51		63
52	listrpm_calls = stub_koji.calls('listRPMs')	64		listrpm_calls = stub_koji.calls('listRPMs')
53	requested_arches = listrpm_calls[0][2]['arches']	65		requested_arches = listrpm_calls[0][2]['arches']
Show All 12 Lines

View Options

testing/test_python_directive.py

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Line(s)		48	def test_task_method_is_found(self, monkeypatch):
52		52
53	stub_getattr = Dingus()	53		stub_getattr = Dingus()
54		54
55	test_directive = python_directive.PythonDirective()	55		test_directive = python_directive.PythonDirective()
56	monkeypatch.setattr(test_directive, '_do_getattr', stub_getattr)	56		monkeypatch.setattr(test_directive, '_do_getattr', stub_getattr)
57		57
58	test_directive.execute(ref_modulename, ref_methodname, ref_kwargs)	58		test_directive.execute(ref_modulename, ref_methodname, ref_kwargs)
59		59
60	assert (stub_getattr.calls()[0].name, stub_getattr.calls()[0].args) == ('()', (ref_modulename, ref_methodname))	60		assert (stub_getattr.calls()[0].name, stub_getattr.calls()[0].args) == (
		61		'()', (ref_modulename, ref_methodname))
61		62
62	def test_task_method_is_executed(self, monkeypatch):	63		def test_task_method_is_executed(self, monkeypatch):
63	ref_modulename = 'foo'	64		ref_modulename = 'foo'
64	ref_methodname = 'bar'	65		ref_methodname = 'bar'
65	ref_kwargs = {'baz': 'why', 'blah': 2}	66		ref_kwargs = {'baz': 'why', 'blah': 2}
66		67
67	stub_getattr = Dingus()	68		stub_getattr = Dingus()
68		69
69	test_directive = python_directive.PythonDirective()	70		test_directive = python_directive.PythonDirective()
70	monkeypatch.setattr(test_directive, '_do_getattr', stub_getattr)	71		monkeypatch.setattr(test_directive, '_do_getattr', stub_getattr)
71		72
72	test_directive.execute(ref_modulename, ref_methodname, ref_kwargs)	73		test_directive.execute(ref_modulename, ref_methodname, ref_kwargs)
73		74
74	assert (stub_getattr.calls()[1].name, stub_getattr.calls()[1].args, stub_getattr.calls()[1].kwargs) == ('()', (), (ref_kwargs))	75		assert (stub_getattr.calls()[1].name, stub_getattr.calls()[1].args,
		76		stub_getattr.calls()[1].kwargs) == ('()', (), ref_kwargs)
75		77
76		78
77	class TestProcess(object):	79		class TestProcess(object):
78		80
79	def setup_method(self, method):	81		def setup_method(self, method):
80		82
81	self.ref_taskyaml = '/path/to/foo/footask.yml'	83		self.ref_taskyaml = '/path/to/foo/footask.yml'
82	self.ref_input = {'file': 'foo.py', 'callable': 'bar', 'kwarg1': 'baz'}	84		self.ref_input = {'file': 'foo.py', 'callable': 'bar', 'kwarg1': 'baz'}
83	self.ref_env = {'taskfile': self.ref_taskyaml}	85		self.ref_env = {'taskfile': self.ref_taskyaml}
84	self.ref_pyfile = os.path.join(os.path.dirname(self.ref_taskyaml), self.ref_input['file'])	86		self.ref_pyfile = os.path.join(os.path.dirname(self.ref_taskyaml),
		87		self.ref_input['file'])
85		88
86	self.stub_checkfile = Dingus('checkfile')	89		self.stub_checkfile = Dingus('checkfile')
87	self.stub_imported = Dingus('imported')	90		self.stub_imported = Dingus('imported')
88	self.stub_pyload = Dingus('pyload', dostuff__returns=('name', self.stub_imported))	91		self.stub_pyload = Dingus('pyload', dostuff__returns=('name',
		92		self.stub_imported))
89	self.stub_execute = Dingus('execute')	93		self.stub_execute = Dingus('execute')
90		94
91	def test_process_checks_file(self, monkeypatch):	95		def test_process_checks_file(self, monkeypatch):
92		96
93		97
94	test_directive = python_directive.PythonDirective()	98		test_directive = python_directive.PythonDirective()
95	monkeypatch.setattr(test_directive, 'checkfile', self.stub_checkfile)	99		monkeypatch.setattr(test_directive, 'checkfile', self.stub_checkfile)
96	monkeypatch.setattr(test_directive, 'load_pyfile', self.stub_pyload.dostuff)	100		monkeypatch.setattr(test_directive, 'load_pyfile',
		101		self.stub_pyload.dostuff)
97	monkeypatch.setattr(test_directive, 'execute', self.stub_execute)	102		monkeypatch.setattr(test_directive, 'execute', self.stub_execute)
98		103
99	test_output = test_directive.process(copy.copy(self.ref_input), self.ref_env)	104		test_directive.process(copy.copy(self.ref_input),
		105		self.ref_env)
100		106
101	checkfile_call = self.stub_checkfile.calls[0]	107		checkfile_call = self.stub_checkfile.calls[0]
102		108
103		109		assert (checkfile_call.name, checkfile_call.args,
104	assert (checkfile_call.name, checkfile_call.args, checkfile_call.kwargs) == ('()', (self.ref_pyfile,), {})	110		checkfile_call.kwargs) == ('()', (self.ref_pyfile,), {})
105		111
106	def test_process_loads_file(self, monkeypatch):	112		def test_process_loads_file(self, monkeypatch):
107		113
108	test_directive = python_directive.PythonDirective()	114		test_directive = python_directive.PythonDirective()
109	monkeypatch.setattr(test_directive, 'checkfile', self.stub_checkfile)	115		monkeypatch.setattr(test_directive, 'checkfile', self.stub_checkfile)
110	monkeypatch.setattr(test_directive, 'load_pyfile', self.stub_pyload.dostuff)	116		monkeypatch.setattr(test_directive, 'load_pyfile',
		117		self.stub_pyload.dostuff)
111	monkeypatch.setattr(test_directive, 'execute', self.stub_execute)	118		monkeypatch.setattr(test_directive, 'execute', self.stub_execute)
112		119
113	test_output = test_directive.process(copy.copy(self.ref_input), self.ref_env)	120		test_directive.process(copy.copy(self.ref_input),
		121		self.ref_env)
114		122
115	pyload_call = self.stub_pyload.calls[0]	123		pyload_call = self.stub_pyload.calls[0]
116		124
117	assert (pyload_call.name, pyload_call.args, pyload_call.kwargs) == ('dostuff', (self.ref_pyfile,), {})	125		assert (pyload_call.name, pyload_call.args, pyload_call.kwargs) == (
		126		'dostuff', (self.ref_pyfile,), {})
118		127
119	def test_process_executes(self, monkeypatch):	128		def test_process_executes(self, monkeypatch):
120		129
121	ref_kwargs = {'kwarg1': 'baz'}	130		ref_kwargs = {'kwarg1': 'baz'}
122		131
123	test_directive = python_directive.PythonDirective()	132		test_directive = python_directive.PythonDirective()
124	monkeypatch.setattr(test_directive, 'checkfile', self.stub_checkfile)	133		monkeypatch.setattr(test_directive, 'checkfile', self.stub_checkfile)
125	monkeypatch.setattr(test_directive, 'load_pyfile', self.stub_pyload.dostuff)	134		monkeypatch.setattr(test_directive, 'load_pyfile',
		135		self.stub_pyload.dostuff)
126	monkeypatch.setattr(test_directive, 'execute', self.stub_execute)	136		monkeypatch.setattr(test_directive, 'execute', self.stub_execute)
127		137
128	test_output = test_directive.process(copy.copy(self.ref_input), self.ref_env)	138		test_directive.process(copy.copy(self.ref_input),
		139		self.ref_env)
129		140
130	execute_call = self.stub_execute.calls[0]	141		execute_call = self.stub_execute.calls[0]
131		142
132	assert (execute_call.name, execute_call.args, execute_call.kwargs) == ('()', (self.stub_imported, self.ref_input['callable'], ref_kwargs), {})	143		assert (execute_call.name, execute_call.args, execute_call.kwargs) == (
133	No newline at end of file	144		'()', (self.stub_imported, self.ref_input['callable'], ref_kwargs), {})
		145		No newline at end of file

View Options

testing/test_python_utils.py

1	# -- coding: utf-8 --	1	# -- coding: utf-8 --
2	# Copyright 2014, Red Hat, Inc.	2	# Copyright 2014, Red Hat, Inc.
3	# License: GNU General Public License version 2 or later	3	# License: GNU General Public License version 2 or later
4		4
5	'''Unit tests for libtaskotron/python_utils.py'''	5	'''Unit tests for libtaskotron/python_utils.py'''
6		6
7	from libtaskotron import python_utils	7	from libtaskotron import python_utils
8		8
9	class TestPythonUtils:	9	class TestPythonUtils:
10		10
11	def test_listlike_true(self):	11	def test_listlike_true(self):
12	'''Test 'listlike' method when it returns True'''	12	'''Test 'listlike' method when it returns True'''
13	assert python_utils.listlike([1, 2])	13	assert python_utils.listlike([1, 2])
14	assert python_utils.listlike(['a', 'b'])	14	assert python_utils.listlike(['a', 'b'])
15	assert python_utils.listlike(('foo',))	15	assert python_utils.listlike(('foo',))
16	assert python_utils.listlike(set(('foo','bar','baz')))	16	assert python_utils.listlike({'foo', 'bar', 'baz'})
17	assert python_utils.listlike(set())	17	assert python_utils.listlike(set())
18	assert python_utils.listlike(())	18	assert python_utils.listlike(())
19	assert python_utils.listlike([u'foo', u'bar'])	19	assert python_utils.listlike([u'foo', u'bar'])
20	assert python_utils.listlike({'a': 1, 'b': 2})	20	assert python_utils.listlike({'a': 1, 'b': 2})
21		21
22	def test_listlike_false(self):	22	def test_listlike_false(self):
23	'''Test 'listlike' method when it returns False'''	23	'''Test 'listlike' method when it returns False'''
24	assert not python_utils.listlike('a')	24	assert not python_utils.listlike('a')
25	assert not python_utils.listlike(u'a')	25	assert not python_utils.listlike(u'a')
26	assert not python_utils.listlike(unicode('foo'))	26	assert not python_utils.listlike(unicode('foo'))
27	assert not python_utils.listlike(3)	27	assert not python_utils.listlike(3)
28	assert not python_utils.listlike(3.14)	28	assert not python_utils.listlike(3.14)
29	assert not python_utils.listlike(None)	29	assert not python_utils.listlike(None)
30	assert not python_utils.listlike(object())	30	assert not python_utils.listlike(object())

View Options

testing/test_runner.py

1	import pytest	1		import pytest
2	import os	2		import os
3	import sys	3		import sys
4		4
5	from libtaskotron import runner	5		from libtaskotron import runner
6	from libtaskotron.exceptions import TaskotronYamlError	6		from libtaskotron.exceptions import TaskotronYamlError
7		7
8		8
9	class TestRunnerInputVerify():	9		class TestRunnerInputVerify():
10	def test_yamlrunner_valid_input(self):	10		def test_yamlrunner_valid_input(self):
11	ref_cmd = '-e foo-1.2-3.fc99 -a x86_64 footask.yml'	11		ref_cmd = '-e foo-1.2-3.fc99 -a x86_64 footask.yml'
12	ref_argdata = {'input': {'args': 'envr,arch'}}	12		ref_argdata = {'input': {'args': 'envr,arch'}}
13	ref_data = {'envr': 'foo-1.2-3.fc99', 'arch': 'x86_64', 'taskfile': 'footask.yml'}
14		13
15	test_parser = runner.get_argparser()	14		test_parser = runner.get_argparser()
16	test_args = vars(test_parser.parse_args(ref_cmd.split()))	15		test_args = vars(test_parser.parse_args(ref_cmd.split()))
17		16
18	test_runner = runner.Runner(ref_argdata, test_args)	17		test_runner = runner.Runner(ref_argdata, test_args)
19		18
20	test_runner._validate_input()	19		test_runner._validate_input()
21		20
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Line(s)		93	def test_trivial_creation(self, tmpdir):
99	ref_inputdata = {}	98		ref_inputdata = {}
100		99
101	test_runner = runner.Runner(ref_taskdata, ref_inputdata, tmpdir)	100		test_runner = runner.Runner(ref_taskdata, ref_inputdata, tmpdir)
102		101
103	assert test_runner.taskdata == ref_taskdata	102		assert test_runner.taskdata == ref_taskdata
104		103
105	class TestRunnerPrep():	104		class TestRunnerPrep():
106	def test_prep_invalid_commands(self, tmpdir):	105		def test_prep_invalid_commands(self, tmpdir):
107	ref_taskdata = {'preparation': {'turboencabulator':'reduce sinusoidal repleneration'}}	106		ref_taskdata = {'preparation': {'turboencabulator':
		107		'reduce sinusoidal repleneration'}}
108	ref_inputdata = {}	108		ref_inputdata = {}
109		109
110	test_runner = runner.Runner(ref_taskdata, ref_inputdata, tmpdir)	110		test_runner = runner.Runner(ref_taskdata, ref_inputdata, tmpdir)
111		111
112	with pytest.raises(Exception):	112		with pytest.raises(Exception):
113	test_runner.do_prep()	113		test_runner.do_prep()
114		114
115	class TestRunnerDirectiveLoader():	115		class TestRunnerDirectiveLoader():
Show All 33 Lines		148	class TestRunnerSingleAction():
149		149
150	def setup_method(self, method):	150		def setup_method(self, method):
151	self.ref_taskdata = {}	151		self.ref_taskdata = {}
152	self.ref_inputdata = {}	152		self.ref_inputdata = {}
153		153
154	def test_runner_extract_directive_name(self):	154		def test_runner_extract_directive_name(self):
155	ref_directivename = 'dummy'	155		ref_directivename = 'dummy'
156	ref_action = {'name': 'test action',	156		ref_action = {'name': 'test action',
157	ref_directivename: {'result': 'pass', 'msg': 'dummy message'}}	157		ref_directivename: {'result': 'pass',
		158		'msg': 'dummy message'}}
158		159
159	test_runner = runner.Runner(self.ref_taskdata, self.ref_inputdata)	160		test_runner = runner.Runner(self.ref_taskdata, self.ref_inputdata)
160		161
161	test_directivename = test_runner._extract_directive_from_action(ref_action)	162		test_directivename = test_runner._extract_directive_from_action(
		163		ref_action)
162		164
163	assert test_directivename == ref_directivename	165		assert test_directivename == ref_directivename
164		166
165	def test_runner_single_dummy_action_pass(self):	167		def test_runner_single_dummy_action_pass(self):
166	ref_action = {'dummy': {'result': 'pass'}}	168		ref_action = {'dummy': {'result': 'pass'}}
167	ref_action.update({'name': 'Dummy Action' })	169		ref_action.update({'name': 'Dummy Action' })
168		170
169	test_runner = runner.Runner(self.ref_taskdata, self.ref_inputdata)	171		test_runner = runner.Runner(self.ref_taskdata, self.ref_inputdata)
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Line(s)		286	class TestRunnerRenderAction():
285		287
286	def setup_method(self, method):	288		def setup_method(self, method):
287	self.ref_taskdata = {}	289		self.ref_taskdata = {}
288	self.ref_inputdata = {}	290		self.ref_inputdata = {}
289		291
290	def test_runner_render_single_variable(self):	292		def test_runner_render_single_variable(self):
291	ref_message = 'This is a variable message'	293		ref_message = 'This is a variable message'
292	ref_messagename = 'variable_messsage'	294		ref_messagename = 'variable_messsage'
293	ref_action = {'name': 'test dummy action', 'dummy': {'result': 'pass', 'msg': '{{ %s }}' % ref_messagename}}	295		ref_action = {'name': 'test dummy action', 'dummy':
		296		{'result': 'pass', 'msg': '{{ %s }}' % ref_messagename}}
294		297
			kparalUnsubmitted Not Done This is actually longer than 80 chars.
295	test_runner = runner.Runner(self.ref_taskdata, self.ref_inputdata)	298		test_runner = runner.Runner(self.ref_taskdata, self.ref_inputdata)
296	test_runner.working_data[ref_messagename] = ref_message	299		test_runner.working_data[ref_messagename] = ref_message
297		300
298	test_rendered_action = test_runner._render_action(ref_action)	301		test_rendered_action = test_runner._render_action(ref_action)
299		302
300	assert test_rendered_action['dummy']['msg'] == ref_message	303		assert test_rendered_action['dummy']['msg'] == ref_message
301		304
302		305

Reformat all files to conform with PEP8
ClosedPublic
Actions

Details

Diff Detail

Revision Contents

Diff 84

libtaskotron/directives/createrepo_directive.py

libtaskotron/directives/dummy_directive.py

libtaskotron/directives/koji_directive.py

libtaskotron/directives/python_directive.py

libtaskotron/file_utils.py

libtaskotron/koji_utils.py

libtaskotron/logger.py

libtaskotron/python_utils.py

libtaskotron/runner.py

setup.py

testing/conftest.py

testing/functest_python_directive.py

testing/test_koji_directive.py

testing/test_koji_utils.py

testing/test_python_directive.py

testing/test_python_utils.py

testing/test_runner.py

Reformat all files to conform with PEP8ClosedPublicActions

Details

Diff Detail

Revision Contents

Diff 84

libtaskotron/directives/createrepo_directive.py

libtaskotron/directives/dummy_directive.py

libtaskotron/directives/koji_directive.py

libtaskotron/directives/python_directive.py

libtaskotron/file_utils.py

libtaskotron/koji_utils.py

libtaskotron/logger.py

libtaskotron/python_utils.py

libtaskotron/runner.py

setup.py

testing/conftest.py

testing/functest_python_directive.py

testing/test_koji_directive.py

testing/test_koji_utils.py

testing/test_python_directive.py

testing/test_python_utils.py

testing/test_runner.py

Reformat all files to conform with PEP8
ClosedPublic
Actions