Differential D109

operate on arches and input args as with lists, not CSV-strings
ClosedPublic
Actions

Authored by kparal on May 27 2014, 11:46 AM.

Details

Reviewers
tflink
mkrizek
jskladan
Commits
rLTRN0b5101425486: handle arches and input args as lists, not CSV-strings
Summary

This reverts a hack introduced in 052595dc (T156, D81). Once T169 has
been fixed, we can now use proper objects and don't need to simulate
lists with CSV structures. This patch converts task input args and
--arch cmdline option to behave as lists.

Depends on D108.

Test Plan

Tests adjusted and pass.

Diff Detail

Repository
rLTRN libtaskotron
Lint
Lint Skipped
Unit
Unit Tests Skipped
kparal retitled this revision from to operate on arches and input args as with lists, not CSV-strings.May 27 2014, 11:46 AM
kparal updated this object.
kparal edited the test plan for this revision. (Show Details)
kparal added reviewers: mkrizek, tflink, jskladan.
kparal added a dependency: D108: Make task YAML file support non-string (and nested) variables.
kparal added a comment.May 27 2014, 11:56 AM

This will require the checks to abandon this syntax:

input:
    args: envr,arch

And use this:

input:
    args: 
        - envr
        - arch

or this:

input:
    args: [envr, arch]

That will be in line with the rest of the YAML structure.

kparal updated this revision to Diff 305.May 27 2014, 12:02 PM
  • fix documentation
mkrizek accepted this revision.May 27 2014, 1:04 PM

Looks good to me

This revision is now accepted and ready to land.May 27 2014, 1:04 PM
tflink accepted this revision.May 27 2014, 1:51 PM

Looks good to me.

It occurs to me that we're going to have to do a task audit with the changes from this and D108 to make sure that the syntax is updated everywhere.

kparal closed this revision.May 27 2014, 2:43 PM
kparal updated this revision to Diff 309.

Closed by commit rLTRN0b5101425486 (authored by @kparal).

Revision Contents

Diff 309

View Options

docs/source/taskyaml.rst

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Line(s)
44----- 44​-----
45 45​
46Most tasks require some form of input. The required input must be declared in 46​Most tasks require some form of input. The required input must be declared in
47order to verify that the task can be run 47​order to verify that the task can be run
48 48​
49.. code-block:: yaml 49​.. code-block:: yaml
50 50​
51 input: 51​ input:
52 args: arch,envr 52​ args:
53​ - arch
54​ - envr
53 55​
54Valid args include: 56​Valid args include:
55 57​
56 * arch 58​ * arch
57 * envr 59​ * envr
58 * bodhi_id 60​ * bodhi_id
59 * koji_tag 61​ * koji_tag
60 62​
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines
View Options

docs/source/writingtasks.rst

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Line(s)
95.. code-block:: yaml 95​.. code-block:: yaml
96 96​
97 --- 97​ ---
98 name: mytask 98​ name: mytask
99 desc: do something stupendous 99​ desc: do something stupendous
100 maintainer: somefasuser 100​ maintainer: somefasuser
101 101​
102 input: 102​ input:
103 args: arch,bodhi_id 103​ args:
104​ - arch
105​ - bodhi_id
104 106​
105 environment: 107​ environment:
106 rpm: 108​ rpm:
107 - libtaskotron 109​ - libtaskotron
108 110​
109 111​
110Executed Task Information 112​Executed Task Information
111------------------------- 113​-------------------------
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Line(s)239Now if we run the task we get output that ends with::
239 [libtaskotron:resultsdb_directive.py:123] 2014-05-15 09:17:44 INFO Reporting to ResultsDB is disabled. 241​ [libtaskotron:resultsdb_directive.py:123] 2014-05-15 09:17:44 INFO Reporting to ResultsDB is disabled.
240 INFO:libtaskotron:Reporting to ResultsDB is disabled. 242​ INFO:libtaskotron:Reporting to ResultsDB is disabled.
241 [libtaskotron:runner.py:198] 2014-05-15 09:17:44 INFO 243​ [libtaskotron:runner.py:198] 2014-05-15 09:17:44 INFO
242 TAP version 13 244​ TAP version 13
243 1..1 245​ 1..1
244 ok - $CHECKNAME for Bodhi update openvswitch-2.1.2-1.fc19 246​ ok - $CHECKNAME for Bodhi update openvswitch-2.1.2-1.fc19
245 --- 247​ ---
246 details: 248​ details:
247 output: " foo-1.2-3.fc99.x86_64.rpm" 249​ output: "foo-1.2-3.fc99.x86_64.rpm"
248 item: foo-1.2-3.fc99 250​ item: foo-1.2-3.fc99
249 outcome: PASSED 251​ outcome: PASSED
250 summary: mycheck PASSED for foo-1.2-3.fc99 252​ summary: mycheck PASSED for foo-1.2-3.fc99
251 type: bodhi_update 253​ type: bodhi_update
252 ... 254​ ...
253 255​
254.. note:: 256​.. note::
255 Reporting is disabled in the default configuration for Taskotron. While it is 257​ Reporting is disabled in the default configuration for Taskotron. While it is
Show All 9 Lines
View Options

