def test_underlying_instrument_property_for_delegate_parameter():
p = BetterGettableParam('testparam', set_cmd=None, get_cmd=None)
d = DelegateParameter('delegate_parameter_with_source', p)
assert d.underlying_instrument is p.root_instrument
d = DelegateParameter('delegate_parameter_without_source', source=None)
assert d.underlying_instrument is None
def test_initial_value_and_none_source_raises():
with pytest.raises(KeyError,
match="It is not allowed to supply"
" 'initial_value' or"
" 'initial_cache_value'"):
DelegateParameter("delegate", source=None, initial_value=1)
with pytest.raises(KeyError,
match="It is not allowed to supply"
" 'initial_value' or "
"'initial_cache_value'"):
DelegateParameter("delegate", source=None, initial_cache_value=1)
def test_set_source_cache_changes_delegate_get(simple_param):
""" When the delegate parameter's ``get`` is called, the new
value of the source propagates.
"""
offset = 4
scale = 5
d = DelegateParameter('d', simple_param, offset=offset, scale=scale)
new_source_value = 3
simple_param.cache.set(new_source_value)
assert d.get() == (new_source_value - offset) / scale
def test_gettable_settable_snapshotget_delegate_parameter_2(
gettable, get_cmd, settable, set_cmd, snapshot_value):
"""
Test that gettable/settable and snapshot_get are updated correctly
when source changes
"""
source_param = Parameter("source",
get_cmd=get_cmd,
set_cmd=set_cmd,
snapshot_value=snapshot_value)
delegate_param = DelegateParameter("delegate", source=None)
delegate_param.source = source_param
assert delegate_param.gettable is gettable
assert delegate_param.settable is settable
assert delegate_param._snapshot_value is snapshot_value
def test_delegate_parameter_change_source_reflected_in_label_and_unit():
delegate_param = DelegateParameter("delegate", source=None)
source_param_1 = Parameter("source1", label="source 1", unit="unit1")
source_param_2 = Parameter("source2", label="source 2", unit="unit2")
assert delegate_param.label == "delegate"
assert delegate_param.unit == ""
delegate_param.source = source_param_1
assert delegate_param.label == "source 1"
assert delegate_param.unit == "unit1"
delegate_param.source = source_param_2
assert delegate_param.label == "source 2"
assert delegate_param.unit == "unit2"
delegate_param.source = None
assert delegate_param.label == "delegate"
assert delegate_param.unit == ""
def test_overwritten_label_on_init(simple_param):
d = DelegateParameter('test_delegate_parameter',
simple_param,
label='Physical parameter')
assert d.unit == simple_param.unit
assert not d.label == simple_param.label
assert d.label == 'Physical parameter'
def test_scaling_initial_value(simple_param, numeric_val):
scale = 5
offset = 3
d = DelegateParameter('test_delegate_parameter',
simple_param,
offset=offset,
scale=scale)
assert d() == (simple_param() - offset) / scale
def test_same_label_and_unit_on_init(simple_param):
"""
Test that the label and unit get used from source parameter if not
specified otherwise.
"""
d = DelegateParameter('test_delegate_parameter', simple_param)
assert d.label == simple_param.label
assert d.unit == simple_param.unit
def test_setting_initial_cache_delegate_parameter():
value = 10
p = Parameter('testparam', set_cmd=None, get_cmd=None)
d = DelegateParameter('test_delegate_parameter',
p,
initial_cache_value=value)
assert p.cache.get(get_if_invalid=False) == value
assert d.cache.get(get_if_invalid=False) == value
def test_get_set_raises(simple_param):
"""
Test that providing a get/set_cmd kwarg raises an error.
"""
for kwargs in ({'set_cmd': None}, {'get_cmd': None}):
with pytest.raises(KeyError) as e:
DelegateParameter('test_delegate_parameter', simple_param,
**kwargs)
assert str(e.value).startswith('\'It is not allowed to set')
def test_delegate_get_updates_cache(make_observable_parameter, numeric_val):
initial_value = numeric_val
t = make_observable_parameter('observable_parameter',
initial_value=initial_value)
d = DelegateParameter('delegate', t)
assert d() == initial_value
assert d.cache.get() == initial_value
assert t.get_instr_val() == initial_value
def test_snapshot():
p = Parameter('testparam',
set_cmd=None,
get_cmd=None,
offset=1,
scale=2,
initial_value=1)
d = DelegateParameter('test_delegate_parameter',
p,
offset=3,
scale=5,
initial_value=2)
delegate_snapshot = d.snapshot()
source_snapshot = delegate_snapshot.pop('source_parameter')
assert source_snapshot == p.snapshot()
assert delegate_snapshot['value'] == 2
assert source_snapshot['value'] == 13
def test_set_delegate_cache_changes_source_cache(simple_param):
offset = 4
scale = 5
d = DelegateParameter('d', simple_param, offset=offset, scale=scale)
new_delegate_value = 2
d.cache.set(new_delegate_value)
assert simple_param.cache.get() == (new_delegate_value * scale + offset)
def test_set_delegate_cache_with_raw_value(simple_param):
offset = 4
scale = 5
d = DelegateParameter('d', simple_param, offset=offset, scale=scale)
new_delegate_value = 2
d.cache._set_from_raw_value(new_delegate_value * scale + offset)
assert simple_param.cache.get() == (new_delegate_value * scale + offset)
assert d.cache.get(get_if_invalid=False) == new_delegate_value
def test_delegate_parameter_fixed_label_unit_unchanged():
delegate_param = DelegateParameter("delegate",
label="delegatelabel",
unit="delegateunit",
source=None)
source_param_1 = Parameter("source1", label="source 1", unit="unit1")
source_param_2 = Parameter("source2", label="source 2", unit="unit2")
assert delegate_param.label == "delegatelabel"
assert delegate_param.unit == "delegateunit"
delegate_param.source = source_param_1
assert delegate_param.label == "delegatelabel"
assert delegate_param.unit == "delegateunit"
delegate_param.source = source_param_2
assert delegate_param.label == "delegatelabel"
assert delegate_param.unit == "delegateunit"
delegate_param.source = None
assert delegate_param.label == "delegatelabel"
assert delegate_param.unit == "delegateunit"
def test_scaling_delegate_initial_value(simple_param, numeric_val):
scale = 5
offset = 3
DelegateParameter('test_delegate_parameter',
simple_param,
offset=offset,
scale=scale,
initial_value=numeric_val)
assert simple_param() == numeric_val * scale + offset
def test_set_source_cache_changes_delegate_cache(simple_param):
""" Setting the cached value of the source parameter changes the
delegate parameter cache accordingly.
"""
offset = 4
scale = 5
d = DelegateParameter('d', simple_param, offset=offset, scale=scale)
new_source_value = 3
simple_param.cache.set(new_source_value)
assert d.cache.get() == (new_source_value - offset) / scale
def test_delegate_parameter_with_changed_source_snapshot_matches_value(
value, scale, offset):
delegate_param = DelegateParameter(name="delegate",
source=None,
scale=scale,
offset=offset)
source_parameter = Parameter(name="source",
get_cmd=None,
set_cmd=None,
initial_value=value)
_assert_none_source_is_correct(delegate_param)
delegate_param.source = source_parameter
calc_value = (value - offset) / scale
assert delegate_param.cache.get(get_if_invalid=False) == calc_value
assert delegate_param.source.cache.get(get_if_invalid=False) == value
snapshot = delegate_param.snapshot()
# disregard timestamp that might be slightly different
snapshot["source_parameter"].pop("ts")
source_snapshot = source_parameter.snapshot()
source_snapshot.pop("ts")
assert snapshot["source_parameter"] == source_snapshot
assert snapshot["value"] == calc_value
assert delegate_param.get() == calc_value
# now remove the source again
delegate_param.source = None
_assert_none_source_is_correct(delegate_param)
_assert_delegate_cache_none_source(delegate_param)
def test_scaling(simple_param, numeric_val):
scale = 5
offset = 3
d = DelegateParameter('test_delegate_parameter',
simple_param,
offset=offset,
scale=scale)
simple_param(numeric_val)
assert d() == (numeric_val - offset) / scale
d(numeric_val)
assert simple_param() == numeric_val * scale + offset
def test_cache_no_source():
d = DelegateParameter('test_delegate_parameter', source=None)
assert d.cache.valid is False
assert d.cache.timestamp is None
assert d.cache.max_val_age is None
with pytest.raises(TypeError,
match="Cannot get the cache of a "
"DelegateParameter that delegates to None"):
d.cache.get()
d.cache.invalidate()
def test_gettable_settable_snapshotget_delegate_parameter(
gettable, get_cmd, settable, set_cmd, snapshot_value):
"""
Test that gettable, settable and snapshot_get are correctly reflected
in the DelegateParameter
"""
source_param = Parameter("source",
get_cmd=get_cmd,
set_cmd=set_cmd,
snapshot_value=snapshot_value)
delegate_param = DelegateParameter("delegate", source=source_param)
assert delegate_param.gettable is gettable
assert delegate_param.settable is settable
assert delegate_param._snapshot_value is snapshot_value
def test_raw_value_scaling(make_observable_parameter):
"""
The :attr:`raw_value` will be deprecated soon,
so other tests should not use it.
"""
p = Parameter('testparam', set_cmd=None, get_cmd=None, offset=1, scale=2)
d = DelegateParameter('test_delegate_parameter', p, offset=3, scale=5)
val = 1
p(val)
assert d() == (val - 3) / 5
d(val)
assert d.raw_value == val * 5 + 3
assert d.raw_value == p()
def test_cache_invalidation():
value = 10
p = BetterGettableParam('testparam', set_cmd=None, get_cmd=None)
d = DelegateParameter('test_delegate_parameter',
p,
initial_cache_value=value)
assert p._get_count == 0
assert d.cache.get() == value
assert p._get_count == 0
assert d.cache.valid is True
assert p.cache.valid is True
d.cache.invalidate()
assert d.cache.valid is False
assert p.cache.valid is False
d.cache.get()
assert p._get_count == 1
assert d.cache.valid is True
assert p.cache.valid is True
def test_overwritten_unit_on_init(simple_param):
d = DelegateParameter('test_delegate_parameter', simple_param, unit='Ohm')
assert d.label == simple_param.label
assert not d.unit == simple_param.unit
assert d.unit == 'Ohm'
def test_same_value(simple_param):
d = DelegateParameter('test_delegate_parameter', simple_param)
assert d() == simple_param()
def test_delegate_cache_pristine_if_not_set():
p = Parameter('test')
d = DelegateParameter('delegate', p)
gotten_delegate_cache = d.cache.get(get_if_invalid=False)
assert gotten_delegate_cache is None
def test_delegate_parameter_get_and_snapshot_with_none_source():
"""
Test that a delegate parameter returns None on get and snapshot if
the source has a value of None and an offset or scale is used.
And returns a value if the source is remapped to a real parameter.
"""
none_param = Parameter("None")
source_param = Parameter('source',
get_cmd=None,
set_cmd=None,
initial_value=2)
delegate_param = DelegateParameter(name='delegate', source=none_param)
delegate_param.offset = 4
assert delegate_param.get() is None
assert delegate_param.snapshot()['value'] is None
delegate_param.offset = None
delegate_param.scale = 2
assert delegate_param.get() is None
assert delegate_param.snapshot()['value'] is None
assert delegate_param.cache._parameter.source.cache is none_param.cache
delegate_param.source = source_param
assert delegate_param.get() == 1
assert delegate_param.snapshot()['value'] == 1
assert delegate_param.cache._parameter.source.cache is source_param.cache
def test_delegate_parameter_with_none_source_works_as_expected():
delegate_param = DelegateParameter(name='delegate',
source=None,
scale=2,
offset=1)
_assert_none_source_is_correct(delegate_param)