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)
