def test_validate_pdesc_failed(self):
# test setting of parameter where the automatic conversion fails
# set
test_param = 'focus_distance_m'
test_val = 'foo'
expecting_type = float
param = Parameter(test_param, test_val, expecting_type)
# we know the parameter, this should not raise anything
ParametersStore.get(test_param)
# same as this one
self.assertRaises(ValueError, ParametersStore.set,
param.name, param.value)
self.assertRaises(ValueError, ParametersStore.validate,
param.name, param.value)
self.assertRaises(ValueError, ParametersStore.validate_desc,
param)
# change value to correct one
param.value = 10
try:
ParametersStore.validate_desc(param)
except Exception as err:
self.fail("Exception raised")
def test_read_only(self):
par = Parameter('foo', 'bar', str)
self.assertFalse(par.is_read_only())
par = ReadOnlyParameter('foo', 'bar', str)
self.assertTrue(par.is_read_only())
class ParameterGetValueTestCase(unittest.TestCase):
PARAMETERS = [
Parameter('foo', 1, int),
Parameter('bar', 'baz', str)
]
def setUp(self):
ParametersStore.load_parameters(self.PARAMETERS)
def tearDown(self):
ParametersStore.clear_parameters()
def find_key_param(self, name):
found = [pdesc for pdesc in self.PARAMETERS
if pdesc.name == name]
return found[0]
def test_get_value(self):
for param_in in self.PARAMETERS:
pdesc = ParametersStore.get(param_in.name)
self.assertEqual(param_in.name, pdesc.name)
self.assertEqual(param_in.value, pdesc.value)
self.assertEqual(param_in.value_type, pdesc.value_type)
pvalue = ParametersStore.get_value(param_in.name)
self.assertEqual(pvalue, param_in.value)
self.assertEqual(type(pvalue), param_in.value_type)
class ParameterEvaluationTestCase(unittest.TestCase):
class BarEvaluator(Evaluator):
REQUIRES = [
'foo'
]
def __call__(self, foo=None):
return foo + 1
class BazEvaluator(Evaluator):
REQUIRES = [
'foo',
'bar'
]
def __call__(self, foo=None, bar=None):
return foo * bar + 1
class CafeEvaluator(Evaluator):
REQUIRES = [
'baz',
'bar'
]
def __call__(self, baz=None, bar=None):
return baz ** 2 + bar
PARAMETERS = [
Parameter('foo', 1, int),
Parameter('cafe', 0, int, evaluator=CafeEvaluator),
Parameter('bar', 0, int, evaluator=BarEvaluator),
Parameter('baz', 0, int, evaluator=BazEvaluator),
]
def setUp(self):
ParametersStore.load_parameters(self.PARAMETERS)
def tearDown(self):
ParametersStore.clear_parameters()
def test_set_value(self):
self.assertNotEqual(ParametersStore.DEPENDENCIES, {})
pdesc_bar = ParametersStore.get('bar')
ParametersStore.set('foo', 3)
bar_val = ParametersStore.get_value('bar')
# bar = foo + 1
self.assertEqual(bar_val, 4)
baz_val = ParametersStore.get_value('baz')
# baz = foo * bar + 1
self.assertEqual(baz_val, 13)
# cafe = baz ** 2 + bar
cafe_val = ParametersStore.get_value('cafe')
self.assertEqual(cafe_val, 173)
def test_modify_take_snapshot(self):
# take snapshot with current parameters
self.ctrl.take_snapshot()
snaps = self.ctrl.list_snapshots()
self.assertEqual(len(snaps), 1)
for param in snaps:
if param == 'foo-writable':
self.assertEqual(param.value, 'bar')
# now modify a value of foo-writable and take another snapshot
self.ctrl.apply_parameters([Parameter('foo-writable', 'test', str)])
self.ctrl.take_snapshot()
snaps = self.ctrl.list_snapshots()
self.assertEqual(len(snaps), 2)
# most recent snapshot gets the highest snapshot ID
last_snap = max(snaps)
snap = self.ctrl.get_snapshot(last_snap)
for param in snap:
if param.name == 'foo-writable':
self.assertEqual(param.value, 'test')
def test_encode_infinity(self):
params = [
Parameter('foo-max', float('inf'), float),
Parameter('foo-min', float('-inf'), float),
Parameter('foo-other', 20e10, float)
]
encoded = self.codec.encode(params)
_log.debug('encoded: %s', encoded)
dec = json.loads(encoded)
_log.debug('parsed: %s', dec)
self.assertEqual(dec['foo-max']['value'], Infinity.PLUS)
self.assertEqual(dec['foo-min']['value'], Infinity.MINUS)
self.assertEqual(dec['foo-other']['value'], 20e10)
def test_apply(self):
to_apply = [
Parameter('foo-writable', 'test', str),
Parameter('foo-readonly', 'test2', str)
]
applied = self.ctrl.apply_parameters(to_apply)
# only one parameter was applied
self.assertEqual(len(applied), 1)
app_param = applied[0]
self.assertEqual(app_param.name, 'foo-writable')
self.assertEqual(app_param.value, 'test')
# writable parameter was set
self.assertEqual(ParametersStore.get('foo-writable').value, 'test')
# readonly remains unchanged
self.assertEqual(ParametersStore.get('foo-readonly').value, 'baz')
def test_encode_list(self):
params = [
Parameter('foo', 'bar', str),
Parameter('baz', 1, int)
]
# this should produce a valid json
enc = self.codec.encode(params)
_log.debug('encoded: %s', enc)
try:
parsed = json.loads(enc)
except ValueError:
self.fail('invalid JSON produced')
_log.debug('parsed: %s', parsed)
self.assertIsInstance(parsed, dict)
self.assertTrue('foo' in parsed)
self.assertTrue('baz' in parsed)
class StoreLoadClearTestCase(unittest.TestCase):
PARAMETERS = [
Parameter('foo', 1, int),
Parameter('bar', 2, float)
]
def setUp(self):
ParametersStore.clear_parameters()
def test_load_clear(self):
self.assertEqual(ParametersStore.PARAMETERS, {})
ParametersStore.load_parameters(self.PARAMETERS)
self.assertNotEqual(ParametersStore.PARAMETERS, {})
self.assertIn('foo', ParametersStore.PARAMETERS)
self.assertIn('bar', ParametersStore.PARAMETERS)
ParametersStore.clear_parameters()
self.assertEqual(ParametersStore.PARAMETERS, {})
def test_new_status(self):
st = ParameterStatus()
par = Parameter('foo', 1, int, status=st, min_val=0, max_val=10)
self.assertEqual(par.name, 'foo')
self.assertEqual(par.value, 1)
self.assertIsInstance(par.value, int)
self.assertEqual(par.value_type, int)
self.assertEqual(par.min_value, 0)
self.assertEqual(par.max_value, 10)
self.assertIs(par.status, st)
class ParmetersGetTestCase(ControllerTestCase):
PARAMETERS = [
Parameter('foo-writable', 'bar', str),
ReadOnlyParameter('foo-readonly', 'baz', str)
]
def test_get(self):
dict_params = self.ctrl.get_parameters()
for param in self.PARAMETERS:
self.assertTrue(dict_params.has_key(param.name))
self.assertFalse(dict_params.has_key('foo-not-present'))
def test_new_no_status(self):
par = Parameter('foo', 'bar', str)
self.assertEqual(par.name, 'foo')
self.assertEqual(par.value, 'bar')
self.assertIsInstance(par.value, str)
self.assertEqual(par.value_type, str)
self.assertTrue(hasattr(par, 'status'))
status = par.status
self.assertIsInstance(status, ParameterStatus)
self.assertEqual(status.read, True)
self.assertEqual(status.write, True)
self.assertEqual(status.status, ParameterStatus.SOFTWARE)
def test_encode_single(self):
p = Parameter('foo', 'bar', str)
# this should produce a valid json
enc = self.codec.encode(p)
_log.debug('encoded: %s', enc)
try:
parsed = json.loads(enc)
except ValueError:
self.fail('invalid JSON produced')
_log.debug('parsed: %s', parsed)
self.assertIsInstance(parsed, dict)
self.assertTrue('foo' in parsed)
self.assertTrue('value' in parsed['foo'])
self.assertTrue('type' in parsed['foo'])
self.assertTrue('status' in parsed['foo'])
self.assertEqual(parsed['foo']['value'], 'bar')
self.assertEqual(parsed['foo']['type'], str.__name__)
class ParametersApplyTestCase(ControllerTestCase):
PARAMETERS = [
Parameter('foo-writable', 'bar', str),
ReadOnlyParameter('foo-readonly', 'baz', str)
]
def test_apply(self):
to_apply = [
Parameter('foo-writable', 'test', str),
Parameter('foo-readonly', 'test2', str)
]
applied = self.ctrl.apply_parameters(to_apply)
# only one parameter was applied
self.assertEqual(len(applied), 1)
app_param = applied[0]
self.assertEqual(app_param.name, 'foo-writable')
self.assertEqual(app_param.value, 'test')
# writable parameter was set
self.assertEqual(ParametersStore.get('foo-writable').value, 'test')
# readonly remains unchanged
self.assertEqual(ParametersStore.get('foo-readonly').value, 'baz')
'baseline_mm', 'focus_distance_m', 'focal_length_mm', 'aperture'
]
CAMERA_PARAMETERS = [
'iso', 'camera_type', 'record_framerate', 'shutter_us', 'scene_no',
'shot_no', 'take_no', 'start_absolute_timecode', 'project_framerate',
'director', 'director_of_photography', 'copyright', 'camera_id', 'clip_id',
'reel_id', 'camera_operator', 'location', 'frame_width_px',
'frame_height_px', 'frame_format', 'camera_operator', 'production_name',
'record_date', 'record_time', 'sensor_width_mm', 'sensor_height_mm',
'sensor_width_px', 'sensor_height_px'
]
SYSTEM_PARAMETERS = [
# shot parameters
Parameter('scene_no', '', str),
Parameter('scene_name', '', str),
Parameter('shot_no', '', str),
Parameter('location', '', str),
Parameter('notes', '', str),
# clip parameters
ReadOnlyParameter('camera_id', 'A', str),
Parameter('record_framerate', 25, float),
Parameter('shutter_deg', 180, float),
Parameter('shutter_us', 20000, float, evaluator=ShutterUSCalc),
Parameter('iso', 800, int),
Parameter('filters', '', str),
ReadOnlyParameter('reel_id', '001', str),
ReadOnlyParameter('clip_id', '001', str),
Parameter('take_no', '3', str),
def test_encode_no_set(self):
p = Parameter('foo', 'bar', str)
# this should produce a valid json
codec = ParameterCodec()
self.assertRaises(NotImplementedError, codec.encode, p)
def setUp(self):
ParametersStore.load_parameters([
ReadOnlyParameter('foo-readonly', 'bar', str),
Parameter('foo-writable', 'bar', str)
])
class SnapshotsTestCase(SnapshotTestCaseBase):
PARAMETERS = [
Parameter('foo-writable', 'bar', str),
ReadOnlyParameter('foo-readonly', 'baz', str),
# snapshot records a timestamp in record_date parameter
ReadOnlyParameter('record_date', '', str)
]
def test_take_snapshot(self):
# there should be no files in snapshots directory
self.assertEqual(os.listdir(self.SNAPSHOTS_LOCATION), [])
self.ctrl.take_snapshot()
# there snould be some files in the snapshots directory
self.assertNotEqual(os.listdir(self.SNAPSHOTS_LOCATION), [])
snaps = self.ctrl.list_snapshots()
self.assertEqual(len(snaps), 1)
# get a snapshot of current parameters list
snap = self.ctrl.get_snapshot(snaps[0])
self.assertEqual(len(snap), len(self.PARAMETERS))
self.assertTrue(isinstance(snap, list))
# make sure that all parameters are found in the snapshot and
# that they have correct values
all_params = [p.name for p in self.PARAMETERS]
for param in snap:
self.assertTrue(isinstance(param, Parameter))
all_params.remove(param.name)
# parameters that went into the snapshot
self.assertTrue(self.PARAMETERS_DICT.has_key(param.name))
in_param = self.PARAMETERS_DICT[param.name]
self.assertEqual(in_param.name, param.name)
self.assertEqual(in_param.value, param.value)
self.assertEqual(all_params, [])
def test_modify_take_snapshot(self):
# take snapshot with current parameters
self.ctrl.take_snapshot()
snaps = self.ctrl.list_snapshots()
self.assertEqual(len(snaps), 1)
for param in snaps:
if param == 'foo-writable':
self.assertEqual(param.value, 'bar')
# now modify a value of foo-writable and take another snapshot
self.ctrl.apply_parameters([Parameter('foo-writable', 'test', str)])
self.ctrl.take_snapshot()
snaps = self.ctrl.list_snapshots()
self.assertEqual(len(snaps), 2)
# most recent snapshot gets the highest snapshot ID
last_snap = max(snaps)
snap = self.ctrl.get_snapshot(last_snap)
for param in snap:
if param.name == 'foo-writable':
self.assertEqual(param.value, 'test')
