Differential D113

python_utils: replace listlike() with iterable() and sequence()
ClosedPublic
Actions

Authored by kparal on May 29 2014, 12:16 PM.

Details

Reviewers
tflink
mkrizek
jskladan
Commits
rLTRN6fe71ab8c461: python_utils: replace listlike() with iterable() and sequence()
Summary

This fixes a pet peeve of mine - the listlike() function name. It was a bit misleading. Hopefully it should be clearer after this patch.

These two new functions are often handy. As a bonus, they can also check
type validity of items they contain.

The new names match better their purpose. By separating them, it's easy
to pick the right one in different situations. It requires a person to
be familiar with abstract base classes, though (iterable, sequence,
mapping, container, etc).

This patch also improves isinstance() checking on various places and
uses ABCs instead of hardcoded object names (like list, dict, etc).

Test Plan

New tests, all pass.

Diff Detail

Repository
rLTRN libtaskotron
Lint
Lint Skipped
Unit
Unit Tests Skipped
kparal retitled this revision from to python_utils: replace listlike() with iterable() and sequence().May 29 2014, 12:16 PM
kparal updated this object.
kparal edited the test plan for this revision. (Show Details)
kparal added reviewers: tflink, mkrizek, jskladan.
tflink accepted this revision.May 29 2014, 1:45 PM

The code still feels a bit un-pythonic (the concept of type checking, mostly) but I know why it's there and I'm not objecting to it as long as we don't start using it everywhere :)

Overall, it's an improvement. Looks good to me.

This revision is now accepted and ready to land.May 29 2014, 1:45 PM
jskladan added inline comments.May 29 2014, 2:54 PM
libtaskotron/check.py
92

Are you sure you really want to be testing for sequence here? From what the rest of the code looks like, it seems that list is specifically required, not just any sequence - see line #159

libtaskotron/python_utils.py
30

Judging from the diff - do you really think sequence is needed? There is nothing specifically sequence-specific - i.e. nothing in the diff (but I might have missed something, of course) does not need the direct access via integer indices.

Also, should we keep both iterable and sequence, it might be usefull to re-phrase the docstring a bit, so it captures the most basic diffenrece (IMHO) between iterable and sequence - that dict is an iterable, but not a sequence. Other than that, these are quite inter-changeable (given that our code does not specifically need integer indexing).

Also /me has a bit of a bad-english-day, so any perceived snarkiness is unintended byproduct :)

kparal updated this revision to Diff 327.May 30 2014, 11:48 AM
  • address issues in review
kparal added a comment.May 30 2014, 11:56 AM

Thanks, Josef, very good points. Another attempt posted.

libtaskotron/check.py
92

Good catch, output must be a MutableSequence, not just any Sequence.

And I thought I'd keep the python_utils methods really simple. I had to add an additional method argument.

libtaskotron/python_utils.py
30

For example CheckDetail.output must be a sequence, because it must be ordered - it doesn't make sense to have a set of strings as a check output. The same applies for python directive output.

That's also a reply what I consider the biggest difference between an iterable and a sequence - being ordered and indexable. I don't think dict constitutes a big difference, because you rarely want to consider dict as something else than a Mapping. It's a way too different structure from all those lists, sets and tuples.

kparal requested a review of this revision.May 30 2014, 2:49 PM
tflink accepted this revision.May 30 2014, 3:12 PM

Looks good to me.

This revision is now accepted and ready to land.May 30 2014, 3:12 PM
jskladan accepted this revision.Jun 2 2014, 8:21 AM

OOK!

kparal closed this revision.Jun 2 2014, 9:47 AM
kparal updated this revision to Diff 339.

Closed by commit rLTRN6fe71ab8c461 (authored by @kparal).

Revision Contents

Diff 339

View Options

