|
0
|
1 |
#
|
|
|
2 |
# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
|
3 |
# All rights reserved.
|
|
|
4 |
# This component and the accompanying materials are made available
|
|
|
5 |
# under the terms of "Eclipse Public License v1.0"
|
|
|
6 |
# which accompanies this distribution, and is available
|
|
|
7 |
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
|
8 |
#
|
|
|
9 |
# Initial Contributors:
|
|
|
10 |
# Nokia Corporation - initial contribution.
|
|
|
11 |
#
|
|
|
12 |
# Contributors:
|
|
|
13 |
#
|
|
|
14 |
# Description:
|
|
|
15 |
#
|
|
|
16 |
|
|
|
17 |
import unittest
|
|
|
18 |
import sys
|
|
5
|
19 |
from cone.public import api, exceptions, container
|
|
0
|
20 |
from cone.confml import model
|
|
|
21 |
|
|
|
22 |
|
|
|
23 |
class TestConfmlMeta(unittest.TestCase):
|
|
|
24 |
def test_create_meta(self):
|
|
|
25 |
metaelem = model.ConfmlMeta()
|
|
3
|
26 |
self.assertEquals(str(metaelem),"ConfmlMeta object\n")
|
|
0
|
27 |
|
|
|
28 |
def test_create_with_data(self):
|
|
|
29 |
prop1 = model.ConfmlMetaProperty("foo", 123)
|
|
|
30 |
prop2 = model.ConfmlMetaProperty("bar", 312)
|
|
|
31 |
prop3 = model.ConfmlMetaProperty("test", 'testing string')
|
|
|
32 |
prop4 = model.ConfmlMetaProperty("testName", 'testing string2', \
|
|
|
33 |
"http://www.nokia.com/xml/cpf-id/1", \
|
|
|
34 |
attrs={"name":"name1", "value": "value1"})
|
|
|
35 |
metaelem = model.ConfmlMeta([prop1, prop2, prop3, prop4])
|
|
|
36 |
self.assertEquals(metaelem[0].tag, "foo")
|
|
3
|
37 |
self.assertEquals(metaelem[0].attrs, {})
|
|
0
|
38 |
self.assertEquals(metaelem[0].value, 123)
|
|
|
39 |
self.assertEquals(metaelem[1].tag, "bar")
|
|
|
40 |
self.assertEquals(metaelem[1].value, 312)
|
|
|
41 |
self.assertEquals(metaelem[2].tag, "test")
|
|
|
42 |
self.assertEquals(metaelem[2].value, "testing string")
|
|
|
43 |
self.assertEquals(metaelem[3].tag, "testName")
|
|
|
44 |
self.assertEquals(metaelem[3].value, "testing string2")
|
|
|
45 |
self.assertEquals(metaelem[3].ns, "http://www.nokia.com/xml/cpf-id/1")
|
|
|
46 |
|
|
|
47 |
def test_add_data(self):
|
|
|
48 |
metaelem = model.ConfmlMeta()
|
|
|
49 |
metaelem.append(model.ConfmlMetaProperty('test', 123, "abc", attrs = {"foo":"bar", "abc":1}))
|
|
|
50 |
self.assertEquals(metaelem[0].tag, 'test')
|
|
|
51 |
self.assertEquals(metaelem[0].value, 123)
|
|
|
52 |
self.assertEquals(metaelem[0].ns, "abc")
|
|
|
53 |
self.assertEquals(metaelem[0].attrs, {"foo":"bar", "abc":1})
|
|
|
54 |
|
|
3
|
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 |
|
|
0
|
84 |
def test_find_data(self):
|
|
|
85 |
metaelem = model.ConfmlMeta()
|
|
|
86 |
metaelem.append(model.ConfmlMetaProperty('test', 123, "abc",\
|
|
|
87 |
attrs = {"foo":"bar", "abc":1}))
|
|
|
88 |
metaelem.append(model.ConfmlMetaProperty('abc', "efg", None,\
|
|
|
89 |
attrs = {"foo2":"bar2", "abc2":2}))
|
|
3
|
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"}))
|
|
0
|
94 |
self.assertEquals(metaelem.find_by_tag("test"), 0)
|
|
|
95 |
self.assertEquals(metaelem.get_property_by_tag("test").tag, 'test')
|
|
|
96 |
self.assertEquals(metaelem.get_property_by_tag("test").value, 123)
|
|
3
|
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')
|
|
0
|
99 |
self.assertEquals(metaelem.get("test"), 123)
|
|
|
100 |
self.assertEquals(metaelem.get("test", 'ddd'), 123)
|
|
|
101 |
# test get_value with not found elem
|
|
|
102 |
self.assertEquals(metaelem.get("notthere"), None)
|
|
|
103 |
self.assertEquals(metaelem.get("notthere", 'fooman'), 'fooman')
|
|
|
104 |
self.assertEquals(metaelem.find_by_attribute("foo2", "bar2"), 1)
|
|
|
105 |
self.assertEquals(metaelem.find_by_attribute("qwerty", ""), -1)
|
|
|
106 |
|
|
|
107 |
def test_clone_meta(self):
|
|
|
108 |
prop1 = model.ConfmlMetaProperty("foo", 123)
|
|
|
109 |
prop2 = model.ConfmlMetaProperty("bar", 312)
|
|
|
110 |
prop3 = model.ConfmlMetaProperty("test", 'testing string')
|
|
|
111 |
metaelem1 = model.ConfmlMeta([prop1, prop2, prop3])
|
|
|
112 |
metaelem2 = metaelem1.clone()
|
|
|
113 |
self.assertEquals(metaelem1, metaelem2)
|
|
|
114 |
|
|
3
|
115 |
def test_meta_set_property_by_tag(self):
|
|
|
116 |
meta = model.ConfmlMeta()
|
|
|
117 |
meta.set_property_by_tag('test', 'fooval')
|
|
|
118 |
self.assertEquals(meta.get('test'), 'fooval')
|
|
|
119 |
self.assertEquals(meta.get_property_by_tag('test').attrs, {})
|
|
|
120 |
meta.set_property_by_tag('test', 'newval')
|
|
|
121 |
self.assertEquals(meta.get_property_by_tag('test').attrs, {})
|
|
|
122 |
self.assertEquals(meta.get('test'), 'newval')
|
|
|
123 |
meta.add('test', 'twoval')
|
|
|
124 |
self.assertEquals(meta.get_property_by_tag('test').attrs, {})
|
|
|
125 |
self.assertEquals(meta.get('test'), 'newval')
|
|
|
126 |
meta.set_property_by_tag('test', 'trheval')
|
|
|
127 |
self.assertEquals(meta.get('test'), 'trheval')
|
|
|
128 |
|
|
0
|
129 |
class TestConfmlDescription(unittest.TestCase):
|
|
|
130 |
def test_create_desc(self):
|
|
|
131 |
descelem1 = model.ConfmlDescription("testing")
|
|
|
132 |
descelem2 = model.ConfmlDescription()
|
|
|
133 |
descelem3 = model.ConfmlDescription()
|
|
|
134 |
descelem3.text = "changed"
|
|
|
135 |
self.assertEquals(descelem1.text, "testing")
|
|
|
136 |
self.assertEquals(descelem2.text, "")
|
|
|
137 |
self.assertEquals(descelem3.text, "changed")
|
|
|
138 |
|
|
|
139 |
def test_clone_desc(self):
|
|
|
140 |
descelem1 = model.ConfmlDescription("testing")
|
|
|
141 |
descelem2 = descelem1._clone()
|
|
|
142 |
self.assertEquals(descelem1.text, descelem2.text)
|
|
|
143 |
|
|
|
144 |
class TestConfmlGroup(unittest.TestCase):
|
|
|
145 |
def test_create_group(self):
|
|
|
146 |
group1 = model.ConfmlGroup("foo")
|
|
|
147 |
self.assertEquals(group1.ref, "foo")
|
|
|
148 |
self.assertEquals(group1.icon, None)
|
|
|
149 |
self.assertEquals(group1.desc, None)
|
|
|
150 |
|
|
|
151 |
def test_group_access_icon(self):
|
|
|
152 |
group1 = model.ConfmlGroup("foo", icon='first/icon.bmp')
|
|
|
153 |
self.assertEquals(group1.icon, "first/icon.bmp")
|
|
|
154 |
group1.icon = 'foo/bar.jpg'
|
|
|
155 |
self.assertEquals(group1.icon, "foo/bar.jpg")
|
|
|
156 |
del group1.icon
|
|
|
157 |
self.assertEquals(group1.icon, None)
|
|
|
158 |
|
|
|
159 |
def test_group_access_description(self):
|
|
|
160 |
group1 = model.ConfmlGroup("foo", desc='Testing description. for this something!')
|
|
|
161 |
self.assertEquals(group1.desc, "Testing description. for this something!")
|
|
|
162 |
group1.desc = 'Something else'
|
|
|
163 |
self.assertEquals(group1.desc, "Something else")
|
|
|
164 |
del group1.desc
|
|
|
165 |
self.assertEquals(group1.icon, None)
|
|
|
166 |
|
|
|
167 |
def test_clone_group(self):
|
|
|
168 |
group1 = model.ConfmlGroup("foo")
|
|
|
169 |
group2 = group1._clone()
|
|
|
170 |
self.assertEquals(group1.ref, group2.ref)
|
|
|
171 |
self.assertEquals(group1.desc, group2.desc)
|
|
|
172 |
self.assertEquals(group1.icon, group2.icon)
|
|
|
173 |
|
|
|
174 |
group1 = model.ConfmlGroup("foo", desc='testing desc', icon='link.bmp')
|
|
|
175 |
group2 = group1._clone(recursion=True)
|
|
|
176 |
self.assertEquals(group1.ref, group2.ref)
|
|
|
177 |
self.assertEquals(group1.desc, group2.desc)
|
|
|
178 |
self.assertEquals(group1.icon, group2.icon)
|
|
|
179 |
|
|
|
180 |
|
|
|
181 |
class TestConfmlSetting(unittest.TestCase):
|
|
|
182 |
def test_create_setting(self):
|
|
|
183 |
elem = model.ConfmlSetting('test')
|
|
|
184 |
self.assertTrue(elem)
|
|
|
185 |
self.assertEquals(elem.desc, None)
|
|
|
186 |
self.assertEquals(elem.readOnly, None)
|
|
|
187 |
self.assertEquals(elem.constraint, None)
|
|
|
188 |
self.assertEquals(elem.required, None)
|
|
|
189 |
self.assertEquals(elem.relevant, None)
|
|
3
|
190 |
self.assertEquals(elem.id, None)
|
|
|
191 |
|
|
|
192 |
def test_setting_id(self):
|
|
|
193 |
elem = model.ConfmlSetting('foo', id="test id")
|
|
|
194 |
self.assertEquals(elem.id,'test id')
|
|
|
195 |
elem.id = "new id"
|
|
|
196 |
self.assertEquals(elem.id,'new id')
|
|
|
197 |
del elem.id
|
|
|
198 |
self.assertEquals(elem.id,None)
|
|
0
|
199 |
|
|
|
200 |
def test_getters(self):
|
|
3
|
201 |
elem = model.ConfmlSetting('foo', name="foo")
|
|
|
202 |
self.assertEquals(elem.get_ref(),'foo')
|
|
0
|
203 |
self.assertEquals(elem.get_type(),None)
|
|
3
|
204 |
self.assertEquals(elem.get_name(),'foo')
|
|
0
|
205 |
|
|
|
206 |
def test_set_type(self):
|
|
3
|
207 |
elem = model.ConfmlSetting('foo', name="bar")
|
|
0
|
208 |
elem.type = 'string'
|
|
3
|
209 |
self.assertEquals(elem.ref,'foo')
|
|
|
210 |
self.assertEquals(elem.type,'string')
|
|
|
211 |
self.assertEquals(elem.name, "bar")
|
|
0
|
212 |
|
|
|
213 |
def test_setting_with_options(self):
|
|
|
214 |
elem = model.ConfmlSetting('foo',type='selection')
|
|
|
215 |
elem.create_option('foo','1')
|
|
|
216 |
elem.create_option('bar','bar')
|
|
|
217 |
elem.create_option('hou','sut')
|
|
|
218 |
self.assertTrue('1' in elem.get_valueset())
|
|
|
219 |
self.assertEquals(elem.options['1'].name, 'foo')
|
|
|
220 |
self.assertEquals(elem.options['1'].value, '1')
|
|
|
221 |
self.assertEquals(elem.options['bar'].name, 'bar')
|
|
|
222 |
|
|
3
|
223 |
def test_create_options(self):
|
|
|
224 |
elem = model.ConfmlSetting('foo',type='property', name='foo')
|
|
|
225 |
self.assertEquals(elem.name, 'foo')
|
|
|
226 |
self.assertEquals(elem.type, 'property')
|
|
|
227 |
|
|
0
|
228 |
def test_setting_create_with_nonetype(self):
|
|
|
229 |
elem = model.ConfmlSetting('foo',type=None)
|
|
|
230 |
self.assertEqual(elem.type,None)
|
|
|
231 |
|
|
|
232 |
def test_setting_with_properties(self):
|
|
|
233 |
elem = model.ConfmlSetting('foo')
|
|
3
|
234 |
elem.create_property(name='foo',value='bar/foo')
|
|
|
235 |
elem.create_property(name='bar',value='only/bar')
|
|
|
236 |
elem.create_property(name='testing',value='1', unit='mB')
|
|
0
|
237 |
self.assertEquals(elem.list_properties(), ['foo','bar','testing'])
|
|
|
238 |
self.assertEquals(elem.get_property('foo').value, 'bar/foo')
|
|
|
239 |
elem.remove_property('foo')
|
|
|
240 |
try:
|
|
|
241 |
elem.remove_property('bss')
|
|
|
242 |
self.fail('removing invalid succeeds')
|
|
|
243 |
except exceptions.NotFound:
|
|
|
244 |
pass
|
|
|
245 |
self.assertEquals(elem.list_properties(), ['bar','testing'])
|
|
|
246 |
for property_name in elem.list_properties():
|
|
|
247 |
elem.remove_property(property_name)
|
|
|
248 |
self.assertEquals(elem.list_properties(), [])
|
|
|
249 |
|
|
|
250 |
|
|
|
251 |
def test_setting_with_properties_property(self):
|
|
|
252 |
elem = model.ConfmlSetting('foo')
|
|
3
|
253 |
elem.create_property(name='foo',value='bar/foo')
|
|
|
254 |
elem.create_property(name='bar',value='only/bar')
|
|
|
255 |
elem.create_property(name='testing',value='1', unit='mB')
|
|
|
256 |
self.assertEquals(elem.property_foo.value,'bar/foo')
|
|
|
257 |
self.assertEquals(elem.property_bar.value,'only/bar')
|
|
0
|
258 |
|
|
|
259 |
def test_setting_with_readOnly_value(self):
|
|
|
260 |
elem = model.ConfmlSetting('foo', readOnly=True)
|
|
|
261 |
self.assertEquals(elem.readOnly,True)
|
|
|
262 |
elem.readOnly = False
|
|
|
263 |
self.assertEquals(elem.readOnly,False)
|
|
|
264 |
|
|
|
265 |
def test_setting_with_constaint(self):
|
|
|
266 |
elem = model.ConfmlSetting('foo', constraint=". > '1'")
|
|
|
267 |
self.assertEquals(elem.constraint,". > '1'")
|
|
|
268 |
elem.constraint = 'foobar'
|
|
|
269 |
self.assertEquals(elem.constraint,"foobar")
|
|
|
270 |
|
|
|
271 |
def test_setting_with_required_value(self):
|
|
|
272 |
elem = model.ConfmlSetting('foo', required=False)
|
|
|
273 |
self.assertEquals(elem.required,False)
|
|
|
274 |
elem = model.ConfmlSetting('foo', required=True)
|
|
|
275 |
self.assertEquals(elem.required,True)
|
|
|
276 |
elem.required = False
|
|
|
277 |
self.assertEquals(elem.required,False)
|
|
|
278 |
|
|
|
279 |
def test_setting_with_relevant_value(self):
|
|
|
280 |
elem = model.ConfmlSetting('foo', relevant='ffoo oss')
|
|
|
281 |
self.assertEquals(elem.relevant,'ffoo oss')
|
|
|
282 |
elem.relevant = ''
|
|
|
283 |
self.assertEquals(elem.relevant,'')
|
|
|
284 |
|
|
|
285 |
def test_setting_with_max_length(self):
|
|
|
286 |
elem = model.ConfmlSetting('foo', maxLength=10)
|
|
|
287 |
self.assertEquals(elem.maxLength,10)
|
|
|
288 |
elem.maxLength = 20
|
|
|
289 |
self.assertEquals(elem.maxLength,20)
|
|
|
290 |
self.assertTrue(elem._has(model.ConfmlMaxLength.refname))
|
|
|
291 |
|
|
|
292 |
def test_setting_with_min_length(self):
|
|
|
293 |
elem = model.ConfmlSetting('foo', minLength=10)
|
|
|
294 |
self.assertEquals(elem.minLength,10)
|
|
|
295 |
elem.minLength = 20
|
|
|
296 |
self.assertEquals(elem.minLength,20)
|
|
|
297 |
self.assertTrue(elem._has(model.ConfmlMinLength.refname))
|
|
3
|
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)
|
|
0
|
306 |
|
|
|
307 |
def test_setting_rfs_casting(self):
|
|
|
308 |
elem = model.ConfmlSetting('foo', minLength=10)
|
|
|
309 |
self.assertEquals(elem.get_rfs_cast('true'),True)
|
|
|
310 |
self.assertEquals(elem.get_rfs_cast('false'),False)
|
|
|
311 |
self.assertEquals(elem.set_rfs_cast(True),'true')
|
|
|
312 |
self.assertEquals(elem.set_rfs_cast(False),'false')
|
|
|
313 |
self.assertEquals(elem.set_rfs_cast(1),'true')
|
|
3
|
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')])
|
|
0
|
363 |
|
|
|
364 |
class TestConfmlSelectionSetting(unittest.TestCase):
|
|
|
365 |
def test_create_selection_setting(self):
|
|
3
|
366 |
elem = model.ConfmlSelectionSetting('foo', desc="Test desc", name="Foo fea")
|
|
0
|
367 |
self.assertTrue(elem)
|
|
|
368 |
self.assertEquals(elem.type, 'selection')
|
|
3
|
369 |
self.assertEquals(elem.name, 'Foo fea')
|
|
|
370 |
self.assertEquals(elem.desc, "Test desc")
|
|
0
|
371 |
self.assertEquals(elem.readOnly, None)
|
|
|
372 |
self.assertEquals(elem.constraint, None)
|
|
|
373 |
self.assertEquals(elem.required, None)
|
|
|
374 |
self.assertEquals(elem.relevant, None)
|
|
|
375 |
|
|
|
376 |
def test_selection_valueset(self):
|
|
|
377 |
elem = model.ConfmlSelectionSetting('foo')
|
|
|
378 |
self.assertEquals(elem.type, 'selection')
|
|
|
379 |
elem.create_option('foo', '1')
|
|
|
380 |
elem.create_option('bar', '2')
|
|
|
381 |
elem.create_option('baz', '3')
|
|
|
382 |
self.assertEquals(elem.get_valueset(), api.ValueSet(['1', '2', '3']))
|
|
|
383 |
|
|
|
384 |
class TestConfmlMultiSelectionSetting(unittest.TestCase):
|
|
|
385 |
def test_create_multiselection_setting(self):
|
|
3
|
386 |
elem = model.ConfmlMultiSelectionSetting('mset1', name="Setting 1", desc="de")
|
|
0
|
387 |
self.assertTrue(elem)
|
|
|
388 |
self.assertEquals(elem.type, 'multiSelection')
|
|
3
|
389 |
self.assertEquals(elem.name, "Setting 1")
|
|
|
390 |
self.assertEquals(elem.desc, "de")
|
|
0
|
391 |
self.assertEquals(elem.readOnly, None)
|
|
|
392 |
self.assertEquals(elem.constraint, None)
|
|
|
393 |
self.assertEquals(elem.required, None)
|
|
|
394 |
self.assertEquals(elem.relevant, None)
|
|
|
395 |
|
|
|
396 |
def test_multiselection_valueset(self):
|
|
|
397 |
elem = model.ConfmlMultiSelectionSetting('foo')
|
|
|
398 |
self.assertEquals(elem.type, 'multiSelection')
|
|
|
399 |
elem.create_option('foo', '1')
|
|
|
400 |
elem.create_option('bar', '2')
|
|
|
401 |
elem.create_option('baz', '3')
|
|
|
402 |
self.assertEquals(elem.get_valueset(), api.ValueSet(['1', '2', '3']))
|
|
|
403 |
|
|
|
404 |
def test_setting_value_to_multiselection(self):
|
|
|
405 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
406 |
elem = model.ConfmlMultiSelectionSetting('mset2', type='multiSelection')
|
|
|
407 |
conf.add_feature(elem)
|
|
3
|
408 |
elem.value = ["sel1", "sel2"]
|
|
0
|
409 |
self.assertEquals(elem.type, 'multiSelection')
|
|
3
|
410 |
self.assertEquals(elem.get_value(), ("sel1", "sel2"))
|
|
0
|
411 |
|
|
|
412 |
def test_setting_value_to_multiselection2(self):
|
|
|
413 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
414 |
elem = model.ConfmlMultiSelectionSetting('mset3', type='multiSelection')
|
|
|
415 |
conf.add_feature(elem)
|
|
3
|
416 |
elem.value = ["sel1", "sel2 with some spaces"]
|
|
0
|
417 |
self.assertEquals(elem.type, 'multiSelection')
|
|
3
|
418 |
self.assertEquals(elem.get_value(), ("sel1", "sel2 with some spaces"))
|
|
0
|
419 |
elem.value = ["sel1", "sel2 with some spaces"]
|
|
3
|
420 |
self.assertEquals(elem.get_value(), ("sel1", "sel2 with some spaces"))
|
|
0
|
421 |
|
|
|
422 |
def test_setting_not_list_value_to_multiselection(self):
|
|
|
423 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
424 |
elem = model.ConfmlMultiSelectionSetting('mset4', type='multiSelection')
|
|
|
425 |
conf.add_feature(elem)
|
|
|
426 |
self.assertRaises(ValueError, elem.set_value, "not list")
|
|
|
427 |
|
|
|
428 |
def test_setting_list_value_to_multiselection(self):
|
|
|
429 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
430 |
elem = model.ConfmlMultiSelectionSetting('mset5', type='multiSelection')
|
|
|
431 |
conf.add_feature(elem)
|
|
|
432 |
elem.set_value(["li1", "li2"])
|
|
3
|
433 |
self.assertEquals(elem.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)
|
|
0
|
546 |
|
|
|
547 |
class TestConfmlIntSetting(unittest.TestCase):
|
|
|
548 |
def test_create_setting(self):
|
|
|
549 |
elem = model.ConfmlIntSetting('test')
|
|
|
550 |
self.assertTrue(elem)
|
|
|
551 |
self.assertEquals(elem.type, 'int')
|
|
|
552 |
self.assertEquals(elem.desc, None)
|
|
|
553 |
self.assertEquals(elem.readOnly, None)
|
|
|
554 |
self.assertEquals(elem.constraint, None)
|
|
|
555 |
self.assertEquals(elem.required, None)
|
|
|
556 |
self.assertEquals(elem.relevant, None)
|
|
3
|
557 |
self.assertEquals(elem.get_valueset().fromvalue, 0)
|
|
|
558 |
self.assertEquals(elem.get_valueset().tovalue, sys.maxint)
|
|
0
|
559 |
|
|
|
560 |
def test_setting_value_to_int(self):
|
|
|
561 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
562 |
elem = model.ConfmlIntSetting('foo', type='int')
|
|
|
563 |
conf.add_feature(elem)
|
|
|
564 |
elem.value = 1
|
|
|
565 |
self.assertEquals(elem.value,1)
|
|
|
566 |
self.assertEquals(elem.get_original_value(),'1')
|
|
|
567 |
self.assertEquals(elem.get_data().get_value(),'1')
|
|
|
568 |
|
|
|
569 |
def test_setting_value_with_incompatible_values(self):
|
|
|
570 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
571 |
elem = model.ConfmlIntSetting('foo')
|
|
|
572 |
conf.add_feature(elem)
|
|
|
573 |
try:
|
|
|
574 |
elem.value = 'hh'
|
|
|
575 |
self.fail('setting string to int succeeds')
|
|
|
576 |
except ValueError:
|
|
|
577 |
pass
|
|
|
578 |
elem.value = '1234'
|
|
|
579 |
self.assertEquals(elem.value, 1234)
|
|
|
580 |
elem.value = 0xA
|
|
|
581 |
self.assertEquals(elem.value, 10)
|
|
|
582 |
del elem.value
|
|
|
583 |
self.assertEquals(elem.value, None)
|
|
|
584 |
|
|
3
|
585 |
def test_setting_value_to_int_with_aritmethic_operations(self):
|
|
0
|
586 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
587 |
elem1 = model.ConfmlIntSetting('foo')
|
|
|
588 |
elem2 = model.ConfmlIntSetting('bar')
|
|
|
589 |
conf.add_feature(elem1)
|
|
|
590 |
conf.add_feature(elem2)
|
|
|
591 |
elem1.value = 1
|
|
|
592 |
elem2.value = 2
|
|
|
593 |
test = elem1.value + elem2.value
|
|
|
594 |
self.assertEquals(test,3)
|
|
|
595 |
elem1.value = elem1.value + elem2.value + 5
|
|
|
596 |
self.assertEquals(elem1.value,8)
|
|
|
597 |
|
|
3
|
598 |
class TestConfmlHexBinarySetting(unittest.TestCase):
|
|
|
599 |
def test_hexbinary_default_value_set(self):
|
|
|
600 |
setting = model.ConfmlHexBinarySetting('test')
|
|
|
601 |
vset = setting.get_valueset()
|
|
|
602 |
self.assertTrue('' in vset)
|
|
|
603 |
self.assertTrue('0123456789ABCDEF' in vset)
|
|
|
604 |
self.assertTrue('00112233445566778899AABBCCDDEEFF' in vset)
|
|
|
605 |
|
|
|
606 |
self.assertFalse('foobar' in vset)
|
|
|
607 |
self.assertFalse('1' in vset)
|
|
|
608 |
self.assertFalse('F' in vset)
|
|
|
609 |
self.assertFalse('1G' in vset)
|
|
|
610 |
self.assertFalse('0123456789abcdef' in vset)
|
|
|
611 |
self.assertFalse('00112233445566778899aabbccddeeff' in vset)
|
|
|
612 |
|
|
|
613 |
self.assertTrue('foobar' not in vset)
|
|
|
614 |
|
|
|
615 |
def test_hexbinary_get_value_none(self):
|
|
|
616 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
617 |
setting = model.ConfmlHexBinarySetting('foo')
|
|
|
618 |
conf.add_feature(setting)
|
|
|
619 |
self.assertEquals(setting.value, None)
|
|
|
620 |
|
|
|
621 |
def test_hexbinary_get_value_empty(self):
|
|
|
622 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
623 |
setting = model.ConfmlHexBinarySetting('foo')
|
|
|
624 |
conf.add_feature(setting)
|
|
|
625 |
conf.add_data(api.Data(ref='foo', value=None))
|
|
|
626 |
self.assertEquals(setting.value, '')
|
|
|
627 |
|
|
|
628 |
def test_hexbinary_get_value(self):
|
|
|
629 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
630 |
setting = model.ConfmlHexBinarySetting('foo')
|
|
|
631 |
conf.add_feature(setting)
|
|
|
632 |
conf.add_data(api.Data(ref='foo', value='0123456789ABCDEF'))
|
|
|
633 |
self.assertEquals(setting.value, '\x01\x23\x45\x67\x89\xab\xcd\xef')
|
|
|
634 |
self.assertEquals(setting.get_original_value(), '0123456789ABCDEF')
|
|
|
635 |
|
|
|
636 |
def test_hexbinary_set_value(self):
|
|
|
637 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
638 |
setting = model.ConfmlHexBinarySetting('foo')
|
|
|
639 |
conf.add_feature(setting)
|
|
|
640 |
|
|
|
641 |
setting.value = '\x01\xab'
|
|
|
642 |
self.assertEquals(setting.value, '\x01\xab')
|
|
|
643 |
|
|
|
644 |
data_list = conf.get_all_datas()
|
|
|
645 |
self.assertEquals(len(data_list), 1)
|
|
|
646 |
d = data_list[0]
|
|
|
647 |
self.assertEquals(d.attr, 'data')
|
|
|
648 |
self.assertEquals(d.fqr, 'foo')
|
|
|
649 |
self.assertEquals(d.value, '01AB')
|
|
|
650 |
self.assertEquals(d.empty, False)
|
|
|
651 |
|
|
|
652 |
def test_hexbinary_get_data_cast(self):
|
|
|
653 |
setting = model.ConfmlHexBinarySetting('foo')
|
|
|
654 |
|
|
|
655 |
self.assertEquals(setting.get_data_cast(''), '')
|
|
|
656 |
self.assertEquals(setting.get_data_cast(None), '')
|
|
|
657 |
self.assertEquals(setting.get_data_cast('0123456789ABCDEF'), '\x01\x23\x45\x67\x89\xab\xcd\xef')
|
|
|
658 |
|
|
|
659 |
self.assertRaises(ValueError, setting.get_data_cast, 'X')
|
|
|
660 |
self.assertRaises(ValueError, setting.get_data_cast, '1')
|
|
|
661 |
self.assertRaises(ValueError, setting.get_data_cast, 'XX')
|
|
|
662 |
|
|
|
663 |
def test_hexbinary_set_data_cast(self):
|
|
|
664 |
setting = model.ConfmlHexBinarySetting('foo')
|
|
|
665 |
|
|
|
666 |
self.assertEquals(setting.set_data_cast(''), '')
|
|
|
667 |
self.assertEquals(setting.set_data_cast('\x01'), '01')
|
|
|
668 |
self.assertEquals(setting.set_data_cast('x'), '78')
|
|
|
669 |
self.assertEquals(setting.set_data_cast('\x01\x23\x45\x67\x89\xab\xcd\xef'), '0123456789ABCDEF')
|
|
|
670 |
|
|
0
|
671 |
class TestConfmlBooleanSetting(unittest.TestCase):
|
|
|
672 |
def test_create_setting(self):
|
|
|
673 |
elem = model.ConfmlBooleanSetting('test')
|
|
|
674 |
self.assertTrue(elem)
|
|
|
675 |
self.assertEquals(elem.type, 'boolean')
|
|
|
676 |
self.assertEquals(elem.desc, None)
|
|
|
677 |
self.assertEquals(elem.readOnly, None)
|
|
|
678 |
self.assertEquals(elem.constraint, None)
|
|
|
679 |
self.assertEquals(elem.required, None)
|
|
|
680 |
self.assertEquals(elem.relevant, None)
|
|
|
681 |
|
|
|
682 |
def test_setting_value_to_int(self):
|
|
|
683 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
684 |
elem = model.ConfmlBooleanSetting('foo', type='int')
|
|
|
685 |
self.assertEquals(elem.type, 'boolean')
|
|
|
686 |
conf.add_feature(elem)
|
|
|
687 |
elem.value = 1
|
|
|
688 |
# Set elem rfs value
|
|
|
689 |
elem.set_value(True, 'rfs')
|
|
|
690 |
self.assertEquals(elem.get_value('rfs'),True)
|
|
|
691 |
self.assertEquals(elem.get_original_value('rfs'),'true')
|
|
|
692 |
self.assertEquals(elem.value,1)
|
|
|
693 |
self.assertEquals(elem.get_original_value(),'true')
|
|
|
694 |
self.assertEquals(elem.get_data().get_value(),'true')
|
|
|
695 |
|
|
|
696 |
def test_setting_value_with_incompatible_values(self):
|
|
|
697 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
698 |
elem = model.ConfmlBooleanSetting('foo')
|
|
|
699 |
conf.add_feature(elem)
|
|
|
700 |
elem.value = '1234'
|
|
|
701 |
self.assertEquals(elem.value, True)
|
|
|
702 |
elem.value = 0xA
|
|
|
703 |
self.assertEquals(elem.value, True)
|
|
|
704 |
elem.value = False
|
|
|
705 |
self.assertEquals(elem.value, False)
|
|
|
706 |
elem.value = ''
|
|
|
707 |
self.assertEquals(elem.value, False)
|
|
|
708 |
del elem.value
|
|
|
709 |
self.assertEquals(elem.value, None)
|
|
|
710 |
|
|
|
711 |
def test_setting_value_with_supported_values(self):
|
|
|
712 |
conf = model.ConfmlConfiguration('test.confml')
|
|
|
713 |
elem = model.ConfmlBooleanSetting('foo')
|
|
|
714 |
conf.add_feature(elem)
|
|
|
715 |
elem.value = '1'
|
|
|
716 |
self.assertEquals(elem.value, True)
|
|
|
717 |
elem.value = 'true'
|
|
|
718 |
self.assertEquals(elem.value, True)
|
|
|
719 |
elem.value = True
|
|
|
720 |
self.assertEquals(elem.value, True)
|
|
|
721 |
elem.value = '0'
|
|
|
722 |
self.assertEquals(elem.value, False)
|
|
|
723 |
elem.value = 'false'
|
|
|
724 |
self.assertEquals(elem.value, False)
|
|
|
725 |
elem.value = False
|
|
|
726 |
self.assertEquals(elem.value, False)
|
|
|
727 |
del elem.value
|
|
|
728 |
self.assertEquals(elem.value, None)
|
|
|
729 |
|
|
|
730 |
class TestConfmlSequenceSetting(unittest.TestCase):
|
|
|
731 |
def test_create_setting(self):
|
|
3
|
732 |
elem = model.ConfmlSequenceSetting('test', name="testing fea", desc="Test desc")
|
|
0
|
733 |
self.assertTrue(elem)
|
|
3
|
734 |
self.assertEquals(elem.name, "testing fea")
|
|
|
735 |
self.assertEquals(elem.desc, "Test desc")
|
|
|
736 |
subfea = elem.create_feature("subfea")
|
|
|
737 |
self.assertEquals(subfea.is_sequence(), True)
|
|
|
738 |
subfea.is_sequence = lambda : False
|
|
|
739 |
self.assertEquals(subfea.is_sequence(), False)
|
|
|
740 |
|
|
|
741 |
def test_create_sequence_setting_with_mapping(self):
|
|
|
742 |
elem = model.ConfmlSequenceSetting('test', name="testing fea", desc="Test desc", mapKey="setting", mapValue="setval")
|
|
|
743 |
self.assertTrue(elem)
|
|
|
744 |
self.assertEquals(elem.name, "testing fea")
|
|
|
745 |
self.assertEquals(elem.desc, "Test desc")
|
|
|
746 |
self.assertEquals(elem.mapKey, "setting")
|
|
|
747 |
self.assertEquals(elem.mapValue, "setval")
|
|
0
|
748 |
|
|
|
749 |
def test_setting_with_properties_property(self):
|
|
|
750 |
elem = model.ConfmlSequenceSetting('foo')
|
|
3
|
751 |
elem.create_property(name='foo',value='bar/foo')
|
|
|
752 |
elem.create_property(name='bar',value='only/bar')
|
|
|
753 |
elem.create_property(name='testing',value='1', unit='mB')
|
|
|
754 |
self.assertEquals(elem.property_foo.value,'bar/foo')
|
|
|
755 |
self.assertEquals(elem.property_bar.value,'only/bar')
|
|
0
|
756 |
|
|
|
757 |
def test_setting_with_min_occurs(self):
|
|
|
758 |
elem = model.ConfmlSequenceSetting('foo', minOccurs=1)
|
|
|
759 |
self.assertEquals(elem.minOccurs,1)
|
|
|
760 |
elem.minOccurs = 2
|
|
|
761 |
self.assertEquals(elem.minOccurs,2)
|
|
|
762 |
|
|
|
763 |
def test_setting_with_max_occurs(self):
|
|
|
764 |
elem = model.ConfmlSequenceSetting('foo', maxOccurs=10)
|
|
|
765 |
self.assertEquals(elem.maxOccurs,10)
|
|
|
766 |
elem.maxOccurs = 20
|
|
|
767 |
self.assertEquals(elem.maxOccurs,20)
|
|
|
768 |
|
|
3
|
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 |
|
|
0
|
777 |
config = api.Configuration('foo.confml')
|
|
3
|
778 |
fea= model.ConfmlSequenceSetting("foo", displayName='TestDisplayName')
|
|
0
|
779 |
fea.add_feature(model.ConfmlIntSetting('child1'))
|
|
|
780 |
fea.add_feature(model.ConfmlBooleanSetting('child2'))
|
|
|
781 |
fea.add_feature(model.ConfmlSetting('child3'))
|
|
|
782 |
config.add_feature(fea)
|
|
|
783 |
dview = config.get_default_view()
|
|
|
784 |
foofea = dview.get_feature('foo')
|
|
|
785 |
# Test adding a data row with array
|
|
3
|
786 |
foofea.set_value([[1,True,'foo'],
|
|
|
787 |
[2,False,'bar'],
|
|
|
788 |
[3,True,'sumthin']
|
|
0
|
789 |
])
|
|
3
|
790 |
|
|
|
791 |
self.assertEquals(foofea.displayName, 'TestDisplayName')
|
|
|
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']
|
|
0
|
798 |
])
|
|
|
799 |
|
|
3
|
800 |
self.assertEquals(foofea.get_original_value(), [['1','true','foo'],
|
|
|
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']
|
|
0
|
813 |
]
|
|
|
814 |
|
|
3
|
815 |
self.assertEquals(foofea.data[0].value,[1,True,'foo'])
|
|
|
816 |
self.assertEquals(foofea.data[1].value,[2,False,'bar'])
|
|
|
817 |
self.assertEquals(foofea.data[1][1].value,False)
|
|
|
818 |
self.assertEquals(foofea.get_value(), [[1,True,'foo'],
|
|
|
819 |
[2,False,'bar']
|
|
0
|
820 |
])
|
|
3
|
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')
|
|
0
|
1178 |
|
|
|
1179 |
class TestConfmlFile(unittest.TestCase):
|
|
|
1180 |
def test_create_localpath_elem(self):
|
|
|
1181 |
elem = model.ConfmlLocalPath()
|
|
|
1182 |
self.assertTrue(elem)
|
|
|
1183 |
self.assertEquals(elem.get_ref(),'localPath')
|
|
|
1184 |
|
|
|
1185 |
def test_create_targetpath_elem(self):
|
|
|
1186 |
elem = model.ConfmlTargetPath()
|
|
|
1187 |
self.assertTrue(elem)
|
|
|
1188 |
self.assertEquals(elem.get_ref(),'targetPath')
|
|
|
1189 |
|
|
|
1190 |
def test_create_file_elem(self):
|
|
|
1191 |
elem = model.ConfmlFileSetting('test')
|
|
|
1192 |
self.assertTrue(elem)
|
|
|
1193 |
self.assertEquals(elem.get_ref(),'test')
|
|
|
1194 |
self.assertEquals(elem.list_features(), ['localPath','targetPath'])
|
|
|
1195 |
self.assertEquals(elem.get_feature('localPath').fqr, 'test.localPath')
|
|
|
1196 |
self.assertEquals(elem.get_feature('targetPath').fqr, 'test.targetPath')
|
|
3
|
1197 |
self.assertEquals(elem.get_feature('localPath').name, 'localPath')
|
|
|
1198 |
self.assertEquals(elem.get_feature('targetPath').name, 'targetPath')
|
|
0
|
1199 |
|
|
|
1200 |
def test_create_file_elem_and_set_value(self):
|
|
|
1201 |
config = api.Configuration('test.confml')
|
|
|
1202 |
elem = model.ConfmlFileSetting('test', localpath='test.txt')
|
|
|
1203 |
config.add_feature(elem)
|
|
|
1204 |
dview = config.get_default_view()
|
|
|
1205 |
self.assertEquals(dview.list_all_features(),['test','test.localPath','test.targetPath'])
|
|
|
1206 |
dview.get_feature('test.localPath').set_value('foo/test.txt')
|
|
|
1207 |
dview.get_feature('test.targetPath').set_value('Z:\\test\test.txt')
|
|
|
1208 |
dview.get_feature('test.localPath').set_value('now/test.txt')
|
|
|
1209 |
self.assertEquals(dview.get_feature('test.localPath').get_value(),'now/test.txt')
|
|
|
1210 |
self.assertEquals(len(dview.get_feature('test.localPath').get_datas()),1)
|
|
|
1211 |
|
|
|
1212 |
def test_clone_file_elem(self):
|
|
|
1213 |
elem1 = model.ConfmlFileSetting('test')
|
|
|
1214 |
elem2 = elem1._clone(recursion=True)
|
|
|
1215 |
|
|
|
1216 |
|
|
3
|
1217 |
def test_create_file_elem_to_a_sequence(self):
|
|
|
1218 |
config = model.ConfmlConfiguration('foo.confml')
|
|
|
1219 |
seq = model.ConfmlSequenceSetting('foo')
|
|
|
1220 |
elem = model.ConfmlFileSetting('test')
|
|
|
1221 |
seq.add_feature(elem)
|
|
|
1222 |
config.add_feature(seq)
|
|
|
1223 |
seq.value = [[['local file', 'targetfile']],
|
|
|
1224 |
[['local file2', 'targetfile2']]]
|
|
|
1225 |
|
|
|
1226 |
self.assertEquals(seq.test.localPath.get_value(), ['local file',
|
|
|
1227 |
'local file2'])
|
|
|
1228 |
|
|
|
1229 |
def test_create_folder_elem_to_a_sequence(self):
|
|
|
1230 |
config = model.ConfmlConfiguration('foo.confml')
|
|
|
1231 |
seq = model.ConfmlSequenceSetting('foo')
|
|
|
1232 |
elem = model.ConfmlFolderSetting('test')
|
|
|
1233 |
seq.add_feature(elem)
|
|
|
1234 |
config.add_feature(seq)
|
|
|
1235 |
seq.value = [[['local file', 'targetfile']],
|
|
|
1236 |
[['local file2', 'targetfile2']]]
|
|
|
1237 |
|
|
|
1238 |
self.assertEquals(seq.test.localPath.get_value(), ['local file',
|
|
|
1239 |
'local file2'])
|
|
|
1240 |
|
|
|
1241 |
|
|
0
|
1242 |
class TestConfmlIcon(unittest.TestCase):
|
|
|
1243 |
def test_create_icon(self):
|
|
|
1244 |
icon = model.ConfmlIcon("test/foo/bar.jpg")
|
|
|
1245 |
self.assertEquals(icon.href, "test/foo/bar.jpg")
|
|
|
1246 |
icon.href = 'new/icon.jpg'
|
|
|
1247 |
self.assertEquals(icon.href, "new/icon.jpg")
|
|
|
1248 |
|
|
|
1249 |
def test_clone_icon(self):
|
|
|
1250 |
icon1 = model.ConfmlIcon("test/foo/bar.jpg")
|
|
|
1251 |
icon2 = icon1._clone()
|
|
|
1252 |
self.assertEquals(icon1.href, icon2.href)
|
|
|
1253 |
|
|
|
1254 |
|
|
|
1255 |
class TestLengths(unittest.TestCase):
|
|
|
1256 |
def test_create_maxLength(self):
|
|
|
1257 |
max = model.ConfmlMaxLength('100')
|
|
3
|
1258 |
self.assertEquals(max.value, 100)
|
|
|
1259 |
max.value = 10
|
|
|
1260 |
self.assertEquals(max.value, 10)
|
|
|
1261 |
max.value = '1000'
|
|
|
1262 |
self.assertEquals(max.value, 1000)
|
|
|
1263 |
|
|
0
|
1264 |
def test_create_minLength(self):
|
|
|
1265 |
min = model.ConfmlMinLength('100')
|
|
3
|
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)
|
|
0
|
1279 |
|
|
|
1280 |
class TestConfmlFacets(unittest.TestCase):
|
|
3
|
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 |
|
|
0
|
1297 |
def test_create_inclusive(self):
|
|
|
1298 |
min = model.ConfmlMinInclusive('-10')
|
|
|
1299 |
max = model.ConfmlMaxInclusive('10')
|
|
3
|
1300 |
self.assertEquals(min.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)
|
|
0
|
1310 |
|
|
|
1311 |
def test_create_exclusive(self):
|
|
|
1312 |
min = model.ConfmlMinExclusive('0')
|
|
|
1313 |
max = model.ConfmlMaxExclusive("9")
|
|
3
|
1314 |
self.assertEquals(min.value, 0)
|
|
|
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)
|
|
0
|
1324 |
|
|
|
1325 |
def test_create_pattern(self):
|
|
|
1326 |
pattern = model.ConfmlPattern("[a-zA-Z]")
|
|
|
1327 |
self.assertEquals(pattern.value, "[a-zA-Z]")
|
|
|
1328 |
|
|
|
1329 |
def test_create_totalDigits(self):
|
|
|
1330 |
digits = model.ConfmlTotalDigits("3")
|
|
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)
|
|
0
|
1336 |
|
|
|
1337 |
class TestConfmlConfiguration(unittest.TestCase):
|
|
|
1338 |
def test_create_configuration(self):
|
|
|
1339 |
config = model.ConfmlConfiguration("test/foo/bar.jpg")
|
|
|
1340 |
self.assertEquals(config.meta, None)
|
|
|
1341 |
self.assertEquals(config.desc, None)
|
|
|
1342 |
self.assertEquals(config.name, 'test__foo__bar_jpg')
|
|
|
1343 |
self.assertEquals(config.ref, 'test__foo__bar_jpg')
|
|
|
1344 |
self.assertEquals(config.path, 'test/foo/bar.jpg')
|
|
|
1345 |
|
|
3
|
1346 |
def test_create_configuration_and_features(self):
|
|
|
1347 |
conf = model.ConfmlConfiguration("simple.confml")
|
|
|
1348 |
fea = conf.create_feature("test")
|
|
|
1349 |
self.assertTrue(isinstance(fea, model.ConfmlFeature))
|
|
|
1350 |
self.assertEquals(conf.get_feature('test'), fea)
|
|
|
1351 |
fea = conf.create_feature("test1", name="test name")
|
|
|
1352 |
self.assertEquals(conf.get_feature('test1').name, 'test name')
|
|
|
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'])
|
|
0
|
1364 |
|
|
|
1365 |
def test_configuration_access_desc(self):
|
|
|
1366 |
config = model.ConfmlConfiguration("test/foo/bar.jpg", desc="testing description")
|
|
|
1367 |
self.assertEquals(config.desc, "testing description")
|
|
|
1368 |
config.desc = 'new desc'
|
|
|
1369 |
self.assertEquals(config.desc, "new desc")
|
|
|
1370 |
del config.desc
|
|
|
1371 |
self.assertEquals(config.desc, None)
|
|
|
1372 |
|
|
3
|
1373 |
def test_use_create_configuration(self):
|
|
|
1374 |
config = model.ConfmlConfiguration("test/foo/bar.jpg")
|
|
|
1375 |
subconfig = config.create_configuration("sub/jee.confml")
|
|
|
1376 |
self.assertEquals(subconfig.get_full_path(),'test/foo/sub/jee.confml')
|
|
|
1377 |
self.assertTrue(isinstance(subconfig,model.ConfmlConfiguration))
|
|
|
1378 |
|
|
|
1379 |
class TestConfmlView(unittest.TestCase):
|
|
|
1380 |
def test_create_view(self):
|
|
|
1381 |
view = model.ConfmlView("test", id="test")
|
|
|
1382 |
self.assertTrue(view)
|
|
|
1383 |
self.assertEquals(view.get_ref(),'test')
|
|
|
1384 |
self.assertEquals(view.id,"test")
|
|
|
1385 |
|
|
|
1386 |
def test_create_view_with_create_view(self):
|
|
|
1387 |
config = model.ConfmlConfiguration("test")
|
|
|
1388 |
view = config.create_view("test")
|
|
|
1389 |
group = view.create_group("group1")
|
|
|
1390 |
fl = group.create_featurelink("intset1")
|
|
|
1391 |
self.assertTrue(isinstance(view, model.ConfmlView))
|
|
|
1392 |
self.assertTrue(isinstance(group, model.ConfmlGroup))
|
|
|
1393 |
self.assertTrue(isinstance(fl, model.ConfmlFeatureLink))
|
|
|
1394 |
|
|
|
1395 |
def test_create_confml_featurelink(self):
|
|
|
1396 |
fealink = model.ConfmlFeatureLink("test")
|
|
|
1397 |
self.assertTrue(fealink)
|
|
|
1398 |
self.assertEquals(fealink.get_ref(),'link_test')
|
|
|
1399 |
|
|
|
1400 |
def test_create_confml_featurelink_with_overrides(self):
|
|
|
1401 |
fealink = model.ConfmlFeatureLink("test")
|
|
|
1402 |
fealink.desc = "test desc"
|
|
|
1403 |
self.assertEquals(fealink.desc,'test desc')
|
|
|
1404 |
self.assertEquals(fealink._has('_desc'),True)
|
|
|
1405 |
self.assertEquals(fealink.get_attributes(),{'properties': {},'options': {}, 'desc' : 'test desc'})
|
|
|
1406 |
|
|
|
1407 |
def test_create_confml_featurelink_with_option_overrides(self):
|
|
|
1408 |
fealink = model.ConfmlFeatureLink("test")
|
|
|
1409 |
fealink.add(api.Option('opt2', '2'))
|
|
|
1410 |
self.assertEquals(fealink.options['2'].name,'opt2')
|
|
|
1411 |
|
|
|
1412 |
def test_create_view_with_groups(self):
|
|
|
1413 |
view = model.ConfmlView("test")
|
|
|
1414 |
view.create_group("group1")
|
|
|
1415 |
view.create_group("group2")
|
|
|
1416 |
self.assertEquals(view.list_groups(),['group1','group2'])
|
|
|
1417 |
|
|
|
1418 |
def test_create_configuration_with_featurelinks(self):
|
|
|
1419 |
config = model.ConfmlConfiguration("test")
|
|
|
1420 |
config.add_feature(model.ConfmlFeature("fea1", name="Feature 1"))
|
|
|
1421 |
intset1 = model.ConfmlIntSetting("intset1", name="Setting 1")
|
|
|
1422 |
intset1.desc = "int setting desc"
|
|
|
1423 |
config.add_feature(intset1, "fea1")
|
|
|
1424 |
|
|
|
1425 |
view = config.create_view("test")
|
|
|
1426 |
group = view.create_group("group1")
|
|
|
1427 |
fl = group.create_featurelink("intset1")
|
|
|
1428 |
self.assertTrue(isinstance(fl, model.ConfmlFeatureLink))
|
|
|
1429 |
self.assertTrue(len(config.get_default_view().get_features('**')), 2)
|
|
|
1430 |
|
|
|
1431 |
|
|
|
1432 |
def test_create_configuration_with_view_and_featurelink_overrides(self):
|
|
|
1433 |
config = model.ConfmlConfiguration("test")
|
|
|
1434 |
config.add_feature(model.ConfmlFeature("fea1", name="Feature 1"))
|
|
|
1435 |
intset1 = model.ConfmlIntSetting("intset1", name="Setting 1")
|
|
|
1436 |
intset1.desc = "int setting desc"
|
|
|
1437 |
config.add_feature(intset1, "fea1")
|
|
|
1438 |
|
|
|
1439 |
view = config.create_view("test")
|
|
|
1440 |
view.create_group("group1")
|
|
|
1441 |
fl = model.ConfmlFeatureLink("fea1.intset1", name="override name")
|
|
|
1442 |
fl.desc = "override desc"
|
|
|
1443 |
fl.minLength = 2
|
|
|
1444 |
fl.maxLength = 10
|
|
|
1445 |
fl.minOccurs = 2
|
|
|
1446 |
fl.maxOccurs = 10
|
|
|
1447 |
|
|
|
1448 |
fl.pattern = '^.*@.*$'
|
|
|
1449 |
fl.totalDigits = 10
|
|
|
1450 |
fl.minInclusive = 0
|
|
|
1451 |
fl.maxInclusive = 10
|
|
|
1452 |
fl.minExclusive = 0
|
|
|
1453 |
fl.maxExclusive = 10
|
|
|
1454 |
|
|
|
1455 |
fl.add(api.Option('opt1', '1'))
|
|
|
1456 |
|
|
|
1457 |
view.get_group('group1').add(fl)
|
|
|
1458 |
view.populate()
|
|
|
1459 |
self.assertEquals(view.list_all_features(),['group1.proxy_fea1_intset1'])
|
|
|
1460 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').desc, "override desc")
|
|
|
1461 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').name, "override name")
|
|
|
1462 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').minLength, 2)
|
|
|
1463 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').maxLength, 10)
|
|
|
1464 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').minOccurs, 2)
|
|
|
1465 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').maxOccurs, 10)
|
|
|
1466 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').pattern, '^.*@.*$')
|
|
|
1467 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').totalDigits, 10)
|
|
|
1468 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').minInclusive, 0)
|
|
|
1469 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').maxInclusive, 10)
|
|
|
1470 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').minExclusive, 0)
|
|
|
1471 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').maxExclusive, 10)
|
|
|
1472 |
self.assertEquals(view.get_feature('group1.proxy_fea1_intset1').options['1'].name,'opt1')
|
|
5
|
1473 |
|
|
|
1474 |
class TestConfmlExtensions(unittest.TestCase):
|
|
|
1475 |
def test_create_extensions(self):
|
|
|
1476 |
extensionselem = model.ConfmlExtensions()
|
|
|
1477 |
self.assertEquals(str(extensionselem),"ConfmlExtensions({'ref': '_extensions'})")
|
|
|
1478 |
|
|
3
|
1479 |
if __name__ == '__main__':
|
|
|
1480 |
unittest.main()
|