def test_check_with_cast_func(self):
check.register_class(self._wine, cast_func=self._wine.parse)
self.assertEqual(self._wine.OPORTO,
check.check__wine(self._wine.OPORTO))
self.assertEqual(self._wine.SANCERRE, check.check__wine(1))
self.assertEqual(self._wine.CHABLIS, check.check__wine('CHABLIS'))
check.unregister_class(self._wine)
def test_check_seq(self):
class _test_check_orange(object):
pass
C.register_class(_test_check_orange, '_test_check_orange')
C.check__test_check_orange_seq(
[_test_check_orange(), _test_check_orange()])
def test_is(self):
class _test_check_baz(object):
pass
C.register_class(_test_check_baz, '_test_check_baz')
self.assertTrue(C.is__test_check_baz(_test_check_baz()))
self.assertFalse(C.is__test_check_baz(int(6)))
def test_register_class_duplicate(self):
class _test_check_bar(object):
pass
C.register_class(_test_check_bar, '_test_check_bar')
with self.assertRaises(RuntimeError) as context:
C.register_class(_test_check_bar, '_test_check_bar')
def test_check_with_cast_func(self):
check.register_class(self._spread, cast_func=self._spread.parse)
self.assertEqual(self._spread.BUTTER,
check.check__spread(self._spread.BUTTER))
self.assertEqual(self._spread.CREAM_CHEESE,
check.check__spread('CREAM_CHEESE'))
self.assertEqual(self._spread.JAM, check.check__spread('JAM'))
check.unregister_class(self._spread)
def test_register_class(self):
class _test_check_foo(object):
pass
C.register_class(_test_check_foo, '_test_check_foo')
C.check__test_check_foo(_test_check_foo())
with self.assertRaises(TypeError) as context:
C.check__test_check_foo(6)
def test_custom_class_allow_none(self):
class _test_check_wine(object):
pass
C.register_class(_test_check_wine, '_test_check_wine')
C.check__test_check_wine(_test_check_wine())
C.check__test_check_wine(None, allow_none=True)
C.check__test_check_wine_seq([_test_check_wine(), _test_check_wine()])
C.check__test_check_wine_seq(None, allow_none=True)
def test_is_seq(self):
class _test_check_kiwi(object):
pass
C.register_class(_test_check_kiwi, '_test_check_kiwi')
self.assertTrue(
C.is__test_check_kiwi_seq([_test_check_kiwi(),
_test_check_kiwi()]))
self.assertFalse(
C.is__test_check_kiwi_seq([_test_check_kiwi(),
int(6)]))
def test_check_seq(self):
class _test_check_potato(object):
pass
C.register_class(_test_check_potato,
'_test_check_potato',
include_seq=False)
with self.assertRaises(AttributeError) as context:
C.check__test_check_potato_seq(
[_test_check_potato(),
_test_check_potato()])
def test_is_seq_not_registered(self):
class _test_check_apple(object):
pass
C.register_class(_test_check_apple,
'_test_check_apple',
include_seq=False)
with self.assertRaises(AttributeError) as context:
self.assertTrue(
C.is__test_check_apple_seq(
[_test_check_apple(),
_test_check_apple()]))
def test_check(self):
class _cheese(checked_int_enum):
BRIE = 1
CHEDDAR = 2
GOUDA = 3
check.register_class(_cheese)
check.check__cheese(_cheese.GOUDA)
with self.assertRaises(TypeError) as ctx:
check.check__cheese(1)
with self.assertRaises(TypeError) as ctx:
check.check__cheese('GOUDA')
def test_check(self):
class _dessert(checked_enum):
FRUIT = 'fruit'
CHEESECAKE = 'cheesecake'
CHEESE = 'cheese'
check.register_class(_dessert)
check.check__dessert(_dessert.CHEESE)
with self.assertRaises(TypeError) as ctx:
check.check__dessert('fruit')
with self.assertRaises(TypeError) as ctx:
check.check__dessert('CHEESE')
result = file_info_list()
for finfo in iter(self):
if self._match_test(patterns, finfo.filename):
result.append(finfo)
result.remove_dups()
return result
def filter_by_filenames(self, patterns):
check.check_unit_test_description_seq(patterns)
filename_patterns = [p.filename for p in patterns if p.filename]
if not filename_patterns:
return file_info_list(self._values)
return self._match_filenames(filename_patterns)
def filter_by_test_filename_only(self):
result = file_info_list()
for finfo in iter(self):
filename = path.basename(finfo.filename).lower()
if filename.startswith('test_') and filename.endswith('.py'):
result.append(finfo)
result.remove_dups()
return result
# # FIXME: change to ignore_without_tests()
# file_infos = file_info_list([ f for f in file_infos if f.filename in self.inspect_map ])
# # FIXME: change to filter_with_patterns_tests()
# file_infos = file_infos.filter_by_filenames(filter_patterns)
check.register_class(file_info_list, include_seq=False)
#-*- coding:utf-8; mode:python; indent-tabs-mode: nil; c-basic-offset: 2; tab-width: 2 -*-
from bes.system.check import check
from bes.common.dict_util import dict_util
from bes.script.blurber import blurber
class brew_installer_options(object):
def __init__(self, *args, **kargs):
self.verbose = False
self.password = None
self.blurber = blurber()
for key, value in kargs.items():
setattr(self, key, value)
check.check_bool(self.verbose)
check.check_string(self.password, allow_none=True)
check.check_blurber(self.blurber)
def __str__(self):
return str(dict_util.hide_passwords(self.__dict__, ['password']))
check.register_class(brew_installer_options)
from bes.system.check import check
from bes.common.dict_util import dict_util
from bes.script.blurber import blurber
class sudo_cli_options(object):
def __init__(self, *args, **kargs):
self.verbose = False
self.password = None
self.blurber = blurber()
self.working_dir = tempfile.gettempdir()
self.prompt = 'sudo password: '******'password']))
check.register_class(sudo_cli_options)
@classmethod
def media_type_matches(clazz, filename, media_types):
filename = file_check.check_file(filename)
check.check_string_seq(media_types)
media_type = clazz.get_metadata(filename, 'media_type')
if not media_type:
return False
return media_type in media_types
@classmethod
def is_media(clazz, filename):
return clazz.media_type_matches(filename, ('image', 'video'))
@classmethod
def is_video(clazz, filename):
return clazz.media_type_matches(filename, ('video'))
@classmethod
def is_image(clazz, filename):
return clazz.media_type_matches(filename, ('image'))
check.register_class(file_attributes_metadata, include_seq=False)
file_attributes_metadata.register_getter(file_metadata_getter_checksum_md5)
file_attributes_metadata.register_getter(file_metadata_getter_checksum_sha1)
file_attributes_metadata.register_getter(file_metadata_getter_checksum_sha256)
file_attributes_metadata.register_getter(file_metadata_getter_media_type)
file_attributes_metadata.register_getter(file_metadata_getter_mime_type)
#-*- coding:utf-8; mode:python; indent-tabs-mode: nil; c-basic-offset: 2; tab-width: 2 -*-
from bes.system.check import check
from bes.common.dict_util import dict_util
from bes.script.blurber import blurber
class brew_options(object):
def __init__(self, *args, **kargs):
self.verbose = False
self.blurber = blurber()
for key, value in kargs.items():
setattr(self, key, value)
check.check_bool(self.verbose)
check.check_blurber(self.blurber)
check.register_class(brew_options)
value = value.strip()
values[key] = clazz._parse_value(key, value)
return cpu_info(values)
@classmethod
def _parse_value(clazz, key, value):
if key == 'flags':
value = set(string_util.split_by_white_space(value, strip = True))
else:
try:
value = int(value)
except ValueError as ex:
pass
return value
check.register_class(cpu_info, include_seq = False)
class cpu_info_list(type_checked_list):
__value_type__ = cpu_info
def __init__(self, values = None):
super(cpu_info_list, self).__init__(values = values)
@classmethod
def parse_text(clazz, text):
check.check_string(text)
values = cpu_info_list()
chunks = text.strip().split('\n\n')
for chunk in chunks:
def register_check_class(clazz):
check.register_class(clazz, include_seq=False, cast_func=clazz.parse)
if fixture is not None:
check.check_string(fixture)
if function is not None:
check.check_string(function)
return clazz.__bases__[0].__new__(clazz, filename, fixture, function)
@classmethod
def parse(clazz, s):
'Parse a unit test description in the form filename:fixutre.function'
filename, _, right = s.partition(':')
if '.' in right:
fixture, _, function = right.partition('.')
else:
fixture, function = (None, right)
return clazz(filename or None, fixture or None, function or None)
def __str__(self):
v = []
if self.filename:
v.append(self.filename)
v.append('.')
if self.fixture:
v.append(self.fixture)
v.append(':')
if self.function:
v.append(self.function)
return ''.join(v)
check.register_class(unit_test_description)