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')