libtaskotron/bodhi_utils.py

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Line(s)84 * The second dict provides mapping between ``builds`` and their
87 possible cause of failure if ``strict=False``). Or the value 87​ possible cause of failure if ``strict=False``). Or the value
88 is a Bodhi update that was incomplete (happens only if 88​ is a Bodhi update that was incomplete (happens only if
89 ``strict=True``). 89​ ``strict=True``).
90 90​
91 ``{build (string): Bodhi update (Bunch) or None}`` 91​ ``{build (string): Bodhi update (Bunch) or None}``
92 :raise TaskotronValueError: if ``builds`` type is incorrect 92​ :raise TaskotronValueError: if ``builds`` type is incorrect
93 ''' 93​ '''
94 # validate input params 94​ # validate input params
95 if not python_utils.listlike(builds): 95​ if not python_utils.iterable(builds, basestring):
96 raise exc.TaskotronValueError("Param 'builds' must be iterable, " 96​ raise exc.TaskotronValueError("Param 'builds' must be an iterable "
97 "and yours was: %s" % type(builds)) 97​ "of strings, and yours was: %s" % type(builds))
98 98​
99 build2update = {} 99​ build2update = {}
100 failures = {} 100​ failures = {}
101 # Bodhi works with NVR only, but we have to ensure we receive and return 101​ # Bodhi works with NVR only, but we have to ensure we receive and return
102 # even NEVR format. So we need to convert internally. 102​ # even NEVR format. So we need to convert internally.
103 builds_nvr = set([rpm_utils.rpmformat(build, 'nvr') 103​ builds_nvr = set([rpm_utils.rpmformat(build, 'nvr')
104 for build in builds]) 104​ for build in builds])
105 105​
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines
View Options