libtaskotron/directives/bodhi_directive.py

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Line(s)72 if action == 'download':
73 if 'bodhi_id' not in input_data or 'arch' not in input_data: 73​ if 'bodhi_id' not in input_data or 'arch' not in input_data:
74 detected_args = ', '.join(input_data.keys()) 74​ detected_args = ', '.join(input_data.keys())
75 raise TaskotronDirectiveError("The bodhi directive 'download'" 75​ raise TaskotronDirectiveError("The bodhi directive 'download'"
76 " requires both 'bodhi_id' and" 76​ " requires both 'bodhi_id' and"
77 " 'arch' arguments. Detected arguments: %s" % detected_args) 77​ " 'arch' arguments. Detected arguments: %s" % detected_args)
78 78​
79 workdir = env_data['workdir'] 79​ workdir = env_data['workdir']
80 update = input_data['bodhi_id'] 80​ update = input_data['bodhi_id']
81 if input_data['arch'] == 'all': 81​ if 'all' in input_data['arch']:
82 arches = ['i386', 'x86_64', 'noarch', 'armhfp'] 82​ arches = ['i386', 'x86_64', 'noarch', 'armhfp']
83 else: 83​ else:
84 arches = [arch.strip() for arch in input_data['arch'].split(',')] 84​ arches = input_data['arch']
85 if 'noarch' not in arches and arches != ['src']: 85​ if 'noarch' not in arches and arches != ['src']:
86 arches.append('noarch') 86​ arches.append('noarch')
87 87​
88 log.info("getting rpms for update %s (%s) and downloading to %s", 88​ log.info("getting rpms for update %s (%s) and downloading to %s",
89 update, arches, workdir) 89​ update, arches, workdir)
90 90​
91 output_data['downloaded_rpms'] = self.action_download(update, arches, workdir) 91​ output_data['downloaded_rpms'] = self.action_download(update, arches, workdir)
92 92​
93 return output_data 93​ return output_data
View Options

libtaskotron/directives/koji_directive.py

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Line(s)46 raise TaskotronDirectiveError(
47 "The koji directive requires 'arch' as an argument. Detected" 47​ "The koji directive requires 'arch' as an argument. Detected"
48 "arguments: %s" % detected_args) 48​ "arguments: %s" % detected_args)
49 49​
50 if not 'target_dir' in input_data: 50​ if not 'target_dir' in input_data:
51 self.target_dir = env_data['workdir'] 51​ self.target_dir = env_data['workdir']
52 else: 52​ else:
53 self.target_dir = input_data['target_dir'] 53​ self.target_dir = input_data['target_dir']
54 54​
55 self.arches = [arch.strip() for arch in input_data['arch'].split(',')] 55​ self.arches = input_data['arch']
56 56​
57 # https://phab.qadevel.cloud.fedoraproject.org/T155 57​ # https://phab.qadevel.cloud.fedoraproject.org/T155
58 if 'noarch' not in self.arches: 58​ if 'noarch' not in self.arches:
59 self.arches.append('noarch') 59​ self.arches.append('noarch')
60 60​
61 if action == 'download': 61​ if action == 'download':
62 if 'envr' not in input_data: 62​ if 'envr' not in input_data:
63 detected_args = ', '.join(input_data.keys()) 63​ detected_args = ', '.join(input_data.keys())
Show All 27 Lines
View Options

