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)