Differential D1171

argparse: change --arch to be a single value instead of a string
ClosedPublic
Actions

Authored by kparal on Mar 17 2017, 3:03 PM.

Details

Reviewers
tflink
mkrizek
jskladan
Group Reviewers
libtaskotron
Maniphest Tasks
T894: a race condition between downloading i386 and x86_64 packages
Commits
rLTRN73bb7e91d922: argparse: change --arch to be a single value instead of a string
Summary

This makes it easier to handle this value in formula and pass it to
other directives (like a bash directive), or modify it (append something
to it).

This is a substantial change. None of existing tasks seem to be making
use of multi-valued ${arch}. Generic tasks usually use 'all' arch value
in koji directive and process everything in one pass. Arch-specific
tasks will mostly want to handle just a single arch in a single pass.
That will also help us keep our sanity.

This patch is helpful for resolving T894 (making depcheck/rpmdeplint a
per-arch task).

Test Plan

tested with rpmdeplint adjusted to be a per-ach task, seems to work fine. Tested with legacy arch: ${arch} in koji directive, also works.

Diff Detail

Repository
rLTRN libtaskotron
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.
kparal created this revision.Mar 17 2017, 3:03 PM
jskladan requested changes to this revision.Mar 21 2017, 11:17 AM
jskladan added inline comments.
docs/source/writingtasks.rst
123 ↗(On Diff #2982)

Could Bodhi Directive manage both string and list of strings for arch? If not, then change arch to arches to make the "this needs to be a list" intuitive.

This revision now requires changes to proceed.Mar 21 2017, 11:17 AM
kparal updated this revision to Diff 2985.Mar 21 2017, 1:24 PM
  • accept both str and list of str in 'arch' parameters in directives
kparal updated this revision to Diff 2986.Mar 21 2017, 1:26 PM
  • fix docs
This revision is now accepted and ready to land.Mar 21 2017, 1:26 PM
Closed by commit rLTRN73bb7e91d922: argparse: change --arch to be a single value instead of a string (authored by Kamil Páral <kparal@redhat.com>). · Explain WhyMar 21 2017, 1:34 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 2987

View Options

libtaskotron/directives/bodhi_directive.py

1# -*- coding: utf-8 -*- 1​# -*- coding: utf-8 -*-
2# Copyright 2009-2016, Red Hat, Inc. 2​# Copyright 2009-2016, Red Hat, Inc.
3# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> 3​# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
4# See the LICENSE file for more details on Licensing 4​# See the LICENSE file for more details on Licensing
5 5​
6from __future__ import absolute_import 6​from __future__ import absolute_import
7 7​
8from libtaskotron.directives import BaseDirective 8​from libtaskotron.directives import BaseDirective
9from libtaskotron.logger import log 9​from libtaskotron.logger import log
10from libtaskotron.exceptions import TaskotronDirectiveError 10​from libtaskotron.exceptions import TaskotronDirectiveError
11import libtaskotron.ext.fedora.bodhi_utils as bodhi 11​import libtaskotron.ext.fedora.bodhi_utils as bodhi
12from libtaskotron.ext.fedora.koji_utils import KojiClient 12​from libtaskotron.ext.fedora.koji_utils import KojiClient
13from libtaskotron import config 13​from libtaskotron import config
14​from libtaskotron import exceptions as exc
14 15​
15DOCUMENTATION = """ 16​DOCUMENTATION = """
16module: bodhi_directive 17​module: bodhi_directive
17short_description: download updates from Bodhi 18​short_description: download updates from Bodhi
18description: | 19​description: |
19 The bodhi directive interfaces with `Bodhi`_ to facilitate various actions. 20​ The bodhi directive interfaces with `Bodhi`_ to facilitate various actions.
20 At the moment, the only action supported is downloading updates (i.e. all RPMs 21​ At the moment, the only action supported is downloading updates (i.e. all RPMs
21 from all builds related to a specific update). 22​ from all builds related to a specific update).
22 23​
23 .. _Bodhi: https://bodhi.fedoraproject.org 24​ .. _Bodhi: https://bodhi.fedoraproject.org
24parameters: 25​parameters:
25 action: 26​ action:
26 required: true 27​ required: true
27 description: specify action type. The only action available at the moment 28​ description: specify action type. The only action available at the moment
28 is ``download``. 29​ is ``download``.
29 type: str 30​ type: str
30 update_id: 31​ update_id:
31 required: true 32​ required: true
32 description: Bodhi update ID to download, e.g. ``FEDORA-2014-7485``. 33​ description: Bodhi update ID to download, e.g. ``FEDORA-2014-7485``.
33 type: str 34​ type: str
34 arch: 35​ arch:
35 required: true 36​ required: true
36 description: | 37​ description: |
37 a list of architectures for which to download RPMs. 38​ an architecture (or a list of architectures) for which to download RPMs.
38 39​
39 Note: ``noarch`` RPMs are always automatically downloaded even when not 40​ Note: ``noarch`` RPMs are always automatically downloaded even when not
40 requested, unless ``arch=[]`` and ``src=True``. 41​ requested, unless ``arch=[]`` and ``src=True``.
41 type: list of str 42​ type: str or list of str
42 src: 43​ src:
43 required: false 44​ required: false
44 description: download also ``src`` RPM files 45​ description: download also ``src`` RPM files
45 type: bool 46​ type: bool
46 default: False 47​ default: False
47returns: | 48​returns: |
48 A dictionary containing following items: 49​ A dictionary containing following items:
49 50​
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Line(s)97 def action_download(self, updateid, arches, src, workdir):
107 for nvr in nvrs: 108​ for nvr in nvrs:
108 res = self.koji_session.get_nvr_rpms(nvr, workdir, arches, src=src) 109​ res = self.koji_session.get_nvr_rpms(nvr, workdir, arches, src=src)
109 downloaded_rpms.extend(res) 110​ downloaded_rpms.extend(res)
110 111​
111 return downloaded_rpms 112​ return downloaded_rpms
112 113​
113 def process(self, params, arg_data): 114​ def process(self, params, arg_data):
114 output_data = {} 115​ output_data = {}
115 ​
116 valid_actions = ['download'] 116​ valid_actions = ['download']
117 ​
118 action = params['action'] 117​ action = params['action']
119 118​
120 if action not in valid_actions: 119​ if action not in valid_actions:
121 raise TaskotronDirectiveError('%s is not a valid command for bodhi directive' 120​ raise TaskotronDirectiveError('%s is not a valid command for bodhi directive'
122 % action) 121​ % action)
123 122​
123​ if 'arch' not in params:
124​ detected_args = ', '.join(params.keys())
125​ raise exc.TaskotronDirectiveError(
126​ "The bodhi directive requires 'arch' as an argument. Detected "
127​ "arguments: %s" % detected_args)
128​
129​ # convert str to list
130​ if isinstance(params['arch'], basestring):
131​ params['arch'] = [params['arch']]
132​
124 if action == 'download': 133​ if action == 'download':
125 if 'update_id' not in params or 'arch' not in params: 134​ if 'update_id' not in params or 'arch' not in params:
126 detected_args = ', '.join(params.keys()) 135​ detected_args = ', '.join(params.keys())
127 raise TaskotronDirectiveError( 136​ raise TaskotronDirectiveError(
128 "The bodhi directive 'download' requires both 'update_id' and " 137​ "The bodhi directive 'download' requires both 'update_id' and "
129 "'arch' arguments. Detected arguments: %s" % detected_args) 138​ "'arch' arguments. Detected arguments: %s" % detected_args)
130 139​
131 workdir = arg_data['workdir'] 140​ workdir = arg_data['workdir']
Show All 16 Lines
View Options

libtaskotron/directives/koji_directive.py

Show All 22 Lines19 description: |
23 * ``download_tag``: download all builds belonging to a Koji tag 23​ * ``download_tag``: download all builds belonging to a Koji tag
24 * ``download_latest_stable``: download the latest build (of the same package you provide in 24​ * ``download_latest_stable``: download the latest build (of the same package you provide in
25 ``koji_build``) that is currently in stable Fedora repositories (main or updates repo) 25​ ``koji_build``) that is currently in stable Fedora repositories (main or updates repo)
26 type: str 26​ type: str
27 choices: [download, download_tag, download_latest_stable] 27​ choices: [download, download_tag, download_latest_stable]
28 arch: 28​ arch:
29 required: true 29​ required: true
30 description: | 30​ description: |
31 a list of architectures for which to download RPMs for the requested build/tag. If you want 31​ an architecture (or a list of architectures) for which to download RPMs for the requested
32 to download RPMs for all Taskotron-supported arches, use ``['all']``. If you don't want to 32​ build/tag. If you want to download RPMs for all Taskotron-supported arches, use ``'all'``.
33 download any binary arch (i.e. you're only interested in SRPMs, which is controlled by `src` 33​ If you don't want to download any binary arch (i.e. you're only interested in SRPMs, which is
34 option), use an empty list ``[]``. 34​ controlled by `src` option), use an empty list ``[]``.
35 35​
36 Note: ``noarch`` RPMs are always automatically downloaded unless ``arch=[]``, 36​ Note: ``noarch`` RPMs are always automatically downloaded unless ``arch=[]``,
37 or you specifically exclude them using ``arch_exclude``. Also, if you specify base arches 37​ or you specifically exclude them using ``arch_exclude``. Also, if you specify base arches
38 (like ``i386``), all concrete binary arches for that base arch will be automatically added 38​ (like ``i386``), all concrete binary arches for that base arch will be automatically added
39 (e.g. ``i[3-6]86``). 39​ (e.g. ``i[3-6]86``).
40 type: list of str 40​ type: str or list of str
41 choices: [supported architectures, all] 41​ choices: [supported architectures, all]
42 arch_exclude: 42​ arch_exclude:
43 required: false 43​ required: false
44 description: | 44​ description: |
45 a list of architectures to exclude from downloading (overrides ``arch`` 45​ an architecture (or a list of architectures) to exclude from downloading (overrides ``arch``
46 value). You can use it to exclude some specific archicture while using 46​ value). You can use it to exclude some specific archicture while using ``arch='all'``.
47 ``arch=['all']``. Example: ``['armhfp', 'noarch']`` 47​ Example: ``['armhfp', 'noarch']``
48 type: list of str 48​ type: str or list of str
49 choices: [supported architectures] 49​ choices: [supported architectures]
50 build_log: 50​ build_log:
51 required: false 51​ required: false
52 description: download also ``build.log`` files for each requested architecture (the files will 52​ description: download also ``build.log`` files for each requested architecture (the files will
53 be saved as ``build.log.<arch>``). Note that some logs can be already deleted in Koji and 53​ be saved as ``build.log.<arch>``). Note that some logs can be already deleted in Koji and
54 might not be available for download. Such missing logs will be skipped. This option will be 54​ might not be available for download. Such missing logs will be skipped. This option will be
55 considered only for single build downloads (i.e. ``action='download'`` or 55​ considered only for single build downloads (i.e. ``action='download'`` or
56 ``action='download_latest_stable'``). 56​ ``action='download_latest_stable'``).
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Line(s)
101EXAMPLES = """ 101​EXAMPLES = """
102Rpmlint needs to download a specific build from Koji, all supported architectures including 102​Rpmlint needs to download a specific build from Koji, all supported architectures including
103src.rpm:: 103​src.rpm::
104 104​
105 - name: download rpms from koji 105​ - name: download rpms from koji
106 koji: 106​ koji:
107 action: download 107​ action: download
108 koji_build: ${koji_build} 108​ koji_build: ${koji_build}
109 arch: ['all'] 109​ arch: all
110 src: True 110​ src: True
111 111​
112Depcheck needs to download all builds in a specific Koji tag for the current 112​Depcheck needs to download all builds in a specific Koji tag for the current
113architecture:: 113​architecture::
114 114​
115 - name: download koji tag 115​ - name: download koji tag
116 koji: 116​ koji:
117 action: download_tag 117​ action: download_tag
118 koji_tag: ${koji_tag} 118​ koji_tag: ${koji_tag}
119 arch: ${arch} 119​ arch: ${arch}
120 target_dir: ${workdir}/downloaded_tag/ 120​ target_dir: ${workdir}/downloaded_tag/
121 121​
122Abicheck downloads both current build and latest stable build. It checks all supported binary 122​Abicheck downloads both current build and latest stable build. It checks all supported binary
123arches, but doesn't need ``noarch``:: 123​arches, but doesn't need ``noarch``::
124 124​
125 - name: download latest stable rpms for the package 125​ - name: download latest stable rpms for the package
126 koji: 126​ koji:
127 action: download_latest_stable 127​ action: download_latest_stable
128 koji_build: ${koji_build} 128​ koji_build: ${koji_build}
129 arch: ['all'] 129​ arch: all
130 arch_exclude: ['noarch'] 130​ arch_exclude: noarch
131 debuginfo: True 131​ debuginfo: True
132 target_dir: ${workdir}/stable 132​ target_dir: ${workdir}/stable
133 133​
134 - name: download rpms for the tested build 134​ - name: download rpms for the tested build
135 koji: 135​ koji:
136 action: download 136​ action: download
137 koji_build: ${koji_build} 137​ koji_build: ${koji_build}
138 arch: ['all'] 138​ arch: all
139 arch_exclude: ['noarch'] 139​ arch_exclude: noarch
140 debuginfo: True 140​ debuginfo: True
141 target_dir: ${workdir}/update 141​ target_dir: ${workdir}/update
142 142​
143""" 143​"""
144 144​
145from libtaskotron.directives import BaseDirective 145​from libtaskotron.directives import BaseDirective
146import libtaskotron.exceptions as exc 146​import libtaskotron.exceptions as exc
147from libtaskotron.ext.fedora.koji_utils import KojiClient 147​from libtaskotron.ext.fedora.koji_utils import KojiClient
Show All 27 Lines174 else:
175 target_dir = params['target_dir'] 175​ target_dir = params['target_dir']
176 176​
177 if 'arch' not in params: 177​ if 'arch' not in params:
178 detected_args = ', '.join(params.keys()) 178​ detected_args = ', '.join(params.keys())
179 raise exc.TaskotronDirectiveError( 179​ raise exc.TaskotronDirectiveError(
180 "The koji directive requires 'arch' as an argument. Detected " 180​ "The koji directive requires 'arch' as an argument. Detected "
181 "arguments: %s" % detected_args) 181​ "arguments: %s" % detected_args)
182 182​
183​ # convert str to list
184​ for param in ('arch', 'arch_exclude'):
185​ if param in params and isinstance(params[param], basestring):
186​ params[param] = [params[param]]
187​
183 arches = list(params['arch']) 188​ arches = list(params['arch'])
184 if arches and ('all' not in arches) and ('noarch' not in arches): 189​ if arches and ('all' not in arches) and ('noarch' not in arches):
185 arches.append('noarch') 190​ arches.append('noarch')
186 191​
187 arch_exclude = params.get('arch_exclude', []) 192​ arch_exclude = params.get('arch_exclude', [])
188 debuginfo = params.get('debuginfo', False) 193​ debuginfo = params.get('debuginfo', False)
189 src = params.get('src', False) 194​ src = params.get('src', False)
190 build_log = params.get('build_log', False) 195​ build_log = params.get('build_log', False)
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines
View Options

libtaskotron/directives/mash_directive.py

Show All 23 Lines
24parameters: 24​parameters:
25 rpmdir: 25​ rpmdir:
26 required: true 26​ required: true
27 description: absolute or relative path to the directory containing RPM files 27​ description: absolute or relative path to the directory containing RPM files
28 (the task directory is considered the current working directory) 28​ (the task directory is considered the current working directory)
29 type: str 29​ type: str
30 arch: 30​ arch:
31 required: true 31​ required: true
32 description: list of architectures for which to create YUM metadata 32​ description: an architecture (or a list of architectures) for which to create YUM metadata
33 type: list of str 33​ type: str or list of str
34 outdir: 34​ outdir:
35 required: false 35​ required: false
36 description: absolute or relative path to an output directory, where 36​ description: absolute or relative path to an output directory, where
37 repository should be created. If not specified, then ``rpmdir`` is used 37​ repository should be created. If not specified, then ``rpmdir`` is used
38 as an output directory. ``outdir`` will be created automatically if not 38​ as an output directory. ``outdir`` will be created automatically if not
39 present. 39​ present.
40 type: str 40​ type: str
41 default: None 41​ default: None
Show All 20 Lines61 koji:
62 action: download_tag 62​ action: download_tag
63 koji_tag: ${koji_tag} 63​ koji_tag: ${koji_tag}
64 arch: ${arch} 64​ arch: ${arch}
65 target_dir: "${workdir}/downloaded_tag/" 65​ target_dir: "${workdir}/downloaded_tag/"
66 66​
67 - name: mash downloaded rpms 67​ - name: mash downloaded rpms
68 mash: 68​ mash:
69 rpmdir: "${workdir}/downloaded_tag/" 69​ rpmdir: "${workdir}/downloaded_tag/"
70 dodelta: False ​
71 arch: ${arch} 70​ arch: ${arch}
72""" 71​"""
73 72​
74import subprocess as sub 73​import subprocess as sub
75import os 74​import os
76import mash 75​import mash
77import mash.config 76​import mash.config
78import StringIO 77​import StringIO
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Line(s)88class MashDirective(BaseDirective):
155 154​
156 def process(self, params, arg_data): 155​ def process(self, params, arg_data):
157 if 'rpmdir' not in params or 'arch' not in params: 156​ if 'rpmdir' not in params or 'arch' not in params:
158 detected_args = ', '.join(params.keys()) 157​ detected_args = ', '.join(params.keys())
159 raise TaskotronDirectiveError( 158​ raise TaskotronDirectiveError(
160 "The mash directive requires 'rpmdir' and 'arch' " 159​ "The mash directive requires 'rpmdir' and 'arch' "
161 "arguments. Detected arguments: %s" % detected_args) 160​ "arguments. Detected arguments: %s" % detected_args)
162 161​
162​ # convert str to list
163​ if isinstance(params['arch'], basestring):
164​ params['arch'] = [params['arch']]
165​
163 if 'dodelta' not in params: 166​ if 'dodelta' not in params:
164 dodelta = False 167​ dodelta = False
165 else: 168​ else:
166 dodelta = params['dodelta'] 169​ dodelta = params['dodelta']
167 170​
168 rpmdir = params['rpmdir'] 171​ rpmdir = params['rpmdir']
169 outdir = params.get('outdir', None) 172​ outdir = params.get('outdir', None)
170 arch = params['arch'] 173​ arch = params['arch']
Show All 10 Lines
View Options

libtaskotron/directives/yumrepoinfo_directive.py

Show All 18 Lines18 description: |
19 name of the Koji tag, e.g. ``f20``, ``f20-updates``, 19​ name of the Koji tag, e.g. ``f20``, ``f20-updates``,
20 ``f20-updates-testing``, or ``rawhide``. 20​ ``f20-updates-testing``, or ``rawhide``.
21 21​
22 If the tag ends with ``-pending`` suffix, this suffix is stripped (because 22​ If the tag ends with ``-pending`` suffix, this suffix is stripped (because
23 pending tags are not real repositories), and the resulting tag is used. 23​ pending tags are not real repositories), and the resulting tag is used.
24 type: str 24​ type: str
25 arch: 25​ arch:
26 required: true 26​ required: true
27 description: list of architectures. In this list, all "meta architectures" 27​ description: an architecure (or a list of architectures). All "meta architectures"
28 like ``all``, ``src`` and ``noarch`` are ignored, list of "real 28​ like ``all``, ``src`` and ``noarch`` are ignored, "real
29 architectures" is expected there (e.g. ``x86_64`` or ``i386``). 29​ architectures" are expected there instead (e.g. ``x86_64`` or ``i386``).
30 type: list of str 30​ type: str or list of str
31returns: | 31​returns: |
32 A dictionary of dictionaries. Main key is ``koji_tag`` with value of 32​ A dictionary of dictionaries. Main key is ``koji_tag`` with value of
33 dictionary that contains ``arch`` as key and URL for the respective 33​ dictionary that contains ``arch`` as key and URL for the respective
34 repository is its value. 34​ repository is its value.
35 35​
36 If the repository in question has some parent repositories (e.g. 36​ If the repository in question has some parent repositories (e.g.
37 ``f20-updates`` is a child of ``f20``), all its parents names and their 37​ ``f20-updates`` is a child of ``f20``), all its parents names and their
38 repository URLs are returned in the dictionary as well as additional keys. 38​ repository URLs are returned in the dictionary as well as additional keys.
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Line(s)94 def run_yumrepoinfo(self, arch, koji_tag):
119 return output 119​ return output
120 120​
121 def process(self, params, arg_data): 121​ def process(self, params, arg_data):
122 122​
123 if 'koji_tag' not in params or 'arch' not in params: 123​ if 'koji_tag' not in params or 'arch' not in params:
124 raise TaskotronDirectiveError("The yumrepoinfo directive requires " 124​ raise TaskotronDirectiveError("The yumrepoinfo directive requires "
125 "koji_tag and arch arguments.") 125​ "koji_tag and arch arguments.")
126 126​
127 arches = params['arch'] 127​ # convert str to list
128​ if isinstance(params['arch'], basestring):
129​ params['arch'] = [params['arch']]
128 130​
131​ arches = params['arch']
129 processed_arches = [arch for arch in arches if arch in Arches.base] 132​ processed_arches = [arch for arch in arches if arch in Arches.base]
130 133​
131 if len(processed_arches) == 0: 134​ if len(processed_arches) == 0:
132 raise TaskotronDirectiveError("No valid yumrepo arches supplied to " 135​ raise TaskotronDirectiveError("No valid yumrepo arches supplied to "
133 "yumrepoinfo directive. Recieved %r" 136​ "yumrepoinfo directive. Recieved %r"
134 % arches) 137​ % arches)
135 138​
136 # create output in format: 139​ # create output in format:
Show All 10 Lines
View Options

libtaskotron/ext/fedora/koji_utils.py

Show First 20 Lines • Show All 191 Lines • ▼ Show 20 Line(s)191 :param arch_exclude: exclude some specific arches, even if they are specified in
192 ``arches`` or they are implicit in the default ``'all'`` value 192​ ``arches`` or they are implicit in the default ``'all'`` value
193 :type arch_exclude: list of str 193​ :type arch_exclude: list of str
194 :param bool debuginfo: whether to provide URLs for debuginfo RPM files 194​ :param bool debuginfo: whether to provide URLs for debuginfo RPM files
195 or ignore them 195​ or ignore them
196 :param bool src: whether to include a URL for the source RPM 196​ :param bool src: whether to include a URL for the source RPM
197 :rtype: list of str 197​ :rtype: list of str
198 :raise TaskotronRemoteError: when the requested build doesn't exist 198​ :raise TaskotronRemoteError: when the requested build doesn't exist
199 ''' 199​ '''
200 log.info('Querying Koji for a list of RPMS for: %s', nvr) ​
201 ​
202 arches = list(self._compute_arches(arches, arch_exclude, src)) 200​ arches = list(self._compute_arches(arches, arch_exclude, src))
203 201​
202​ log.info('Querying Koji for a list of RPMS for: %s (arches %s)', nvr, sorted(arches))
203​
204 if not arches: 204​ if not arches:
205 log.debug('Nothing to query for, the combination of `arches`, `arch_exclude` and ' 205​ log.debug('Nothing to query for, the combination of `arches`, `arch_exclude` and '
206 '`src` ended up an empty list.') 206​ '`src` ended up an empty list.')
207 return [] 207​ return []
208 208​
209 # find the koji build 209​ # find the koji build
210 info = self.session.getBuild(nvr) 210​ info = self.session.getBuild(nvr)
211 if info is None: 211​ if info is None:
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines
View Options

libtaskotron/main.py

Show All 24 Lines22def get_argparser():
25 :rtype: :class:`argparse.ArgumentParser` 25​ :rtype: :class:`argparse.ArgumentParser`
26 ''' 26​ '''
27 # IMPORTANT: When you add a new argument, look into `minion.BaseMinion.arg_data_exclude` and 27​ # IMPORTANT: When you add a new argument, look into `minion.BaseMinion.arg_data_exclude` and
28 # update it if needed! 28​ # update it if needed!
29 29​
30 parser = argparse.ArgumentParser() 30​ parser = argparse.ArgumentParser()
31 parser.add_argument("task", help="task formula to run") 31​ parser.add_argument("task", help="task formula to run")
32 parser.add_argument("-a", "--arch", 32​ parser.add_argument("-a", "--arch",
33 choices=["i386", "x86_64", "armhfp", "noarch"], 33​ choices=["i386", "x86_64", "armhfp", "noarch"], default='noarch',
34 action='append', 34​ help="architecture specifying the item to be checked. 'noarch' value "
35 help="architecture specifying the item to be checked. If omitted, " 35​ 'means an arch-independent task (if the task supports it, it can '
36 "defaults to noarch.") 36​ 'process all archs in a single go). [default: %(default)s]')
37 parser.add_argument("-i", "--item", help="item to be checked") 37​ parser.add_argument("-i", "--item", help="item to be checked")
38 parser.add_argument("-t", "--type", 38​ parser.add_argument("-t", "--type",
39 choices=check.ReportType.list(), 39​ choices=check.ReportType.list(),
40 help="type of --item argument") 40​ help="type of --item argument")
41 parser.add_argument("-j", "--jobid", default="-1", 41​ parser.add_argument("-j", "--jobid", default="-1",
42 help="optional job identifier used to render log urls") 42​ help="optional job identifier used to render log urls")
43 parser.add_argument("-d", "--debug", action="store_true", 43​ parser.add_argument("-d", "--debug", action="store_true",
44 help="Enable debug output " 44​ help="Enable debug output "
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Line(s)92def process_args(raw_args):
102 102​
103 # store the original unprocessed args for later use when passing it to the minion 103​ # store the original unprocessed args for later use when passing it to the minion
104 args['_orig_args'] = raw_args 104​ args['_orig_args'] = raw_args
105 105​
106 # process item + type 106​ # process item + type
107 if args['type'] in check.ReportType.list(): 107​ if args['type'] in check.ReportType.list():
108 args[args['type']] = args['item'] 108​ args[args['type']] = args['item']
109 109​
110 # process arch ​
111 if args['arch'] is None: ​
112 args['arch'] = ['noarch'] ​
113 ​
114 override = {} 110​ override = {}
115 for var in args['override']: 111​ for var in args['override']:
116 name, value = var.split('=', 1) 112​ name, value = var.split('=', 1)
117 override[name] = value 113​ override[name] = value
118 args['override'] = override 114​ args['override'] = override
119 115​
120 # parse ssh 116​ # parse ssh
121 if args['ssh']: 117​ if args['ssh']:
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines
View Options

libtaskotron/taskformula.py

Show First 20 Lines • Show All 220 Lines • ▼ Show 20 Line(s)204 if not env['release']:
221 else: 221​ else:
222 log.debug("Environment/release can not be inferred from %r:%r. Using default." % 222​ log.debug("Environment/release can not be inferred from %r:%r. Using default." %
223 (item_type, item)) 223​ (item_type, item))
224 224​
225 if not env['flavor']: 225​ if not env['flavor']:
226 log.debug("Environment/flavor not specified. Using default") 226​ log.debug("Environment/flavor not specified. Using default")
227 227​
228 if not env['arch']: 228​ if not env['arch']:
229 arches = [i for i in arg_data.get('arch', []) if i != 'noarch'] 229​ arch = arg_data.get('arch')
230 230​ if not arch or arch == 'noarch':
231 if arches and len(arches) == 1: 231​ log.warn("Environment/arch can not be inferred from %r. Using default." % arch)
232 env['arch'] = arches[0] ​
233 log.debug("Environment/arch inferred from %r to %r" % ​
234 (arg_data.get('arch', []), env['arch'])) ​
235 else: 232​ else:
236 log.warn("Environment/arch can not be inferred from %r. Using default." % 233​ env['arch'] = arch
237 arg_data.get('arch', [])) 234​ log.debug("Environment/arch inferred from %r to %r" % (arch, env['arch']))
238 235​
239 return env 236​ return env
View Options

testing/functest_mash_directive.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Line(s)15 def setup_method(self, tmpdir):
42 self.rpms = [os.path.basename(rpm) for rpm in rpms] 42​ self.rpms = [os.path.basename(rpm) for rpm in rpms]
43 43​
44 #jump back 44​ #jump back
45 os.chdir(startdir) 45​ os.chdir(startdir)
46 46​
47 def test_mash_arch_i686(self): 47​ def test_mash_arch_i686(self):
48 params = { 48​ params = {
49 'rpmdir': self.rpmdir, 49​ 'rpmdir': self.rpmdir,
50 'arch': ['i386'] 50​ 'arch': 'i386'
51 } 51​ }
52 directive = mash_directive.MashDirective() 52​ directive = mash_directive.MashDirective()
53 before = os.listdir(self.rpmdir) 53​ before = os.listdir(self.rpmdir)
54 directive.process(params, {}) 54​ directive.process(params, {})
55 after = os.listdir(self.rpmdir) 55​ after = os.listdir(self.rpmdir)
56 56​
57 assert self.rpms[0] in before and self.rpms[0] in after and \ 57​ assert self.rpms[0] in before and self.rpms[0] in after and \
58 self.rpms[1] in before and self.rpms[1] in after 58​ self.rpms[1] in before and self.rpms[1] in after
59 59​
60 60​
61 def test_mash_arch_x86_64(self): 61​ def test_mash_arch_x86_64(self):
62 params = { 62​ params = {
63 'rpmdir': self.rpmdir, 63​ 'rpmdir': self.rpmdir,
64​ 'arch': 'x86_64'
65​ }
66​ directive = mash_directive.MashDirective()
67​ before = os.listdir(self.rpmdir)
68​ directive.process(params, {})
69​ after = os.listdir(self.rpmdir)
70​
71​ assert (self.rpms[0] in before and self.rpms[0] in after and
72​ self.rpms[1] in before and self.rpms[1] not in after)
73​
74​ def test_mash_arch_as_list(self):
75​ params = {
76​ 'rpmdir': self.rpmdir,
64 'arch': ['x86_64'] 77​ 'arch': ['x86_64']
65 } 78​ }
66 directive = mash_directive.MashDirective() 79​ directive = mash_directive.MashDirective()
67 before = os.listdir(self.rpmdir) 80​ before = os.listdir(self.rpmdir)
68 directive.process(params, {}) 81​ directive.process(params, {})
69 after = os.listdir(self.rpmdir) 82​ after = os.listdir(self.rpmdir)
70 83​
71 assert self.rpms[0] in before and self.rpms[0] in after and \ 84​ assert self.rpms[0] in before and self.rpms[0] in after and \
72 self.rpms[1] in before and self.rpms[1] not in after 85​ self.rpms[1] in before and self.rpms[1] not in after
73 86​
74 def test_outdir_is_created(self, tmpdir): 87​ def test_outdir_is_created(self, tmpdir):
75 outdir_path = tmpdir.join('somewhere/along/the/highway').strpath 88​ outdir_path = tmpdir.join('somewhere/along/the/highway').strpath
76 params = { 89​ params = {
77 'rpmdir': self.rpmdir, 90​ 'rpmdir': self.rpmdir,
78 'outdir': outdir_path, 91​ 'outdir': outdir_path,
79 'arch': ['i386'] 92​ 'arch': 'i386'
80 } 93​ }
81 94​
82 directive = mash_directive.MashDirective() 95​ directive = mash_directive.MashDirective()
83 ret_path = directive.process(params, {}) 96​ ret_path = directive.process(params, {})
84 97​
85 assert ret_path == outdir_path 98​ assert ret_path == outdir_path
86 assert os.path.isdir(ret_path) 99​ assert os.path.isdir(ret_path)
87 100​
88 101​
89 def test_repodata_in_rpmdir(self): 102​ def test_repodata_in_rpmdir(self):
90 params = { 103​ params = {
91 'rpmdir': self.rpmdir, 104​ 'rpmdir': self.rpmdir,
92 'arch': ['x86_64'] 105​ 'arch': 'x86_64'
93 } 106​ }
94 directive = mash_directive.MashDirective() 107​ directive = mash_directive.MashDirective()
95 directive.process(params, {}) 108​ directive.process(params, {})
96 after = os.listdir(self.rpmdir) 109​ after = os.listdir(self.rpmdir)
97 110​
98 assert 'repodata' in after 111​ assert 'repodata' in after
99 112​
100 def test_repodata_in_outdir(self, tmpdir): 113​ def test_repodata_in_outdir(self, tmpdir):
101 outdir = tmpdir.strpath 114​ outdir = tmpdir.strpath
102 params = { 115​ params = {
103 'rpmdir': self.rpmdir, 116​ 'rpmdir': self.rpmdir,
104 'outdir': outdir, 117​ 'outdir': outdir,
105 'arch': ['x86_64'] 118​ 'arch': 'x86_64'
106 } 119​ }
107 directive = mash_directive.MashDirective() 120​ directive = mash_directive.MashDirective()
108 directive.process(params, {}) 121​ directive.process(params, {})
109 after = os.listdir(self.rpmdir) 122​ after = os.listdir(self.rpmdir)
110 123​
111 assert 'repodata' not in after and 'repodata' in os.listdir(outdir) 124​ assert 'repodata' not in after and 'repodata' in os.listdir(outdir)
View Options

testing/functest_yumrepoinfo_directive.py

Show All 21 Lines18class TestYumrepoinfoDirective(object):
22 def setup_class(cls, tmpdir): 22​ def setup_class(cls, tmpdir):
23 '''One-time class initialization''' 23​ '''One-time class initialization'''
24 # create YumRepoInfo initialized with TEST_CONF 24​ # create YumRepoInfo initialized with TEST_CONF
25 cls.temp_conf = tmpdir.join("functest_yumrepoinfo.conf") 25​ cls.temp_conf = tmpdir.join("functest_yumrepoinfo.conf")
26 cls.temp_conf.write(TEST_CONF) 26​ cls.temp_conf.write(TEST_CONF)
27 27​
28 def test_missing_kojitag(self): 28​ def test_missing_kojitag(self):
29 directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath]) 29​ directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath])
30 ref_input = {"arch": ["x86_64"]} 30​ ref_input = {"arch": "x86_64"}
31 31​
32 with pytest.raises(TaskotronDirectiveError): 32​ with pytest.raises(TaskotronDirectiveError):
33 directive.process(ref_input, None) 33​ directive.process(ref_input, None)
34 34​
35 def test_missing_arch(self): 35​ def test_missing_arch(self):
36 directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath]) 36​ directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath])
37 ref_input = {"koji_tag": "rawhide"} 37​ ref_input = {"koji_tag": "rawhide"}
38 38​
39 with pytest.raises(TaskotronDirectiveError): 39​ with pytest.raises(TaskotronDirectiveError):
40 directive.process(ref_input, None) 40​ directive.process(ref_input, None)
41 41​
42 def test_pending(self): 42​ def test_pending(self):
43 directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath]) 43​ directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath])
44 ref_input = {"koji_tag": "f20-pending", "arch": ["x86_64"]} 44​ ref_input = {"koji_tag": "f20-pending", "arch": "x86_64"}
45 45​
46 output = directive.process(ref_input, None) 46​ output = directive.process(ref_input, None)
47 47​
48 assert output == {"f20": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/releases/20/Everything/x86_64/os"}} 48​ assert output == {"f20": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/releases/20/Everything/x86_64/os"}}
49 49​
50 def test_rawhide(self): 50​ def test_rawhide(self):
51 directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath]) 51​ directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath])
52 ref_input = {"koji_tag": "rawhide", "arch": ["x86_64"]} 52​ ref_input = {"koji_tag": "rawhide", "arch": "x86_64"}
53 53​
54 output = directive.process(ref_input, None) 54​ output = directive.process(ref_input, None)
55 55​
56 assert output == {"rawhide": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/development/rawhide/x86_64/os"}} 56​ assert output == {"rawhide": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/development/rawhide/x86_64/os"}}
57 57​
58 def test_bad_kojitag(self): 58​ def test_bad_kojitag(self):
59 directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath]) 59​ directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath])
60 ref_input = {"koji_tag": "my random tag"} 60​ ref_input = {"koji_tag": "my random tag"}
61 61​
62 with pytest.raises(TaskotronDirectiveError): 62​ with pytest.raises(TaskotronDirectiveError):
63 directive.process(ref_input, None) 63​ directive.process(ref_input, None)
64 64​
65 def test_repo_path(self): 65​ def test_repo_path(self):
66 66​
67 directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath]) 67​ directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath])
68 ref_input = {"koji_tag": "f20-updates", "arch": ["x86_64"]} 68​ ref_input = {"koji_tag": "f20-updates", "arch": "x86_64"}
69 69​
70 output = directive.process(ref_input, None) 70​ output = directive.process(ref_input, None)
71 71​
72 assert output == { 72​ assert output == {
73 "f20": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/releases/20/Everything/x86_64/os"}, 73​ "f20": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/releases/20/Everything/x86_64/os"},
74 "f20-updates": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/updates/20/x86_64"}, 74​ "f20-updates": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/updates/20/x86_64"},
75 } 75​ }
76 76​
77 def test_use_arch(self, monkeypatch): 77​ def test_use_arch(self, monkeypatch):
78 """Make sure that the arch passed in as an arg is used to create the 78​ """Make sure that the arch passed in as an arg is used to create the
79 yumrepoinfo object instead of falling back to the default system arch""" 79​ yumrepoinfo object instead of falling back to the default system arch"""
80 ref_arch = 'i386' 80​ ref_arch = 'i386'
81 repoinfo = yumrepoinfo.YumRepoInfo(filelist=[], arch=['x86_64']) 81​ repoinfo = yumrepoinfo.YumRepoInfo(filelist=[], arch='x86_64')
82 repoinfo.parser.readfp(StringIO.StringIO(TEST_CONF)) 82​ repoinfo.parser.readfp(StringIO.StringIO(TEST_CONF))
83 83​
84 stub_getrepoinfo = Dingus(return_value=repoinfo) 84​ stub_getrepoinfo = Dingus(return_value=repoinfo)
85 monkeypatch.setattr(yumrepoinfo, 'get_yumrepoinfo', stub_getrepoinfo) 85​ monkeypatch.setattr(yumrepoinfo, 'get_yumrepoinfo', stub_getrepoinfo)
86 86​
87 # don't set the repoinfo object, we've stubbed out the code that would 87​ # don't set the repoinfo object, we've stubbed out the code that would
88 # hit the filesystem, so it's not a risk here 88​ # hit the filesystem, so it's not a risk here
89 directive = yumrepoinfo_directive.YumrepoinfoDirective() 89​ directive = yumrepoinfo_directive.YumrepoinfoDirective()
90 ref_input = {"koji_tag": "f20-updates", "arch": [ref_arch]} 90​ ref_input = {"koji_tag": "f20-updates", "arch": ref_arch}
91 91​
92 directive.process(ref_input, None) 92​ directive.process(ref_input, None)
93 93​
94 # check the first arg of the first call to the stub object 94​ # check the first arg of the first call to the stub object
95 assert stub_getrepoinfo.calls()[0][1][0] == ref_arch 95​ assert stub_getrepoinfo.calls()[0][1][0] == ref_arch
96 96​
97 def test_only_meta_arches(self): 97​ def test_only_meta_arches(self):
98 directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath]) 98​ directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath])
99 ref_input = {"koji_tag": "f20", "arch": ["src", "noarch"]} 99​ ref_input = {"koji_tag": "f20", "arch": ["src", "noarch"]}
100 100​
101 with pytest.raises(TaskotronDirectiveError): 101​ with pytest.raises(TaskotronDirectiveError):
102 directive.process(ref_input, None) 102​ directive.process(ref_input, None)
103 103​
104 def test_one_base_arch(self): 104​ def test_one_base_arch(self):
105 directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath]) 105​ directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath])
106​ ref_input = {"koji_tag": "f20", "arch": "x86_64"}
107​
108​ output = directive.process(ref_input, None)
109​
110​ assert output == {
111​ "f20": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/releases/20/"
112​ "Everything/x86_64/os"}
113​ }
114​
115​ def test_one_arch_as_list(self):
116​ directive = yumrepoinfo_directive.YumrepoinfoDirective(filelist=[self.temp_conf.strpath])
106 ref_input = {"koji_tag": "f20", "arch": ["x86_64"]} 117​ ref_input = {"koji_tag": "f20", "arch": ["x86_64"]}
107 118​
108 output = directive.process(ref_input, None) 119​ output = directive.process(ref_input, None)
109 120​
110 assert output == { 121​ assert output == {
111 "f20": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/releases/20/Everything/x86_64/os"} 122​ "f20": {"x86_64": "http://download.fedoraproject.org/pub/fedora/linux/releases/20/Everything/x86_64/os"}
112 } 123​ }
113 124​
Show All 39 Lines
View Options