libtaskotron/check.py

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Line(s)22class CheckDetail(object):
83 83​
84 outcome_priority = ('PASSED', 'INFO', 'FAILED', 'NEEDS_INSPECTION', 84​ outcome_priority = ('PASSED', 'INFO', 'FAILED', 'NEEDS_INSPECTION',
85 'ABORTED', 'CRASHED') 85​ 'ABORTED', 'CRASHED')
86 86​
87 87​
88 def __init__(self, item, report_type=None, outcome=None, summary='', 88​ def __init__(self, item, report_type=None, outcome=None, summary='',
89 output=None, keyvals=None): 89​ output=None, keyvals=None):
90 # validate input 90​ # validate input
91 if output is not None and not python_utils.listlike(output): 91​ if (output is not None and
92 raise exc.TaskotronValueError("'output' parameter must be a list. " 92​ not python_utils.sequence(output, basestring, mutable=True)):
jskladanUnsubmitted
Not Done

Are you sure you really want to be testing for sequence here? From what the rest of the code looks like, it seems that list is specifically required, not just any sequence - see line #159

kparalAuthorUnsubmitted
Not Done

Good catch, output must be a MutableSequence, not just any Sequence.

And I thought I'd keep the python_utils methods really simple. I had to add an additional method argument.

93 "Yours was: %s" % type(output)) 93​ raise exc.TaskotronValueError("'output' parameter must be a "
94​ "mutable sequence of strings. Yours was: %s" % type(output))
94 if keyvals is not None and not isinstance(keyvals, collections.Mapping): 95​ if keyvals is not None and not isinstance(keyvals, collections.Mapping):
95 raise exc.TaskotronValueError("'keyvals' parameter must behave like" 96​ raise exc.TaskotronValueError("'keyvals' parameter must be a "
96 " a dictionary. Yours was: %s" % type(keyvals)) 97​ "mapping. Yours was: %s" % type(keyvals))
97 98​
98 self.item = item 99​ self.item = item
99 self.report_type = report_type 100​ self.report_type = report_type
100 self._outcome = None 101​ self._outcome = None
101 if outcome: 102​ if outcome:
102 self.outcome = outcome 103​ self.outcome = outcome
103 self.summary = summary 104​ self.summary = summary
104 self.output = output or [] 105​ self.output = output or []
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Line(s)189 def create_multi_item_summary(cls, outcomes):
195 ''' 196​ '''
196 # validate input 197​ # validate input
197 if isinstance(outcomes, CheckDetail): 198​ if isinstance(outcomes, CheckDetail):
198 outcomes = (outcomes,) 199​ outcomes = (outcomes,)
199 200​
200 if len(outcomes) <= 0: 201​ if len(outcomes) <= 0:
201 return '' 202​ return ''
202 203​
203 if isinstance(iter(outcomes).next(), CheckDetail): 204​ if python_utils.iterable(outcomes, CheckDetail):
204 all_outcomes = [detail.outcome for detail in outcomes] 205​ all_outcomes = [detail.outcome for detail in outcomes]
205 else: # list of strings 206​ else: # list of strings
206 if not python_utils.listlike(outcomes): 207​ if not python_utils.iterable(outcomes, basestring):
207 raise exc.TaskotronValueError("'outcomes' parameter type is " 208​ raise exc.TaskotronValueError("'outcomes' parameter type is "
208 'incorrect: %s' % type(outcomes)) 209​ 'incorrect: %s' % type(outcomes))
209 all_outcomes = outcomes 210​ all_outcomes = outcomes
210 211​
211 # create the summary 212​ # create the summary
212 summary = [] 213​ summary = []
213 for res in cls.outcome_priority: 214​ for res in cls.outcome_priority:
214 count = all_outcomes.count(res) 215​ count = all_outcomes.count(res)
215 if count > 0: 216​ if count > 0:
216 summary.append('%d %s' % (count, res)) 217​ summary.append('%d %s' % (count, res))
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Line(s)337 for test in tap.tests:
337 y = test.yaml 338​ y = test.yaml
338 item = y.get('item', None) 339​ item = y.get('item', None)
339 report_type = y.get('type', None) 340​ report_type = y.get('type', None)
340 outcome = 'PASSED' if test.result == 'ok' else 'FAILED' 341​ outcome = 'PASSED' if test.result == 'ok' else 'FAILED'
341 outcome = y.get('outcome', outcome) 342​ outcome = y.get('outcome', outcome)
342 summary = y.get('summary', '') 343​ summary = y.get('summary', '')
343 details = y.get('details', {}) 344​ details = y.get('details', {})
344 output = details.get('output', None) 345​ output = details.get('output', None)
346​ if output is not None:
347​ output = [output]
345 348​
346 # TODO: is there a better way to do this? 349​ # TODO: is there a better way to do this?
347 other_keys = set(y.keys()) - set(RESERVED_KEYS) 350​ other_keys = set(y.keys()) - set(RESERVED_KEYS)
348 keyvals = dict([(k,y[k]) for k in other_keys]) 351​ keyvals = dict([(k,y[k]) for k in other_keys])
349 352​
350 cd = CheckDetail(item, report_type, outcome, summary, [output]) 353​ cd = CheckDetail(item, report_type, outcome, summary, output)
351 354​
352 cd.keyvals = keyvals 355​ cd.keyvals = keyvals
353 check_details.append(cd) 356​ check_details.append(cd)
354 357​
355 return check_details 358​ return check_details
356 359​
View Options

libtaskotron/config.py