libtaskotron/runner.py

Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Line(s)97 def do_actions(self):
111 for action in self.taskdata['task']: 111​ for action in self.taskdata['task']:
112 self.do_single_action(action) 112​ self.do_single_action(action)
113 113​
114 def _validate_input(self): 114​ def _validate_input(self):
115 if 'input' not in self.taskdata: 115​ if 'input' not in self.taskdata:
116 return 116​ return
117 117​
118 if not isinstance(self.taskdata['input'], dict): 118​ if not isinstance(self.taskdata['input'], dict):
119 raise TaskotronYamlError("Input yaml should contain correct" 119​ raise TaskotronYamlError("Input yaml should contain correct 'input'"
120 " 'input' section") 120​ "section (a dictionary). Yours was: %s" % type(
121​ self.taskdata['input']))
121 122​
122 if ('args' not in self.taskdata['input']) or not isinstance( 123​ required_input = self.taskdata['input'].get('args', None)
123 self.taskdata['input']['args'], str): ​
124 raise TaskotronYamlError("Input yaml should contain correct" ​
125 " 'args' section") ​
126 124​
127 required_input = self.taskdata['input']['args'].split(',') 125​ if not isinstance(required_input, list):
126​ raise TaskotronYamlError("Input yaml should contain correct 'args' "
127​ "section (a list). Yours was: %s" % type(required_input))
128 128​
129 for arg in required_input: 129​ for arg in required_input:
130 if not arg in self.envdata: 130​ if not arg in self.envdata:
131 raise TaskotronYamlError('Required input arg %s ' 131​ raise TaskotronYamlError("Required input arg '%s' "
132 'was not defined' % arg) 132​ "was not defined" % arg)
133 133​
134 def _validate_env(self): 134​ def _validate_env(self):
135 # TODO: implement this 135​ # TODO: implement this
136 raise NotImplementedError("Environment validation is not" 136​ raise NotImplementedError("Environment validation is not"
137 " yet implemented") 137​ " yet implemented")
138 138​
139 139​
140def get_argparser(): 140​def get_argparser():
Show All 28 Lines157def process_args(args):
169 if args['type'] == 'bodhi_id': 169​ if args['type'] == 'bodhi_id':
170 args['bodhi_id'] = args['item'] 170​ args['bodhi_id'] = args['item']
171 if args['type'] == 'koji_tag': 171​ if args['type'] == 'koji_tag':
172 args['tag'] = args['item'] 172​ args['tag'] = args['item']
173 173​
174 # process arch 174​ # process arch
175 if args['arch'] is None: 175​ if args['arch'] is None:
176 args['arch'] = ['noarch'] 176​ args['arch'] = ['noarch']
177 # since lists don't play nice with yaml, convert arch to csv ​
178 # this is a workaround for https://phab.qadevel.cloud.fedoraproject.org/T148 ​
179 args['arch'] = ','.join(args['arch']) ​
180 177​
181 return args 178​ return args
182 179​
183 180​
184def main(): 181​def main():
185 parser = get_argparser() 182​ parser = get_argparser()
186 args = parser.parse_args() 183​ args = parser.parse_args()
187 184​
Show All 19 Lines
View Options

testing/test_bodhi_directive.py

