def test_create_data_getters(self):
data = api.Data(ref="foo", value=123)
self.assertEquals(data.fqr, "foo")
data = api.Data(fqr="foo.bar.test", value=123)
self.assertEquals(data.get_ref(), "test")
self.assertEquals(data.get_value(), 123)
self.assertEquals(data.get_policy(), "")
def test_get_set_template_single_data_level(self):
# Create a sequence feature with only a single level of sub-features
# (i.e. no sub-sub-features)
config = api.Configuration('foo.confml')
seq = api.FeatureSequence("seq")
seq.add_feature(api.Feature('child1'))
seq.add_feature(api.Feature('child2'))
seq.add_feature(api.Feature('child3'))
config.add_feature(seq)
# Add a template for the sequence with the data elements under it
# in a different order than what the features were defined in
template_data = api.Data(ref='seq', template=True)
template_data.add(api.Data(ref='child2', value='foo2'))
template_data.add(api.Data(ref='child3', value='foo3'))
template_data.add(api.Data(ref='child1', value='foo1'))
config.add_data(template_data)
# Get the template data (should be in order)
dview = config.get_default_view()
seq = dview.get_feature('seq')
self.assertEquals(seq.get_template(), ['foo1', 'foo2', 'foo3'])
seq.set_template(['x1', 'x2', 'x3'])
self.assertEquals(seq.get_template(), ['x1', 'x2', 'x3'])
seq.set_template(None)
self.assertEquals(seq.get_template(), None)
# Test attempting to set invalid template data
self.assertRaises(TypeError, seq.set_template, 'foo')
self.assertRaises(ValueError, seq.set_template, [])
self.assertRaises(ValueError, seq.set_template, ['foo', 'bar'])
self.assertRaises(ValueError, seq.set_template, [['foo', 'x'], 'bar'])
def test_set_data_to_configuration(self):
conf = api.Configuration("foo/foo.confml")
conf.add_data(api.Data(fqr='feature1', value=123))
self.assertEquals(conf.get_data('feature1').get_value(), 123)
conf.add_data(api.Data(fqr='feature1.feature12', value="test"))
self.assertEquals(
conf.get_data('feature1.feature12').get_value(), "test")
self.assertEquals(conf.data.feature1.feature12.get_value(), "test")
def convert_value_to_data(self, value, attr=None):
if not isinstance(value,
(types.ListType, types.TupleType, types.NoneType)):
raise ValueError("Only list, tuple and None types are allowed.")
if value:
return [api.Data(fqr=self.fqr, value=v, attr=attr) for v in value]
else:
return [api.Data(fqr=self.fqr, empty=True, attr=attr)]
def test_create_data(self):
data = api.Data(fqr="foo", value=123)
self.assertTrue(data)
data = api.Data(fqr="foo.bar", value=123, attr='rfs')
self.assertEquals(data.attr,'rfs')
data = api.Data(fqr="foo.bar", value=123, attr=None)
self.assertEquals(data.attr,'data')
data = api.Data(fqr="foo.bar", value=123, attr='data')
self.assertEquals(data.attr,'data')
def test_clone_sequential_data(self):
data1 = api.Data(ref="seq")
data1._add(api.Data(ref="foo", value='sss'),container.APPEND)
data1._add(api.Data(ref="foo", value='aaa'),container.APPEND)
data1._add(api.Data(ref="foo", value=123),container.APPEND)
data2 = data1._clone(recursion=True)
self.comparedata(data1, data2)
self.comparedata(data1.foo[0], data2.foo[0])
self.comparedata(data1.foo[1], data2.foo[1])
self.comparedata(data1.foo[2], data2.foo[2])
def test_clone_hierarchical_data(self):
data1 = api.Data(ref="seq")
data1._add(api.Data(ref="foo1", value='sss'))
data1._add(api.Data(ref="foo2", value='aaa'))
data1._add(api.Data(ref="foo3", value=123))
data2 = data1._clone(recursion=True)
self.comparedata(data1, data2)
self.comparedata(data1.foo1, data2.foo1)
self.comparedata(data1.foo2, data2.foo2)
self.comparedata(data1.foo3, data2.foo3)
def test_create_configuration_with_data(self):
config = api.Configuration("dataconf")
config.add_data(api.Data(fqr='foo.setting1',value=123))
config.add_data(api.Data(fqr='foo.setting2',value=456))
config.add_data(api.Data(fqr='foo.seq.data1',value='juhuu'))
config.add_data(api.Data(fqr='foo.seq.data2',value='x:\\ss'))
self.assertEquals(config.data.foo.setting1.get_value(), 123)
self.assertEquals(config.data.foo.setting1.fqr, 'foo.setting1')
self.assertEquals(config.data.foo.seq.data2.fqr, 'foo.seq.data2')
self.assertEquals(config.data.foo.seq.data2.get_ref(), 'data2')
self.assertEquals(config.get_data('foo.seq.data2').get_value(), 'x:\\ss')
def test_create_feature_data_proxy(self):
fea= api.Feature("foo")
feaproxy = api._FeatureDataProxy("foo",fea)
self.assertTrue(feaproxy.get_ref(),"foo")
self.assertEquals(feaproxy._get_data(),None)
self.assertEquals(feaproxy._get_value(),None)
feaproxy._add_data(api.Data(ref="foo", value=123))
self.assertEquals(feaproxy._get_data().get_value(),123)
feaproxy._add_data(api.Data(ref="foo", value=321))
self.assertEquals(feaproxy._get_data().get_value(),321)
self.assertEquals(feaproxy._get_datas()[0].get_value(),123)
self.assertEquals(feaproxy._get_datas()[1].get_value(),321)
self.assertEquals(feaproxy._get_values(),[123,321])
def check(data_objs, policy, expected):
conf = api.Configuration("foo/foo.confml")
conf.add_data(api.Data(ref='base1', value="foo"))
conf.add_data(api.Data(ref='foo', value="foobar"))
conf.add_data(api.Data(ref='base2', value="bar"))
if policy is None:
conf.add_data(data_objs)
else:
conf.add_data(data_objs, policy=policy)
actual = []
for d in conf._traverse(type=api.Data):
actual.append((d.fqr, d.value))
self.assertEquals(actual, expected)
def loads(self, dict):
"""
@param obj: The Configuration object
"""
fealist_expanded = dict.get('expanded')
fealist_version = dict.get('version_identifier')
fealist_is_latest_version = dict.get('is_latest_version')
fealist_list_id = dict.get('list_id')
fealist_path = dict.get('path')
fealist_version_title = dict.get('version_title')
fealist_can_be_released = dict.get('can_be_released')
fealist_type = dict.get('type')
fealist_has_external_relations = dict.get('is_latest_version')
# Create a configuration object from the featurelist
conf = model.FeatureList(path='featurelists/'+fealist_version_title+'.confml')
conf.meta.add('version_identifier', fealist_version)
for feature in dict.get('features'):
reader = FeatureReader()
fea = reader.loads(feature)
if fea != None:
conf.add_feature(fea)
for feafqr in conf.list_all_features():
# Add empty data object to featurelist configuration
conf.add_data(api.Data(fqr=feafqr))
return conf
def create_feature(self, config):
"""
Add a feature based on this temp feature definition to the given configuration.
"""
if '.' in self.ref:
pos = self.ref.rfind('.')
ref = self.ref[pos + 1:]
namespace = self.ref[:pos]
else:
ref = self.ref
namespace = ''
mapping = {
'string': cone.confml.model.ConfmlStringSetting,
'int': cone.confml.model.ConfmlIntSetting,
'real': cone.confml.model.ConfmlRealSetting,
'boolean': cone.confml.model.ConfmlBooleanSetting
}
# Create temp variables always name being also the ref
feature = mapping[self.type](ref, name=ref)
setattr(feature, TEMP_FEATURE_MARKER_VARNAME, True)
config.add_feature(feature, namespace)
value = utils.expand_refs_by_default_view(self.value,
config.get_default_view())
config.add_data(api.Data(fqr=self.ref, value=value))
def test_create_data_for_sequences(self):
data = api.Data(ref="seq")
data._add(api.Data(ref="foo", value='sss'),container.APPEND)
data._add(api.Data(ref="foo", value='aaa'),container.APPEND)
data._add(api.Data(ref="foo", value=123),container.PREPEND)
self.assertEquals(data.fqr, "seq")
self.assertEquals(data._get('foo[0]').get_ref(), "foo")
self.assertEquals(data._get('foo[0]').fqr, "seq.foo")
self.assertEquals(data.foo[0].get_value(), 123)
self.assertEquals(data.foo[0].get_index(), 0)
self.assertEquals(data.foo[1].get_value(), 'sss')
self.assertEquals(data.foo[1].get_index(), 1)
self.assertEquals(data.foo[2].get_value(), 'aaa')
self.assertEquals(data.foo[2].get_index(), 2)
data._add(api.Data(ref="foo", value='NEW'))
self.assertEquals(data.foo.get_value(), 'NEW')
def test_create_features_with_rfs_data(self):
conf = api.Configuration("foo/foo.confml")
conf.add_feature(api.Feature('feature1'))
conf.add_feature(api.Feature('child1'), 'feature1')
conf.add_feature(api.Feature('child2'), 'feature1')
conf.add_feature(api.Feature('child3'), 'feature1')
conf.add_data(api.Data(fqr='feature1.child1', attr='rfs',
value='true'))
conf.add_data(
api.Data(fqr='feature1.child2', attr='rfs', value='false'))
dview = conf.get_default_view()
self.assertEquals(
dview.get_feature('feature1.child1').get_value(), None)
self.assertEquals(
dview.get_feature('feature1.child1').get_value('rfs'), 'true')
self.assertEquals(
dview.get_feature('feature1.child2').get_value('rfs'), 'false')
def test_simple_name_id_mapping(self):
config = api.Configuration('foo.confml')
seq = api.FeatureSequence('seq', mapKey='sub1', mapValue='sub1')
seq.add_feature(api.Feature('sub1'))
seq.add_feature(api.Feature('sub2'))
config.add_feature(seq)
config.add_feature(api.Feature('target'))
config.add_data(api.Data(fqr='seq.sub1', value='foo'))
config.add_data(api.Data(fqr='seq.sub2', value='bar'))
config.add_data(api.Data(fqr='target', map="seq[@key='foo']"))
fea = config.get_default_view().get_feature('target')
self.assertEquals(fea.value, 'foo')
self.assertEquals(fea.get_value(), 'foo')
self.assertEquals(fea.get_original_value(), 'foo')
seq.mapValue = 'sub2'
self.assertEquals(fea.value, 'bar')
self.assertEquals(fea.get_value(), 'bar')
self.assertEquals(fea.get_original_value(), 'bar')
def test_create_configuration_with_sequence_and_mapping_properties(self):
fea = api.FeatureSequence("SequenceSetting", mapKey='KeySubSetting', mapValue="ValueSubSetting")
fea.add_feature(api.Feature('KeySubSetting'))
fea.add_feature(api.Feature('ValueSubSetting'))
config = api.Configuration('foo.confml')
config.add_feature(fea)
dview = config.get_default_view()
seqfea = dview.get_feature("SequenceSetting")
self.assertEquals(seqfea.mapKey, "KeySubSetting")
self.assertEquals(seqfea.mapValue, "ValueSubSetting")
#add item 1
data = api.Data(ref='SequenceSetting')
data._add(api.Data(ref='KeySubSetting',value='Default'))
data._add(api.Data(ref='ValueSubSetting',value='Default value'))
seqfea.add_data(data)
#add item 2
data1 = api.Data(ref='SequenceSetting', policy='append')
data1._add(api.Data(ref='KeySubSetting',value='Key 1'))
data1._add(api.Data(ref='ValueSubSetting',value='Value 1'))
seqfea.add_data(data1)
self.assertEquals(len(seqfea.get_data()), 2)
def loads(self, dict):
"""
@param obj: The Configuration object
"""
datacont = api.Configuration('confml/data.confml')
for dataref in dict.keys():
# Ignore null values
if dict[dataref]:
refs = []
for elem in dataref.split('.'):
refs.append(utils.resourceref.to_objref(elem))
newref = '.'.join(refs)
dataelem = api.Data(fqr=newref, value=map_carbon2confml_value(dict[dataref]))
datacont.add_data(dataelem)
return datacont
def test_create_configuration_with_sequence_and_add_data_with_default_view(self):
fea= api.FeatureSequence("foo")
fea.add_feature(api.Feature('child1'))
fea.add_feature(api.Feature('child2'))
fea.add_feature(api.Feature('child3'))
config = api.Configuration('foo.confml')
config.add_feature(fea)
dview = config.get_default_view()
foofea = dview.get_feature('foo')
data = api.Data(ref='foo')
data._add(api.Data(ref='child1',value='test1'))
data._add(api.Data(ref='child2',value='test2'))
data._add(api.Data(ref='child3',value='test3'))
foofea.add_data(data)
data1 = api.Data(ref='foo', policy='append')
data1._add(api.Data(ref='child1',value='jee'))
data1._add(api.Data(ref='child2',value='oo'))
data1._add(api.Data(ref='child3',value='aa'))
foofea.add_data(data1)
self.assertEquals(len(foofea.get_data()), 2)
self.assertEquals(foofea.get_data()[0].list_features(), ['child1','child2','child3'])
self.assertEquals(foofea.get_data()[0].get_feature('child1').get_value(), 'test1')
self.assertEquals(foofea.get_data()[0].get_feature('child2').get_value(), 'test2')
self.assertEquals(foofea.get_data()[0].get_feature('child3').get_value(), 'test3')
self.assertEquals(foofea.get_data()[1].list_features(), ['child1','child2','child3'])
self.assertEquals(foofea.get_data()[1].get_feature('child1').get_value(), 'jee')
self.assertEquals(foofea.get_data()[1].get_feature('child2').get_value(), 'oo')
self.assertEquals(foofea.get_data()[1].get_feature('child3').get_value(), 'aa')
self.assertEquals(foofea.get_value(), [['test1','test2','test3'],
['jee','oo','aa']])
self.assertEquals(foofea.get_data()[0][0].get_value(), 'test1')
# Test recurse
for row in foofea.get_data():
for col in row:
print col.get_value(),
print
def test_add_features_and_add_data_via_default_view(self):
conf = api.Configuration("foo/foo.confml")
conf.add_feature(api.Feature('feature1'))
conf.add_feature(api.Feature('feature2'))
conf.add_feature(api.Feature('feature3'))
conf.add_feature(api.Feature('feature4'))
conf.add_feature(api.Feature('feature12'), 'feature1')
dview = conf.get_default_view()
dview.feature1._add_data(api.Data(ref="feature1", value=123))
dview.feature2._add_data(api.Data(ref="feature2", value=123))
dview.feature3._add_data(api.Data(ref="feature3", value=123))
dview.feature1.feature12._add_data(api.Data(ref="feature12",
value=123))
dview.feature1._add_data(api.Data(ref="feature1", value=123))
self.assertEquals(dview.feature1.get_value(), 123)
dview.feature1._add_data(api.Data(ref="feature1", value=111))
self.assertEquals(dview.feature1.get_value(), 111)
def test_get_set_template_two_data_levels(self):
# Create a sequence feature with two levels of sub-features
config = api.Configuration('foo.confml')
seq = api.FeatureSequence("seq")
seq.add_feature(api.Feature('a1'))
seq.add_feature(api.Feature('b1'), 'a1')
seq.add_feature(api.Feature('b2'), 'a1')
seq.add_feature(api.Feature('a2'))
seq.add_feature(api.Feature('a3'))
config.add_feature(seq)
# Add a template for the sequence with the data elements under it
# in a different order than what the features were defined in
template_data = api.Data(ref='seq', template=True)
template_data.add(api.Data(ref='a3', value='t: a3'))
data_a1 = api.Data(ref='a1')
data_a1.add(api.Data(ref='b2', value='t: a1.b2'))
data_a1.add(api.Data(ref='b1', value='t: a1.b1'))
template_data.add(data_a1)
template_data.add(api.Data(ref='a2', value='t: a2'))
config.add_data(template_data)
template_data = api.Data(ref='seq')
template_data.add(api.Data(ref='a3', value='t: a3'))
data_a1 = api.Data(ref='a1')
data_a1.add(api.Data(ref='b2', value='t: a1.b2'))
data_a1.add(api.Data(ref='b1', value='t: a1.b1'))
template_data.add(data_a1)
template_data.add(api.Data(ref='a2', value='t: a2'))
config.add_data(template_data, api.FeatureSequence.POLICY_APPEND)
# Get the template data (should be in order)
dview = config.get_default_view()
seq = dview.get_feature('seq')
self.assertEquals(seq.value, [[['t: a1.b1', 't: a1.b2'], 't: a2', 't: a3']])
self.assertEquals(seq.get_template(), [['t: a1.b1', 't: a1.b2'], 't: a2', 't: a3'])
# Set the template and get it again
seq.set_template([['t: a1.b1 (x)', 't: a1.b2 (x)'], 't: a2 (x)', 't: a3 (x)'])
self.assertEquals(seq.get_template(), [['t: a1.b1 (x)', 't: a1.b2 (x)'], 't: a2 (x)', 't: a3 (x)'])
def test_clone_data(self):
data1 = api.Data(ref="dat")
data2 = data1._clone()
self.comparedata(data1, data2)
def test_create_feature_data(self):
dataobj = api.Data(ref="foo", value=132)
self.assertTrue(dataobj.fqr,"foo")
self.assertTrue(dataobj.get_value(),123)
self.assertTrue(dataobj.value,123)
def test_add_data_to_configuration_from_list(self):
def check(data_objs, policy, expected):
conf = api.Configuration("foo/foo.confml")
conf.add_data(api.Data(ref='base1', value="foo"))
conf.add_data(api.Data(ref='foo', value="foobar"))
conf.add_data(api.Data(ref='base2', value="bar"))
if policy is None:
conf.add_data(data_objs)
else:
conf.add_data(data_objs, policy=policy)
actual = []
for d in conf._traverse(type=api.Data):
actual.append((d.fqr, d.value))
self.assertEquals(actual, expected)
# Adding an empty list should do nothing
check(data_objs=[],
policy=None,
expected=[('base1', 'foo'), ('foo', 'foobar'), ('base2', 'bar')])
# Default policy (replace)
check(data_objs=[
api.Data(ref="foo", value="1"),
api.Data(ref="foo", value="2"),
api.Data(ref="foo", value="3"),
],
policy=None,
expected=[('base1', 'foo'), ('foo', '1'), ('foo', '2'),
('foo', '3'), ('base2', 'bar')])
# Replace explicitly
check(data_objs=[
api.Data(ref="foo", value="1"),
api.Data(ref="foo", value="2"),
api.Data(ref="foo", value="3"),
],
policy=api.container.REPLACE,
expected=[('base1', 'foo'), ('foo', '1'), ('foo', '2'),
('foo', '3'), ('base2', 'bar')])
# Append
check(data_objs=[
api.Data(ref="foo", value="1"),
api.Data(ref="foo", value="2"),
api.Data(ref="foo", value="3"),
],
policy=api.container.APPEND,
expected=[('base1', 'foo'), ('foo', 'foobar'), ('foo', '1'),
('foo', '2'), ('foo', '3'), ('base2', 'bar')])
# Prepend
check(data_objs=[
api.Data(ref="foo", value="1"),
api.Data(ref="foo", value="2"),
api.Data(ref="foo", value="3"),
],
policy=api.container.PREPEND,
expected=[('base1', 'foo'), ('foo', '1'), ('foo', '2'),
('foo', '3'), ('foo', 'foobar'), ('base2', 'bar')])