1# -*- coding: utf-8 -*- 1​# -*- coding: utf-8 -*-
2# Copyright 2010-2014, Red Hat, Inc. 2​# Copyright 2010-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'''Global configuration for Taskotron and relevant helper methods.''' 5​'''Global configuration for Taskotron and relevant helper methods.'''
6 6​
7import os 7​import os
8import yaml 8​import yaml
9​import collections
9 10​
10import libtaskotron 11​import libtaskotron
11 12​
12from . import exceptions as exc 13​from . import exceptions as exc
13from .logger import log 14​from .logger import log
14from .config_defaults import (Config, ProductionConfig, TestingConfig, 15​from .config_defaults import (Config, ProductionConfig, TestingConfig,
15 ProfileName) 16​ ProfileName)
16from . import file_utils 17​from . import file_utils
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 Line(s)142def _load_file(conf_file):
169 170​
170 # config file might be empty (all commented out), returning None. For 171​ # config file might be empty (all commented out), returning None. For
171 # further processing, let's replace it with empty dict 172​ # further processing, let's replace it with empty dict
172 if conf_obj is None: 173​ if conf_obj is None:
173 conf_obj = {} 174​ conf_obj = {}
174 175​
175 # check correct types 176​ # check correct types
176 # we should receive a single dictionary with keyvals 177​ # we should receive a single dictionary with keyvals
177 if not isinstance(conf_obj, dict): 178​ if not isinstance(conf_obj, collections.Mapping):
178 raise exc.TaskotronConfigError('The config file %s does not have ' 179​ raise exc.TaskotronConfigError('The config file %s does not have '
179 'a valid structure. Instead of a dictionary, it is recognized as: %s' % 180​ 'a valid structure. Instead of a mapping, it is recognized as: %s' %
180 (filename, type(conf_obj))) 181​ (filename, type(conf_obj)))
181 182​
182 default_conf = Config() 183​ default_conf = Config()
183 for option, value in conf_obj.items(): 184​ for option, value in conf_obj.items():
184 # check for unknown options 185​ # check for unknown options
185 try: 186​ try:
186 default_value = getattr(default_conf, option) 187​ default_value = getattr(default_conf, option)
187 except AttributeError: 188​ except AttributeError:
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines
View Options

libtaskotron/directives/bodhi_comment_directive.py

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Line(s)202 '''Check if Taskotron comment is already posted.
215 215​
216 Throws: 216​ Throws:
217 TaskotronValueError -- if no such update can be found 217​ TaskotronValueError -- if no such update can be found
218 ''' 218​ '''
219 219​
220 Config = config.get_config() 220​ Config = config.get_config()
221 221​
222 # if we received update title or ID, let's convert it to update object first 222​ # if we received update title or ID, let's convert it to update object first
223 if isinstance(update, unicode) or isinstance(update, str): 223​ if isinstance(update, basestring):
224 u = bodhi_api.query_update(update) 224​ u = bodhi_api.query_update(update)
225 if u: 225​ if u:
226 update = u 226​ update = u
227 else: 227​ else:
228 raise TaskotronValueError("No such update: %s" % update) 228​ raise TaskotronValueError("No such update: %s" % update)
229 229​
230 comment_re = r'Taskotron:[\s]+%s[\s]+test[\s]+(\w+)[\s]+on[\s]+%s' % (testname, arch) 230​ comment_re = r'Taskotron:[\s]+%s[\s]+test[\s]+(\w+)[\s]+on[\s]+%s' % (testname, arch)
231 old_result = '' 231​ old_result = ''
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines
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​
7import collections 7​import collections
8 8​
9​import libtaskotron.exceptions as exc
9 10​
10def listlike(value): ​
11 '''Return whether ``value`` is iterable (``list``, ``tuple``, ``set``, ​
12 etc), but not ``str`` (which is iterable, but we don't often want to ​
13 consider it as such). This method is useful e.g. if you want to check that a ​
14 variable contains a list/set/etc of strings. ​
15 11​
16 :param any value: any object or literal you want to check 12​def iterable(obj, item_type=None):
17 :return: whether ``value`` is iterable but not string 13​ '''Decide whether ``obj`` is an :class:`~collections.Iterable` (you can
14​ traverse through its elements - e.g. ``list``, ``tuple``, ``set``, even
15​ ``dict``), but not ``basestring`` (which satisfies most collections'
16​ requirements, but we don't often want to consider as a collection). You can
17​ also verify the types of items in the collection.
18​
19​ :param any obj: any object you want to check
20​ :param type item_type: all items in ``obj`` must be instances of this
21​ provided type. If ``None``, no check is performed.
22​ :return: whether ``obj`` is iterable but not a string, and whether ``obj``
23​ contains only ``item_type`` items
18 :rtype: bool 24​ :rtype: bool
25​ :raise TaskotronValueError: if you provide invalid parameter value
26​ '''
27​ return _collection_of(obj, collections.Iterable, item_type)
28​
29​
30​def sequence(obj, item_type=None, mutable=False):
jskladanUnsubmitted
Not Done