Show All 21 Lines15 def setup_method(self, method):
22 self.ref_nvr2 = 'bar-1.2.3.fc99' 22​ self.ref_nvr2 = 'bar-1.2.3.fc99'
23 self.ref_update = {'title': 'Random update', 23​ self.ref_update = {'title': 'Random update',
24 'builds': [{'nvr': self.ref_nvr1, 'package': {}}, 24​ 'builds': [{'nvr': self.ref_nvr1, 'package': {}},
25 {'nvr': self.ref_nvr2, 'package': {}} 25​ {'nvr': self.ref_nvr2, 'package': {}}
26 ], 26​ ],
27 'other_keys': {} 27​ 'other_keys': {}
28 } 28​ }
29 self.ref_input = {'action': 'download', 29​ self.ref_input = {'action': 'download',
30 'arch': ', '.join(self.ref_arch), 30​ 'arch': self.ref_arch,
31 'bodhi_id': self.ref_bodhi_id 31​ 'bodhi_id': self.ref_bodhi_id
32 } 32​ }
33 self.ref_envdata = {'workdir': self.ref_workdir} 33​ self.ref_envdata = {'workdir': self.ref_workdir}
34 self.ref_rpmfile = '%s/%s.rpm' % (self.ref_workdir, self.ref_nvr1) 34​ self.ref_rpmfile = '%s/%s.rpm' % (self.ref_workdir, self.ref_nvr1)
35 35​
36 self.helper = bodhi_directive.BodhiDirective() 36​ self.helper = bodhi_directive.BodhiDirective()
37 37​
38 38​
Show All 17 Lines39 def test_action_download_existing_update(self):
56 assert requested_nvrs == [self.ref_nvr1, self.ref_nvr2] 56​ assert requested_nvrs == [self.ref_nvr1, self.ref_nvr2]
57 assert output_data == ref_output_data 57​ assert output_data == ref_output_data
58 58​
59 59​
60 def test_action_download_all_archs(self): 60​ def test_action_download_all_archs(self):
61 '''Test download when all arches are demanded''' 61​ '''Test download when all arches are demanded'''
62 self.ref_arch = ['all'] 62​ self.ref_arch = ['all']
63 self.ref_input = {'action': 'download', 63​ self.ref_input = {'action': 'download',
64 'arch': ', '.join(self.ref_arch), 64​ 'arch': self.ref_arch,
65 'bodhi_id': self.ref_bodhi_id 65​ 'bodhi_id': self.ref_bodhi_id
66 } 66​ }
67 67​
68 stub_bodhi = Dingus(query_update__returns = self.ref_update) 68​ stub_bodhi = Dingus(query_update__returns = self.ref_update)
69 stub_koji = Dingus(get_nvr_rpms__returns = [self.ref_rpmfile]) 69​ stub_koji = Dingus(get_nvr_rpms__returns = [self.ref_rpmfile])
70 70​
71 test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji) 71​ test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji)
72 72​
73 test_bodhi.process(self.ref_input, self.ref_envdata) 73​ test_bodhi.process(self.ref_input, self.ref_envdata)
74 74​
75 ref_arches = set(['i386', 'x86_64', 'noarch', 'armhfp']) 75​ ref_arches = set(['i386', 'x86_64', 'noarch', 'armhfp'])
76 getrpms_calls = stub_koji.calls() 76​ getrpms_calls = stub_koji.calls()
77 req_arches = map(lambda x: x[1][2], getrpms_calls) 77​ req_arches = map(lambda x: x[1][2], getrpms_calls)
78 78​
79 # checks whether all get_nvr_rpms calls demanded all arches 79​ # checks whether all get_nvr_rpms calls demanded all arches
80 assert True == all(map(lambda x: set(x) == ref_arches, req_arches)) 80​ assert all(map(lambda x: set(x) == ref_arches, req_arches))
81 81​
82 def test_action_download_source(self): 82​ def test_action_download_source(self):
83 '''Test download of source packages''' 83​ '''Test download of source packages'''
84 self.ref_arch = ['src'] 84​ self.ref_arch = ['src']
85 self.ref_input = {'action': 'download', 85​ self.ref_input = {'action': 'download',
86 'arch': ', '.join(self.ref_arch), 86​ 'arch': self.ref_arch,
87 'bodhi_id': self.ref_bodhi_id 87​ 'bodhi_id': self.ref_bodhi_id
88 } 88​ }
89 89​
90 stub_bodhi = Dingus(query_update__returns = self.ref_update) 90​ stub_bodhi = Dingus(query_update__returns = self.ref_update)
91 stub_koji = Dingus(get_nvr_rpms__returns = [self.ref_rpmfile]) 91​ stub_koji = Dingus(get_nvr_rpms__returns = [self.ref_rpmfile])
92 92​
93 test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji) 93​ test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji)
94 94​
95 test_bodhi.process(self.ref_input, self.ref_envdata) 95​ test_bodhi.process(self.ref_input, self.ref_envdata)
96 96​
97 getrpms_calls = stub_koji.calls() 97​ getrpms_calls = stub_koji.calls()
98 req_arches = map(lambda x: x[1][2], getrpms_calls) 98​ req_arches = map(lambda x: x[1][2], getrpms_calls)
99 99​
100 # checks whether all get_nvr_rpms calls demanded only source pkgs 100​ # checks whether all get_nvr_rpms calls demanded only source pkgs
101 assert all(map(lambda x: x == ['src'], req_arches)) 101​ assert all(map(lambda x: x == ['src'], req_arches))
102 102​
103 def test_action_download_multiple_arch(self): 103​ def test_action_download_multiple_arch(self):
104 '''Test download of multiple arches packages''' 104​ '''Test download of multiple arches packages'''
105 self.ref_arch = ['x86_64', 'noarch'] 105​ self.ref_arch = ['x86_64', 'noarch']
106 self.ref_input = {'action': 'download', 106​ self.ref_input = {'action': 'download',
107 'arch': ', '.join(self.ref_arch), 107​ 'arch': self.ref_arch,
108 'bodhi_id': self.ref_bodhi_id 108​ 'bodhi_id': self.ref_bodhi_id
109 } 109​ }
110 110​
111 stub_bodhi = Dingus(query_update__returns = self.ref_update) 111​ stub_bodhi = Dingus(query_update__returns = self.ref_update)
112 stub_koji = Dingus(get_nvr_rpms__returns = [self.ref_rpmfile]) 112​ stub_koji = Dingus(get_nvr_rpms__returns = [self.ref_rpmfile])
113 113​
114 test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji) 114​ test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji)
115 115​
116 test_bodhi.process(self.ref_input, self.ref_envdata) 116​ test_bodhi.process(self.ref_input, self.ref_envdata)
117 117​
118 getrpms_calls = stub_koji.calls() 118​ getrpms_calls = stub_koji.calls()
119 req_arches = map(lambda x: x[1][2], getrpms_calls) 119​ req_arches = map(lambda x: x[1][2], getrpms_calls)
120 120​
121 # checks whether all get_nvr_rpms calls demanded only source pkgs 121​ # checks whether all get_nvr_rpms calls demanded only source pkgs
122 assert all(map(lambda x: x == ['x86_64', 'noarch'], req_arches)) 122​ assert all(map(lambda x: x == ['x86_64', 'noarch'], req_arches))
123 123​
124 def test_action_download_added_noarch(self): 124​ def test_action_download_added_noarch(self):
125 '''Test whether noarch is automaticaly added''' 125​ '''Test whether noarch is automaticaly added'''
126 self.ref_arch = ['i386'] 126​ self.ref_arch = ['i386']
127 self.ref_input = {'action': 'download', 127​ self.ref_input = {'action': 'download',
128 'arch': ', '.join(self.ref_arch), 128​ 'arch': self.ref_arch,
129 'bodhi_id': self.ref_bodhi_id 129​ 'bodhi_id': self.ref_bodhi_id
130 } 130​ }
131 131​
132 stub_bodhi = Dingus(query_update__returns = self.ref_update) 132​ stub_bodhi = Dingus(query_update__returns = self.ref_update)
133 stub_koji = Dingus(get_nvr_rpms__returns = [self.ref_rpmfile]) 133​ stub_koji = Dingus(get_nvr_rpms__returns = [self.ref_rpmfile])
134 134​
135 test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji) 135​ test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji)
136 136​
137 test_bodhi.process(self.ref_input, self.ref_envdata) 137​ test_bodhi.process(self.ref_input, self.ref_envdata)
138 138​
139 ref_arches = set(['i386', 'noarch']) ​
140 getrpms_calls = stub_koji.calls() 139​ getrpms_calls = stub_koji.calls()
141 req_arches = map(lambda x: x[1][2], getrpms_calls) 140​ req_arches = map(lambda x: x[1][2], getrpms_calls)
142 141​
143 # checks whether noarch is demanded in all get_nvr_rpms calls 142​ # checks whether noarch is demanded in all get_nvr_rpms calls
144 assert all(map(lambda x: 'noarch' in x, req_arches)) 143​ assert all(map(lambda x: 'noarch' in x, req_arches))
145 144​
146 145​
147 def test_action_download_nonexisting_update(self): 146​ def test_action_download_nonexisting_update(self):
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines
View Options

