52 self.assertEquals(metaelem[0].tag, 'test') |
50 self.assertEquals(metaelem[0].tag, 'test') |
53 self.assertEquals(metaelem[0].value, 123) |
51 self.assertEquals(metaelem[0].value, 123) |
54 self.assertEquals(metaelem[0].ns, "abc") |
52 self.assertEquals(metaelem[0].ns, "abc") |
55 self.assertEquals(metaelem[0].attrs, {"foo":"bar", "abc":1}) |
53 self.assertEquals(metaelem[0].attrs, {"foo":"bar", "abc":1}) |
56 |
54 |
|
55 def test_update_data(self): |
|
56 metaelem = model.ConfmlMeta() |
|
57 metaelem.append(model.ConfmlMetaProperty('test', 123, "abc", attrs = {"foo":"bar", "abc":1})) |
|
58 metaelem.set_property_by_tag('foo', 3) |
|
59 metaelem.set_property_by_tag('bar', None, 'http://me.com', {'name':'me', 'value':1}) |
|
60 self.assertEquals(metaelem[0].tag, 'test') |
|
61 self.assertEquals(metaelem[0].value, 123) |
|
62 self.assertEquals(metaelem[0].ns, "abc") |
|
63 self.assertEquals(metaelem[0].attrs, {"foo":"bar", "abc":1}) |
|
64 self.assertEquals(metaelem[1].tag, 'foo') |
|
65 self.assertEquals(metaelem[1].value, 3) |
|
66 self.assertEquals(metaelem[2].tag, "bar") |
|
67 self.assertEquals(metaelem[2].attrs, {'name':'me', 'value':1}) |
|
68 |
|
69 metaelem1 = model.ConfmlMeta() |
|
70 metaelem.set_property_by_tag('foo', 2) |
|
71 metaelem.set_property_by_tag('bar', None, 'http://me.com', {'name':'me', 'value':2}) |
|
72 metaelem.update(metaelem1) |
|
73 self.assertEquals(len(metaelem), 3) |
|
74 self.assertEquals(metaelem[0].tag, 'test') |
|
75 self.assertEquals(metaelem[0].value, 123) |
|
76 self.assertEquals(metaelem[0].ns, "abc") |
|
77 self.assertEquals(metaelem[0].attrs, {"foo":"bar", "abc":1}) |
|
78 self.assertEquals(metaelem[1].tag, 'foo') |
|
79 self.assertEquals(metaelem[1].value, 2) |
|
80 self.assertEquals(metaelem[2].tag, "bar") |
|
81 self.assertEquals(metaelem[2].attrs, {'name':'me', 'value':2}) |
|
82 |
|
83 |
57 def test_find_data(self): |
84 def test_find_data(self): |
58 metaelem = model.ConfmlMeta() |
85 metaelem = model.ConfmlMeta() |
59 metaelem.append(model.ConfmlMetaProperty('test', 123, "abc",\ |
86 metaelem.append(model.ConfmlMetaProperty('test', 123, "abc",\ |
60 attrs = {"foo":"bar", "abc":1})) |
87 attrs = {"foo":"bar", "abc":1})) |
61 metaelem.append(model.ConfmlMetaProperty('abc', "efg", None,\ |
88 metaelem.append(model.ConfmlMetaProperty('abc', "efg", None,\ |
62 attrs = {"foo2":"bar2", "abc2":2})) |
89 attrs = {"foo2":"bar2", "abc2":2})) |
|
90 metaelem.append(model.ConfmlMetaProperty('test', None, "demons",\ |
|
91 attrs = {"name":"bar1", "value":"foo1"})) |
|
92 metaelem.append(model.ConfmlMetaProperty('test', None, "demons",\ |
|
93 attrs = {"name":"bar2", "value":"foo2"})) |
63 self.assertEquals(metaelem.find_by_tag("test"), 0) |
94 self.assertEquals(metaelem.find_by_tag("test"), 0) |
64 self.assertEquals(metaelem.get_property_by_tag("test").tag, 'test') |
95 self.assertEquals(metaelem.get_property_by_tag("test").tag, 'test') |
65 self.assertEquals(metaelem.get_property_by_tag("test").value, 123) |
96 self.assertEquals(metaelem.get_property_by_tag("test").value, 123) |
|
97 self.assertEquals(metaelem.get_property_by_tag("test", {'name' : 'bar1'}).tag, 'test') |
|
98 self.assertEquals(metaelem.get_property_by_tag("test", {'name' : 'bar1'}).attrs['value'], 'foo1') |
66 self.assertEquals(metaelem.get("test"), 123) |
99 self.assertEquals(metaelem.get("test"), 123) |
67 self.assertEquals(metaelem.get("test", 'ddd'), 123) |
100 self.assertEquals(metaelem.get("test", 'ddd'), 123) |
68 # test get_value with not found elem |
101 # test get_value with not found elem |
69 self.assertEquals(metaelem.get("notthere"), None) |
102 self.assertEquals(metaelem.get("notthere"), None) |
70 self.assertEquals(metaelem.get("notthere", 'fooman'), 'fooman') |
103 self.assertEquals(metaelem.get("notthere", 'fooman'), 'fooman') |
233 elem = model.ConfmlSetting('foo', minLength=10) |
293 elem = model.ConfmlSetting('foo', minLength=10) |
234 self.assertEquals(elem.minLength,10) |
294 self.assertEquals(elem.minLength,10) |
235 elem.minLength = 20 |
295 elem.minLength = 20 |
236 self.assertEquals(elem.minLength,20) |
296 self.assertEquals(elem.minLength,20) |
237 self.assertTrue(elem._has(model.ConfmlMinLength.refname)) |
297 self.assertTrue(elem._has(model.ConfmlMinLength.refname)) |
|
298 |
|
299 def test_setting_with_length(self): |
|
300 elem = model.ConfmlSetting('foo', length=10) |
|
301 self.assertEquals(elem.length,10) |
|
302 elem.length = 20 |
|
303 self.assertEquals(elem.length,20) |
|
304 self.assertTrue(elem._has(model.ConfmlLength.refname)) |
|
305 self.assertEquals(elem._get(model.ConfmlLength.refname).value, 20) |
238 |
306 |
239 def test_setting_rfs_casting(self): |
307 def test_setting_rfs_casting(self): |
240 elem = model.ConfmlSetting('foo', minLength=10) |
308 elem = model.ConfmlSetting('foo', minLength=10) |
241 self.assertEquals(elem.get_rfs_cast('true'),True) |
309 self.assertEquals(elem.get_rfs_cast('true'),True) |
242 self.assertEquals(elem.get_rfs_cast('false'),False) |
310 self.assertEquals(elem.get_rfs_cast('false'),False) |
243 self.assertEquals(elem.set_rfs_cast(True),'true') |
311 self.assertEquals(elem.set_rfs_cast(True),'true') |
244 self.assertEquals(elem.set_rfs_cast(False),'false') |
312 self.assertEquals(elem.set_rfs_cast(False),'false') |
245 self.assertEquals(elem.set_rfs_cast(1),'true') |
313 self.assertEquals(elem.set_rfs_cast(1),'true') |
|
314 |
|
315 def test_get_rfs_with_no_value(self): |
|
316 conf = api.Configuration("test.confml") |
|
317 conf.add_feature(model.ConfmlSetting("foo")) |
|
318 |
|
319 # Test that initially the RFS value is None |
|
320 fea = conf.get_default_view().get_feature('foo') |
|
321 self.assertEquals(fea.get_value(attr='rfs'), None) |
|
322 self.assertEquals(fea.get_original_value(attr='rfs'), None) |
|
323 |
|
324 def test_get_rfs_true(self): |
|
325 conf = api.Configuration("test.confml") |
|
326 conf.add_feature(model.ConfmlSetting("foo")) |
|
327 conf.add_data(api.Data(ref='foo', attr='rfs', value='true')) |
|
328 |
|
329 fea = conf.get_default_view().get_feature('foo') |
|
330 self.assertEquals(fea.get_value(attr='rfs'), True) |
|
331 self.assertEquals(fea.get_original_value(attr='rfs'), 'true') |
|
332 |
|
333 def test_get_rfs_false(self): |
|
334 conf = api.Configuration("test.confml") |
|
335 conf.add_feature(model.ConfmlSetting("foo")) |
|
336 conf.add_data(api.Data(ref='foo', attr='rfs', value='false')) |
|
337 |
|
338 fea = conf.get_default_view().get_feature('foo') |
|
339 self.assertEquals(fea.get_value(attr='rfs'), False) |
|
340 self.assertEquals(fea.get_original_value(attr='rfs'), 'false') |
|
341 |
|
342 def test_set_rfs(self): |
|
343 conf = api.Configuration("test.confml") |
|
344 conf.add_feature(model.ConfmlSetting("foo")) |
|
345 |
|
346 def check_data_elements(expected): |
|
347 actual = [] |
|
348 for d in conf._traverse(type=api.Data): |
|
349 actual.append((d.fqr, d.attr, d.value)) |
|
350 self.assertEquals(actual, expected) |
|
351 |
|
352 fea = conf.get_default_view().get_feature('foo') |
|
353 |
|
354 fea.set_value(True, attr='rfs') |
|
355 self.assertEquals(fea.get_value(attr='rfs'), True) |
|
356 self.assertEquals(fea.get_original_value(attr='rfs'), 'true') |
|
357 check_data_elements([('foo', 'rfs', 'true')]) |
|
358 |
|
359 fea.set_value(False, attr='rfs') |
|
360 self.assertEquals(fea.get_value(attr='rfs'), False) |
|
361 self.assertEquals(fea.get_original_value(attr='rfs'), 'false') |
|
362 check_data_elements([('foo', 'rfs', 'false')]) |
246 |
363 |
247 class TestConfmlSelectionSetting(unittest.TestCase): |
364 class TestConfmlSelectionSetting(unittest.TestCase): |
248 def test_create_selection_setting(self): |
365 def test_create_selection_setting(self): |
249 elem = model.ConfmlSelectionSetting('foo') |
366 elem = model.ConfmlSelectionSetting('foo', desc="Test desc", name="Foo fea") |
250 self.assertTrue(elem) |
367 self.assertTrue(elem) |
251 self.assertEquals(elem.type, 'selection') |
368 self.assertEquals(elem.type, 'selection') |
252 self.assertEquals(elem.desc, None) |
369 self.assertEquals(elem.name, 'Foo fea') |
|
370 self.assertEquals(elem.desc, "Test desc") |
253 self.assertEquals(elem.readOnly, None) |
371 self.assertEquals(elem.readOnly, None) |
254 self.assertEquals(elem.constraint, None) |
372 self.assertEquals(elem.constraint, None) |
255 self.assertEquals(elem.required, None) |
373 self.assertEquals(elem.required, None) |
256 self.assertEquals(elem.relevant, None) |
374 self.assertEquals(elem.relevant, None) |
257 |
375 |
323 def test_setting_list_value_to_multiselection(self): |
428 def test_setting_list_value_to_multiselection(self): |
324 conf = model.ConfmlConfiguration('test.confml') |
429 conf = model.ConfmlConfiguration('test.confml') |
325 elem = model.ConfmlMultiSelectionSetting('mset5', type='multiSelection') |
430 elem = model.ConfmlMultiSelectionSetting('mset5', type='multiSelection') |
326 conf.add_feature(elem) |
431 conf.add_feature(elem) |
327 elem.set_value(["li1", "li2"]) |
432 elem.set_value(["li1", "li2"]) |
328 self.assertEquals(elem.get_value(), ["li1", "li2"]) |
433 self.assertEquals(elem.get_value(), ("li1", "li2")) |
329 self.assertEquals(elem.get_data().get_value(), '"li1" "li2"') |
434 self.assertEquals(elem.get_datas()[0].get_value(), 'li1') |
|
435 self.assertEquals(elem.get_datas()[1].get_value(), 'li2') |
|
436 |
|
437 def test_get_value_from_old_style_data(self): |
|
438 def check(data_value, expected): |
|
439 config = api.Configuration('foo.confml') |
|
440 fea = model.ConfmlMultiSelectionSetting('multisel', type='multiSelection') |
|
441 config.add_feature(fea) |
|
442 config.add_data(api.Data(ref='multisel', value=data_value)) |
|
443 |
|
444 dview = config.get_default_view() |
|
445 foofea = dview.get_feature('multisel') |
|
446 self.assertEquals(foofea.value, expected) |
|
447 |
|
448 check('x', ('x',)) |
|
449 check('"x"', ('x',)) |
|
450 check('"x" "y"', ('x', 'y')) |
|
451 check('"x" "y" "" "z"', ('x', 'y', '', 'z')) |
|
452 |
|
453 def test_get_value_with_new_style_data(self): |
|
454 def check(data_object_values, expected_value, empty_option=False): |
|
455 config = api.Configuration('foo.confml') |
|
456 fea = model.ConfmlMultiSelectionSetting('multisel', type='multiSelection') |
|
457 if empty_option: |
|
458 fea.add_option(api.Option('Empty option', '')) |
|
459 config.add_feature(fea) |
|
460 for dv in data_object_values: |
|
461 config.add_data(api.Data(ref='multisel', value=dv), policy=api.container.APPEND) |
|
462 |
|
463 dview = config.get_default_view() |
|
464 foofea = dview.get_feature('multisel') |
|
465 self.assertEquals(foofea.value, expected_value) |
|
466 |
|
467 check([], ()) |
|
468 check(['x'], ('x',)) |
|
469 check(['x', 'y'], ('x', 'y')) |
|
470 check(['y', 'x', 'y',], ('y', 'x')) |
|
471 check(['"foo"', '"bar"'], ('"foo"', '"bar"')) |
|
472 check(['foo bar'], ('foo bar',)) |
|
473 check(['foo bar', 'foo baz'], ('foo bar', 'foo baz')) |
|
474 check(['foo "bar"'], ('foo "bar"',)) |
|
475 |
|
476 # Element with no data is interpreted as meaning the option '' |
|
477 # if it is allowed, otherwise it is ignored |
|
478 check([None], (), empty_option=False) |
|
479 check([None], ('',), empty_option=True) |
|
480 |
|
481 def test_get_value_from_data_with_empty_attribute(self): |
|
482 config = api.Configuration('foo.confml') |
|
483 fea = model.ConfmlMultiSelectionSetting('multisel', type='multiSelection') |
|
484 config.add_feature(fea) |
|
485 config.add_data(api.Data(ref='multisel', empty=True)) |
|
486 |
|
487 dview = config.get_default_view() |
|
488 foofea = dview.get_feature('multisel') |
|
489 self.assertEquals(foofea.value, ()) |
|
490 |
|
491 |
|
492 def test_set_value(self): |
|
493 def check(value, expected_data_object_values): |
|
494 config = api.Configuration('foo.confml') |
|
495 fea = model.ConfmlMultiSelectionSetting('multisel', type='multiSelection') |
|
496 config.add_feature(fea) |
|
497 |
|
498 dview = config.get_default_view() |
|
499 foofea = dview.get_feature('multisel') |
|
500 self.assertEquals(foofea.value, ()) |
|
501 |
|
502 foofea.value = value |
|
503 # Check that the value is visible directly after setting |
|
504 # (the 'or' is because setting to None actually set the value |
|
505 # to an empty tuple) |
|
506 self.assertEquals(foofea.value, value or ()) |
|
507 |
|
508 # Check that the data elements have been set as expected |
|
509 actual = [] |
|
510 for d in config._traverse(type=api.Data): |
|
511 actual.append((d.fqr, d.value, d.empty)) |
|
512 expected = [] |
|
513 for val, empty in expected_data_object_values: |
|
514 expected.append(('multisel', val, empty)) |
|
515 self.assertEquals(actual, expected) |
|
516 |
|
517 # Setting empty should create a single data object with empty=True |
|
518 check((), [(None, True)]) |
|
519 check([], [(None, True)]) |
|
520 check(None, [(None, True)]) |
|
521 |
|
522 check(('x',), [('x', False)]) |
|
523 check(('x', 'y'), [('x', False), ('y', False)]) |
|
524 check(('"foo"', '"bar"'), [('"foo"', False), ('"bar"', False)]) |
|
525 check(('foo bar',), [('foo bar', False)]) |
|
526 check(('foo bar', 'foo baz'), [('foo bar', False), ('foo baz', False)]) |
|
527 check(('foo "bar"',), [('foo "bar"', False)]) |
|
528 |
|
529 def test_old_style_data_pattern(self): |
|
530 def check(value, expected): |
|
531 m = model.ConfmlMultiSelectionSetting.OLD_STYLE_DATA_PATTERN.match(value) |
|
532 self.assertEquals(m is not None, expected) |
|
533 |
|
534 check('', False) |
|
535 check('""', True) |
|
536 check('foo', False) |
|
537 check('foo bar', False) |
|
538 check('"foo bar"', True) |
|
539 check('"foo bar " " foo baz" " yeah " ""', True) |
|
540 check('"foo"', True) |
|
541 check('"foo" "bar"', True) |
|
542 check('"foo" "bar" "baz"', True) |
|
543 check('"a" "b" "c" "d" "e" "f" "g" "h"', True) |
|
544 check('a b c d e f g h', False) |
|
545 check('"a b c d e f g h"', True) |
330 |
546 |
331 class TestConfmlIntSetting(unittest.TestCase): |
547 class TestConfmlIntSetting(unittest.TestCase): |
332 def test_create_setting(self): |
548 def test_create_setting(self): |
333 elem = model.ConfmlIntSetting('test') |
549 elem = model.ConfmlIntSetting('test') |
334 self.assertTrue(elem) |
550 self.assertTrue(elem) |
460 elem = model.ConfmlSequenceSetting('foo', maxOccurs=10) |
764 elem = model.ConfmlSequenceSetting('foo', maxOccurs=10) |
461 self.assertEquals(elem.maxOccurs,10) |
765 self.assertEquals(elem.maxOccurs,10) |
462 elem.maxOccurs = 20 |
766 elem.maxOccurs = 20 |
463 self.assertEquals(elem.maxOccurs,20) |
767 self.assertEquals(elem.maxOccurs,20) |
464 |
768 |
465 def test_create_feature_seq_with_int_bool_settings_access_feature_value_with_property(self): |
769 def test_create_feature_seq_with_values(self): |
|
770 import logging |
|
771 logger = logging.getLogger('cone') |
|
772 logger.setLevel(logging.DEBUG) |
|
773 ch = logging.StreamHandler() |
|
774 ch.setLevel(logging.DEBUG) |
|
775 logger.addHandler(ch) |
|
776 |
466 config = api.Configuration('foo.confml') |
777 config = api.Configuration('foo.confml') |
467 fea= model.ConfmlSequenceSetting("foo") |
778 fea= model.ConfmlSequenceSetting("foo", displayName='TestDisplayName') |
468 fea.add_feature(model.ConfmlIntSetting('child1')) |
779 fea.add_feature(model.ConfmlIntSetting('child1')) |
469 fea.add_feature(model.ConfmlBooleanSetting('child2')) |
780 fea.add_feature(model.ConfmlBooleanSetting('child2')) |
470 fea.add_feature(model.ConfmlSetting('child3')) |
781 fea.add_feature(model.ConfmlSetting('child3')) |
471 config.add_feature(fea) |
782 config.add_feature(fea) |
472 dview = config.get_default_view() |
783 dview = config.get_default_view() |
473 foofea = dview.get_feature('foo') |
784 foofea = dview.get_feature('foo') |
474 # Test adding a data row with array |
785 # Test adding a data row with array |
475 foofea.set_value([['1','2','3'], |
786 foofea.set_value([[1,True,'foo'], |
476 ['4','5','6'], |
787 [2,False,'bar'], |
477 ['7','8','9'] |
788 [3,True,'sumthin'] |
478 ]) |
789 ]) |
479 self.assertEquals(foofea.value, [['1','2','3'], |
790 |
480 ['4','5','6'], |
791 self.assertEquals(foofea.displayName, 'TestDisplayName') |
481 ['7','8','9'] |
792 self.assertEquals(foofea.data[0][0].get_original_value(), '1') |
|
793 self.assertEquals(foofea.data[0].get_original_value(), ['1', 'true', 'foo']) |
|
794 |
|
795 self.assertEquals(foofea.value, [[1,True,'foo'], |
|
796 [2,False,'bar'], |
|
797 [3,True,'sumthin'] |
482 ]) |
798 ]) |
483 |
799 |
484 foofea.value = [['1','2','3'], |
800 self.assertEquals(foofea.get_original_value(), [['1','true','foo'], |
485 ['7','8','9'] |
801 ['2','false','bar'], |
|
802 ['3','true','sumthin'] |
|
803 ]) |
|
804 self.assertEquals(foofea.data[0].get_original_value(), ['1','true','foo']) |
|
805 self.assertEquals(foofea.data[1].get_original_value(), ['2','false','bar']) |
|
806 self.assertEquals(foofea.data[2].get_original_value(), ['3', 'true', 'sumthin']) |
|
807 self.assertEquals(foofea.child1.get_original_value(), ['1', '2', '3']) |
|
808 self.assertEquals(foofea.child2.get_original_value(), ['true', 'false', 'true']) |
|
809 self.assertEquals(foofea.child3.get_original_value(), ['foo', 'bar', 'sumthin']) |
|
810 |
|
811 foofea.value = [[1,True,'foo'], |
|
812 [2,False,'bar'] |
486 ] |
813 ] |
487 |
814 |
488 self.assertEquals(foofea.data[0].value,['1','2','3']) |
815 self.assertEquals(foofea.data[0].value,[1,True,'foo']) |
489 self.assertEquals(foofea.data[1].value,['7','8','9']) |
816 self.assertEquals(foofea.data[1].value,[2,False,'bar']) |
490 self.assertEquals(foofea.data[1][1].value,'8') |
817 self.assertEquals(foofea.data[1][1].value,False) |
491 self.assertEquals(foofea.get_value(), [['1','2','3'], |
818 self.assertEquals(foofea.get_value(), [[1,True,'foo'], |
492 ['7','8','9'] |
819 [2,False,'bar'] |
493 ]) |
820 ]) |
494 self.assertEquals(foofea.child1.value,['1','7']) |
821 self.assertEquals(foofea.child1.value,[1,2]) |
|
822 |
|
823 def test_sequence_with_mapped_data(self): |
|
824 config = api.Configuration('foo.confml') |
|
825 |
|
826 fea = model.ConfmlSequenceSetting("SourceSequence", mapKey='KeySubSetting', mapValue="ValueSubSetting") |
|
827 fea.add_feature(model.ConfmlIntSetting("KeySubSetting")) |
|
828 fea.add_feature(model.ConfmlStringSetting("ValueSubSetting")) |
|
829 config.add_feature(fea) |
|
830 |
|
831 fea = model.ConfmlSelectionSetting('TargetSetting') |
|
832 config.add_feature(fea) |
|
833 |
|
834 data = api.Data(ref='SourceSequence') |
|
835 data.add(api.Data(ref='KeySubSetting', value='1')) |
|
836 data.add(api.Data(ref='ValueSubSetting', value='Value 1')) |
|
837 config.add_data(data) |
|
838 |
|
839 data = api.Data(ref='TargetSetting', map="SourceSequence[@key='1']") |
|
840 config.add_data(data) |
|
841 |
|
842 fea = config.get_default_view().get_feature('TargetSetting') |
|
843 self.assertEquals(fea.get_value(), 'Value 1') |
|
844 |
|
845 def test_sequence_with_mapped_data_in_sequence(self): |
|
846 config = api.Configuration('foo.confml') |
|
847 |
|
848 fea = model.ConfmlSequenceSetting("SourceSequence", mapKey='KeySubSetting', mapValue="ValueSubSetting") |
|
849 fea.add_feature(model.ConfmlIntSetting("KeySubSetting")) |
|
850 fea.add_feature(model.ConfmlStringSetting("ValueSubSetting")) |
|
851 config.add_feature(fea) |
|
852 |
|
853 fea = model.ConfmlSequenceSetting('TargetSequence') |
|
854 fea.add_feature(model.ConfmlSelectionSetting("Setting")) |
|
855 config.add_feature(fea) |
|
856 |
|
857 data = api.Data(ref='SourceSequence') |
|
858 data.add(api.Data(ref='KeySubSetting', value='1')) |
|
859 data.add(api.Data(ref='ValueSubSetting', value='Value 1')) |
|
860 config.add_data(data) |
|
861 |
|
862 data = api.Data(ref='TargetSequence') |
|
863 data.add(api.Data(ref='Setting', map="SourceSequence[@key='1']")) |
|
864 config.add_data(data) |
|
865 |
|
866 fea = config.get_default_view().get_feature('TargetSequence') |
|
867 self.assertEquals(fea.get_value(), [['Value 1']]) |
|
868 |
|
869 def test_sequence_with_multiselection_set_value(self): |
|
870 config = api.Configuration('foo.confml') |
|
871 |
|
872 fea = model.ConfmlSequenceSetting("fooseq") |
|
873 fea.add_feature(model.ConfmlMultiSelectionSetting("msel")) |
|
874 config.add_feature(fea) |
|
875 |
|
876 dview = config.get_default_view() |
|
877 fea = dview.get_feature(fea.fqr) |
|
878 self.assertEquals(fea.value, []) |
|
879 |
|
880 def check_data_elements(expected_data_object_values): |
|
881 actual = [] |
|
882 for d in config._traverse(type=api.Data): |
|
883 actual.append((d.fqr, d.value, d.empty)) |
|
884 expected = [] |
|
885 for fqr, val, empty in expected_data_object_values: |
|
886 expected.append((fqr, val, empty)) |
|
887 self.assertEquals(actual, expected) |
|
888 |
|
889 fea.value = [] |
|
890 self.assertEquals(fea.value, []) |
|
891 check_data_elements( |
|
892 [('fooseq', None, False),]) |
|
893 |
|
894 fea.value = [[()]] |
|
895 self.assertEquals(fea.value, [[()]]) |
|
896 check_data_elements( |
|
897 [('fooseq', None, False), |
|
898 ('fooseq.msel', None, True),]) |
|
899 |
|
900 fea.value = [[('x',)]] |
|
901 self.assertEquals(fea.value, [[('x',)]]) |
|
902 check_data_elements( |
|
903 [('fooseq', None, False), |
|
904 ('fooseq.msel', 'x', False),]) |
|
905 |
|
906 fea.value = [[('x',)], [('y',)]] |
|
907 self.assertEquals(fea.value, [[('x',)], [('y',)]]) |
|
908 check_data_elements( |
|
909 [('fooseq', None, False), |
|
910 ('fooseq.msel', 'x', False), |
|
911 ('fooseq', None, False), |
|
912 ('fooseq.msel', 'y', False),]) |
|
913 |
|
914 fea.value = [[('x', 'y')], |
|
915 [('a', 'b', 'c')], |
|
916 [()], |
|
917 [('d', 'e', 'f')]] |
|
918 self.assertEquals(fea.value, [[('x', 'y')], |
|
919 [('a', 'b', 'c')], |
|
920 [()], |
|
921 [('d', 'e', 'f')]]) |
|
922 check_data_elements( |
|
923 [('fooseq', None, False), |
|
924 ('fooseq.msel', 'x', False), |
|
925 ('fooseq.msel', 'y', False), |
|
926 ('fooseq', None, False), |
|
927 ('fooseq.msel', 'a', False), |
|
928 ('fooseq.msel', 'b', False), |
|
929 ('fooseq.msel', 'c', False), |
|
930 ('fooseq', None, False), |
|
931 ('fooseq.msel', None, True), |
|
932 ('fooseq', None, False), |
|
933 ('fooseq.msel', 'd', False), |
|
934 ('fooseq.msel', 'e', False), |
|
935 ('fooseq.msel', 'f', False),]) |
|
936 |
|
937 def test_sequence_with_multiselection_get_value(self): |
|
938 config = api.Configuration('foo.confml') |
|
939 fea = model.ConfmlSequenceSetting("fooseq") |
|
940 fea.add_feature(model.ConfmlMultiSelectionSetting("msel")) |
|
941 config.add_feature(fea) |
|
942 |
|
943 seqdata1 = api.Data(ref='fooseq') |
|
944 seqdata1._add([api.Data(ref='msel', value='x'), |
|
945 api.Data(ref='msel', value='y')]) |
|
946 seqdata2 = api.Data(ref='fooseq') |
|
947 seqdata2._add([api.Data(ref='msel', empty=True)]) |
|
948 seqdata3 = api.Data(ref='fooseq') |
|
949 seqdata3._add([api.Data(ref='msel', value='a'), |
|
950 api.Data(ref='msel', value='b'), |
|
951 api.Data(ref='msel', value='c')]) |
|
952 config.add_data([seqdata1, seqdata2, seqdata3]) |
|
953 |
|
954 dview = config.get_default_view() |
|
955 fea = dview.get_feature(fea.fqr) |
|
956 self.assertEquals(fea.value, [[('x', 'y')], [()], [('a', 'b', 'c')]]) |
|
957 |
|
958 def test_simple_name_id_mapping(self): |
|
959 config = api.Configuration('foo.confml') |
|
960 seq = model.ConfmlSequenceSetting('seq', mapKey='strsub', mapValue='strsub') |
|
961 seq.add_feature(model.ConfmlStringSetting('strsub')) |
|
962 seq.add_feature(model.ConfmlIntSetting('intsub')) |
|
963 seq.add_feature(model.ConfmlRealSetting('realsub')) |
|
964 seq.add_feature(model.ConfmlBooleanSetting('boolsub')) |
|
965 config.add_feature(seq) |
|
966 config.add_feature(api.Feature('target')) |
|
967 |
|
968 config.add_data(api.Data(fqr='seq.strsub', value='foo')) |
|
969 config.add_data(api.Data(fqr='seq.intsub', value='123')) |
|
970 config.add_data(api.Data(fqr='seq.realsub', value='1.5')) |
|
971 config.add_data(api.Data(fqr='seq.boolsub', value='true')) |
|
972 config.add_data(api.Data(fqr='target', map="seq[@key='foo']")) |
|
973 |
|
974 fea = config.get_default_view().get_feature('target') |
|
975 self.assertEquals(fea.value, 'foo') |
|
976 self.assertEquals(fea.get_original_value(), 'foo') |
|
977 |
|
978 seq.mapValue = 'intsub' |
|
979 self.assertEquals(fea.value, 123) |
|
980 self.assertEquals(fea.get_original_value(), '123') |
|
981 |
|
982 seq.mapValue = 'realsub' |
|
983 self.assertEquals(fea.value, 1.5) |
|
984 self.assertEquals(fea.get_original_value(), '1.5') |
|
985 |
|
986 seq.mapValue = 'boolsub' |
|
987 self.assertEquals(fea.value, True) |
|
988 self.assertEquals(fea.get_original_value(), 'true') |
|
989 |
|
990 def test_simple_name_id_mapping_with_multiselection(self): |
|
991 config = api.Configuration('foo.confml') |
|
992 seq = model.ConfmlSequenceSetting('seq', mapKey='strsub', mapValue='intsub') |
|
993 seq.add_feature(model.ConfmlStringSetting('strsub')) |
|
994 seq.add_feature(model.ConfmlIntSetting('intsub')) |
|
995 config.add_feature(seq) |
|
996 config.add_feature(model.ConfmlMultiSelectionSetting('target')) |
|
997 |
|
998 d = api.Data(fqr='seq') |
|
999 d.add(api.Data(ref='strsub', value='foo')) |
|
1000 d.add(api.Data(ref='intsub', value='123')) |
|
1001 config.add_data(d, api.container.APPEND) |
|
1002 |
|
1003 d = api.Data(fqr='seq') |
|
1004 d.add(api.Data(ref='strsub', value='bar')) |
|
1005 d.add(api.Data(ref='intsub', value='321')) |
|
1006 config.add_data(d, api.container.APPEND) |
|
1007 |
|
1008 d = api.Data(fqr='seq') |
|
1009 d.add(api.Data(ref='strsub', value='baz')) |
|
1010 d.add(api.Data(ref='intsub', value='456')) |
|
1011 config.add_data(d, api.container.APPEND) |
|
1012 |
|
1013 config.add_data([api.Data(fqr='target', map="seq[@key='bar']"), |
|
1014 api.Data(ref='target', map="seq[@key='baz']"), |
|
1015 api.Data(ref='target', map="seq[@key='foo']")]) |
|
1016 |
|
1017 fea = config.get_default_view().get_feature('target') |
|
1018 self.assertEquals(fea.value, (321, 456, 123)) |
|
1019 self.assertEquals(fea.get_original_value(), ('321', '456', '123')) |
|
1020 |
|
1021 def test_simple_name_id_mapping_with_file_and_folder_setting(self): |
|
1022 def _run_test(subsetting_class): |
|
1023 config = api.Configuration('foo.confml') |
|
1024 seq = model.ConfmlSequenceSetting('seq') |
|
1025 seq.add_feature(subsetting_class('filefoldersub')) |
|
1026 config.add_feature(seq) |
|
1027 config.add_feature(model.ConfmlSelectionSetting('target')) |
|
1028 |
|
1029 def _add_seq_data(local_path, target_path): |
|
1030 d = api.Data(fqr='seq') |
|
1031 subd = api.Data(ref='filefoldersub') |
|
1032 subd.add(api.Data(ref='localPath', value=local_path)) |
|
1033 subd.add(api.Data(ref='targetPath', value=target_path)) |
|
1034 d.add(subd) |
|
1035 config.add_data(d, api.container.APPEND) |
|
1036 _add_seq_data('local/path/1', 'target/path/1') |
|
1037 _add_seq_data('local/path/2', 'target/path/2') |
|
1038 _add_seq_data('local/path/3', 'target/path/3') |
|
1039 target_data = api.Data(fqr='target') |
|
1040 config.add_data(target_data) |
|
1041 |
|
1042 fea = config.get_default_view().get_feature('target') |
|
1043 |
|
1044 seq.mapKey = 'filefoldersub' |
|
1045 seq.mapValue = 'filefoldersub' |
|
1046 target_data.map = "seq[@key='local/path/1']" |
|
1047 self.assertEquals(fea.value, 'local/path/1') |
|
1048 |
|
1049 seq.mapKey = 'filefoldersub/localPath' |
|
1050 seq.mapValue = 'filefoldersub/localPath' |
|
1051 target_data.map = "seq[@key='local/path/1']" |
|
1052 self.assertEquals(fea.value, 'local/path/1') |
|
1053 |
|
1054 seq.mapKey = 'filefoldersub/targetPath' |
|
1055 seq.mapValue = 'filefoldersub/targetPath' |
|
1056 target_data.map = "seq[@key='target/path/2']" |
|
1057 self.assertEquals(fea.value, 'target/path/2') |
|
1058 |
|
1059 seq.mapKey = 'filefoldersub/localPath' |
|
1060 seq.mapValue = 'filefoldersub/targetPath' |
|
1061 target_data.map = "seq[@key='local/path/3']" |
|
1062 self.assertEquals(fea.value, 'target/path/3') |
|
1063 |
|
1064 _run_test(subsetting_class=model.ConfmlFileSetting) |
|
1065 _run_test(subsetting_class=model.ConfmlFolderSetting) |
|
1066 |
|
1067 def test_simple_name_id_mapping_override_map_value_in_option(self): |
|
1068 config = api.Configuration('foo.confml') |
|
1069 fea = model.ConfmlFeature('fea') |
|
1070 config.add_feature(fea) |
|
1071 seq = model.ConfmlSequenceSetting('seq', mapKey='strsub', mapValue='strsub') |
|
1072 seq.add_feature(model.ConfmlStringSetting('strsub')) |
|
1073 seq.add_feature(model.ConfmlIntSetting('intsub')) |
|
1074 fea.add_feature(seq) |
|
1075 target = api.Feature('target') |
|
1076 target.add_option(api.Option(None, None, map='fea/seq', map_value='intsub')) |
|
1077 fea.add_feature(target) |
|
1078 |
|
1079 config.add_data(api.Data(fqr='fea.seq.strsub', value='foo')) |
|
1080 config.add_data(api.Data(fqr='fea.seq.intsub', value='123')) |
|
1081 config.add_data(api.Data(fqr='fea.target', map="fea/seq[@key='foo']")) |
|
1082 |
|
1083 fea = config.get_default_view().get_feature('fea.target') |
|
1084 self.assertEquals(fea.value, 123) |
|
1085 self.assertEquals(fea.get_original_value(), '123') |
|
1086 |
|
1087 def _assert_raises(self, exception_class, func, *args, **kwargs): |
|
1088 try: |
|
1089 func(*args, **kwargs) |
|
1090 self.fail("No exception raised") |
|
1091 except exception_class, e: |
|
1092 return e |
|
1093 |
|
1094 def test_name_id_mapping_errors(self): |
|
1095 config = api.Configuration('foo.confml') |
|
1096 seq = model.ConfmlSequenceSetting('seq') |
|
1097 seq.add_feature(model.ConfmlStringSetting('strsub')) |
|
1098 seq.add_feature(model.ConfmlIntSetting('intsub')) |
|
1099 config.add_feature(seq) |
|
1100 |
|
1101 config.add_feature(model.ConfmlIntSetting('foosetting'), 'foofea') |
|
1102 |
|
1103 target = api.Feature('target') |
|
1104 target_option = api.Option(None, None, map='seq') |
|
1105 target.add_option(target_option) |
|
1106 config.add_feature(target) |
|
1107 |
|
1108 config.add_data(api.Data(fqr='seq.strsub', value='foo')) |
|
1109 config.add_data(api.Data(fqr='seq.intsub', value='123')) |
|
1110 target_data = api.Data(fqr='target', map="seq[@key='123']") |
|
1111 config.add_data(target_data) |
|
1112 |
|
1113 fea = config.get_default_view().get_feature('target') |
|
1114 |
|
1115 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1116 self.assertEquals(str(e), "Source sequence 'seq' must have both mapKey and mapValue specified") |
|
1117 |
|
1118 seq.mapKey = 'strsub' |
|
1119 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1120 self.assertEquals(str(e), "Source sequence 'seq' must have both mapKey and mapValue specified") |
|
1121 |
|
1122 seq.mapKey = None |
|
1123 seq.mapValue = 'strsub' |
|
1124 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1125 self.assertEquals(str(e), "Source sequence 'seq' must have both mapKey and mapValue specified") |
|
1126 |
|
1127 seq.mapKey = 'intsub' |
|
1128 seq.mapValue = 'strsub' |
|
1129 |
|
1130 target_data.map = "foobar" |
|
1131 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1132 self.assertEquals(str(e), "Malformed mapping expression: foobar") |
|
1133 |
|
1134 target_data.map = "foo/bar[key='321']" |
|
1135 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1136 self.assertEquals(str(e), "Malformed mapping expression: foo/bar[key='321']") |
|
1137 |
|
1138 target_data.map = "foo/bar[@key='321'" |
|
1139 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1140 self.assertEquals(str(e), "Malformed mapping expression: foo/bar[@key='321'") |
|
1141 |
|
1142 target_data.map = "foo/nonexistent[@key='321']" |
|
1143 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1144 self.assertEquals(str(e), "Mapping source sequence 'foo.nonexistent' does not exist") |
|
1145 |
|
1146 target_data.map = "foofea/foosetting[@key='321']" |
|
1147 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1148 self.assertEquals(str(e), "Mapping source setting 'foofea.foosetting' is not a sequence setting") |
|
1149 |
|
1150 target_data.map = "seq[@key='321']" |
|
1151 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1152 self.assertEquals(str(e), "No item-setting in source sequence 'seq' matches key '321'") |
|
1153 |
|
1154 seq.mapKey = 'foo' |
|
1155 target_data.map = "seq[@key='321']" |
|
1156 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1157 self.assertEquals(str(e), "Invalid mapKey in source sequence 'seq': no sub-setting with ref 'foo'") |
|
1158 |
|
1159 seq.mapKey = 'intsub' |
|
1160 seq.mapValue = 'foo' |
|
1161 target_data.map = "seq[@key='321']" |
|
1162 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1163 self.assertEquals(str(e), "Invalid mapValue in source sequence 'seq': no sub-setting with ref 'foo'") |
|
1164 |
|
1165 seq.mapValue = 'strsub' |
|
1166 target_data.map = "seq[@key='123']" |
|
1167 target_option.map_value = 'foobar' |
|
1168 e = self._assert_raises(exceptions.NameIdMappingError, fea.get_value) |
|
1169 self.assertEquals(str(e), "Invalid mapValue override in option: sub-setting 'foobar' does not exist under source sequence 'seq'") |
|
1170 |
|
1171 # Test successful mapping for good measure |
|
1172 seq.mapKey = 'intsub' |
|
1173 seq.mapValue = 'strsub' |
|
1174 target_data.map = "seq[@key='123']" |
|
1175 target_option.map_value = 'intsub' |
|
1176 self.assertEquals(fea.get_value(), 123) |
|
1177 self.assertEquals(fea.get_original_value(), '123') |
495 |
1178 |
496 class TestConfmlFile(unittest.TestCase): |
1179 class TestConfmlFile(unittest.TestCase): |
497 def test_create_localpath_elem(self): |
1180 def test_create_localpath_elem(self): |
498 elem = model.ConfmlLocalPath() |
1181 elem = model.ConfmlLocalPath() |
499 self.assertTrue(elem) |
1182 self.assertTrue(elem) |
543 |
1253 |
544 |
1254 |
545 class TestLengths(unittest.TestCase): |
1255 class TestLengths(unittest.TestCase): |
546 def test_create_maxLength(self): |
1256 def test_create_maxLength(self): |
547 max = model.ConfmlMaxLength('100') |
1257 max = model.ConfmlMaxLength('100') |
548 self.assertEquals(max.value, '100') |
1258 self.assertEquals(max.value, 100) |
549 |
1259 max.value = 10 |
|
1260 self.assertEquals(max.value, 10) |
|
1261 max.value = '1000' |
|
1262 self.assertEquals(max.value, 1000) |
|
1263 |
550 def test_create_minLength(self): |
1264 def test_create_minLength(self): |
551 min = model.ConfmlMinLength('100') |
1265 min = model.ConfmlMinLength('100') |
552 self.assertEquals(min.value, '100') |
1266 self.assertEquals(min.value, 100) |
|
1267 min.value = 10 |
|
1268 self.assertEquals(min.value, 10) |
|
1269 min.value = '1000' |
|
1270 self.assertEquals(min.value, 1000) |
|
1271 |
|
1272 def test_create_length(self): |
|
1273 len = model.ConfmlLength('100') |
|
1274 self.assertEquals(len.value, 100) |
|
1275 len.value = 10 |
|
1276 self.assertEquals(len.value, 10) |
|
1277 len.value = '1000' |
|
1278 self.assertEquals(len.value, 1000) |
553 |
1279 |
554 class TestConfmlFacets(unittest.TestCase): |
1280 class TestConfmlFacets(unittest.TestCase): |
|
1281 def test_numeric_base_classs(self): |
|
1282 numeric = model.ConfmlNumericValue() |
|
1283 numeric.value = 3 |
|
1284 self.assertEquals(numeric.value, 3) |
|
1285 numeric.value = 0.3 |
|
1286 self.assertEquals(numeric.value, 0.3) |
|
1287 numeric.value = '22' |
|
1288 self.assertEquals(numeric.value, 22) |
|
1289 numeric.value = '0.1' |
|
1290 self.assertEquals(numeric.value, 0.1) |
|
1291 try: |
|
1292 numeric.value = 'foo' |
|
1293 self.fail("setting string to float property succeeded!") |
|
1294 except ValueError: |
|
1295 pass |
|
1296 |
555 def test_create_inclusive(self): |
1297 def test_create_inclusive(self): |
556 min = model.ConfmlMinInclusive('-10') |
1298 min = model.ConfmlMinInclusive('-10') |
557 max = model.ConfmlMaxInclusive('10') |
1299 max = model.ConfmlMaxInclusive('10') |
558 self.assertEquals(min.value, '-10') |
1300 self.assertEquals(min.value, -10) |
559 self.assertEquals(max.value, '10') |
1301 self.assertEquals(max.value, 10) |
|
1302 min.value = 10 |
|
1303 self.assertEquals(min.value, 10) |
|
1304 min.value = '1000' |
|
1305 self.assertEquals(min.value, 1000) |
|
1306 max.value = 10 |
|
1307 self.assertEquals(max.value, 10) |
|
1308 max.value = '1000' |
|
1309 self.assertEquals(max.value, 1000) |
560 |
1310 |
561 def test_create_exclusive(self): |
1311 def test_create_exclusive(self): |
562 min = model.ConfmlMinExclusive('0') |
1312 min = model.ConfmlMinExclusive('0') |
563 max = model.ConfmlMaxExclusive("9") |
1313 max = model.ConfmlMaxExclusive("9") |
564 self.assertEquals(min.value, '0') |
1314 self.assertEquals(min.value, 0) |
565 self.assertEquals(max.value, '9') |
1315 self.assertEquals(max.value, 9) |
|
1316 max.value = 10 |
|
1317 self.assertEquals(max.value, 10) |
|
1318 max.value = '1000' |
|
1319 self.assertEquals(max.value, 1000) |
|
1320 min.value = 10 |
|
1321 self.assertEquals(min.value, 10) |
|
1322 min.value = '1000' |
|
1323 self.assertEquals(min.value, 1000) |
566 |
1324 |
567 def test_create_pattern(self): |
1325 def test_create_pattern(self): |
568 pattern = model.ConfmlPattern("[a-zA-Z]") |
1326 pattern = model.ConfmlPattern("[a-zA-Z]") |
569 self.assertEquals(pattern.value, "[a-zA-Z]") |
1327 self.assertEquals(pattern.value, "[a-zA-Z]") |
570 |
1328 |
571 def test_create_totalDigits(self): |
1329 def test_create_totalDigits(self): |
572 digits = model.ConfmlTotalDigits("3") |
1330 digits = model.ConfmlTotalDigits("3") |
573 self.assertEquals(digits.value, '3') |
1331 self.assertEquals(digits.value, 3) |
|
1332 digits.value = 10 |
|
1333 self.assertEquals(digits.value, 10) |
|
1334 digits.value = '1000' |
|
1335 self.assertEquals(digits.value, 1000) |
574 |
1336 |
575 class TestConfmlConfiguration(unittest.TestCase): |
1337 class TestConfmlConfiguration(unittest.TestCase): |
576 def test_create_configuration(self): |
1338 def test_create_configuration(self): |
577 config = model.ConfmlConfiguration("test/foo/bar.jpg") |
1339 config = model.ConfmlConfiguration("test/foo/bar.jpg") |
578 self.assertEquals(config.meta, None) |
1340 self.assertEquals(config.meta, None) |
579 self.assertEquals(config.desc, None) |
1341 self.assertEquals(config.desc, None) |
580 self.assertEquals(config.name, 'test__foo__bar_jpg') |
1342 self.assertEquals(config.name, 'test__foo__bar_jpg') |
581 self.assertEquals(config.ref, 'test__foo__bar_jpg') |
1343 self.assertEquals(config.ref, 'test__foo__bar_jpg') |
582 self.assertEquals(config.path, 'test/foo/bar.jpg') |
1344 self.assertEquals(config.path, 'test/foo/bar.jpg') |
583 |
1345 |
584 # def test_configuration_access_meta(self): |
1346 def test_create_configuration_and_features(self): |
585 # config = model.ConfmlConfiguration("test/foo/bar.jpg", meta={'test':'foo','bar':' hd dd'}) |
1347 conf = model.ConfmlConfiguration("simple.confml") |
586 # self.assertEquals(config.meta.dict, {'test':'foo','bar':' hd dd'}) |
1348 fea = conf.create_feature("test") |
587 # self.assertEquals(config.meta['test'],'foo') |
1349 self.assertTrue(isinstance(fea, model.ConfmlFeature)) |
588 # config.meta = {'test':'123'} |
1350 self.assertEquals(conf.get_feature('test'), fea) |
589 # self.assertEquals(config.meta['test'],'123') |
1351 fea = conf.create_feature("test1", name="test name") |
590 # del config.meta |
1352 self.assertEquals(conf.get_feature('test1').name, 'test name') |
591 # self.assertEquals(config.meta, None) |
1353 subfea = fea.create_feature("subfea", name="subfea name") |
|
1354 self.assertTrue(isinstance(subfea, model.ConfmlSetting)) |
|
1355 self.assertEquals(conf.list_all_features(), ['test','test1','test1.subfea']) |
|
1356 |
|
1357 def test_configuration_get_default_view(self): |
|
1358 config = model.ConfmlConfiguration("test/foo/bar.jpg") |
|
1359 config.add_feature(model.ConfmlFeature("test")) |
|
1360 view = config.create_view("testview") |
|
1361 group = view.create_group("group1") |
|
1362 group.create_featurelink("test") |
|
1363 self.assertEquals(config.list_all_features(), ['test']) |
592 |
1364 |
593 def test_configuration_access_desc(self): |
1365 def test_configuration_access_desc(self): |
594 config = model.ConfmlConfiguration("test/foo/bar.jpg", desc="testing description") |
1366 config = model.ConfmlConfiguration("test/foo/bar.jpg", desc="testing description") |
595 self.assertEquals(config.desc, "testing description") |
1367 self.assertEquals(config.desc, "testing description") |
596 config.desc = 'new desc' |
1368 config.desc = 'new desc' |
597 self.assertEquals(config.desc, "new desc") |
1369 self.assertEquals(config.desc, "new desc") |
598 del config.desc |
1370 del config.desc |
599 self.assertEquals(config.desc, None) |
1371 self.assertEquals(config.desc, None) |
600 |
1372 |
601 class TestConfmlProperty(unittest.TestCase): |
1373 def test_use_create_configuration(self): |
602 def test_create_property(self): |
1374 config = model.ConfmlConfiguration("test/foo/bar.jpg") |
603 property = model.ConfmlProperty(name='test',value='foo', unit='kB') |
1375 subconfig = config.create_configuration("sub/jee.confml") |
604 self.assertEquals(property.name, 'test') |
1376 self.assertEquals(subconfig.get_full_path(),'test/foo/sub/jee.confml') |
605 self.assertEquals(property.value, 'foo') |
1377 self.assertTrue(isinstance(subconfig,model.ConfmlConfiguration)) |
606 self.assertEquals(property.unit, 'kB') |
1378 |
607 property.name = 'testnew' |
1379 |
608 property.value = 'foo faa' |
1380 class TestConfmlView(unittest.TestCase): |
609 self.assertEquals(property.name, 'testnew') |
1381 def test_create_view(self): |
610 self.assertEquals(property.value, 'foo faa') |
1382 view = model.ConfmlView("test", id="test") |
611 |
1383 self.assertTrue(view) |
|
1384 self.assertEquals(view.get_ref(),'test') |
|
1385 self.assertEquals(view.id,"test") |
|
1386 |
|
1387 def test_create_view_with_create_view(self): |
|
1388 config = model.ConfmlConfiguration("test") |
|
1389 view = config.create_view("test") |
|
1390 group = view.create_group("group1") |
|
1391 fl = group.create_featurelink("intset1") |
|
1392 self.assertTrue(isinstance(view, model.ConfmlView)) |
|
1393 self.assertTrue(isinstance(group, model.ConfmlGroup)) |
|
1394 self.assertTrue(isinstance(fl, model.ConfmlFeatureLink)) |
|
1395 |
|
1396 def test_create_confml_featurelink(self): |
|
1397 fealink = model.ConfmlFeatureLink("test") |
|
1398 self.assertTrue(fealink) |
|
1399 self.assertEquals(fealink.get_ref(),'link_test') |
|
1400 |
|
1401 def test_create_confml_featurelink_with_overrides(self): |
|
1402 fealink = model.ConfmlFeatureLink("test") |
|
1403 fealink.desc = "test desc" |
|
1404 self.assertEquals(fealink.desc,'test desc') |
|
1405 self.assertEquals(fealink._has('_desc'),True) |
|
1406 self.assertEquals(fealink.get_attributes(),{'properties': {},'options': {}, 'desc' : 'test desc'}) |
|
1407 |
|
1408 def test_create_confml_featurelink_with_option_overrides(self): |
|
1409 fealink = model.ConfmlFeatureLink("test") |
|
1410 fealink.add(api.Option('opt2', '2')) |
|
1411 self.assertEquals(fealink.options['2'].name,'opt2') |
|
1412 |
|
1413 def test_create_view_with_groups(self): |
|
1414 view = model.ConfmlView("test") |
|
1415 view.create_group("group1") |
|
1416 view.create_group("group2") |
|
1417 self.assertEquals(view.list_groups(),['group1','group2']) |
|
1418 |
|
1419 def test_create_configuration_with_featurelinks(self): |
|
1420 config = model.ConfmlConfiguration("test") |
|
1421 config.add_feature(model.ConfmlFeature("fea1", name="Feature 1")) |
|
1422 intset1 = model.ConfmlIntSetting("intset1", name="Setting 1") |
|
1423 intset1.desc = "int setting desc" |
|
1424 config.add_feature(intset1, "fea1") |
|
1425 |
|
1426 view = config.create_view("test") |
|
1427 group = view.create_group("group1") |
|
1428 fl = group.create_featurelink("intset1") |
|
1429 self.assertTrue(isinstance(fl, model.ConfmlFeatureLink)) |
|
1430 self.assertTrue(len(config.get_default_view().get_features('**')), 2) |
|
1431 |
|
1432 |
|
1433 def test_create_configuration_with_view_and_featurelink_overrides(self): |
|
1434 config = model.ConfmlConfiguration("test") |
|
1435 config.add_feature(model.ConfmlFeature("fea1", name="Feature 1")) |
|
1436 intset1 = model.ConfmlIntSetting("intset1", name="Setting 1") |
|
1437 intset1.desc = "int setting desc" |
|
1438 config.add_feature(intset1, "fea1") |
|
1439 |
|
1440 view = config.create_view("test") |
|
1441 view.create_group("group1") |
|
1442 fl = model.ConfmlFeatureLink("fea1.intset1", name="override name") |
|
1443 fl.desc = "override desc" |
|
1444 fl.minLength = 2 |
|
1445 fl.maxLength = 10 |
|
1446 fl.minOccurs = 2 |
|
1447 fl.maxOccurs = 10 |
|
1448 |
|
1449 fl.pattern = '^.*@.*$' |
|
1450 fl.totalDigits = 10 |
|
1451 fl.minInclusive = 0 |
|
1452 fl.maxInclusive = 10 |
|
1453 fl.minExclusive = 0 |
|
1454 fl.maxExclusive = 10 |
|
1455 |
|
1456 fl.add(api.Option('opt1', '1')) |
|
1457 |
|
1458 view.get_group('group1').add(fl) |
|
1459 view.populate() |
|
1460 self.assertEquals(view.list_all_features(),['group1.proxy_fea1_intset1']) |
|
1461 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').desc, "override desc") |
|
1462 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').name, "override name") |
|
1463 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').minLength, 2) |
|
1464 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').maxLength, 10) |
|
1465 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').minOccurs, 2) |
|
1466 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').maxOccurs, 10) |
|
1467 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').pattern, '^.*@.*$') |
|
1468 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').totalDigits, 10) |
|
1469 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').minInclusive, 0) |
|
1470 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').maxInclusive, 10) |
|
1471 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').minExclusive, 0) |
|
1472 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').maxExclusive, 10) |
|
1473 self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').options['1'].name,'opt1') |
|
1474 |
|
1475 if __name__ == '__main__': |
|
1476 unittest.main() |