Judging from the diff - do you really think sequence is needed? There is nothing specifically sequence-specific - i.e. nothing in the diff (but I might have missed something, of course) does not need the direct access via integer indices.

Also, should we keep both iterable and sequence, it might be usefull to re-phrase the docstring a bit, so it captures the most basic diffenrece (IMHO) between iterable and sequence - that dict is an iterable, but not a sequence. Other than that, these are quite inter-changeable (given that our code does not specifically need integer indexing).

Also /me has a bit of a bad-english-day, so any perceived snarkiness is unintended byproduct :)

kparalAuthorUnsubmitted
Not Done

For example CheckDetail.output must be a sequence, because it must be ordered - it doesn't make sense to have a set of strings as a check output. The same applies for python directive output.

That's also a reply what I consider the biggest difference between an iterable and a sequence - being ordered and indexable. I don't think dict constitutes a big difference, because you rarely want to consider dict as something else than a Mapping. It's a way too different structure from all those lists, sets and tuples.

31​ '''This has the same functionality and basic arguments as :func:`iterable`
32​ (read its documentation), but decides whether ``obj`` is a
33​ :class:`~collections.Sequence` (ordered and indexable collection - e.g.
34​ ``list`` or ``tuple``, but not ``set`` or ``dict``).
35​
36​ :param bool mutable: if ``True``, the ``obj`` must be a mutable sequence
37​ (e.g. ``list``, but not ``tuple``)
19 ''' 38​ '''
20 return (isinstance(value, collections.Iterable) and 39​ col = collections.MutableSequence if mutable else collections.Sequence
21 not isinstance(value, basestring)) 40​ return _collection_of(obj, col, item_type)
41​
42​
43​def _collection_of(obj, collection_cls, item_type=None):
44​ '''The same as :func:`iterable` or :func:`sequence`, but the abstract
45​ collection class can be specified dynamically with ``collection_cls``.
46​ '''
47​ if not isinstance(obj, collection_cls) or isinstance(obj, basestring):
48​ return False
49​
50​ if item_type is not None and isinstance(obj, collections.Iterable):
51​ try:
52​ return all([isinstance(item, item_type) for item in obj])
53​ except TypeError as e:
54​ raise exc.TaskotronValueError("'item_type' must be a type "
55​ "definition, not '%r': %s" % (item_type, e))
56​
57​ return True
View Options

libtaskotron/runner.py

1import logging 1​import logging
2import tempfile 2​import tempfile
3import os.path 3​import os.path
4import argparse 4​import argparse
5import imp 5​import imp
6import copy 6​import copy
7​import collections
7 8​
8from libtaskotron import taskyaml 9​from libtaskotron import taskyaml
9from libtaskotron import logger 10​from libtaskotron import logger
10from libtaskotron import python_utils 11​from libtaskotron import python_utils
11from libtaskotron import config 12​from libtaskotron import config
12from libtaskotron.logger import log 13​from libtaskotron.logger import log
13from libtaskotron.exceptions import TaskotronYamlError 14​from libtaskotron.exceptions import TaskotronYamlError
14 15​
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Line(s)103 def do_actions(self):
115 116​
116 for action in self.taskdata['task']: 117​ for action in self.taskdata['task']:
117 self.do_single_action(action) 118​ self.do_single_action(action)
118 119​
119 def _validate_input(self): 120​ def _validate_input(self):
120 if 'input' not in self.taskdata: 121​ if 'input' not in self.taskdata:
121 return 122​ return
122 123​
123 if not isinstance(self.taskdata['input'], dict): 124​ if not isinstance(self.taskdata['input'], collections.Mapping):
124 raise TaskotronYamlError("Input yaml should contain correct 'input'" 125​ raise TaskotronYamlError("Input yaml should contain correct 'input'"
125 "section (a dictionary). Yours was: %s" % type( 126​ "section (a mapping). Yours was: %s" % type(
126 self.taskdata['input'])) 127​ self.taskdata['input']))
127 128​
128 required_input = self.taskdata['input'].get('args', None) 129​ required_args = self.taskdata['input'].get('args', None)
129 130​
130 if not isinstance(required_input, list): 131​ if not python_utils.iterable(required_args):
131 raise TaskotronYamlError("Input yaml should contain correct 'args' " 132​ raise TaskotronYamlError("Input yaml should contain correct 'args' "
132 "section (a list). Yours was: %s" % type(required_input)) 133​ "section (an iterable). Yours was: %s" % type(required_args))
133 134​
134 for arg in required_input: 135​ for arg in required_args:
135 if not arg in self.envdata: 136​ if not arg in self.envdata:
136 raise TaskotronYamlError("Required input arg '%s' " 137​ raise TaskotronYamlError("Required input arg '%s' "
137 "was not defined" % arg) 138​ "was not defined" % arg)
138 139​
139 def _validate_env(self): 140​ def _validate_env(self):
140 # TODO: implement this 141​ # TODO: implement this
141 raise NotImplementedError("Environment validation is not" 142​ raise NotImplementedError("Environment validation is not"
142 " yet implemented") 143​ " yet implemented")
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Line(s)183def main():
193 194​
194 if not task_data: 195​ if not task_data:
195 raise TaskotronYamlError('Input file should not be empty') 196​ raise TaskotronYamlError('Input file should not be empty')
196 197​
197 task_runner = Runner(task_data, arg_data) 198​ task_runner = Runner(task_data, arg_data)
198 task_runner.run() 199​ task_runner.run()
199 200​
200 for output in task_runner.working_data: 201​ for output in task_runner.working_data:
201 if python_utils.listlike(task_runner.working_data[output]): 202​ if python_utils.sequence(task_runner.working_data[output], basestring):
202 log.info("\n" + "\n".join(task_runner.working_data[output])) 203​ log.info("\n" + "\n".join(task_runner.working_data[output]))
203 else: 204​ else:
204 log.info("\n" + task_runner.working_data[output]) 205​ log.info("\n" + task_runner.working_data[output])
View Options

testing/test_bodhi_comment_directive.py

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Line(s)20 def setup(self, monkeypatch):
42 42​
43 self.cd = check.CheckDetail( 43​ self.cd = check.CheckDetail(
44 item = 'update_title', 44​ item = 'update_title',
45 report_type = check.ReportType.BODHI_UPDATE, 45​ report_type = check.ReportType.BODHI_UPDATE,
46 outcome = 'PASSED', 46​ outcome = 'PASSED',
47 ) 47​ )
48 48​
49 49​
50 #TODO: remove this ugly hack - it is here because of the bug in bayeux 50​ tap = check.export_TAP(self.cd)
51 tap = "TAP version 13\n1..1\n%s" % check.export_TAP(self.cd) ​
52 ​
53 51​
54 self.ref_input = { 52​ self.ref_input = {
55 'results': tap, 53​ 'results': tap,
56 'doreport': 'onchange', 54​ 'doreport': 'onchange',
57 } 55​ }
58 self.ref_envdata = { 56​ self.ref_envdata = {
59 'checkname': 'depcheck', 57​ 'checkname': 'depcheck',
60 } 58​ }
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines
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​import pytest
8​
7from libtaskotron import python_utils 9​from libtaskotron import python_utils
10​import libtaskotron.exceptions as exc
11​
12​class TestCollectionOf:
13​ '''This basically tests `iterable` and `sequence`.'''
14​
15​ def test_iterable(self):
16​ assert python_utils.iterable([1, 2])
17​ assert python_utils.iterable(['a', 'b'])
18​ assert python_utils.iterable(('foo',))
19​ assert python_utils.iterable({'foo', 'bar', 'baz'})
20​ assert python_utils.iterable(set())
21​ assert python_utils.iterable(())
22​ assert python_utils.iterable([u'foo', u'bar'])
23​ assert python_utils.iterable({'a': 1, 'b': 2})
24​
25​ def test_not_iterable(self):
26​ assert not python_utils.iterable('a')
27​ assert not python_utils.iterable(u'a')
28​ assert not python_utils.iterable(unicode('foo'))
29​ assert not python_utils.iterable(3)
30​ assert not python_utils.iterable(3.14)
31​ assert not python_utils.iterable(None)
32​ assert not python_utils.iterable(object())
33​
34​ def test_iterable_items(self):
35​ assert python_utils.iterable([1, 2], int)
36​ assert not python_utils.iterable([1, 2], float)
37​ assert not python_utils.iterable([1, 2.2], float)
38​
39​ assert python_utils.iterable(['a', 'b'], str)
40​ assert python_utils.iterable(['a', 'b'], basestring)
41​ assert not python_utils.iterable(['a', 'b'], unicode)
42​
43​ assert python_utils.iterable([[],[]], list)
44​
45​ # empty classes
46​ X = type('X', (object,), {})
47​ Y = type('Y', (X,), {})
48​ assert python_utils.iterable((X(), X()), X)
49​ assert python_utils.iterable((X(), Y()), X)
50​ assert not python_utils.iterable((X(), Y()), Y)
51​
52​ def test_raise(self):
53​ with pytest.raises(exc.TaskotronValueError):
54​ assert python_utils.iterable([1, 2], 1)
55​
56​ with pytest.raises(exc.TaskotronValueError):
57​ assert python_utils.iterable([1, 2], 'a')
58​
59​ with pytest.raises(exc.TaskotronValueError):
60​ assert python_utils.iterable([1, 2], [])
61​
62​ X = type('X', (object,), {})
63​ with pytest.raises(exc.TaskotronValueError):
64​ assert python_utils.iterable([1, 2], X())
65​
66​ def test_sequence(self):
67​ assert python_utils.sequence([1, 2])
68​ assert python_utils.sequence(['a', 'b'])
69​ assert python_utils.sequence(('foo',))
70​ assert python_utils.sequence(())
71​ assert python_utils.sequence([u'foo', u'bar'])
8 72​
9class TestPythonUtils: 73​ def test_not_sequence(self):
10 74​ assert not python_utils.sequence({'foo', 'bar', 'baz'})
11 def test_listlike_true(self): 75​ assert not python_utils.sequence(set())
12 '''Test 'listlike' method when it returns True''' 76​ assert not python_utils.sequence({'a': 1, 'b': 2})
13 assert python_utils.listlike([1, 2]) ​
14 assert python_utils.listlike(['a', 'b']) ​
15 assert python_utils.listlike(('foo',)) ​
16 assert python_utils.listlike({'foo', 'bar', 'baz'}) ​
17 assert python_utils.listlike(set()) ​
18 assert python_utils.listlike(()) ​
19 assert python_utils.listlike([u'foo', u'bar']) ​
20 assert python_utils.listlike({'a': 1, 'b': 2}) ​
21 ​
22 def test_listlike_false(self): ​
23 '''Test 'listlike' method when it returns False''' ​
24 assert not python_utils.listlike('a') ​
25 assert not python_utils.listlike(u'a') ​
26 assert not python_utils.listlike(unicode('foo')) ​
27 assert not python_utils.listlike(3) ​
28 assert not python_utils.listlike(3.14) ​
29 assert not python_utils.listlike(None) ​
30 assert not python_utils.listlike(object()) ​