testing/test_koji_directive.py

Show All 16 Lines15 self.ref_build = {'package_name': self.ref_name,
17 'release': self.ref_release, 17​ 'release': self.ref_release,
18 'id': self.ref_buildid} 18​ 'id': self.ref_buildid}
19 19​
20 self.ref_rpms = [{'name': self.ref_name, 'version': self.ref_version, 20​ self.ref_rpms = [{'name': self.ref_name, 'version': self.ref_version,
21 'release': self.ref_release, 'nvr': self.ref_nvr, 21​ 'release': self.ref_release, 'nvr': self.ref_nvr,
22 'arch': self.ref_arch}, 22​ 'arch': self.ref_arch},
23 {'name': self.ref_name, 'version': self.ref_version, 23​ {'name': self.ref_name, 'version': self.ref_version,
24 'release': self.ref_release, 'nvr': self.ref_nvr, 24​ 'release': self.ref_release, 'nvr': self.ref_nvr,
25 'arch': 'src'}] 25​ 'arch': ['src']}]
26 26​
27 self.ref_tagged = [{'nvr': self.ref_nvr}] 27​ self.ref_tagged = [{'nvr': self.ref_nvr}]
28 28​
29 self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm'\ 29​ self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm'\
30 % self.ref_nvr 30​ % self.ref_nvr
31 self.helper = koji_directive.KojiDirective() 31​ self.helper = koji_directive.KojiDirective()
32 32​
33 self.ref_envdata = {'workdir': '/var/tmp/foo'} 33​ self.ref_envdata = {'workdir': '/var/tmp/foo'}
34 34​
35 self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm' 35​ self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm'
36 % (self.ref_nvr, self.ref_arch)] 36​ % (self.ref_nvr, self.ref_arch)]
37 37​
38 def test_parse_download_command(self): 38​ def test_parse_download_command(self):
39 39​
40 self.ref_input = {'action': 'download', 40​ self.ref_input = {'action': 'download',
41 'arch': ', '.join(self.ref_arch), 41​ 'arch': self.ref_arch,
42 'envr': self.ref_nvr} 42​ 'envr': self.ref_nvr}
43 43​
44 stub_koji = Dingus(get_nvr_rpms__returns = self.ref_rpms) 44​ stub_koji = Dingus(get_nvr_rpms__returns = self.ref_rpms)
45 45​
46 test_helper = koji_directive.KojiDirective(stub_koji) 46​ test_helper = koji_directive.KojiDirective(stub_koji)
47 47​
48 test_helper.process(self.ref_input, self.ref_envdata) 48​ test_helper.process(self.ref_input, self.ref_envdata)
49 49​
50 getrpm_calls = stub_koji.calls() 50​ getrpm_calls = stub_koji.calls()
51 requested_nvr = getrpm_calls[0][1][0] 51​ requested_nvr = getrpm_calls[0][1][0]
52 52​
53 assert len(getrpm_calls) == 1 53​ assert len(getrpm_calls) == 1
54 assert requested_nvr == self.ref_nvr 54​ assert requested_nvr == self.ref_nvr
55 55​
56 def test_parse_download_tag_command(self): 56​ def test_parse_download_tag_command(self):
57 57​
58 self.ref_input = {'action': 'download_tag', 58​ self.ref_input = {'action': 'download_tag',
59 'arch': ', '.join(self.ref_arch), 59​ 'arch': self.ref_arch,
60 'tag': self.ref_tag} 60​ 'tag': self.ref_tag}
61 61​
62 stub_koji = Dingus(get_tagged_rpms__returns=self.ref_rpms) 62​ stub_koji = Dingus(get_tagged_rpms__returns=self.ref_rpms)
63 63​
64 test_helper = koji_directive.KojiDirective(stub_koji) 64​ test_helper = koji_directive.KojiDirective(stub_koji)
65 65​
66 test_helper.process(self.ref_input, self.ref_envdata) 66​ test_helper.process(self.ref_input, self.ref_envdata)
67 67​
68 getrpm_calls = stub_koji.calls() 68​ getrpm_calls = stub_koji.calls()
69 requested_tag = getrpm_calls[0][1][0] 69​ requested_tag = getrpm_calls[0][1][0]
70 70​
71 assert len(getrpm_calls) == 1 71​ assert len(getrpm_calls) == 1
72 assert requested_tag == self.ref_tag 72​ assert requested_tag == self.ref_tag
73 73​
74 def test_parse_multiple_arches(self): 74​ def test_parse_multiple_arches(self):
75 self.ref_arch = ['noarch', 'i386'] 75​ self.ref_arch = ['noarch', 'i386']
76 76​
77 self.ref_input = {'action': 'download_tag', 77​ self.ref_input = {'action': 'download_tag',
78 'arch': ', '.join(self.ref_arch), 78​ 'arch': self.ref_arch,
79 'tag': self.ref_tag} 79​ 'tag': self.ref_tag}
80 80​
81 stub_koji = Dingus('koji_utils') 81​ stub_koji = Dingus('koji_utils')
82 82​
83 test_helper = koji_directive.KojiDirective(stub_koji) 83​ test_helper = koji_directive.KojiDirective(stub_koji)
84 test_helper.process(self.ref_input, self.ref_envdata) 84​ test_helper.process(self.ref_input, self.ref_envdata)
85 85​
86 assert test_helper.arches == self.ref_arch 86​ assert test_helper.arches == self.ref_arch
87 87​
88 def test_parse_single_arch(self): 88​ def test_parse_single_arch(self):
89 self.ref_input = {'action': 'download_tag', 89​ self.ref_input = {'action': 'download_tag',
90 'arch': ', '.join(self.ref_arch), 90​ 'arch': self.ref_arch,
91 'tag': self.ref_tag} 91​ 'tag': self.ref_tag}
92 92​
93 stub_koji = Dingus('koji_utils') 93​ stub_koji = Dingus('koji_utils')
94 94​
95 test_helper = koji_directive.KojiDirective(stub_koji) 95​ test_helper = koji_directive.KojiDirective(stub_koji)
96 test_helper.process(self.ref_input, self.ref_envdata) 96​ test_helper.process(self.ref_input, self.ref_envdata)
97 97​
98 assert test_helper.arches == self.ref_arch 98​ assert test_helper.arches == self.ref_arch
99 99​
100 def test_add_noarch_download_command(self): 100​ def test_add_noarch_download_command(self):
101 ref_input = {'action': 'download', 'arch': 'x86_64', 101​ ref_input = {'action': 'download', 'arch': ['x86_64'],
102 'envr': self.ref_nvr} 102​ 'envr': self.ref_nvr}
103 ref_envdata = {'workdir': '/var/tmp/foo'} 103​ ref_envdata = {'workdir': '/var/tmp/foo'}
104 104​
105 stub_koji = Dingus() 105​ stub_koji = Dingus()
106 test_helper = koji_directive.KojiDirective(stub_koji) 106​ test_helper = koji_directive.KojiDirective(stub_koji)
107 test_helper.process(ref_input, ref_envdata) 107​ test_helper.process(ref_input, ref_envdata)
108 108​
109 getrpm_calls = stub_koji.calls() 109​ getrpm_calls = stub_koji.calls()
110 print getrpm_calls 110​ print getrpm_calls
111 requested_arches = getrpm_calls[0][1][2] 111​ requested_arches = getrpm_calls[0][1][2]
112 112​
113 assert len(getrpm_calls) == 1 113​ assert len(getrpm_calls) == 1
114 assert 'x86_64' in requested_arches 114​ assert 'x86_64' in requested_arches
115 assert 'noarch' in requested_arches 115​ assert 'noarch' in requested_arches
116 116​
117 def test_add_noarch_download_tag_command(self): 117​ def test_add_noarch_download_tag_command(self):
118 ref_input = {'action': 'download_tag', 'arch': 'x86_64', 118​ ref_input = {'action': 'download_tag', 'arch': ['x86_64'],
119 'tag': self.ref_tag} 119​ 'tag': self.ref_tag}
120 ref_envdata = {'workdir': '/var/tmp/foo'} 120​ ref_envdata = {'workdir': '/var/tmp/foo'}
121 121​
122 stub_koji = Dingus(get_tagged_rpms__returns=self.ref_rpms) 122​ stub_koji = Dingus(get_tagged_rpms__returns=self.ref_rpms)
123 test_helper = koji_directive.KojiDirective(stub_koji) 123​ test_helper = koji_directive.KojiDirective(stub_koji)
124 test_helper.process(ref_input, ref_envdata) 124​ test_helper.process(ref_input, ref_envdata)
125 125​
126 getrpm_calls = stub_koji.calls() 126​ getrpm_calls = stub_koji.calls()
127 requested_arches = getrpm_calls[0][1][2] 127​ requested_arches = getrpm_calls[0][1][2]
128 128​
129 assert len(getrpm_calls) == 1 129​ assert len(getrpm_calls) == 1
130 assert 'x86_64' in requested_arches 130​ assert 'x86_64' in requested_arches
131 assert 'noarch' in requested_arches 131​ assert 'noarch' in requested_arches
View Options

