93 self.assertTrue(feaproxy.bar.get_ref(),"bar") |
90 self.assertTrue(feaproxy.bar.get_ref(),"bar") |
94 self.assertEquals(feaproxy.bar.namespace,"foo") |
91 self.assertEquals(feaproxy.bar.namespace,"foo") |
95 self.assertEquals(feaproxy.bar.fqr,"foo.bar") |
92 self.assertEquals(feaproxy.bar.fqr,"foo.bar") |
96 self.assertEquals(feaproxy.bar.name,"bar man") |
93 self.assertEquals(feaproxy.bar.name,"bar man") |
97 |
94 |
98 |
95 def test_create_feature_proxy_with_options(self): |
|
96 fea= api.Feature("foo", name="foo bar") |
|
97 fea.add_option(api.Option('opt1', '1')) |
|
98 |
|
99 opts = {} |
|
100 opts['opt2'] = api.Option('opt2', '2') |
|
101 |
|
102 feaproxy = api._FeatureProxy("foo",fea, options=opts) |
|
103 self.assertTrue(feaproxy.get_ref(),"foo") |
|
104 self.assertEquals(feaproxy.namespace,"") |
|
105 self.assertEquals(feaproxy.fqr,"foo") |
|
106 self.assertEquals(feaproxy.name,"foo bar") |
|
107 feaproxy.add_feature(api.Feature("bar", name="bar man")) |
|
108 self.assertTrue(feaproxy.bar.get_ref(),"bar") |
|
109 self.assertEquals(feaproxy.bar.namespace,"foo") |
|
110 self.assertEquals(feaproxy.bar.fqr,"foo.bar") |
|
111 self.assertEquals(feaproxy.bar.name,"bar man") |
|
112 opts2 = {} |
|
113 opts2['opt2'] = api.Option('opt2', '2') |
|
114 opts2['opt1'] = api.Option('opt1', '1') |
|
115 self.assertEquals(feaproxy.list_options(), ['value_1', 'value_2']) |
|
116 self.assertEquals(feaproxy.get_option('value_2').get_value(), '2') |
|
117 self.assertEquals(feaproxy.get_option('value_1').get_value(), '1') |
|
118 |
|
119 def test_create_feature_proxy_has_attribute(self): |
|
120 fea= api.Feature("foo", name="foo bar") |
|
121 feaproxy = api._FeatureProxy("foo",fea) |
|
122 self.assertEquals(feaproxy.name, "foo bar") |
|
123 self.assertEquals(feaproxy.has_attribute('name'), False) |
|
124 feaproxy.name = "test" |
|
125 self.assertEquals(feaproxy.has_attribute('name'), True) |
|
126 self.assertEquals(feaproxy.name, "test") |
|
127 |
|
128 def test_feature_proxy_get_proxied_obj(self): |
|
129 fea= api.Feature("foo", name="foo bar") |
|
130 feaproxy = api._FeatureProxy("foo",fea) |
|
131 proxied = feaproxy.get_proxied_obj() |
|
132 self.assertFalse(proxied == None) |
|
133 self.assertEquals(fea, proxied) |
|
134 self.assertEquals(feaproxy.get_proxied_obj(), feaproxy._obj) |
|
135 |
99 def test_create_feature_data(self): |
136 def test_create_feature_data(self): |
100 dataobj = api.Data(ref="foo", value=132) |
137 dataobj = api.Data(ref="foo", value=132) |
101 self.assertTrue(dataobj.fqr,"foo") |
138 self.assertTrue(dataobj.fqr,"foo") |
102 self.assertTrue(dataobj.get_value(),123) |
139 self.assertTrue(dataobj.get_value(),123) |
103 self.assertTrue(dataobj.value,123) |
140 self.assertTrue(dataobj.value,123) |
179 self.assertTrue('3' in vset) |
216 self.assertTrue('3' in vset) |
180 self.assertEquals(fea.get_option('value_2').get_name(), 'one') |
217 self.assertEquals(fea.get_option('value_2').get_name(), 'one') |
181 |
218 |
182 def test_create_sequence_feature(self): |
219 def test_create_sequence_feature(self): |
183 fea = api.FeatureSequence('test') |
220 fea = api.FeatureSequence('test') |
184 fea.add_feature(api.Feature('child1',type='int')) |
221 fea.create_feature('child1',type='int') |
185 fea.add_feature(api.Feature('child2')) |
222 fea.create_feature('child2', name="test") |
186 fea.add_feature(api.Feature('child3')) |
223 fea.create_feature('child3') |
187 self.assertEquals(fea.get_type(), 'sequence') |
224 self.assertEquals(fea.get_type(), 'sequence') |
188 self.assertEquals(fea.list_features(), ['child1','child2','child3']) |
225 self.assertEquals(fea.list_features(), ['child1','child2','child3']) |
|
226 self.assertEquals(fea.get_feature('child1').type, 'int') |
|
227 self.assertEquals(fea.get_feature('child2').type, None) |
|
228 self.assertEquals(fea.get_feature('child2').name, 'test') |
189 |
229 |
190 def test_feature_get_dict(self): |
230 def test_feature_get_dict(self): |
191 fea= api.Feature("foo", type='int') |
231 fea= api.Feature("foo", type='int') |
192 self.assertEquals(fea._dict(), {'ref': 'foo','type': 'int', 'name': 'foo'}) |
232 self.assertEquals(fea._dict(), {'ref': 'foo', |
|
233 'type': 'int', |
|
234 'name': None, |
|
235 'relevant': None, |
|
236 'constraint': None }) |
193 |
237 |
194 def test_clone_single_feature(self): |
238 def test_clone_single_feature(self): |
195 fea= api.Feature("foo", type='int') |
239 fea= api.Feature("foo", type='int') |
196 fea2 = fea._clone() |
240 fea2 = fea._clone() |
197 self.comparefeatures(fea,fea2) |
241 self.comparefeatures(fea,fea2) |
198 |
242 |
199 def test_clone_feature_with_subfeatures(self): |
243 def test_clone_feature_with_subfeatures(self): |
200 fea= api.Feature("foo") |
244 fea= api.Feature("foo") |
201 fea.add_feature(api.Feature("child1",type='string')) |
245 fea.add_feature(api.Feature("child1",type='string')) |
202 fea.add_feature(api.Feature("child2",type='int')) |
246 fea.create_feature("child2",type='int') |
203 fea.child1.add_feature(api.Feature("child12",type='int')) |
247 fea.child1.add_feature(api.Feature("child12",type='int')) |
204 fea2 = fea._clone() |
248 fea2 = fea._clone() |
205 self.comparefeatures(fea,fea2) |
249 self.comparefeatures(fea,fea2) |
206 fea3 = fea._clone(recursion=True, recursion_depth=1) |
250 fea3 = fea._clone(recursion=True, recursion_depth=1) |
207 self.comparefeatures(fea,fea3) |
251 self.comparefeatures(fea,fea3) |
328 self.assertEquals(foofea.get_value(), [['1','2','3'], |
375 self.assertEquals(foofea.get_value(), [['1','2','3'], |
329 ['4','5','6'], |
376 ['4','5','6'], |
330 ['7','8','9'] |
377 ['7','8','9'] |
331 ]) |
378 ]) |
332 |
379 |
|
380 def test_create_configuration_with_sequence_and_get_column_value(self): |
|
381 fea= api.FeatureSequence("foo") |
|
382 c1 = fea.create_feature('child1') |
|
383 c11 = c1.create_feature('child11') |
|
384 c2 = fea.create_feature('child2') |
|
385 c3 = fea.create_feature('child3') |
|
386 config = api.Configuration('foo.confml') |
|
387 config.add_feature(fea) |
|
388 dview = config.get_default_view() |
|
389 foofea = dview.get_feature('foo') |
|
390 # Test adding a data row with array |
|
391 foofea.value = [[['1'],'2','3'],[['4'],'5','6'],[['7'],'8','9']] |
|
392 self.assertEquals(api.get_column_value(foofea, 'child1'), [['1'],['4'],['7']]) |
|
393 self.assertEquals(foofea.child1.value, [['1'],['4'],['7']]) |
|
394 self.assertEquals(foofea.child1.child11.value, ['1','4','7']) |
|
395 self.assertEquals(foofea.child2.value, ['2','5','8']) |
|
396 self.assertEquals(foofea.value, [[['1'],'2','3'], |
|
397 [['4'],'5','6'], |
|
398 [['7'],'8','9']]) |
|
399 |
|
400 def test_create_configuration_with_sequence_and_set_value_via_column(self): |
|
401 fea= api.FeatureSequence("foo") |
|
402 fea.add_feature(api.Feature('child1')) |
|
403 fea.add_feature(api.Feature('child2')) |
|
404 fea.add_feature(api.Feature('child3')) |
|
405 config = api.Configuration('foo.confml') |
|
406 config.add_feature(fea) |
|
407 dview = config.get_default_view() |
|
408 foofea = dview.get_feature('foo') |
|
409 # Test adding a data row with array |
|
410 foofea.value = [['1','2','3'],['4','5','6'],['7','8','9']] |
|
411 self.assertEquals(foofea.get_value(), [['1','2','3'], |
|
412 ['4','5','6'], |
|
413 ['7','8','9'] |
|
414 ]) |
|
415 |
|
416 api.set_column_value(foofea, 'child1', ['0','0','0']) |
|
417 self.assertEquals(foofea.get_value(), [['0','2','3'], |
|
418 ['0','5','6'], |
|
419 ['0','8','9'] |
|
420 ]) |
|
421 self.assertRaises(exceptions.ConeException, api.set_column_value, foofea, 'child2', 'over') |
|
422 self.assertRaises(exceptions.ConeException, api.set_column_value, foofea, 'child2', ['0','0','0', 'over']) |
|
423 foofea.child3.value = ['0','0','0'] |
|
424 self.assertEquals(foofea.get_value(), [['0','2','0'], |
|
425 ['0','5','0'], |
|
426 ['0','8','0'] |
|
427 ]) |
333 |
428 |
334 def test_create_configuration_with_sequence_and_add_sequence_value_directly(self): |
429 def test_create_configuration_with_sequence_and_add_sequence_value_directly(self): |
335 fea= api.FeatureSequence("foo") |
430 fea= api.FeatureSequence("foo") |
336 fea.add_feature(api.Feature('child1')) |
431 fea.add_feature(api.Feature('child1')) |
337 fea.add_feature(api.Feature('child2')) |
432 fea.add_feature(api.Feature('child2')) |
348 self.assertEquals(len(foofea.get_data()), 3) |
443 self.assertEquals(len(foofea.get_data()), 3) |
349 self.assertEquals(foofea.get_value(), [['1','2','3'], |
444 self.assertEquals(foofea.get_value(), [['1','2','3'], |
350 ['4','5','6'], |
445 ['4','5','6'], |
351 ['7','8','9'] |
446 ['7','8','9'] |
352 ]) |
447 ]) |
|
448 |
|
449 # Check the data element values |
|
450 data_elem_values = [(d.fqr, d.value) for d in config._traverse(type=api.Data)] |
|
451 self.assertEquals(data_elem_values, |
|
452 [('foo', None), |
|
453 ('foo.child1', '1'), |
|
454 ('foo.child2', '2'), |
|
455 ('foo.child3', '3'), |
|
456 ('foo', None), |
|
457 ('foo.child1', '4'), |
|
458 ('foo.child2', '5'), |
|
459 ('foo.child3', '6'), |
|
460 ('foo', None), |
|
461 ('foo.child1', '7'), |
|
462 ('foo.child2', '8'), |
|
463 ('foo.child3', '9'),]) |
|
464 |
|
465 def test_set_sequence_to_empty(self): |
|
466 fea= api.FeatureSequence("foo") |
|
467 fea.add_feature(api.Feature('child1')) |
|
468 fea.add_feature(api.Feature('child2')) |
|
469 fea.add_feature(api.Feature('child3')) |
|
470 config = api.Configuration('foo.confml') |
|
471 config.add_feature(fea) |
|
472 dview = config.get_default_view() |
|
473 foofea = dview.get_feature('foo') |
|
474 # Test adding a data row with array |
|
475 foofea.set_value([['1','2','3'], |
|
476 ['4','5','6'], |
|
477 ['7','8','9']]) |
|
478 self.assertEquals(len(foofea.get_data()), 3) |
|
479 self.assertEquals(foofea.get_value(), [['1','2','3'], |
|
480 ['4','5','6'], |
|
481 ['7','8','9']]) |
|
482 self.assertEquals(foofea.child1.get_value(), ['1','4','7']) |
|
483 self.assertEquals(foofea.child2.get_value(), ['2','5','8']) |
|
484 self.assertEquals(foofea.child3.get_value(), ['3','6','9']) |
|
485 |
|
486 # Set empty and check that the single empty data item is created |
|
487 foofea.set_value([]) |
|
488 data_elem_values = [(d.fqr, d.value) for d in config._traverse(type=api.Data)] |
|
489 self.assertEquals(data_elem_values, [('foo', None)]) |
|
490 |
|
491 # Check that get_value() still works correctly |
|
492 self.assertEquals(foofea.get_value(), []) |
|
493 self.assertEquals(foofea.child1.get_value(), []) |
|
494 self.assertEquals(foofea.child2.get_value(), []) |
|
495 self.assertEquals(foofea.child3.get_value(), []) |
|
496 self.assertEquals(foofea.get_original_value(), []) |
|
497 self.assertEquals(foofea.child1.get_original_value(), []) |
|
498 self.assertEquals(foofea.child2.get_original_value(), []) |
|
499 self.assertEquals(foofea.child3.get_original_value(), []) |
|
500 |
|
501 # Check that column-level set_value() reports errors correctly |
|
502 self.assertRaises(exceptions.ConeException, foofea.child1.set_value, ['10', '11']) |
|
503 self.assertRaises(exceptions.ConeException, foofea.child1.set_value, ['10']) |
|
504 foofea.child1.set_value([]) |
|
505 |
|
506 # Check that calling add_sequence() after set_value([]) works correctly |
|
507 foofea.add_sequence(['1', '2', '3']) |
|
508 self.assertEquals(foofea.get_value(), [['1', '2', '3']]) |
|
509 self.assertEquals(foofea.child1.get_value(), ['1']) |
|
510 self.assertEquals(foofea.get_original_value(), [['1', '2', '3']]) |
|
511 data_elem_values = [(d.fqr, d.value) for d in config._traverse(type=api.Data)] |
|
512 self.assertEquals(data_elem_values, |
|
513 [('foo', None), |
|
514 ('foo.child1', '1'), |
|
515 ('foo.child2', '2'), |
|
516 ('foo.child3', '3'),]) |
|
517 |
|
518 # Check that explicitly setting all Nones works |
|
519 foofea.set_value([[None, None, None]]) |
|
520 self.assertEquals(foofea.get_value(), [[None, None, None]]) |
|
521 self.assertEquals(foofea.child1.get_value(), [None]) |
|
522 self.assertEquals(foofea.get_original_value(), [[None, None, None]]) |
|
523 data_elem_values = [(d.fqr, d.value) for d in config._traverse(type=api.Data)] |
|
524 self.assertEquals(data_elem_values, |
|
525 [('foo', None), |
|
526 ('foo.child1', None), |
|
527 ('foo.child2', None), |
|
528 ('foo.child3', None),]) |
353 |
529 |
354 def test_create_configuration_and_access_feature_value_with_property(self): |
530 def test_create_configuration_and_access_feature_value_with_property(self): |
355 config = api.Configuration('foo.confml') |
531 config = api.Configuration('foo.confml') |
356 fea= api.Feature("foo") |
532 fea= api.Feature("foo") |
357 config.add_feature(fea) |
533 config.add_feature(fea) |
466 data1._add(api.Data(ref='ValueSubSetting',value='Value 1')) |
641 data1._add(api.Data(ref='ValueSubSetting',value='Value 1')) |
467 seqfea.add_data(data1) |
642 seqfea.add_data(data1) |
468 |
643 |
469 self.assertEquals(len(seqfea.get_data()), 2) |
644 self.assertEquals(len(seqfea.get_data()), 2) |
470 |
645 |
471 self.assertEquals(seqfea.get_map_key_value('Default'),'Default value') |
646 def test_get_set_template_single_data_level(self): |
472 self.assertEquals(seqfea.get_map_key_value('Key 1'),'Value 1') |
647 # Create a sequence feature with only a single level of sub-features |
|
648 # (i.e. no sub-sub-features) |
|
649 config = api.Configuration('foo.confml') |
|
650 seq = api.FeatureSequence("seq") |
|
651 seq.add_feature(api.Feature('child1')) |
|
652 seq.add_feature(api.Feature('child2')) |
|
653 seq.add_feature(api.Feature('child3')) |
|
654 config.add_feature(seq) |
|
655 |
|
656 # Add a template for the sequence with the data elements under it |
|
657 # in a different order than what the features were defined in |
|
658 template_data = api.Data(ref='seq', template=True) |
|
659 template_data.add(api.Data(ref='child2', value='foo2')) |
|
660 template_data.add(api.Data(ref='child3', value='foo3')) |
|
661 template_data.add(api.Data(ref='child1', value='foo1')) |
|
662 config.add_data(template_data) |
|
663 |
|
664 # Get the template data (should be in order) |
|
665 dview = config.get_default_view() |
|
666 seq = dview.get_feature('seq') |
|
667 self.assertEquals(seq.get_template(), ['foo1', 'foo2', 'foo3']) |
|
668 |
|
669 seq.set_template(['x1', 'x2', 'x3']) |
|
670 self.assertEquals(seq.get_template(), ['x1', 'x2', 'x3']) |
|
671 |
|
672 seq.set_template(None) |
|
673 self.assertEquals(seq.get_template(), None) |
|
674 |
|
675 # Test attempting to set invalid template data |
|
676 self.assertRaises(TypeError, seq.set_template, 'foo') |
|
677 self.assertRaises(ValueError, seq.set_template, []) |
|
678 self.assertRaises(ValueError, seq.set_template, ['foo', 'bar']) |
|
679 self.assertRaises(ValueError, seq.set_template, [['foo', 'x'], 'bar']) |
|
680 |
|
681 def test_get_set_template_two_data_levels(self): |
|
682 # Create a sequence feature with two levels of sub-features |
|
683 config = api.Configuration('foo.confml') |
|
684 seq = api.FeatureSequence("seq") |
|
685 seq.add_feature(api.Feature('a1')) |
|
686 seq.add_feature(api.Feature('b1'), 'a1') |
|
687 seq.add_feature(api.Feature('b2'), 'a1') |
|
688 seq.add_feature(api.Feature('a2')) |
|
689 seq.add_feature(api.Feature('a3')) |
|
690 config.add_feature(seq) |
|
691 |
|
692 # Add a template for the sequence with the data elements under it |
|
693 # in a different order than what the features were defined in |
|
694 template_data = api.Data(ref='seq', template=True) |
|
695 template_data.add(api.Data(ref='a3', value='t: a3')) |
|
696 data_a1 = api.Data(ref='a1') |
|
697 data_a1.add(api.Data(ref='b2', value='t: a1.b2')) |
|
698 data_a1.add(api.Data(ref='b1', value='t: a1.b1')) |
|
699 template_data.add(data_a1) |
|
700 template_data.add(api.Data(ref='a2', value='t: a2')) |
|
701 config.add_data(template_data) |
|
702 |
|
703 template_data = api.Data(ref='seq') |
|
704 template_data.add(api.Data(ref='a3', value='t: a3')) |
|
705 data_a1 = api.Data(ref='a1') |
|
706 data_a1.add(api.Data(ref='b2', value='t: a1.b2')) |
|
707 data_a1.add(api.Data(ref='b1', value='t: a1.b1')) |
|
708 template_data.add(data_a1) |
|
709 template_data.add(api.Data(ref='a2', value='t: a2')) |
|
710 config.add_data(template_data, api.FeatureSequence.POLICY_APPEND) |
|
711 |
|
712 # Get the template data (should be in order) |
|
713 dview = config.get_default_view() |
|
714 seq = dview.get_feature('seq') |
|
715 self.assertEquals(seq.value, [[['t: a1.b1', 't: a1.b2'], 't: a2', 't: a3']]) |
|
716 self.assertEquals(seq.get_template(), [['t: a1.b1', 't: a1.b2'], 't: a2', 't: a3']) |
|
717 |
|
718 # Set the template and get it again |
|
719 seq.set_template([['t: a1.b1 (x)', 't: a1.b2 (x)'], 't: a2 (x)', 't: a3 (x)']) |
|
720 self.assertEquals(seq.get_template(), [['t: a1.b1 (x)', 't: a1.b2 (x)'], 't: a2 (x)', 't: a3 (x)']) |
|
721 |
|
722 def test_sequence_add_data_and_set_template(self): |
|
723 # Create a simple configuration with a sequence feature |
|
724 config = api.Configuration('foo.confml') |
|
725 fea = api.Feature('fea') |
|
726 config.add_feature(fea) |
|
727 seq = api.FeatureSequence("seq") |
|
728 fea.add_feature(seq) |
|
729 seq.add_feature(api.Feature('child1')) |
|
730 seq.add_feature(api.Feature('child2')) |
|
731 |
|
732 sequence = config.get_default_view().get_feature('fea.seq') |
|
733 |
|
734 # Check that initially the sequence is empty |
|
735 self.assertEquals(sequence.get_template(), None) |
|
736 self.assertEquals(sequence.value, []) |
|
737 |
|
738 # Add some data and check again |
|
739 sequence.add_sequence(['row1', 'foo']) |
|
740 sequence.add_sequence(['row2', 'foo']) |
|
741 self.assertEquals(sequence.get_template(), None) |
|
742 self.assertEquals(sequence.value, [['row1', 'foo'], |
|
743 ['row2', 'foo']]) |
|
744 |
|
745 # Setting the template should not affect the data |
|
746 sequence.set_template(['t1', 't2']) |
|
747 self.assertEquals(sequence.get_template(), ['t1', 't2']) |
|
748 self.assertEquals(sequence.value, [['row1', 'foo'], |
|
749 ['row2', 'foo']]) |
|
750 |
|
751 sequence.set_template(['T1', 'T2']) |
|
752 sequence.add_sequence(['row3', 'foo']) |
|
753 self.assertEquals(sequence.get_template(), ['T1', 'T2']) |
|
754 self.assertEquals(sequence.value, [['row1', 'foo'], |
|
755 ['row2', 'foo'], |
|
756 ['row3', 'foo']]) |
|
757 |
|
758 def test_set_value_method_for_sequence(self): |
|
759 config = api.Configuration('foo.confml') |
|
760 fea = api.Feature('Some') |
|
761 config.add_feature(fea) |
|
762 seq = api.FeatureSequence("Sequence") |
|
763 fea.add_feature(seq) |
|
764 seq.add_feature(api.Feature('Feature')) |
|
765 |
|
766 seq = config.get_default_view().get_feature('Some.Sequence') |
|
767 value = [['foo'], ['bar']] |
|
768 seq.set_value(value) |
|
769 |
|
770 self.assertEquals(seq.value, [['foo'], ['bar']]) |
|
771 self.assertEquals(seq.Feature.value, ['foo', 'bar']) |
|
772 |
|
773 def test_simple_name_id_mapping(self): |
|
774 config = api.Configuration('foo.confml') |
|
775 seq = api.FeatureSequence('seq', mapKey='sub1', mapValue='sub1') |
|
776 seq.add_feature(api.Feature('sub1')) |
|
777 seq.add_feature(api.Feature('sub2')) |
|
778 config.add_feature(seq) |
|
779 config.add_feature(api.Feature('target')) |
|
780 |
|
781 config.add_data(api.Data(fqr='seq.sub1', value='foo')) |
|
782 config.add_data(api.Data(fqr='seq.sub2', value='bar')) |
|
783 config.add_data(api.Data(fqr='target', map="seq[@key='foo']")) |
|
784 |
|
785 fea = config.get_default_view().get_feature('target') |
|
786 self.assertEquals(fea.value, 'foo') |
|
787 self.assertEquals(fea.get_value(), 'foo') |
|
788 self.assertEquals(fea.get_original_value(), 'foo') |
|
789 |
|
790 seq.mapValue = 'sub2' |
|
791 self.assertEquals(fea.value, 'bar') |
|
792 self.assertEquals(fea.get_value(), 'bar') |
|
793 self.assertEquals(fea.get_original_value(), 'bar') |
|
794 |
473 if __name__ == '__main__': |
795 if __name__ == '__main__': |
474 unittest.main() |
796 unittest.main() |
475 |
|