testing/test_bodhi_directive.py

Show All 10 Lines
11from libtaskotron.directives import bodhi_directive 11​from libtaskotron.directives import bodhi_directive
12from libtaskotron.exceptions import TaskotronDirectiveError 12​from libtaskotron.exceptions import TaskotronDirectiveError
13from libtaskotron import config 13​from libtaskotron import config
14 14​
15class TestBodhiDownloads(): 15​class TestBodhiDownloads():
16 16​
17 def setup_method(self, method): 17​ def setup_method(self, method):
18 '''Run this before every test invocation''' 18​ '''Run this before every test invocation'''
19 self.ref_arch = ['x86_64'] 19​ self.ref_arch = 'x86_64'
20 self.ref_update_id = 'FEDORA-1234-56789' 20​ self.ref_update_id = 'FEDORA-1234-56789'
21 self.ref_workdir = '/var/tmp/foo' 21​ self.ref_workdir = '/var/tmp/foo'
22 self.ref_taskfile = '/foo/bar/task.yml' 22​ self.ref_taskfile = '/foo/bar/task.yml'
23 self.ref_nvr1 = 'foo-1.2.3.fc99' 23​ self.ref_nvr1 = 'foo-1.2.3.fc99'
24 self.ref_nvr2 = 'bar-1.2.3.fc99' 24​ self.ref_nvr2 = 'bar-1.2.3.fc99'
25 self.ref_update = {'title': 'Random update', 25​ self.ref_update = {'title': 'Random update',
26 'builds': [{'nvr': self.ref_nvr1, 'package': {}}, 26​ 'builds': [{'nvr': self.ref_nvr1, 'package': {}},
27 {'nvr': self.ref_nvr2, 'package': {}} 27​ {'nvr': self.ref_nvr2, 'package': {}}
Show All 28 Lines41 def test_action_download_existing_update(self):
56 # with correct nvrs 56​ # with correct nvrs
57 assert len(getrpms_calls) == 2 57​ assert len(getrpms_calls) == 2
58 assert requested_nvrs == [self.ref_nvr1, self.ref_nvr2] 58​ assert requested_nvrs == [self.ref_nvr1, self.ref_nvr2]
59 assert output_data == ref_output_data 59​ assert output_data == ref_output_data
60 60​
61 61​
62 def test_action_download_all_archs(self): 62​ def test_action_download_all_archs(self):
63 '''Test download when all arches are demanded''' 63​ '''Test download when all arches are demanded'''
64 self.ref_arch = ['all'] 64​ self.ref_arch = 'all'
65 self.ref_input = {'action': 'download', 65​ self.ref_input = {'action': 'download',
66 'arch': self.ref_arch, 66​ 'arch': self.ref_arch,
67 'update_id': self.ref_update_id 67​ 'update_id': self.ref_update_id
68 } 68​ }
69 69​
70 stub_bodhi = Dingus(get_update__returns=self.ref_update) 70​ stub_bodhi = Dingus(get_update__returns=self.ref_update)
71 stub_koji = Dingus(get_nvr_rpms__returns=[self.ref_rpmfile]) 71​ stub_koji = Dingus(get_nvr_rpms__returns=[self.ref_rpmfile])
72 72​
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)106 def test_action_download_multiple_arch(self):
121 getrpms_calls = stub_koji.calls() 121​ getrpms_calls = stub_koji.calls()
122 req_arches = map(lambda x: x[1][2], getrpms_calls) 122​ req_arches = map(lambda x: x[1][2], getrpms_calls)
123 123​
124 # checks whether all get_nvr_rpms calls demanded only source pkgs 124​ # checks whether all get_nvr_rpms calls demanded only source pkgs
125 assert all(map(lambda x: x == ['x86_64', 'noarch'], req_arches)) 125​ assert all(map(lambda x: x == ['x86_64', 'noarch'], req_arches))
126 126​
127 def test_action_download_added_noarch(self): 127​ def test_action_download_added_noarch(self):
128 '''Test whether noarch is automaticaly added''' 128​ '''Test whether noarch is automaticaly added'''
129 self.ref_arch = ['i386'] 129​ self.ref_arch = 'i386'
130 self.ref_input = {'action': 'download', 130​ self.ref_input = {'action': 'download',
131 'arch': self.ref_arch, 131​ 'arch': self.ref_arch,
132 'update_id': self.ref_update_id 132​ 'update_id': self.ref_update_id
133 } 133​ }
134 134​
135 stub_bodhi = Dingus(get_update__returns=self.ref_update) 135​ stub_bodhi = Dingus(get_update__returns=self.ref_update)
136 stub_koji = Dingus(get_nvr_rpms__returns=[self.ref_rpmfile]) 136​ stub_koji = Dingus(get_nvr_rpms__returns=[self.ref_rpmfile])
137 137​
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines
View Options

testing/test_koji_directive.py

Show All 13 Lines
14 14​
15 15​
16class TestKojiDirective(): 16​class TestKojiDirective():
17 def setup_method(self, method): 17​ def setup_method(self, method):
18 self.koji_calls = ('get_nvr_rpms', 'get_tagged_rpms') 18​ self.koji_calls = ('get_nvr_rpms', 'get_tagged_rpms')
19 19​
20 self.ref_nvr = 'foo-1.2-3.fc99' 20​ self.ref_nvr = 'foo-1.2-3.fc99'
21 self.ref_previous_nvr = 'foo-1.2-2.fc99' 21​ self.ref_previous_nvr = 'foo-1.2-2.fc99'
22 self.ref_arch = ['noarch'] 22​ self.ref_arch = 'noarch'
23 self.ref_tag = 'tagfoo' 23​ self.ref_tag = 'tagfoo'
24 self.ref_name = 'foo' 24​ self.ref_name = 'foo'
25 self.ref_version = '1.2' 25​ self.ref_version = '1.2'
26 self.ref_release = '3.fc99' 26​ self.ref_release = '3.fc99'
27 self.ref_buildid = 123456 27​ self.ref_buildid = 123456
28 28​
29 self.ref_build = {'package_name': self.ref_name, 29​ self.ref_build = {'package_name': self.ref_name,
30 'version': self.ref_version, 30​ 'version': self.ref_version,
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Line(s)92 def test_parse_download_latest_stable_command(self):
111 111​
112 assert len(koji_calls) == 2 112​ assert len(koji_calls) == 2
113 assert requested_nvr == self.ref_previous_nvr 113​ assert requested_nvr == self.ref_previous_nvr
114 assert not requested_src 114​ assert not requested_src
115 assert not requested_debuginfo 115​ assert not requested_debuginfo
116 116​
117 @pytest.mark.parametrize('action', ACTIONS) 117​ @pytest.mark.parametrize('action', ACTIONS)
118 def test_parse_multiple_arches(self, action): 118​ def test_parse_multiple_arches(self, action):
119 ref_arch = ['noarch', 'i386'] 119​ self.ref_arch = ['noarch', 'i386']
120 ref_input = {'action': action, 'arch': ref_arch, 120​ ref_input = {'action': action, 'arch': self.ref_arch,
121 'koji_build': self.ref_nvr, 'koji_tag': self.ref_tag} 121​ 'koji_build': self.ref_nvr, 'koji_tag': self.ref_tag}
122 122​
123 stub_koji = Dingus('koji_utils') 123​ stub_koji = Dingus('koji_utils')
124 test_helper = koji_directive.KojiDirective(stub_koji) 124​ test_helper = koji_directive.KojiDirective(stub_koji)
125 test_helper.process(ref_input, self.ref_arg_data) 125​ test_helper.process(ref_input, self.ref_arg_data)
126 126​
127 getrpm_calls = [call for call in stub_koji.calls() if call[0] in self.koji_calls] 127​ getrpm_calls = [call for call in stub_koji.calls() if call[0] in self.koji_calls]
128 assert len(getrpm_calls) >= 1 128​ assert len(getrpm_calls) >= 1
129 for call in getrpm_calls: 129​ for call in getrpm_calls:
130 requested_arches = call[2]['arches'] 130​ requested_arches = call[2]['arches']
131 assert requested_arches == ref_arch 131​ assert requested_arches == self.ref_arch
132 132​
133 @pytest.mark.parametrize('action', ACTIONS) 133​ @pytest.mark.parametrize('action', ACTIONS)
134 def test_parse_single_arch(self, action): 134​ def test_parse_single_arch(self, action):
135 ref_input = {'action': action, 'arch': self.ref_arch, 135​ ref_input = {'action': action, 'arch': self.ref_arch,
136 'koji_build': self.ref_nvr, 'koji_tag': self.ref_tag} 136​ 'koji_build': self.ref_nvr, 'koji_tag': self.ref_tag}
137 137​
138 stub_koji = Dingus('koji_utils') 138​ stub_koji = Dingus('koji_utils')
139 139​
140 test_helper = koji_directive.KojiDirective(stub_koji) 140​ test_helper = koji_directive.KojiDirective(stub_koji)
141 test_helper.process(ref_input, self.ref_arg_data) 141​ test_helper.process(ref_input, self.ref_arg_data)
142 142​
143 getrpm_calls = [call for call in stub_koji.calls() if call[0] in self.koji_calls] 143​ getrpm_calls = [call for call in stub_koji.calls() if call[0] in self.koji_calls]
144 assert len(getrpm_calls) >= 1 144​ assert len(getrpm_calls) >= 1
145 for call in getrpm_calls: 145​ for call in getrpm_calls:
146 requested_arches = call[2]['arches'] 146​ requested_arches = call[2]['arches']
147 assert requested_arches == self.ref_arch 147​ assert requested_arches == [self.ref_arch]
148​
149​ @pytest.mark.parametrize('action', ACTIONS)
150​ def test_parse_single_arch_as_list(self, action):
151​ ref_input = {'action': action, 'arch': [self.ref_arch],
152​ 'koji_build': self.ref_nvr, 'koji_tag': self.ref_tag}
153​
154​ stub_koji = Dingus('koji_utils')
155​
156​ test_helper = koji_directive.KojiDirective(stub_koji)
157​ test_helper.process(ref_input, self.ref_arg_data)
158​
159​ getrpm_calls = [call for call in stub_koji.calls() if call[0] in self.koji_calls]
160​ assert len(getrpm_calls) >= 1
161​ for call in getrpm_calls:
162​ requested_arches = call[2]['arches']
163​ assert requested_arches == [self.ref_arch]
148 164​
149 @pytest.mark.parametrize('action', ACTIONS) 165​ @pytest.mark.parametrize('action', ACTIONS)
150 def test_add_noarch(self, action): 166​ def test_add_noarch(self, action):
151 ref_input = {'action': action, 'arch': ['x86_64'], 167​ ref_input = {'action': action, 'arch': 'x86_64',
152 'koji_build': self.ref_nvr, 'koji_tag': self.ref_tag} 168​ 'koji_build': self.ref_nvr, 'koji_tag': self.ref_tag}
153 169​
154 stub_koji = Dingus() 170​ stub_koji = Dingus()
155 test_helper = koji_directive.KojiDirective(stub_koji) 171​ test_helper = koji_directive.KojiDirective(stub_koji)
156 test_helper.process(ref_input, self.ref_arg_data) 172​ test_helper.process(ref_input, self.ref_arg_data)
157 173​
158 getrpm_calls = [call for call in stub_koji.calls() if call[0] in self.koji_calls] 174​ getrpm_calls = [call for call in stub_koji.calls() if call[0] in self.koji_calls]
159 assert len(getrpm_calls) >= 1 175​ assert len(getrpm_calls) >= 1
160 for call in getrpm_calls: 176​ for call in getrpm_calls:
161 requested_arches = call[2]['arches'] 177​ requested_arches = call[2]['arches']
162 for arch in ref_input['arch']: 178​ for arch in ref_input['arch']:
163 assert arch in requested_arches 179​ assert arch in requested_arches
164 assert 'noarch' in requested_arches 180​ assert 'noarch' in requested_arches
165 181​
166 @pytest.mark.parametrize('action', ACTIONS) 182​ @pytest.mark.parametrize('action', ACTIONS)
167 def test_exclude_arch(self, action): 183​ def test_exclude_arch(self, action):
168 ref_input = {'action': action, 'arch': ['all'], 'arch_exclude': ['x86_64', 'noarch'], 184​ ref_input = {'action': action, 'arch': 'all', 'arch_exclude': ['x86_64', 'noarch'],
169 'koji_build': self.ref_nvr, 'koji_tag': self.ref_tag} 185​ 'koji_build': self.ref_nvr, 'koji_tag': self.ref_tag}
170 186​
171 stub_koji = Dingus() 187​ stub_koji = Dingus()
172 test_helper = koji_directive.KojiDirective(stub_koji) 188​ test_helper = koji_directive.KojiDirective(stub_koji)
173 test_helper.process(ref_input, self.ref_arg_data) 189​ test_helper.process(ref_input, self.ref_arg_data)
174 190​
175 getrpm_calls = [call for call in stub_koji.calls() if call[0] in self.koji_calls] 191​ getrpm_calls = [call for call in stub_koji.calls() if call[0] in self.koji_calls]
176 assert len(getrpm_calls) >= 1 192​ assert len(getrpm_calls) >= 1
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines
View Options

testing/test_main.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Line(s)42 def test_type(self, itemtype):
44 test_args = main.process_args(self.ref_input) 44​ test_args = main.process_args(self.ref_input)
45 assert test_args[itemtype] == self.ref_input['item'] 45​ assert test_args[itemtype] == self.ref_input['item']
46 46​
47 def test_multiple_arches(self): 47​ def test_multiple_arches(self):
48 self.ref_input['arch'] = ['x86_64', 'i386', 'noarch'] 48​ self.ref_input['arch'] = ['x86_64', 'i386', 'noarch']
49 test_args = main.process_args(self.ref_input) 49​ test_args = main.process_args(self.ref_input)
50 assert test_args['arch'] == self.ref_input['arch'] 50​ assert test_args['arch'] == self.ref_input['arch']
51 51​
52 def test_no_arch(self): ​
53 self.ref_input['arch'] = None ​
54 test_args = main.process_args(self.ref_input) ​
55 assert test_args['arch'] == ['noarch'] ​
56 ​
57 def test_orig_args(self): 52​ def test_orig_args(self):
58 test_args = main.process_args(self.ref_input) 53​ test_args = main.process_args(self.ref_input)
59 assert test_args['_orig_args'] == self.ref_input 54​ assert test_args['_orig_args'] == self.ref_input
60 55​
61 def test_override(self): 56​ def test_override(self):
62 self.ref_input['override'] = ['foo=bar', 'baz=qux=zux'] 57​ self.ref_input['override'] = ['foo=bar', 'baz=qux=zux']
63 test_args = main.process_args(self.ref_input) 58​ test_args = main.process_args(self.ref_input)
64 assert test_args['override'] == {'foo': 'bar', 'baz': 'qux=zux'} 59​ assert test_args['override'] == {'foo': 'bar', 'baz': 'qux=zux'}
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines
View Options

testing/test_taskformula.py

Show First 20 Lines • Show All 220 Lines • ▼ Show 20 Line(s)218 def test_infer_from_koji_tag(self):
221 assert ret == {'distro': 'fedora', 'release': '23', 'flavor': None, 'arch': None} 221​ assert ret == {'distro': 'fedora', 'release': '23', 'flavor': None, 'arch': None}
222 222​
223 def test_infer_from_koji_tag_unknown_distro(self): 223​ def test_infer_from_koji_tag_unknown_distro(self):
224 arg_data = {"type": "koji_tag", "item": "el6-updates-pending"} 224​ arg_data = {"type": "koji_tag", "item": "el6-updates-pending"}
225 ret = taskformula.devise_environment({'environment': {}}, arg_data) 225​ ret = taskformula.devise_environment({'environment': {}}, arg_data)
226 assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': None} 226​ assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': None}
227 227​
228 def test_infer_from_arch(self): 228​ def test_infer_from_arch(self):
229 arg_data = {"arch": []} 229​ arg_data = {"arch": None}
230 ret = taskformula.devise_environment({'environment': {}}, arg_data) 230​ ret = taskformula.devise_environment({'environment': {}}, arg_data)
231 assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': None} 231​ assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': None}
232 232​
233 arg_data = {"arch": ['noarch']} 233​ arg_data = {"arch": 'noarch'}
234 ret = taskformula.devise_environment({'environment': {}}, arg_data) 234​ ret = taskformula.devise_environment({'environment': {}}, arg_data)
235 assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': None} 235​ assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': None}
236 236​
237 arg_data = {"arch": ['i386']} 237​ arg_data = {"arch": 'i386'}
238 ret = taskformula.devise_environment({'environment': {}}, arg_data) 238​ ret = taskformula.devise_environment({'environment': {}}, arg_data)
239 assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': 'i386'} 239​ assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': 'i386'}
240 ​
241 def test_infer_from_multiple_arches(self): ​
242 arg_data = {"arch": ['i386', 'noarch']} ​
243 ret = taskformula.devise_environment({'environment': {}}, arg_data) ​
244 assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': 'i386'} ​
245 ​
246 arg_data = {"arch": ['i386', 'x86_64']} ​
247 ret = taskformula.devise_environment({'environment': {}}, arg_data) ​
248 assert ret == {'distro': None, 'release': None, 'flavor': None, 'arch': None} ​