From 1e59aa05c6d7f8e1b7d6f24d0d8c0f2849f0b7f7 Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 10 Jun 2020 09:20:43 +0200 Subject: [PATCH 1/9] move parameter tests to a subfolder --- qcodes/tests/parameter/__init__.py | 0 qcodes/tests/{ => parameter}/test_combined_par.py | 0 qcodes/tests/{ => parameter}/test_delegate_parameter.py | 0 qcodes/tests/{ => parameter}/test_group_parameter.py | 0 qcodes/tests/{ => parameter}/test_parameter.py | 0 qcodes/tests/{ => parameter}/test_parameter_with_setpoints.py | 0 qcodes/tests/{ => parameter}/test_specialized_parameters.py | 0 7 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 qcodes/tests/parameter/__init__.py rename qcodes/tests/{ => parameter}/test_combined_par.py (100%) rename qcodes/tests/{ => parameter}/test_delegate_parameter.py (100%) rename qcodes/tests/{ => parameter}/test_group_parameter.py (100%) rename qcodes/tests/{ => parameter}/test_parameter.py (100%) rename qcodes/tests/{ => parameter}/test_parameter_with_setpoints.py (100%) rename qcodes/tests/{ => parameter}/test_specialized_parameters.py (100%) diff --git a/qcodes/tests/parameter/__init__.py b/qcodes/tests/parameter/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/qcodes/tests/test_combined_par.py b/qcodes/tests/parameter/test_combined_par.py similarity index 100% rename from qcodes/tests/test_combined_par.py rename to qcodes/tests/parameter/test_combined_par.py diff --git a/qcodes/tests/test_delegate_parameter.py b/qcodes/tests/parameter/test_delegate_parameter.py similarity index 100% rename from qcodes/tests/test_delegate_parameter.py rename to qcodes/tests/parameter/test_delegate_parameter.py diff --git a/qcodes/tests/test_group_parameter.py b/qcodes/tests/parameter/test_group_parameter.py similarity index 100% rename from qcodes/tests/test_group_parameter.py rename to qcodes/tests/parameter/test_group_parameter.py diff --git a/qcodes/tests/test_parameter.py b/qcodes/tests/parameter/test_parameter.py similarity index 100% rename from qcodes/tests/test_parameter.py rename to qcodes/tests/parameter/test_parameter.py diff --git a/qcodes/tests/test_parameter_with_setpoints.py b/qcodes/tests/parameter/test_parameter_with_setpoints.py similarity index 100% rename from qcodes/tests/test_parameter_with_setpoints.py rename to qcodes/tests/parameter/test_parameter_with_setpoints.py diff --git a/qcodes/tests/test_specialized_parameters.py b/qcodes/tests/parameter/test_specialized_parameters.py similarity index 100% rename from qcodes/tests/test_specialized_parameters.py rename to qcodes/tests/parameter/test_specialized_parameters.py From 2a1ee5c254ef4f0a014c4660cd45acb57061eb98 Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 10 Jun 2020 09:30:37 +0200 Subject: [PATCH 2/9] split snapshot tests into their own file --- qcodes/tests/parameter/conftest.py | 32 +++ qcodes/tests/parameter/test_parameter.py | 305 +---------------------- qcodes/tests/parameter/test_snapshot.py | 277 ++++++++++++++++++++ 3 files changed, 311 insertions(+), 303 deletions(-) create mode 100644 qcodes/tests/parameter/conftest.py create mode 100644 qcodes/tests/parameter/test_snapshot.py diff --git a/qcodes/tests/parameter/conftest.py b/qcodes/tests/parameter/conftest.py new file mode 100644 index 00000000000..122fed92fc2 --- /dev/null +++ b/qcodes/tests/parameter/conftest.py @@ -0,0 +1,32 @@ +import pytest + +NOT_PASSED = 'NOT_PASSED' + +@pytest.fixture(params=(True, False, NOT_PASSED)) +def snapshot_get(request): + return request.param + + +@pytest.fixture(params=(True, False, NOT_PASSED)) +def snapshot_value(request): + return request.param + + +@pytest.fixture(params=(None, False, NOT_PASSED)) +def get_cmd(request): + return request.param + + +@pytest.fixture(params=(True, False, NOT_PASSED)) +def get_if_invalid(request): + return request.param + + +@pytest.fixture(params=(True, False, None, NOT_PASSED)) +def update(request): + return request.param + + +@pytest.fixture(params=(True, False)) +def cache_is_valid(request): + return request.param diff --git a/qcodes/tests/parameter/test_parameter.py b/qcodes/tests/parameter/test_parameter.py index 0d67e24fb6b..88c88b53236 100644 --- a/qcodes/tests/parameter/test_parameter.py +++ b/qcodes/tests/parameter/test_parameter.py @@ -20,7 +20,7 @@ from qcodes.tests.instrument_mocks import DummyInstrument from qcodes.utils.helpers import create_on_off_val_mapping from qcodes.utils.validators import Numbers - +from .conftest import NOT_PASSED class GettableParam(Parameter): """ Parameter that keeps track of number of get operations""" @@ -32,6 +32,7 @@ def get_raw(self): self._get_count += 1 return 42 + class BetterGettableParam(Parameter): """ Parameter that keeps track of number of get operations, But can actually store values""" @@ -2116,308 +2117,6 @@ def test_no_get_timestamp_none_runtime_error(get_if_invalid): assert local_parameter.cache.get(get_if_invalid=get_if_invalid) is None -NOT_PASSED = 'NOT_PASSED' - - -@pytest.fixture(params=(True, False, NOT_PASSED)) -def snapshot_get(request): - return request.param - - -@pytest.fixture(params=(True, False, NOT_PASSED)) -def snapshot_value(request): - return request.param - - -@pytest.fixture(params=(None, False, NOT_PASSED)) -def get_cmd(request): - return request.param - - -@pytest.fixture(params=(True, False, NOT_PASSED)) -def get_if_invalid(request): - return request.param - - -def create_parameter(snapshot_get, snapshot_value, cache_is_valid, get_cmd, - offset=NOT_PASSED): - kwargs = dict(set_cmd=None, - label='Parameter', - unit='a.u.', - docstring='some docs') - - if offset != NOT_PASSED: - kwargs.update(offset=offset) - - if snapshot_get != NOT_PASSED: - kwargs.update(snapshot_get=snapshot_get) - - if snapshot_value != NOT_PASSED: - kwargs.update(snapshot_value=snapshot_value) - - if get_cmd != NOT_PASSED: - kwargs.update(get_cmd=get_cmd) - - p = Parameter('p', **kwargs) - - if get_cmd is not False: - def wrap_in_call_counter(get_func): - call_count = 0 - - def wrapped_func(*args, **kwargs): - nonlocal call_count - call_count += 1 - return get_func(*args, **kwargs) - - wrapped_func.call_count = lambda: call_count - - return wrapped_func - - p.get = wrap_in_call_counter(p.get) - assert p.get.call_count() == 0 # pre-condition - else: - assert not hasattr(p, 'get') # pre-condition - assert not p.gettable - - if cache_is_valid: - p.set(42) - - return p - - -@pytest.fixture(params=(True, False, None, NOT_PASSED)) -def update(request): - return request.param - - -@pytest.fixture(params=(True, False)) -def cache_is_valid(request): - return request.param - - -def test_snapshot_contains_parameter_attributes( - snapshot_get, snapshot_value, get_cmd, cache_is_valid, update): - p = create_parameter(snapshot_get, snapshot_value, cache_is_valid, get_cmd) - - if update != NOT_PASSED: - s = p.snapshot(update=update) - else: - s = p.snapshot() - - assert isinstance(s, dict) - - # Not metadata key in the snapshot because we didn't pass any metadata - # for the parameter - # TODO: test for parameter with metadata - assert 'metadata' not in s - - assert s['__class__'] == 'qcodes.instrument.parameter.Parameter' - assert s['full_name'] == 'p' - - # The following is because the parameter does not belong to an instrument - # TODO: test for a parameter that is attached to instrument - assert 'instrument' not in s - assert 'instrument_name' not in s - - # These attributes have value of ``None`` hence not included in the snapshot - # TODO: test snapshot when some of these are not None - none_attrs = ('step', 'scale', 'offset', 'val_mapping', 'vals') - for attr in none_attrs: - assert getattr(p, attr) is None # pre-condition - assert attr not in s - - # TODO: test snapshot when some of these are None - not_none_attrs = {'name': p.name, 'label': p.label, 'unit': p.unit, - 'inter_delay': p.inter_delay, 'post_delay': p.post_delay} - for attr, value in not_none_attrs.items(): - assert s[attr] == value - - -def test_snapshot_timestamp_of_non_gettable_depends_only_on_cache_validity( - snapshot_get, snapshot_value, update, cache_is_valid): - p = create_parameter(snapshot_get, snapshot_value, cache_is_valid, - get_cmd=False) - - t0 = p.cache.timestamp - - if update != NOT_PASSED: - s = p.snapshot(update=update) - else: - s = p.snapshot() - - if cache_is_valid: - ts = datetime.strptime(s['ts'], '%Y-%m-%d %H:%M:%S') - t0_up_to_seconds = t0.replace(microsecond=0) - assert ts >= t0_up_to_seconds - else: - assert s['ts'] is None - - -def test_snapshot_timestamp_for_valid_cache_depends_on_cache_update( - snapshot_get, snapshot_value, update): - - p = create_parameter(snapshot_get, snapshot_value, - get_cmd=lambda: 69, cache_is_valid=True) - - # Hack cache's timestamp to simplify this test - p.cache._timestamp = p.cache.timestamp - timedelta(days=31) - - tu = datetime.now() - assert p.cache.timestamp < tu # pre-condition - if update != NOT_PASSED: - s = p.snapshot(update=update) - else: - s = p.snapshot() - - ts = datetime.strptime(s['ts'], '%Y-%m-%d %H:%M:%S') - tu_up_to_seconds = tu.replace(microsecond=0) - - cache_gets_updated_on_snapshot_call = ( - snapshot_value is not False - and snapshot_get is not False - and update is True - ) - - if cache_gets_updated_on_snapshot_call: - assert ts >= tu_up_to_seconds - else: - assert ts < tu_up_to_seconds - - -def test_snapshot_timestamp_for_invalid_cache_depends_only_on_snapshot_flags( - snapshot_get, snapshot_value, update): - - p = create_parameter(snapshot_get, snapshot_value, - get_cmd=lambda: 69, cache_is_valid=False) - - cache_gets_updated_on_snapshot_call = ( - snapshot_value is not False - and snapshot_get is not False - and update is not False - and update != NOT_PASSED - ) - - if cache_gets_updated_on_snapshot_call: - tu = datetime.now() - - if update != NOT_PASSED: - s = p.snapshot(update=update) - else: - s = p.snapshot() - - if cache_gets_updated_on_snapshot_call: - ts = datetime.strptime(s['ts'], '%Y-%m-%d %H:%M:%S') - tu_up_to_seconds = tu.replace(microsecond=0) - assert ts >= tu_up_to_seconds - else: - assert s['ts'] is None - - -def test_snapshot_when_snapshot_value_is_false( - snapshot_get, get_cmd, cache_is_valid, update): - - p = create_parameter( - snapshot_get=snapshot_get, snapshot_value=False, get_cmd=get_cmd, cache_is_valid=cache_is_valid) - - if update != NOT_PASSED: - s = p.snapshot(update=update) - else: - s = p.snapshot() - - assert 'value' not in s - assert 'raw_value' not in s - - if get_cmd is not False: - assert p.get.call_count() == 0 - - -def test_snapshot_value_is_true_by_default(snapshot_get, get_cmd): - p = create_parameter( - snapshot_value=NOT_PASSED, - snapshot_get=snapshot_get, - get_cmd=get_cmd, - cache_is_valid=True - ) - assert p._snapshot_value is True - - -def test_snapshot_get_is_true_by_default(snapshot_value, get_cmd): - p = create_parameter( - snapshot_get=NOT_PASSED, - snapshot_value=snapshot_value, - get_cmd=get_cmd, - cache_is_valid=True - ) - assert p._snapshot_get is True - - -def test_snapshot_when_snapshot_get_is_false(get_cmd, update, cache_is_valid): - p = create_parameter( - snapshot_get=False, - snapshot_value=True, - get_cmd=get_cmd, - cache_is_valid=cache_is_valid, - offset=4) - - if update != NOT_PASSED: - s = p.snapshot(update=update) - else: - s = p.snapshot() - - if cache_is_valid: - assert s['value'] == 42 - assert s['raw_value'] == 46 - else: - assert s['value'] is None - assert s['raw_value'] is None - - if get_cmd is not False: - assert p.get.call_count() == 0 - - -def test_snapshot_of_non_gettable_parameter_mirrors_cache( - update, cache_is_valid): - p = create_parameter( - snapshot_get=True, snapshot_value=True, get_cmd=False, - cache_is_valid=cache_is_valid, offset=4) - - if update != NOT_PASSED: - s = p.snapshot(update=update) - else: - s = p.snapshot() - - if cache_is_valid: - assert s['value'] == 42 - assert s['raw_value'] == 46 - else: - assert s['value'] is None - assert s['raw_value'] is None - - -def test_snapshot_of_gettable_parameter_depends_on_update(update, cache_is_valid): - p = create_parameter( - snapshot_get=True, snapshot_value=True, get_cmd=lambda: 69, - cache_is_valid=cache_is_valid, offset=4) - - if update != NOT_PASSED: - s = p.snapshot(update=update) - else: - s = p.snapshot() - - if update is not True and cache_is_valid: - assert s['value'] == 42 - assert s['raw_value'] == 46 - assert p.get.call_count() == 0 - elif update is False or update == NOT_PASSED: - assert s['value'] is None - assert s['raw_value'] is None - assert p.get.call_count() == 0 - else: - assert s['value'] == 65 - assert s['raw_value'] == 69 - assert p.get.call_count() == 1 - - def test_get_on_parameter_marked_as_non_gettable_raises(): a = Parameter("param") a._gettable = False diff --git a/qcodes/tests/parameter/test_snapshot.py b/qcodes/tests/parameter/test_snapshot.py new file mode 100644 index 00000000000..fff58bd45a4 --- /dev/null +++ b/qcodes/tests/parameter/test_snapshot.py @@ -0,0 +1,277 @@ +from typing import Union, Optional +from datetime import datetime, timedelta + +from qcodes.instrument.parameter import Parameter +from .conftest import NOT_PASSED + + +def create_parameter(snapshot_get: bool, + snapshot_value: bool, + cache_is_valid: bool, + get_cmd: Optional[bool], + offset: Union[str, float] = NOT_PASSED): + kwargs = dict(set_cmd=None, + label='Parameter', + unit='a.u.', + docstring='some docs') + + if offset != NOT_PASSED: + kwargs.update(offset=offset) + + if snapshot_get != NOT_PASSED: + kwargs.update(snapshot_get=snapshot_get) + + if snapshot_value != NOT_PASSED: + kwargs.update(snapshot_value=snapshot_value) + + if get_cmd != NOT_PASSED: + kwargs.update(get_cmd=get_cmd) + + p = Parameter('p', **kwargs) + + if get_cmd is not False: + def wrap_in_call_counter(get_func): + call_count = 0 + + def wrapped_func(*args, **kwargs): + nonlocal call_count + call_count += 1 + return get_func(*args, **kwargs) + + wrapped_func.call_count = lambda: call_count + + return wrapped_func + + p.get = wrap_in_call_counter(p.get) + assert p.get.call_count() == 0 # pre-condition + else: + assert not hasattr(p, 'get') # pre-condition + assert not p.gettable + + if cache_is_valid: + p.set(42) + + return p + + +def test_snapshot_contains_parameter_attributes( + snapshot_get, snapshot_value, get_cmd, cache_is_valid, update): + p = create_parameter(snapshot_get, snapshot_value, cache_is_valid, get_cmd) + + if update != NOT_PASSED: + s = p.snapshot(update=update) + else: + s = p.snapshot() + + assert isinstance(s, dict) + + # Not metadata key in the snapshot because we didn't pass any metadata + # for the parameter + # TODO: test for parameter with metadata + assert 'metadata' not in s + + assert s['__class__'] == 'qcodes.instrument.parameter.Parameter' + assert s['full_name'] == 'p' + + # The following is because the parameter does not belong to an instrument + # TODO: test for a parameter that is attached to instrument + assert 'instrument' not in s + assert 'instrument_name' not in s + + # These attributes have value of ``None`` hence not included in the snapshot + # TODO: test snapshot when some of these are not None + none_attrs = ('step', 'scale', 'offset', 'val_mapping', 'vals') + for attr in none_attrs: + assert getattr(p, attr) is None # pre-condition + assert attr not in s + + # TODO: test snapshot when some of these are None + not_none_attrs = {'name': p.name, 'label': p.label, 'unit': p.unit, + 'inter_delay': p.inter_delay, 'post_delay': p.post_delay} + for attr, value in not_none_attrs.items(): + assert s[attr] == value + + +def test_snapshot_timestamp_of_non_gettable_depends_only_on_cache_validity( + snapshot_get, snapshot_value, update, cache_is_valid): + p = create_parameter(snapshot_get, snapshot_value, cache_is_valid, + get_cmd=False) + + t0 = p.cache.timestamp + + if update != NOT_PASSED: + s = p.snapshot(update=update) + else: + s = p.snapshot() + + if cache_is_valid: + ts = datetime.strptime(s['ts'], '%Y-%m-%d %H:%M:%S') + t0_up_to_seconds = t0.replace(microsecond=0) + assert ts >= t0_up_to_seconds + else: + assert s['ts'] is None + + +def test_snapshot_timestamp_for_valid_cache_depends_on_cache_update( + snapshot_get, snapshot_value, update): + + p = create_parameter(snapshot_get, snapshot_value, + get_cmd=lambda: 69, cache_is_valid=True) + + # Hack cache's timestamp to simplify this test + p.cache._timestamp = p.cache.timestamp - timedelta(days=31) + + tu = datetime.now() + assert p.cache.timestamp < tu # pre-condition + if update != NOT_PASSED: + s = p.snapshot(update=update) + else: + s = p.snapshot() + + ts = datetime.strptime(s['ts'], '%Y-%m-%d %H:%M:%S') + tu_up_to_seconds = tu.replace(microsecond=0) + + cache_gets_updated_on_snapshot_call = ( + snapshot_value is not False + and snapshot_get is not False + and update is True + ) + + if cache_gets_updated_on_snapshot_call: + assert ts >= tu_up_to_seconds + else: + assert ts < tu_up_to_seconds + + +def test_snapshot_timestamp_for_invalid_cache_depends_only_on_snapshot_flags( + snapshot_get, snapshot_value, update): + + p = create_parameter(snapshot_get, snapshot_value, + get_cmd=lambda: 69, cache_is_valid=False) + + cache_gets_updated_on_snapshot_call = ( + snapshot_value is not False + and snapshot_get is not False + and update is not False + and update != NOT_PASSED + ) + + if cache_gets_updated_on_snapshot_call: + tu = datetime.now() + + if update != NOT_PASSED: + s = p.snapshot(update=update) + else: + s = p.snapshot() + + if cache_gets_updated_on_snapshot_call: + ts = datetime.strptime(s['ts'], '%Y-%m-%d %H:%M:%S') + tu_up_to_seconds = tu.replace(microsecond=0) + assert ts >= tu_up_to_seconds + else: + assert s['ts'] is None + + +def test_snapshot_when_snapshot_value_is_false( + snapshot_get, get_cmd, cache_is_valid, update): + + p = create_parameter( + snapshot_get=snapshot_get, snapshot_value=False, get_cmd=get_cmd, cache_is_valid=cache_is_valid) + + if update != NOT_PASSED: + s = p.snapshot(update=update) + else: + s = p.snapshot() + + assert 'value' not in s + assert 'raw_value' not in s + + if get_cmd is not False: + assert p.get.call_count() == 0 + + +def test_snapshot_value_is_true_by_default(snapshot_get, get_cmd): + p = create_parameter( + snapshot_value=NOT_PASSED, + snapshot_get=snapshot_get, + get_cmd=get_cmd, + cache_is_valid=True + ) + assert p._snapshot_value is True + + +def test_snapshot_get_is_true_by_default(snapshot_value, get_cmd): + p = create_parameter( + snapshot_get=NOT_PASSED, + snapshot_value=snapshot_value, + get_cmd=get_cmd, + cache_is_valid=True + ) + assert p._snapshot_get is True + + +def test_snapshot_when_snapshot_get_is_false(get_cmd, update, cache_is_valid): + p = create_parameter( + snapshot_get=False, + snapshot_value=True, + get_cmd=get_cmd, + cache_is_valid=cache_is_valid, + offset=4) + + if update != NOT_PASSED: + s = p.snapshot(update=update) + else: + s = p.snapshot() + + if cache_is_valid: + assert s['value'] == 42 + assert s['raw_value'] == 46 + else: + assert s['value'] is None + assert s['raw_value'] is None + + if get_cmd is not False: + assert p.get.call_count() == 0 + + +def test_snapshot_of_non_gettable_parameter_mirrors_cache( + update, cache_is_valid): + p = create_parameter( + snapshot_get=True, snapshot_value=True, get_cmd=False, + cache_is_valid=cache_is_valid, offset=4) + + if update != NOT_PASSED: + s = p.snapshot(update=update) + else: + s = p.snapshot() + + if cache_is_valid: + assert s['value'] == 42 + assert s['raw_value'] == 46 + else: + assert s['value'] is None + assert s['raw_value'] is None + + +def test_snapshot_of_gettable_parameter_depends_on_update(update, cache_is_valid): + p = create_parameter( + snapshot_get=True, snapshot_value=True, get_cmd=lambda: 69, + cache_is_valid=cache_is_valid, offset=4) + + if update != NOT_PASSED: + s = p.snapshot(update=update) + else: + s = p.snapshot() + + if update is not True and cache_is_valid: + assert s['value'] == 42 + assert s['raw_value'] == 46 + assert p.get.call_count() == 0 + elif update is False or update == NOT_PASSED: + assert s['value'] is None + assert s['raw_value'] is None + assert p.get.call_count() == 0 + else: + assert s['value'] == 65 + assert s['raw_value'] == 69 + assert p.get.call_count() == 1 From a927325e4b8deec81e4ef35ee62995c42ccb5f94 Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 10 Jun 2020 09:39:14 +0200 Subject: [PATCH 3/9] split cache tests to their own file --- qcodes/tests/parameter/conftest.py | 109 ++++++ qcodes/tests/parameter/test_parameter.py | 352 +----------------- .../tests/parameter/test_parameter_cache.py | 250 +++++++++++++ 3 files changed, 363 insertions(+), 348 deletions(-) create mode 100644 qcodes/tests/parameter/test_parameter_cache.py diff --git a/qcodes/tests/parameter/conftest.py b/qcodes/tests/parameter/conftest.py index 122fed92fc2..d6e221d2f7b 100644 --- a/qcodes/tests/parameter/conftest.py +++ b/qcodes/tests/parameter/conftest.py @@ -1,7 +1,11 @@ import pytest +from qcodes.instrument.parameter import Parameter +import qcodes.utils.validators as vals + NOT_PASSED = 'NOT_PASSED' + @pytest.fixture(params=(True, False, NOT_PASSED)) def snapshot_get(request): return request.param @@ -30,3 +34,108 @@ def update(request): @pytest.fixture(params=(True, False)) def cache_is_valid(request): return request.param + + +class GettableParam(Parameter): + """ Parameter that keeps track of number of get operations""" + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._get_count = 0 + + def get_raw(self): + self._get_count += 1 + return 42 + + +class BetterGettableParam(Parameter): + """ Parameter that keeps track of number of get operations, + But can actually store values""" + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._get_count = 0 + + def get_raw(self): + self._get_count += 1 + return self.cache._raw_value + + +class SettableParam(Parameter): + """ Parameter that keeps track of number of set operations""" + def __init__(self, *args, **kwargs): + self._set_count = 0 + super().__init__(*args, **kwargs) + + def set_raw(self, value): + self._set_count += 1 + + +class OverwriteGetParam(Parameter): + """ Parameter that overwrites get.""" + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._value = 42 + self.set_count = 0 + self.get_count = 0 + + def get(self): + self.get_count += 1 + return self._value + + +class OverwriteSetParam(Parameter): + """ Parameter that overwrites set.""" + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._value = 42 + self.set_count = 0 + self.get_count = 0 + + def set(self, value): + self.set_count += 1 + self._value = value + + +class GetSetRawParameter(Parameter): + """ Parameter that implements get and set raw""" + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def get_raw(self): + return self.cache._raw_value + + def set_raw(self, raw_value): + pass + + +class BookkeepingValidator(vals.Validator): + """ + Validator that keeps track of what it validates + """ + def __init__(self, min_value=-float("inf"), max_value=float("inf")): + self.values_validated = [] + + def validate(self, value, context=''): + self.values_validated.append(value) + + is_numeric = True + + +class MemoryParameter(Parameter): + def __init__(self, get_cmd=None, **kwargs): + self.set_values = [] + self.get_values = [] + super().__init__(set_cmd=self.add_set_value, + get_cmd=self.create_get_func(get_cmd), **kwargs) + + def add_set_value(self, value): + self.set_values.append(value) + + def create_get_func(self, func): + def get_func(): + if func is not None: + val = func() + else: + val = self.cache._raw_value + self.get_values.append(val) + return val + return get_func \ No newline at end of file diff --git a/qcodes/tests/parameter/test_parameter.py b/qcodes/tests/parameter/test_parameter.py index 88c88b53236..7a8c7bef197 100644 --- a/qcodes/tests/parameter/test_parameter.py +++ b/qcodes/tests/parameter/test_parameter.py @@ -20,90 +20,10 @@ from qcodes.tests.instrument_mocks import DummyInstrument from qcodes.utils.helpers import create_on_off_val_mapping from qcodes.utils.validators import Numbers -from .conftest import NOT_PASSED - -class GettableParam(Parameter): - """ Parameter that keeps track of number of get operations""" - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self._get_count = 0 - - def get_raw(self): - self._get_count += 1 - return 42 - - -class BetterGettableParam(Parameter): - """ Parameter that keeps track of number of get operations, - But can actually store values""" - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self._get_count = 0 - - def get_raw(self): - self._get_count += 1 - return self.cache._raw_value - - -class SettableParam(Parameter): - """ Parameter that keeps track of number of set operations""" - def __init__(self, *args, **kwargs): - self._set_count = 0 - super().__init__(*args, **kwargs) - - def set_raw(self, value): - self._set_count += 1 - - -class OverwriteGetParam(Parameter): - """ Parameter that overwrites get.""" - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self._value = 42 - self.set_count = 0 - self.get_count = 0 - - def get(self): - self.get_count += 1 - return self._value - - -class OverwriteSetParam(Parameter): - """ Parameter that overwrites set.""" - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self._value = 42 - self.set_count = 0 - self.get_count = 0 - - def set(self, value): - self.set_count += 1 - self._value = value - - -class GetSetRawParameter(Parameter): - """ Parameter that implements get and set raw""" - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - - def get_raw(self): - return self.cache._raw_value - - def set_raw(self, raw_value): - pass - - -class BookkeepingValidator(vals.Validator): - """ - Validator that keeps track of what it validates - """ - def __init__(self, min_value=-float("inf"), max_value=float("inf")): - self.values_validated = [] - - def validate(self, value, context=''): - self.values_validated.append(value) - - is_numeric = True +from .conftest import (GettableParam, BookkeepingValidator, + BetterGettableParam, MemoryParameter, + OverwriteGetParam, OverwriteSetParam, + GetSetRawParameter) blank_instruments = ( @@ -114,27 +34,6 @@ def validate(self, value, context=''): named_instrument = namedtuple('yesname', 'name')('astro') -class MemoryParameter(Parameter): - def __init__(self, get_cmd=None, **kwargs): - self.set_values = [] - self.get_values = [] - super().__init__(set_cmd=self.add_set_value, - get_cmd=self.create_get_func(get_cmd), **kwargs) - - def add_set_value(self, value): - self.set_values.append(value) - - def create_get_func(self, func): - def get_func(): - if func is not None: - val = func() - else: - val = self.cache._raw_value - self.get_values.append(val) - return val - return get_func - - class TestParameter(TestCase): def test_no_name(self): with self.assertRaises(TypeError): @@ -1874,249 +1773,6 @@ def test_get_raw_and_get_cmd_raises(working_get_cmd, working_set_cmd): GetSetRawParameter("param3", get_cmd=working_get_cmd, set_cmd=working_set_cmd) -def test_get_from_cache_does_not_trigger_real_get_if_get_if_invalid_false(): - """ - assert that calling get on the cache with get_if_invalid=False does - not trigger a get of the parameter when parameter has expired due to max_val_age - """ - param = BetterGettableParam(name="param", max_val_age=1) - param.get() - assert param._get_count == 1 - # let the cache expire - time.sleep(2) - param.cache.get(get_if_invalid=False) - assert param._get_count == 1 - - -def test_initial_set_with_without_cache(): - value = 43 - # setting the initial value triggers a set - param1 = SettableParam(name="param", initial_value=value) - assert param1._set_count == 1 - assert param1.cache.get(get_if_invalid=False) == value - # setting the cache does not trigger a set - param2 = SettableParam(name="param", initial_cache_value=value) - assert param2._set_count == 0 - assert param2.cache.get(get_if_invalid=False) == value - - -def test_set_initial_and_initial_cache_raises(): - with pytest.raises(SyntaxError, match="`initial_value` and `initial_cache_value`"): - Parameter(name="param", initial_value=1, initial_cache_value=2) - - -def test_get_cache(): - time_resolution = time.get_clock_info('time').resolution - sleep_delta = 2 * time_resolution - - # Create a gettable parameter - local_parameter = Parameter('test_param', set_cmd=None, get_cmd=None) - before_set = datetime.now() - time.sleep(sleep_delta) - local_parameter.set(1) - time.sleep(sleep_delta) - after_set = datetime.now() - - # Check we return last set value, with the correct timestamp - assert local_parameter.cache.get() == 1 - assert before_set < local_parameter.cache.timestamp < after_set - - # Check that updating the value updates the timestamp - time.sleep(sleep_delta) - local_parameter.set(2) - assert local_parameter.cache.get() == 2 - assert local_parameter.cache.timestamp > after_set - - -def test_get_cache_raw_value(): - # To have a simple distinction between raw value and value of the - # parameter lets create a parameter with an offset - p = Parameter('p', set_cmd=None, get_cmd=None, offset=42) - assert p.cache.timestamp is None - - # Initially, the parameter's raw value is None - assert p.cache.raw_value is None - - # After setting the parameter to some value, the - # raw_value attribute of the cache should return the raw_value - p(3) - assert p.cache.timestamp is not None - assert p.cache.get() == 3 - assert p.cache.raw_value == 3 + 42 - - -def test_get_cache_unknown(): - """ - Test that cache get on a parameter that has not been acquired will - trigger a get - """ - value = 1 - local_parameter = BetterGettableParam('test_param', set_cmd=None, - get_cmd=None) - # fake a parameter that has a value but never been get/set to mock - # an instrument. - local_parameter.cache._value = value - local_parameter.cache._raw_value = value - assert local_parameter.cache.timestamp is None - before_get = datetime.now() - assert local_parameter._get_count == 0 - assert local_parameter.cache.get() == value - assert local_parameter._get_count == 1 - # calling get above will call get since TS is None - # and the TS will therefore no longer be None - assert local_parameter.cache.timestamp is not None - assert local_parameter.cache.timestamp >= before_get - # calling cache.get now will not trigger get - assert local_parameter.cache.get() == value - assert local_parameter._get_count == 1 - - -def test_get_cache_known(): - """ - Test that cache.get on a parameter that has a known value will not - trigger a get - """ - value = 1 - local_parameter = BetterGettableParam('test_param', set_cmd=None, - get_cmd=None) - # fake a parameter that has a value acquired 10 sec ago - start = datetime.now() - set_time = start - timedelta(seconds=10) - local_parameter.cache._update_with( - value=value, raw_value=value, timestamp=set_time) - assert local_parameter._get_count == 0 - assert local_parameter.cache.timestamp == set_time - assert local_parameter.cache.get() == value - # calling cache.get above will not call get since TS is set and - # max_val_age is not - assert local_parameter._get_count == 0 - assert local_parameter.cache.timestamp == set_time - - -def test_get_cache_no_get(): - """ - Test that cache.get on a parameter that does not have get is handled - correctly. - """ - local_parameter = Parameter('test_param', set_cmd=None, get_cmd=False) - # The parameter does not have a get method. - with pytest.raises(AttributeError): - local_parameter.get() - # get_latest will fail as get cannot be called and no cache - # is available - with pytest.raises(RuntimeError): - local_parameter.cache.get() - value = 1 - local_parameter.set(value) - assert local_parameter.cache.get() == value - - local_parameter2 = Parameter('test_param2', set_cmd=None, - get_cmd=False, initial_value=value) - with pytest.raises(AttributeError): - local_parameter2.get() - assert local_parameter2.cache.get() == value - - -def test_set_raw_value_on_cache(): - value = 1 - scale = 10 - local_parameter = BetterGettableParam('test_param', - set_cmd=None, - scale=scale) - before = datetime.now() - local_parameter.cache._set_from_raw_value(value*scale) - after = datetime.now() - assert local_parameter.cache.get(get_if_invalid=False) == value - assert local_parameter.cache.raw_value == value * scale - assert local_parameter.cache.timestamp >= before - assert local_parameter.cache.timestamp <= after - - -def test_max_val_age(): - value = 1 - start = datetime.now() - local_parameter = BetterGettableParam('test_param', - set_cmd=None, - max_val_age=1, - initial_value=value) - assert local_parameter.cache.max_val_age == 1 - assert local_parameter._get_count == 0 - assert local_parameter.cache.get() == value - assert local_parameter._get_count == 0 - # now fake the time stamp so get should be triggered - set_time = start - timedelta(seconds=10) - local_parameter.cache._update_with( - value=value, raw_value=value, timestamp=set_time) - # now that ts < max_val_age calling get_latest should update the time - assert local_parameter.cache.timestamp == set_time - assert local_parameter.cache.get() == value - assert local_parameter._get_count == 1 - assert local_parameter.cache.timestamp >= start - - -def test_no_get_max_val_age(): - """ - Test that cache.get on a parameter with max_val_age set and - no get cmd raises correctly. - """ - value = 1 - with pytest.raises(SyntaxError): - _ = Parameter('test_param', set_cmd=None, - get_cmd=False, - max_val_age=1, initial_value=value) - - -def test_no_get_max_val_age_runtime_error(get_if_invalid): - """ - _BaseParameter does not have a check on creation time that - no get_cmd is mixed with max_val_age since get_cmd could be added - in a subclass. Here we create a subclass that does not add a get - command and also does not implement the check for max_val_age - """ - value = 1 - - class LocalParameter(_BaseParameter): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.set_raw = lambda x: x - self.set = self._wrap_set(self.set_raw) - - local_parameter = LocalParameter('test_param', - None, - max_val_age=1) - start = datetime.now() - set_time = start - timedelta(seconds=10) - local_parameter.cache._update_with( - value=value, raw_value=value, timestamp=set_time) - - if get_if_invalid is True: - with pytest.raises(RuntimeError, match="max_val_age` is not supported"): - local_parameter.cache.get(get_if_invalid=get_if_invalid) - elif get_if_invalid == NOT_PASSED: - with pytest.raises(RuntimeError, match="max_val_age` is not supported"): - local_parameter.cache.get() - else: - assert local_parameter.cache.get(get_if_invalid=get_if_invalid) == 1 - - -def test_no_get_timestamp_none_runtime_error(get_if_invalid): - """ - Test that a parameter that has never been - set, cannot be get and does not support - getting raises a RuntimeError. - """ - local_parameter = Parameter('test_param', get_cmd=False) - - if get_if_invalid is True: - with pytest.raises(RuntimeError, match="Value of parameter test_param"): - local_parameter.cache.get(get_if_invalid=get_if_invalid) - elif get_if_invalid == NOT_PASSED: - with pytest.raises(RuntimeError, match="Value of parameter test_param"): - local_parameter.cache.get() - else: - assert local_parameter.cache.get(get_if_invalid=get_if_invalid) is None - - def test_get_on_parameter_marked_as_non_gettable_raises(): a = Parameter("param") a._gettable = False diff --git a/qcodes/tests/parameter/test_parameter_cache.py b/qcodes/tests/parameter/test_parameter_cache.py new file mode 100644 index 00000000000..ed981445ddd --- /dev/null +++ b/qcodes/tests/parameter/test_parameter_cache.py @@ -0,0 +1,250 @@ +import time +from datetime import datetime, timedelta + +import pytest + +from qcodes.instrument.parameter import Parameter, _BaseParameter +from .conftest import NOT_PASSED, BetterGettableParam, SettableParam + + +def test_get_from_cache_does_not_trigger_real_get_if_get_if_invalid_false(): + """ + assert that calling get on the cache with get_if_invalid=False does + not trigger a get of the parameter when parameter has expired due to max_val_age + """ + param = BetterGettableParam(name="param", max_val_age=1) + param.get() + assert param._get_count == 1 + # let the cache expire + time.sleep(2) + param.cache.get(get_if_invalid=False) + assert param._get_count == 1 + + +def test_initial_set_with_without_cache(): + value = 43 + # setting the initial value triggers a set + param1 = SettableParam(name="param", initial_value=value) + assert param1._set_count == 1 + assert param1.cache.get(get_if_invalid=False) == value + # setting the cache does not trigger a set + param2 = SettableParam(name="param", initial_cache_value=value) + assert param2._set_count == 0 + assert param2.cache.get(get_if_invalid=False) == value + + +def test_set_initial_and_initial_cache_raises(): + with pytest.raises(SyntaxError, match="`initial_value` and `initial_cache_value`"): + Parameter(name="param", initial_value=1, initial_cache_value=2) + + +def test_get_cache(): + time_resolution = time.get_clock_info('time').resolution + sleep_delta = 2 * time_resolution + + # Create a gettable parameter + local_parameter = Parameter('test_param', set_cmd=None, get_cmd=None) + before_set = datetime.now() + time.sleep(sleep_delta) + local_parameter.set(1) + time.sleep(sleep_delta) + after_set = datetime.now() + + # Check we return last set value, with the correct timestamp + assert local_parameter.cache.get() == 1 + assert before_set < local_parameter.cache.timestamp < after_set + + # Check that updating the value updates the timestamp + time.sleep(sleep_delta) + local_parameter.set(2) + assert local_parameter.cache.get() == 2 + assert local_parameter.cache.timestamp > after_set + + +def test_get_cache_raw_value(): + # To have a simple distinction between raw value and value of the + # parameter lets create a parameter with an offset + p = Parameter('p', set_cmd=None, get_cmd=None, offset=42) + assert p.cache.timestamp is None + + # Initially, the parameter's raw value is None + assert p.cache.raw_value is None + + # After setting the parameter to some value, the + # raw_value attribute of the cache should return the raw_value + p(3) + assert p.cache.timestamp is not None + assert p.cache.get() == 3 + assert p.cache.raw_value == 3 + 42 + + +def test_get_cache_unknown(): + """ + Test that cache get on a parameter that has not been acquired will + trigger a get + """ + value = 1 + local_parameter = BetterGettableParam('test_param', set_cmd=None, + get_cmd=None) + # fake a parameter that has a value but never been get/set to mock + # an instrument. + local_parameter.cache._value = value + local_parameter.cache._raw_value = value + assert local_parameter.cache.timestamp is None + before_get = datetime.now() + assert local_parameter._get_count == 0 + assert local_parameter.cache.get() == value + assert local_parameter._get_count == 1 + # calling get above will call get since TS is None + # and the TS will therefore no longer be None + assert local_parameter.cache.timestamp is not None + assert local_parameter.cache.timestamp >= before_get + # calling cache.get now will not trigger get + assert local_parameter.cache.get() == value + assert local_parameter._get_count == 1 + + +def test_get_cache_known(): + """ + Test that cache.get on a parameter that has a known value will not + trigger a get + """ + value = 1 + local_parameter = BetterGettableParam('test_param', set_cmd=None, + get_cmd=None) + # fake a parameter that has a value acquired 10 sec ago + start = datetime.now() + set_time = start - timedelta(seconds=10) + local_parameter.cache._update_with( + value=value, raw_value=value, timestamp=set_time) + assert local_parameter._get_count == 0 + assert local_parameter.cache.timestamp == set_time + assert local_parameter.cache.get() == value + # calling cache.get above will not call get since TS is set and + # max_val_age is not + assert local_parameter._get_count == 0 + assert local_parameter.cache.timestamp == set_time + + +def test_get_cache_no_get(): + """ + Test that cache.get on a parameter that does not have get is handled + correctly. + """ + local_parameter = Parameter('test_param', set_cmd=None, get_cmd=False) + # The parameter does not have a get method. + with pytest.raises(AttributeError): + local_parameter.get() + # get_latest will fail as get cannot be called and no cache + # is available + with pytest.raises(RuntimeError): + local_parameter.cache.get() + value = 1 + local_parameter.set(value) + assert local_parameter.cache.get() == value + + local_parameter2 = Parameter('test_param2', set_cmd=None, + get_cmd=False, initial_value=value) + with pytest.raises(AttributeError): + local_parameter2.get() + assert local_parameter2.cache.get() == value + + +def test_set_raw_value_on_cache(): + value = 1 + scale = 10 + local_parameter = BetterGettableParam('test_param', + set_cmd=None, + scale=scale) + before = datetime.now() + local_parameter.cache._set_from_raw_value(value*scale) + after = datetime.now() + assert local_parameter.cache.get(get_if_invalid=False) == value + assert local_parameter.cache.raw_value == value * scale + assert local_parameter.cache.timestamp >= before + assert local_parameter.cache.timestamp <= after + + +def test_max_val_age(): + value = 1 + start = datetime.now() + local_parameter = BetterGettableParam('test_param', + set_cmd=None, + max_val_age=1, + initial_value=value) + assert local_parameter.cache.max_val_age == 1 + assert local_parameter._get_count == 0 + assert local_parameter.cache.get() == value + assert local_parameter._get_count == 0 + # now fake the time stamp so get should be triggered + set_time = start - timedelta(seconds=10) + local_parameter.cache._update_with( + value=value, raw_value=value, timestamp=set_time) + # now that ts < max_val_age calling get_latest should update the time + assert local_parameter.cache.timestamp == set_time + assert local_parameter.cache.get() == value + assert local_parameter._get_count == 1 + assert local_parameter.cache.timestamp >= start + + +def test_no_get_max_val_age(): + """ + Test that cache.get on a parameter with max_val_age set and + no get cmd raises correctly. + """ + value = 1 + with pytest.raises(SyntaxError): + _ = Parameter('test_param', set_cmd=None, + get_cmd=False, + max_val_age=1, initial_value=value) + + +def test_no_get_max_val_age_runtime_error(get_if_invalid): + """ + _BaseParameter does not have a check on creation time that + no get_cmd is mixed with max_val_age since get_cmd could be added + in a subclass. Here we create a subclass that does not add a get + command and also does not implement the check for max_val_age + """ + value = 1 + + class LocalParameter(_BaseParameter): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.set_raw = lambda x: x + self.set = self._wrap_set(self.set_raw) + + local_parameter = LocalParameter('test_param', + None, + max_val_age=1) + start = datetime.now() + set_time = start - timedelta(seconds=10) + local_parameter.cache._update_with( + value=value, raw_value=value, timestamp=set_time) + + if get_if_invalid is True: + with pytest.raises(RuntimeError, match="max_val_age` is not supported"): + local_parameter.cache.get(get_if_invalid=get_if_invalid) + elif get_if_invalid == NOT_PASSED: + with pytest.raises(RuntimeError, match="max_val_age` is not supported"): + local_parameter.cache.get() + else: + assert local_parameter.cache.get(get_if_invalid=get_if_invalid) == 1 + + +def test_no_get_timestamp_none_runtime_error(get_if_invalid): + """ + Test that a parameter that has never been + set, cannot be get and does not support + getting raises a RuntimeError. + """ + local_parameter = Parameter('test_param', get_cmd=False) + + if get_if_invalid is True: + with pytest.raises(RuntimeError, match="Value of parameter test_param"): + local_parameter.cache.get(get_if_invalid=get_if_invalid) + elif get_if_invalid == NOT_PASSED: + with pytest.raises(RuntimeError, match="Value of parameter test_param"): + local_parameter.cache.get() + else: + assert local_parameter.cache.get(get_if_invalid=get_if_invalid) is None From caf39470f7f53d410117fda5e3299b57f5582a70 Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 10 Jun 2020 09:41:56 +0200 Subject: [PATCH 4/9] missing newline --- qcodes/tests/parameter/conftest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qcodes/tests/parameter/conftest.py b/qcodes/tests/parameter/conftest.py index d6e221d2f7b..9ab64b5267f 100644 --- a/qcodes/tests/parameter/conftest.py +++ b/qcodes/tests/parameter/conftest.py @@ -138,4 +138,4 @@ def get_func(): val = self.cache._raw_value self.get_values.append(val) return val - return get_func \ No newline at end of file + return get_func From 5d7cd0707d3969865b4c5310ed053fe8b27c40ca Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 10 Jun 2020 09:43:28 +0200 Subject: [PATCH 5/9] add a type for pycharms linter --- qcodes/tests/parameter/test_snapshot.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/qcodes/tests/parameter/test_snapshot.py b/qcodes/tests/parameter/test_snapshot.py index fff58bd45a4..b5866a6d041 100644 --- a/qcodes/tests/parameter/test_snapshot.py +++ b/qcodes/tests/parameter/test_snapshot.py @@ -1,4 +1,4 @@ -from typing import Union, Optional +from typing import Union, Optional, Callable from datetime import datetime, timedelta from qcodes.instrument.parameter import Parameter @@ -8,7 +8,7 @@ def create_parameter(snapshot_get: bool, snapshot_value: bool, cache_is_valid: bool, - get_cmd: Optional[bool], + get_cmd: Optional[Union[Callable, bool]], offset: Union[str, float] = NOT_PASSED): kwargs = dict(set_cmd=None, label='Parameter', From 439bb7cc1d4bef9d012ecab1a089e51e36968f3a Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 10 Jun 2020 10:46:39 +0200 Subject: [PATCH 6/9] move DumyPar to a shared location --- qcodes/tests/common.py | 16 +++++++++++++++ qcodes/tests/parameter/test_combined_par.py | 20 ++----------------- .../parameter/test_delegate_parameter.py | 1 + qcodes/tests/test_station.py | 2 +- 4 files changed, 20 insertions(+), 19 deletions(-) diff --git a/qcodes/tests/common.py b/qcodes/tests/common.py index b39a98e8e24..adb35214738 100644 --- a/qcodes/tests/common.py +++ b/qcodes/tests/common.py @@ -3,6 +3,7 @@ from time import sleep import cProfile +from qcodes.utils.metadata import Metadatable if TYPE_CHECKING: from _pytest._code.code import ExceptionInfo @@ -118,3 +119,18 @@ def error_caused_by(excinfo: 'ExceptionInfo', cause: str) -> bool: return cause in str(root_traceback) +class DumyPar(Metadatable): + + """Docstring for DumyPar. """ + + def __init__(self, name): + super().__init__() + self.name = name + self.full_name = name + + def __str__(self): + return self.full_name + + def set(self, value): + value = value * 2 + return value diff --git a/qcodes/tests/parameter/test_combined_par.py b/qcodes/tests/parameter/test_combined_par.py index 005e3f34b7e..818ae7bddb3 100644 --- a/qcodes/tests/parameter/test_combined_par.py +++ b/qcodes/tests/parameter/test_combined_par.py @@ -10,25 +10,9 @@ import numpy as np from qcodes.instrument.parameter import combine -from qcodes.utils.metadata import Metadatable -from qcodes.utils.helpers import full_class - - -class DumyPar(Metadatable): - - """Docstring for DumyPar. """ - def __init__(self, name): - super().__init__() - self.name = name - self.full_name = name - - def __str__(self): - return self.full_name - - def set(self, value): - value = value * 2 - return value +from qcodes.utils.helpers import full_class +from ..common import DumyPar class TestMultiPar(unittest.TestCase): diff --git a/qcodes/tests/parameter/test_delegate_parameter.py b/qcodes/tests/parameter/test_delegate_parameter.py index eeaa8736c98..38e738d3198 100644 --- a/qcodes/tests/parameter/test_delegate_parameter.py +++ b/qcodes/tests/parameter/test_delegate_parameter.py @@ -13,6 +13,7 @@ # Disable warning that is created by using fixtures # pylint: disable=redefined-outer-name + @pytest.fixture() def numeric_val(): yield 1 diff --git a/qcodes/tests/test_station.py b/qcodes/tests/test_station.py index a2cc8b5248d..c966df1563d 100644 --- a/qcodes/tests/test_station.py +++ b/qcodes/tests/test_station.py @@ -21,10 +21,10 @@ from qcodes.monitor.monitor import Monitor from qcodes.tests.instrument_mocks import ( DummyInstrument) -from qcodes.tests.test_combined_par import DumyPar from qcodes.tests.test_config import default_config from qcodes.utils.helpers import NumpyJSONEncoder from qcodes.utils.helpers import YAML +from .common import DumyPar @pytest.fixture(autouse=True) From 2bac085422a3c851d0e2489614b321c7cf8870ff Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 10 Jun 2020 10:48:18 +0200 Subject: [PATCH 7/9] fix tests --- qcodes/tests/parameter/test_snapshot.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/qcodes/tests/parameter/test_snapshot.py b/qcodes/tests/parameter/test_snapshot.py index b5866a6d041..f351081c47d 100644 --- a/qcodes/tests/parameter/test_snapshot.py +++ b/qcodes/tests/parameter/test_snapshot.py @@ -1,4 +1,4 @@ -from typing import Union, Optional, Callable +from typing import Union, Optional, Callable, Dict, Any from datetime import datetime, timedelta from qcodes.instrument.parameter import Parameter @@ -10,10 +10,10 @@ def create_parameter(snapshot_get: bool, cache_is_valid: bool, get_cmd: Optional[Union[Callable, bool]], offset: Union[str, float] = NOT_PASSED): - kwargs = dict(set_cmd=None, - label='Parameter', - unit='a.u.', - docstring='some docs') + kwargs: Dict[str, Any] = dict(set_cmd=None, + label='Parameter', + unit='a.u.', + docstring='some docs') if offset != NOT_PASSED: kwargs.update(offset=offset) @@ -43,7 +43,7 @@ def wrapped_func(*args, **kwargs): return wrapped_func p.get = wrap_in_call_counter(p.get) - assert p.get.call_count() == 0 # pre-condition + assert p.get.call_count() == 0 # type: ignore[attr-defined] # pre-condition else: assert not hasattr(p, 'get') # pre-condition assert not p.gettable From 24edb7966733c7b9b03da092dca6872570f5b4ae Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 10 Jun 2020 11:19:55 +0200 Subject: [PATCH 8/9] ensure that .py files are always text --- .gitattributes | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitattributes b/.gitattributes index 8e15ecd6721..e594b603ccd 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,4 +1,5 @@ qcodes/_version.py export-subst * text=auto eol=lf +*.py text *.{cmd,[cC][mM][dD]} text eol=crlf *.{bat,[bB][aA][tT]} text eol=crlf \ No newline at end of file From a9a4dec3be3ba5aa35c00913ee365cd3f477eb3b Mon Sep 17 00:00:00 2001 From: Jens Hedegaard Nielsen Date: Wed, 10 Jun 2020 11:36:57 +0200 Subject: [PATCH 9/9] fix some codacy warnings --- qcodes/tests/parameter/conftest.py | 6 +++--- qcodes/tests/parameter/test_parameter_cache.py | 6 ++++-- qcodes/tests/parameter/test_snapshot.py | 12 ++++++++---- 3 files changed, 15 insertions(+), 9 deletions(-) diff --git a/qcodes/tests/parameter/conftest.py b/qcodes/tests/parameter/conftest.py index 9ab64b5267f..292ac78521f 100644 --- a/qcodes/tests/parameter/conftest.py +++ b/qcodes/tests/parameter/conftest.py @@ -101,9 +101,9 @@ def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) def get_raw(self): - return self.cache._raw_value + return self.cache.raw_value - def set_raw(self, raw_value): + def set_raw(self, value): pass @@ -135,7 +135,7 @@ def get_func(): if func is not None: val = func() else: - val = self.cache._raw_value + val = self.cache.raw_value self.get_values.append(val) return val return get_func diff --git a/qcodes/tests/parameter/test_parameter_cache.py b/qcodes/tests/parameter/test_parameter_cache.py index ed981445ddd..ef3d469d34e 100644 --- a/qcodes/tests/parameter/test_parameter_cache.py +++ b/qcodes/tests/parameter/test_parameter_cache.py @@ -10,7 +10,8 @@ def test_get_from_cache_does_not_trigger_real_get_if_get_if_invalid_false(): """ assert that calling get on the cache with get_if_invalid=False does - not trigger a get of the parameter when parameter has expired due to max_val_age + not trigger a get of the parameter when parameter + has expired due to max_val_age """ param = BetterGettableParam(name="param", max_val_age=1) param.get() @@ -34,7 +35,8 @@ def test_initial_set_with_without_cache(): def test_set_initial_and_initial_cache_raises(): - with pytest.raises(SyntaxError, match="`initial_value` and `initial_cache_value`"): + with pytest.raises(SyntaxError, + match="`initial_value` and `initial_cache_value`"): Parameter(name="param", initial_value=1, initial_cache_value=2) diff --git a/qcodes/tests/parameter/test_snapshot.py b/qcodes/tests/parameter/test_snapshot.py index f351081c47d..4759daff57e 100644 --- a/qcodes/tests/parameter/test_snapshot.py +++ b/qcodes/tests/parameter/test_snapshot.py @@ -43,9 +43,11 @@ def wrapped_func(*args, **kwargs): return wrapped_func p.get = wrap_in_call_counter(p.get) - assert p.get.call_count() == 0 # type: ignore[attr-defined] # pre-condition + # pre-condition + assert p.get.call_count() == 0 # type: ignore[attr-defined] else: - assert not hasattr(p, 'get') # pre-condition + # pre-condition + assert not hasattr(p, 'get') assert not p.gettable if cache_is_valid: @@ -176,7 +178,8 @@ def test_snapshot_when_snapshot_value_is_false( snapshot_get, get_cmd, cache_is_valid, update): p = create_parameter( - snapshot_get=snapshot_get, snapshot_value=False, get_cmd=get_cmd, cache_is_valid=cache_is_valid) + snapshot_get=snapshot_get, snapshot_value=False, + get_cmd=get_cmd, cache_is_valid=cache_is_valid) if update != NOT_PASSED: s = p.snapshot(update=update) @@ -253,7 +256,8 @@ def test_snapshot_of_non_gettable_parameter_mirrors_cache( assert s['raw_value'] is None -def test_snapshot_of_gettable_parameter_depends_on_update(update, cache_is_valid): +def test_snapshot_of_gettable_parameter_depends_on_update(update, + cache_is_valid): p = create_parameter( snapshot_get=True, snapshot_value=True, get_cmd=lambda: 69, cache_is_valid=cache_is_valid, offset=4)