def parametrize_over_layers(layers: List, tiles: List, biases: List) -> Callable: """Parametrize a TestCase over different kind of layers. The ``TestCase`` will be repeated for each combination of `layer`, `tile` and `bias`. Args: layers: list of layer descriptions. tiles: list of tile descriptions. biases: list of bias values. Returns: The decorated TestCase. """ def object_to_dict(layer, tile, bias): """Convert the public members of an object to a dictionary.""" ret = {key: value for key, value in vars(layer).items() if not key.startswith('_')} ret['parameter'] = '{}_{}_{}'.format(layer.__name__, tile.__name__, 'Bias' if bias else 'NoBias') ret['get_rpu_config'] = tile.get_rpu_config ret['bias'] = bias return ret def class_name(cls, _, params_dict): """Return a user-friendly name for a parametrized test.""" return '{}_{}'.format(cls.__name__, params_dict['parameter']) return parameterized_class( [object_to_dict(layer, tile, bias) for layer, tile, bias in product(layers, tiles, biases)], class_name_func=class_name)
def parametrize_over_tiles(tiles: List) -> Callable: """Parametrize a TestCase over different kind of tiles. Args: tiles: list of tile descriptions. The ``TestCase`` will be repeated for each of the entries in the list. Returns: The decorated TestCase. """ def object_to_dict(obj): """Convert the public members of an object to a dictionary.""" ret = {key: value for key, value in vars(obj).items() if not key.startswith('_')} ret['parameter'] = obj.__name__ return ret def class_name(cls, _, params_dict): """Return a user-friendly name for a parametrized test.""" return '{}_{}'.format(cls.__name__, params_dict['parameter']) return parameterized_class([object_to_dict(tile) for tile in tiles], class_name_func=class_name)
def parametrizeClassWithBuilders(cls): cls.assertSameFile = assertSameFile(cls) keys = ["builder_name", "builder_path"] values = [] for name, path in TEST_ENVS.items(): values += [(name, path)] return parameterized_class(keys, values)(cls)
def parameterized_with_supported_versions(base_class): """ Decorates a class so instead of the base class, multiple copies of it are registered, one for each supported version. """ class_dir = os.path.abspath(os.path.dirname(sys.modules[base_class.__module__].__file__)) versions_path = os.path.join(class_dir, '_meta', 'supported-versions.yml') variants = supported_versions(versions_path) decorator = parameterized_class(['COMPOSE_ENV'], variants) decorator(base_class)
def parametrize_over_layers(layers: List, tiles: List, biases: List) \ -> Callable: """Parametrize a TestCase over different kind of layers. The ``TestCase`` will be repeated for each combination of `layer`, `tile` and `bias`. Args: layers: list of layer descriptions. tiles: list of tile descriptions. biases: list of bias values: 'analog', 'digital' or None Returns: The decorated TestCase. """ def get_rpu_config(tile, digital_bias, *args, **kwargs): rpu_config = tile.get_rpu_config(tile, *args, **kwargs) rpu_config.mapping.digital_bias = digital_bias return rpu_config def object_to_dict(layer, tile, bias): """Convert the public members of an object to a dictionary.""" ret = { key: value for key, value in vars(layer).items() if not key.startswith('_') } ret['parameter'] = '{}_{}_{}Bias'.format( layer.__name__, tile.__name__, 'No' if bias is None else bias.capitalize()) digital_bias = bias == 'digital' analog_bias = bias == 'analog' ret['get_rpu_config'] = partial(get_rpu_config, tile=tile, digital_bias=digital_bias) ret['bias'] = bias is not None ret['digital_bias'] = digital_bias ret['analog_bias'] = analog_bias ret['tile_class'] = tile return ret def class_name(cls, _, params_dict): """Return a user-friendly name for a parametrized test.""" return '{}_{}'.format(cls.__name__, params_dict['parameter']) return parameterized_class([ object_to_dict(layer, tile, bias) for layer, tile, bias in product(layers, tiles, biases) ], class_name_func=class_name)
def parametrize_over_presets(presets: List) -> Callable: """Parametrize a TestCase over different kind of presets. Note that this decorator expects a list of Presets, as opposed to a list of helper objects. Args: presets: list of presets. Returns: The decorated TestCase. """ def class_name(cls, _, params_dict): """Return a user-friendly name for a parametrized test.""" return '{}_{}'.format(cls.__name__, params_dict['preset_cls'].__name__) return parameterized_class( [{'preset_cls': preset} for preset in presets], class_name_func=class_name)
def data_class(attrs, input_values): """ Parameterizes a test class by setting attributes on the class. """ return parameterized_class(attrs, input_values)
def parameterize_asyncio(cls): return parameterized_class(('factory_name', ), targets)(cls)
'Mininum revision required: {}'.format( '.'.join(str(x) for x in version_required) ) ) return wrapper return check @contextmanager def mock_object_attr(dialect, attr, new_value): old_value = getattr(dialect, attr) setattr(dialect, attr, new_value) try: yield finally: setattr(dialect, attr, old_value) def class_name_func(cls, num, params_dict): suffix = 'HTTP' if params_dict['session'] is http_session else 'Native' return cls.__name__ + suffix with_native_and_http_sessions = parameterized_class([ {'session': http_session}, {'session': native_session} ], class_name_func=class_name_func)
return V3Bucket(*args, username="******", **kwargs).default_collection() def setUp(self, **kwargs): super(ClusterTestCase, self).setUp() connargs = self.cluster_info.make_connargs() connstr_abstract = ConnectionString.parse(connargs.pop('connection_string')) bucket_name = connstr_abstract.bucket connstr_abstract.bucket = None connstr_abstract.set_option('enable_collections', 'true') self.cluster = self.cluster_factory(connstr_abstract, ClusterOptions( ClassicAuthenticator(self.cluster_info.admin_username, self.cluster_info.admin_password))) # type: Cluster # self.admin = self.cluster.admin#self.make_admin_connection() self.bucket = self.cluster.bucket(bucket_name, **connargs) self.bucket_name = bucket_name ParamClusterTestCase = parameterized_class(('cluster_factory',), [(Cluster,), (Cluster.connect,)])(ClusterTestCase) class CollectionTestCase(ClusterTestCase): coll = None # type: CBCollection initialised = defaultdict(lambda: {}) def __init__(self, *args, **kwargs): super(CollectionTestCase, self).__init__(*args, **kwargs) def setUp(self, mock_collections=None, real_collections=None): mock_collections = mock_collections or {None: {None: "coll"}} real_collections = real_collections or {"bedrock": {"flintstones": 'coll'}} # prepare: # 1) Connect to a Cluster super(CollectionTestCase, self).setUp()
def parametrizeClassWithFileTypes(cls): keys = ["filetype"] values = [(x, ) for x in ("v", "vh", "sv", "svh")] return parameterized_class(keys, values)(cls)