testing/test_runner.py

1import pytest 1​import pytest
2import os 2​import os
3import sys 3​import sys
4import copy 4​import copy
5 5​
6from libtaskotron import runner 6​from libtaskotron import runner
7from libtaskotron.exceptions import TaskotronYamlError 7​from libtaskotron.exceptions import TaskotronYamlError
8 8​
9 9​
10class TestRunnerInputVerify(): 10​class TestRunnerInputVerify():
11 def test_yamlrunner_valid_input(self): 11​ def test_yamlrunner_valid_input(self):
12 ref_cmd = '-i foo-1.2-3.fc99 -t koji_build -a x86_64 footask.yml' 12​ ref_cmd = '-i foo-1.2-3.fc99 -t koji_build -a x86_64 footask.yml'
13 ref_argdata = {'input': {'args': 'envr,arch'}} 13​ ref_argdata = {'input': {'args': ['envr', 'arch']}}
14 14​
15 test_parser = runner.get_argparser() 15​ test_parser = runner.get_argparser()
16 test_input_args = vars(test_parser.parse_args(ref_cmd.split())) 16​ test_input_args = vars(test_parser.parse_args(ref_cmd.split()))
17 test_args = runner.process_args(test_input_args) 17​ test_args = runner.process_args(test_input_args)
18 18​
19 test_runner = runner.Runner(ref_argdata, test_args) 19​ test_runner = runner.Runner(ref_argdata, test_args)
20 20​
21 test_runner._validate_input() 21​ test_runner._validate_input()
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Line(s)87 def test_yamlrunner_fails_input_is_string(self):
95 test_runner = runner.Runner(ref_inputspec, test_args) 95​ test_runner = runner.Runner(ref_inputspec, test_args)
96 96​
97 with pytest.raises(TaskotronYamlError): 97​ with pytest.raises(TaskotronYamlError):
98 test_runner._validate_input() 98​ test_runner._validate_input()
99 99​
100class TestRunnerSetup(): 100​class TestRunnerSetup():
101 def test_trivial_creation(self, tmpdir): 101​ def test_trivial_creation(self, tmpdir):
102 ref_taskdata = {'preparation': {'koji': 'download envr'}, 102​ ref_taskdata = {'preparation': {'koji': 'download envr'},
103 'input': {'args': 'envr,arch'}, 'post': {'shell': 'clean'}, 103​ 'input': {'args': ['envr','arch']},
104​ 'post': {'shell': 'clean'},
104 'execution': {'python': 'run_rpmlint.py'}, 105​ 'execution': {'python': 'run_rpmlint.py'},
105 'dependencies': ['rpmlint', 'libtaskbot']} 106​ 'dependencies': ['rpmlint', 'libtaskbot']}
106 ref_inputdata = {} 107​ ref_inputdata = {}
107 108​
108 test_runner = runner.Runner(ref_taskdata, ref_inputdata, tmpdir) 109​ test_runner = runner.Runner(ref_taskdata, ref_inputdata, tmpdir)
109 110​
110 assert test_runner.taskdata == ref_taskdata 111​ assert test_runner.taskdata == ref_taskdata
111 112​
▲ Show 20 Lines • Show All 235 Lines • ▼ Show 20 Line(s)346class TestRunnerProcessArgs():
347 def test_process_args_koji_build(self): 348​ def test_process_args_koji_build(self):
348 ref_input = { 'arch': ['x86_64'], 349​ ref_input = { 'arch': ['x86_64'],
349 'item': 'foo-1.2-3.fc99', 350​ 'item': 'foo-1.2-3.fc99',
350 'type': 'koji_build', 351​ 'type': 'koji_build',
351 'task': 'sometask.yml'} 352​ 'task': 'sometask.yml'}
352 353​
353 ref_args = copy.deepcopy(ref_input) 354​ ref_args = copy.deepcopy(ref_input)
354 ref_args['envr'] = 'foo-1.2-3.fc99' 355​ ref_args['envr'] = 'foo-1.2-3.fc99'
355 ref_args['arch'] = 'x86_64' ​
356 356​
357 test_args = runner.process_args(ref_input) 357​ test_args = runner.process_args(ref_input)
358 358​
359 assert test_args == ref_args 359​ assert test_args == ref_args
360 360​
361 def test_process_args_bodhi_id(self): 361​ def test_process_args_bodhi_id(self):
362 ref_input = { 'arch': ['x86_64'], 362​ ref_input = { 'arch': ['x86_64'],
363 'item': 'foo-1.2-3.fc99', 363​ 'item': 'foo-1.2-3.fc99',
364 'type': 'bodhi_id', 364​ 'type': 'bodhi_id',
365 'task': 'sometask.yml'} 365​ 'task': 'sometask.yml'}
366 366​
367 ref_args = copy.deepcopy(ref_input) 367​ ref_args = copy.deepcopy(ref_input)
368 ref_args['bodhi_id'] = 'foo-1.2-3.fc99' 368​ ref_args['bodhi_id'] = 'foo-1.2-3.fc99'
369 ref_args['arch'] = 'x86_64' ​
370 369​
371 test_args = runner.process_args(ref_input) 370​ test_args = runner.process_args(ref_input)
372 371​
373 assert test_args == ref_args 372​ assert test_args == ref_args
374 373​
375 def test_process_args_koji_tag(self): 374​ def test_process_args_koji_tag(self):
376 ref_input = { 'arch': ['x86_64'], 375​ ref_input = { 'arch': ['x86_64'],
377 'item': 'dist-fc99-updates', 376​ 'item': 'dist-fc99-updates',
378 'type': 'koji_tag', 377​ 'type': 'koji_tag',
379 'task': 'sometask.yml'} 378​ 'task': 'sometask.yml'}
380 379​
381 ref_args = copy.deepcopy(ref_input) 380​ ref_args = copy.deepcopy(ref_input)
382 ref_args['tag'] = 'dist-fc99-updates' 381​ ref_args['tag'] = 'dist-fc99-updates'
383 ref_args['arch'] = 'x86_64' ​
384 382​
385 test_args = runner.process_args(ref_input) 383​ test_args = runner.process_args(ref_input)
386 384​
387 assert test_args == ref_args 385​ assert test_args == ref_args
388 386​
389 def test_process_args_koji_tag_multiple_arches(self): 387​ def test_process_args_koji_tag_multiple_arches(self):
390 ref_input = { 'arch': ['x86_64', 'i386', 'noarch'], 388​ ref_input = { 'arch': ['x86_64', 'i386', 'noarch'],
391 'item': 'dist-fc99-updates', 389​ 'item': 'dist-fc99-updates',
392 'type': 'koji_tag', 390​ 'type': 'koji_tag',
393 'task': 'sometask.yml'} 391​ 'task': 'sometask.yml'}
394 392​
395 ref_args = copy.deepcopy(ref_input) 393​ ref_args = copy.deepcopy(ref_input)
396 ref_args['tag'] = 'dist-fc99-updates' 394​ ref_args['tag'] = 'dist-fc99-updates'
397 ref_args['arch'] = 'x86_64,i386,noarch' ​
398 395​
399 test_args = runner.process_args(ref_input) 396​ test_args = runner.process_args(ref_input)
400 397​
401 assert test_args == ref_args 398​ assert test_args == ref_args
402 399​
403 def test_process_args_no_arch(self): 400​ def test_process_args_no_arch(self):
404 ref_input = { 'type': 'invalid', 401​ ref_input = { 'type': 'invalid',
405 'arch': None} 402​ 'arch': None}
406 ref_args = copy.deepcopy(ref_input) 403​ ref_args = copy.deepcopy(ref_input)
407 ref_args['arch'] = 'noarch' 404​ ref_args['arch'] = ['noarch']
408 405​
409 test_args = runner.process_args(ref_input) 406​ test_args = runner.process_args(ref_input)
410 assert test_args == ref_args 407​ assert test_args == ref_args
411 408​