|
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 |
|
|
|
18 |
"""
|
|
|
19 |
Test the CPF root file parsing routines
|
|
|
20 |
"""
|
|
|
21 |
|
|
|
22 |
import zipfile
|
|
|
23 |
import unittest
|
|
|
24 |
import string
|
|
|
25 |
import sys,os,re
|
|
|
26 |
|
|
|
27 |
from cone.public import utils, container, exceptions
|
|
|
28 |
|
|
|
29 |
ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
|
|
|
30 |
importpk = os.path.join(ROOT_PATH,"Import.pk")
|
|
|
31 |
|
|
|
32 |
|
|
|
33 |
class TestC(object):
|
|
|
34 |
def __init__(self, path=""):
|
|
|
35 |
self.path = path
|
|
|
36 |
def test(self):
|
|
|
37 |
return "test string"
|
|
|
38 |
class TestB(object):
|
|
|
39 |
def __init__(self, path=""):
|
|
|
40 |
self.path = path
|
|
|
41 |
def test(self):
|
|
|
42 |
return "test string"
|
|
|
43 |
|
|
|
44 |
|
|
|
45 |
class TestDataContainer(unittest.TestCase):
|
|
|
46 |
def setUp(self):
|
|
|
47 |
pass
|
|
|
48 |
|
|
|
49 |
def test_add_values_and_get_values(self):
|
|
|
50 |
cont = container.DataContainer()
|
|
|
51 |
cont.add_value('test/ff',123)
|
|
|
52 |
cont.add_value('test/ff','test')
|
|
|
53 |
self.assertEquals(cont.get_value('test/ff'),'test')
|
|
|
54 |
self.assertEquals(cont.get_values('test/ff')[0],123)
|
|
|
55 |
self.assertEquals(cont.get_values('test/ff')[1],'test')
|
|
|
56 |
|
|
|
57 |
def test_add_values_and_list_values(self):
|
|
|
58 |
cont = container.DataContainer()
|
|
|
59 |
cont.add_value('test/ff',123)
|
|
|
60 |
cont.add_value('test/ff','test')
|
|
|
61 |
cont.add_value('test/foo','test')
|
|
|
62 |
keys = cont.list_keys()
|
|
|
63 |
self.assertEquals(len(keys),2)
|
|
|
64 |
|
|
|
65 |
def test_add_values_and_remove_one_value(self):
|
|
|
66 |
cont = container.DataContainer()
|
|
|
67 |
cont.add_value('test/ff',123)
|
|
|
68 |
cont.add_value('test/ff','test')
|
|
|
69 |
cont.add_value('test/foo','test')
|
|
|
70 |
cont.add_value('test/foo','123')
|
|
|
71 |
cont.add_value('sss',123)
|
|
|
72 |
cont.remove_value('test/foo','test')
|
|
|
73 |
self.assertEquals(cont.get_values('test/foo'),['123'])
|
|
|
74 |
|
|
|
75 |
def test_add_values_and_remove_all_values_of_a_key(self):
|
|
|
76 |
cont = container.DataContainer()
|
|
|
77 |
cont.add_value('test/ff',123)
|
|
|
78 |
cont.add_value('test/ff','test')
|
|
|
79 |
cont.add_value('test/foo','test')
|
|
|
80 |
cont.add_value('test/foo','123')
|
|
|
81 |
cont.add_value('test/foo','foobar')
|
|
|
82 |
cont.add_value('sss',123)
|
|
|
83 |
for val in cont.get_values('test/foo'):
|
|
|
84 |
cont.remove_value('test/foo',val)
|
|
|
85 |
self.assertEquals(cont.get_values('test/foo'),[])
|
|
|
86 |
|
|
|
87 |
def test_add_values_and_remove_key(self):
|
|
|
88 |
cont = container.DataContainer()
|
|
|
89 |
cont.add_value('test/ff',123)
|
|
|
90 |
cont.add_value('test/ff','test')
|
|
|
91 |
cont.add_value('test/foo','test')
|
|
|
92 |
cont.add_value('test/foo','123')
|
|
|
93 |
cont.add_value('test/foo','foobar')
|
|
|
94 |
cont.add_value('sss',123)
|
|
|
95 |
cont.remove_key('test/foo')
|
|
|
96 |
self.assertEquals(cont.list_keys(),['test/ff','sss'])
|
|
|
97 |
|
|
|
98 |
def test_add_values_clear_all_data(self):
|
|
|
99 |
cont = container.DataContainer()
|
|
|
100 |
cont.add_value('test/ff',123)
|
|
|
101 |
cont.add_value('test/ff','test')
|
|
|
102 |
cont.add_value('test/foo','test')
|
|
|
103 |
cont.add_value('test/foo','123')
|
|
|
104 |
cont.clear()
|
|
|
105 |
self.assertEquals(len(cont.list_keys()),0)
|
|
|
106 |
|
|
|
107 |
def test_conatainer_flatten(self):
|
|
|
108 |
data = container.DataContainer()
|
|
|
109 |
data.add_value('test', 1)
|
|
|
110 |
data.add_value('test', 2)
|
|
|
111 |
data.add_value('test', 3)
|
|
|
112 |
data.add_value('foo', 1)
|
|
|
113 |
data.add_value('foo', 2)
|
|
|
114 |
data.add_value('bar', 3)
|
|
|
115 |
self.assertEquals(data.flatten(),{'test': 3, 'foo' : 2,'bar': 3})
|
|
|
116 |
|
|
|
117 |
|
|
|
118 |
|
|
|
119 |
class TestObjectProxy(unittest.TestCase):
|
|
|
120 |
def test_create_object_proxy_for_test(self):
|
|
|
121 |
cont = container.ObjectProxy(TestC("foo"))
|
|
|
122 |
self.assertTrue(cont)
|
|
|
123 |
self.assertEquals(cont.test(),"test string")
|
|
|
124 |
|
|
|
125 |
def test_create_none_proxy(self):
|
|
|
126 |
cont = container.ObjectProxy("")
|
|
|
127 |
self.assertTrue(cont)
|
|
|
128 |
try:
|
|
|
129 |
cont.test()
|
|
|
130 |
self.fail("calling None succeeds?")
|
|
|
131 |
except AttributeError:
|
|
|
132 |
pass
|
|
|
133 |
|
|
|
134 |
def test_create_object_proxy_for_string(self):
|
|
|
135 |
cont = container.ObjectProxy("test string")
|
|
|
136 |
self.assertTrue(cont)
|
|
|
137 |
self.assertEquals(cont.startswith("test"),True)
|
|
|
138 |
|
|
|
139 |
|
|
3
|
140 |
def graph(obj, filters=None):
|
|
0
|
141 |
if obj._parent:
|
|
|
142 |
return ["%s -> %s" % (obj._parent._name, obj._name)]
|
|
|
143 |
return []
|
|
|
144 |
|
|
|
145 |
class TestObjectContainer(unittest.TestCase):
|
|
|
146 |
def test_create_object_container(self):
|
|
|
147 |
cont = container.ObjectContainer("test")
|
|
|
148 |
self.assertTrue(cont)
|
|
|
149 |
|
|
|
150 |
def test_add_incorrect_type(self):
|
|
|
151 |
cont = container.ObjectContainer()
|
|
|
152 |
try:
|
|
3
|
153 |
cont._add(container.DataContainer())
|
|
0
|
154 |
self.fail("Adding incorrect class type to container succeeds?")
|
|
|
155 |
except exceptions.IncorrectClassError,e:
|
|
|
156 |
pass
|
|
|
157 |
|
|
|
158 |
|
|
|
159 |
def test_add_child(self):
|
|
|
160 |
cont = container.ObjectContainer("root")
|
|
|
161 |
obj = container.ObjectContainer("test")
|
|
|
162 |
cont._add(obj)
|
|
|
163 |
cont._add(container.ObjectContainer("foo"))
|
|
|
164 |
self.assertEquals(cont._list(),['test','foo'])
|
|
|
165 |
self.assertEquals(cont.test,obj)
|
|
3
|
166 |
|
|
|
167 |
def test_add_children_from_list_with_different_policies(self):
|
|
|
168 |
def check(policy, expected):
|
|
|
169 |
cont = container.ObjectContainer("root")
|
|
|
170 |
cont._add(container.ObjectContainer("test1"))
|
|
|
171 |
cont._add(container.ObjectContainer("foo"))
|
|
|
172 |
cont._add(container.ObjectContainer("test2"))
|
|
|
173 |
|
|
|
174 |
objs = [container.ObjectContainer("foo"),
|
|
|
175 |
container.ObjectContainer("foo"),
|
|
|
176 |
container.ObjectContainer("foo")]
|
|
|
177 |
for i, obj in enumerate(objs): obj.test_attr = i
|
|
|
178 |
|
|
|
179 |
cont._add(objs, policy)
|
|
|
180 |
|
|
|
181 |
actual = [(o._name, getattr(o, 'test_attr', None)) for o in cont._objects()]
|
|
|
182 |
self.assertEquals(actual, expected)
|
|
|
183 |
|
|
|
184 |
check(container.REPLACE,
|
|
|
185 |
[('test1', None),
|
|
|
186 |
('foo', 0),
|
|
|
187 |
('foo', 1),
|
|
|
188 |
('foo', 2),
|
|
|
189 |
('test2', None),])
|
|
|
190 |
|
|
|
191 |
check(container.APPEND,
|
|
|
192 |
[('test1', None),
|
|
|
193 |
('foo', None),
|
|
|
194 |
('foo', 0),
|
|
|
195 |
('foo', 1),
|
|
|
196 |
('foo', 2),
|
|
|
197 |
('test2', None),])
|
|
|
198 |
|
|
|
199 |
check(container.PREPEND,
|
|
|
200 |
[('test1', None),
|
|
|
201 |
('foo', 0),
|
|
|
202 |
('foo', 1),
|
|
|
203 |
('foo', 2),
|
|
|
204 |
('foo', None),
|
|
|
205 |
('test2', None),])
|
|
|
206 |
|
|
0
|
207 |
|
|
|
208 |
def test_add_internal_child(self):
|
|
|
209 |
cont = container.ObjectContainer("root")
|
|
|
210 |
obj = container.ObjectContainer("?test")
|
|
|
211 |
cont._add(obj)
|
|
|
212 |
cont._add(container.ObjectContainer("foo"))
|
|
3
|
213 |
cont._add(container.ObjectContainer("bar"))
|
|
|
214 |
self.assertEquals(cont._list(),['foo', 'bar'])
|
|
0
|
215 |
self.assertEquals(cont._get('?test'),obj)
|
|
3
|
216 |
self.assertEquals(cont._list(),['foo', 'bar'])
|
|
|
217 |
cont._remove('?test')
|
|
|
218 |
self.assertRaises(exceptions.NotFound,cont._get,'?test')
|
|
|
219 |
self.assertEquals(cont._list(),['foo','bar'])
|
|
0
|
220 |
|
|
|
221 |
|
|
|
222 |
def test_add_child_to_path(self):
|
|
|
223 |
cont = container.ObjectContainer("test")
|
|
|
224 |
obj = container.ObjectContainer("test")
|
|
|
225 |
cont._add_to_path("com.nokia", obj)
|
|
|
226 |
self.assertEquals(cont._list(),['com'])
|
|
|
227 |
self.assertEquals(cont.com.nokia._list(),['test'])
|
|
|
228 |
self.assertEquals(cont.com.nokia.test,obj)
|
|
|
229 |
|
|
|
230 |
def test_add_child_to_path_and_replace_parent(self):
|
|
|
231 |
cont = container.ObjectContainer("test")
|
|
|
232 |
obj = container.ObjectContainer("test")
|
|
|
233 |
cont._add_to_path("com.nokia", obj)
|
|
|
234 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
235 |
com = container.ObjectContainer("com")
|
|
|
236 |
cont._add(com)
|
|
|
237 |
self.assertEquals(cont._list(),['com'])
|
|
|
238 |
self.assertEquals(cont.com._list(),['nokia','bar'])
|
|
|
239 |
self.assertEquals(cont.com.bar._parent,com)
|
|
|
240 |
self.assertEquals(cont.com.nokia._list(),['test'])
|
|
|
241 |
self.assertEquals(cont.com.nokia.test,obj)
|
|
|
242 |
|
|
|
243 |
def test_append(self):
|
|
|
244 |
cont = container.ObjectContainer("test")
|
|
|
245 |
cont._append(container.ObjectContainer('test'))
|
|
|
246 |
self.assertEquals(len(utils.get_list(cont.test)), 1)
|
|
|
247 |
cont._append(container.ObjectContainer('test'))
|
|
|
248 |
self.assertEquals(len(cont.test), 2)
|
|
|
249 |
|
|
|
250 |
def test_prepend(self):
|
|
|
251 |
cont = container.ObjectContainer("test")
|
|
|
252 |
cont._prepend(container.ObjectContainer('test'))
|
|
|
253 |
self.assertEquals(len(utils.get_list(cont.test)), 1)
|
|
|
254 |
cont._prepend(container.ObjectContainer('test'))
|
|
|
255 |
self.assertEquals(len(cont.test), 2)
|
|
|
256 |
|
|
|
257 |
def test_replace(self):
|
|
|
258 |
cont = container.ObjectContainer("test")
|
|
|
259 |
t1 = container.ObjectContainer('test')
|
|
|
260 |
cont._replace(t1)
|
|
|
261 |
self.assertEquals(cont.test, t1)
|
|
|
262 |
t2 = container.ObjectContainer('test')
|
|
|
263 |
cont._replace(t2)
|
|
|
264 |
self.assertEquals(cont.test, t2)
|
|
|
265 |
|
|
|
266 |
def test_error(self):
|
|
|
267 |
cont = container.ObjectContainer("test")
|
|
|
268 |
t1 = container.ObjectContainer('test')
|
|
|
269 |
cont._error(t1)
|
|
|
270 |
self.assertEquals(cont.test, t1)
|
|
|
271 |
t2 = container.ObjectContainer('test')
|
|
|
272 |
try:
|
|
|
273 |
cont._error(t2)
|
|
|
274 |
self.fail("adding same with error succeeds")
|
|
|
275 |
except exceptions.AlreadyExists, e:
|
|
|
276 |
pass
|
|
|
277 |
|
|
|
278 |
def test_add_child_to_existing_path_with_error(self):
|
|
|
279 |
cont = container.ObjectContainer("test")
|
|
|
280 |
obj = container.ObjectContainer("test")
|
|
|
281 |
cont._add_to_path("com.nokia", obj)
|
|
|
282 |
com = container.ObjectContainer("com")
|
|
|
283 |
try:
|
|
|
284 |
cont._add(com, policy=container.ERROR)
|
|
|
285 |
self.fail("Adding an existing object succeeds with ERROR policy")
|
|
|
286 |
except exceptions.AlreadyExists, e:
|
|
|
287 |
pass
|
|
|
288 |
|
|
3
|
289 |
def test__traverse_depth(self):
|
|
|
290 |
cont = container.ObjectContainer("cont")
|
|
|
291 |
obj1 = container.ObjectContainer("test1")
|
|
|
292 |
obj2 = container.ObjectContainer("test2")
|
|
|
293 |
cont._add_to_path("com.nokia", obj1)
|
|
|
294 |
cont._add_to_path("com.nokia", obj2)
|
|
|
295 |
self.assertEquals(len(cont._traverse()), 4)
|
|
|
296 |
self.assertEquals(len(cont._traverse(depth=1)), 1)
|
|
|
297 |
self.assertEquals(len(cont._traverse(depth=2)), 2)
|
|
|
298 |
self.assertEquals(len(cont._traverse(depth=3)), 4)
|
|
|
299 |
|
|
0
|
300 |
def test_add_child_to_existing_path_append(self):
|
|
|
301 |
cont = container.ObjectContainer("test")
|
|
|
302 |
obj = container.ObjectContainer("test")
|
|
|
303 |
cont._add_to_path("com.nokia", obj)
|
|
|
304 |
cont._add_to_path("com.nokia", container.ObjectContainer("test"), container.APPEND)
|
|
|
305 |
com = container.ObjectContainer("com")
|
|
|
306 |
cont._add(com, policy=container.APPEND)
|
|
|
307 |
self.assertEquals(len(cont._get('com')),2)
|
|
|
308 |
self.assertEquals(cont._get('com')[1],com)
|
|
|
309 |
self.assertEquals(len(cont._objects()),2)
|
|
|
310 |
self.assertEquals(len(cont.com[0].nokia.test),2)
|
|
|
311 |
self.assertEquals(len(cont._get('com[0].nokia.test')),2)
|
|
|
312 |
self.assertEquals([e._name for e in cont._traverse()],['com', 'nokia', 'test', 'test', 'com'])
|
|
|
313 |
|
|
|
314 |
def test_add_child_to_existing_path_append_and_objects(self):
|
|
|
315 |
cont = container.ObjectContainer("test")
|
|
|
316 |
cont._add(container.ObjectContainer("dummy"),container.APPEND)
|
|
|
317 |
cont._add(container.ObjectContainer("child"),container.APPEND)
|
|
|
318 |
cont._add(container.ObjectContainer("child"),container.APPEND)
|
|
|
319 |
cont._add(container.ObjectContainer("child"),container.APPEND)
|
|
|
320 |
self.assertEquals(len(cont._objects()),4)
|
|
|
321 |
cont._remove('child[1]')
|
|
|
322 |
self.assertEquals(len(cont._objects()),3)
|
|
|
323 |
cont._remove('child[0]')
|
|
|
324 |
cont._remove('child[0]')
|
|
|
325 |
self.assertEquals(len(cont._objects()),1)
|
|
|
326 |
|
|
|
327 |
def test_add_child_and_access_via_index(self):
|
|
|
328 |
cont = container.ObjectContainer("test")
|
|
|
329 |
cont._add(container.ObjectContainer("dummy"),container.APPEND)
|
|
|
330 |
d1 = cont._get('dummy')
|
|
|
331 |
d2 = cont._get('dummy[0]')
|
|
|
332 |
self.assertEquals(d1,d2)
|
|
|
333 |
try:
|
|
|
334 |
cont._get('dummy[1]')
|
|
|
335 |
self.fail("getting dummy")
|
|
|
336 |
except exceptions.NotFound:
|
|
|
337 |
pass
|
|
|
338 |
|
|
|
339 |
def test_add_child_to_existing_path_append_and_remove(self):
|
|
|
340 |
cont = container.ObjectContainer("test")
|
|
|
341 |
obj = container.ObjectContainer("test")
|
|
|
342 |
cont._add_to_path("com.nokia", obj)
|
|
|
343 |
com = container.ObjectContainer("com")
|
|
|
344 |
cont._add(com, policy=container.APPEND)
|
|
|
345 |
self.assertEquals(len(cont._get('com')),2)
|
|
|
346 |
self.assertEquals(cont._get('com')[1],com)
|
|
|
347 |
self.assertEquals(cont._list(),['com'])
|
|
|
348 |
cont._remove('com')
|
|
|
349 |
self.assertEquals(cont._list(), [])
|
|
|
350 |
|
|
|
351 |
def test_add_child_to_existing_path_prepend(self):
|
|
|
352 |
cont = container.ObjectContainer("test")
|
|
|
353 |
obj = container.ObjectContainer("test")
|
|
|
354 |
cont._add_to_path("com.nokia", obj)
|
|
|
355 |
com = container.ObjectContainer("com")
|
|
|
356 |
cont._add(com, policy=container.PREPEND)
|
|
|
357 |
self.assertEquals(len(cont._get('com')),2)
|
|
|
358 |
self.assertEquals(cont._get('com')[0],com)
|
|
|
359 |
|
|
|
360 |
def test_add_child_and_get(self):
|
|
|
361 |
cont = container.ObjectContainer("test")
|
|
|
362 |
obj = container.ObjectContainer("test")
|
|
|
363 |
cont._add_to_path("com.nokia", obj)
|
|
|
364 |
self.assertEquals(cont._get('com.nokia.test'),obj)
|
|
|
365 |
self.assertEquals(cont.com._get('nokia.test'),obj)
|
|
|
366 |
self.assertEquals(cont.com.nokia._get('test'),obj)
|
|
|
367 |
|
|
|
368 |
def test_add_child_and_remove_one(self):
|
|
|
369 |
cont = container.ObjectContainer("test")
|
|
|
370 |
obj = container.ObjectContainer("test")
|
|
|
371 |
cont._add_to_path("com.nokia", obj)
|
|
|
372 |
cont._add_to_path("com.nokia", container.ObjectContainer("foo"))
|
|
|
373 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
374 |
self.assertEquals(len(cont._traverse()),5)
|
|
|
375 |
cont._remove("com.nokia.foo")
|
|
|
376 |
self.assertEquals(len(cont._traverse()),4)
|
|
|
377 |
|
|
|
378 |
def test_add_child_and_remove_all(self):
|
|
|
379 |
cont = container.ObjectContainer("test")
|
|
|
380 |
obj = container.ObjectContainer("test")
|
|
|
381 |
cont._add_to_path("com.nokia", obj)
|
|
|
382 |
cont._add_to_path("com.nokia", container.ObjectContainer("foo"))
|
|
|
383 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
384 |
self.assertEquals(len(cont._traverse()),5)
|
|
|
385 |
for item in cont._list():
|
|
|
386 |
cont._remove(item)
|
|
|
387 |
self.assertEquals(len(cont._list()),0)
|
|
|
388 |
|
|
|
389 |
def test_add_children_and_list_all(self):
|
|
|
390 |
cont = container.ObjectContainer("test")
|
|
|
391 |
obj = TestC()
|
|
|
392 |
cont._add_to_path("com.nokia", container.ObjectContainer("test"))
|
|
|
393 |
cont._add_to_path("com.nokia", container.ObjectContainer("foo"))
|
|
|
394 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
395 |
self.assertEquals(len(cont._traverse()),5)
|
|
|
396 |
|
|
|
397 |
def test_create_hieararchy_and_remove_child(self):
|
|
|
398 |
root = container.ObjectContainer("test")
|
|
|
399 |
root._add(container.ObjectContainer("child1"))
|
|
|
400 |
root._add(container.ObjectContainer("child2"))
|
|
|
401 |
root.child1._add(container.ObjectContainer("child11"))
|
|
|
402 |
root.child1._add(container.ObjectContainer("child12"))
|
|
|
403 |
root.child2._add(container.ObjectContainer("child21"))
|
|
|
404 |
self.assertEquals(root._list_traverse(),
|
|
|
405 |
['child1',
|
|
|
406 |
'child1.child11',
|
|
|
407 |
'child1.child12',
|
|
|
408 |
'child2',
|
|
|
409 |
'child2.child21'])
|
|
|
410 |
root.child2._remove('child21')
|
|
|
411 |
self.assertEquals(root._list_traverse()
|
|
|
412 |
,['child1',
|
|
|
413 |
'child1.child11',
|
|
|
414 |
'child1.child12',
|
|
|
415 |
'child2'])
|
|
|
416 |
|
|
|
417 |
def test_add_children_and_traverse_and_get_path(self):
|
|
|
418 |
cont = container.ObjectContainer("default")
|
|
|
419 |
cont._add_to_path("com.nokia", container.ObjectContainer("test"))
|
|
|
420 |
cont._add_to_path("com.nokia", container.ObjectContainer("foo"))
|
|
|
421 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
422 |
cont.com._list()
|
|
|
423 |
self.assertEquals(cont._traverse()[0]._path(),"default.com")
|
|
|
424 |
self.assertEquals(cont._traverse()[0]._path(cont),"com")
|
|
|
425 |
self.assertEquals(cont._traverse()[0]._path(cont.com),"")
|
|
|
426 |
|
|
|
427 |
def test_add_children_and_traverse_filter_name_and_get_path(self):
|
|
|
428 |
cont = container.ObjectContainer("default")
|
|
|
429 |
cont._add_to_path("com.nokia", container.ObjectContainer("test"))
|
|
|
430 |
cont._add_to_path("com.nokia", container.ObjectContainer("foo"))
|
|
|
431 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
432 |
cont.com._list()
|
|
|
433 |
ret = cont._traverse(name="^t.*$")
|
|
|
434 |
self.assertEquals(len(ret),1)
|
|
|
435 |
self.assertEquals(ret[0]._path(),"default.com.nokia.test")
|
|
|
436 |
|
|
|
437 |
def test_add_children_and_traverse_filter_name_many(self):
|
|
|
438 |
cont = container.ObjectContainer("default")
|
|
|
439 |
cont._add_to_path("com.nokia", container.ObjectContainer("test"))
|
|
|
440 |
cont._add_to_path("com.nokia", container.ObjectContainer("foo"))
|
|
|
441 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
442 |
cont.com._list()
|
|
|
443 |
ret = cont._traverse(path=".*nokia.*")
|
|
|
444 |
self.assertEquals(len(ret),3)
|
|
|
445 |
self.assertEquals(ret[0]._path(),"default.com.nokia")
|
|
|
446 |
|
|
|
447 |
def test_add_children_tail_recurse_with_function(self):
|
|
|
448 |
cont = container.ObjectContainer("default")
|
|
|
449 |
cont._add_to_path("com.nokia", container.ObjectContainer("test"))
|
|
|
450 |
cont._add_to_path("com.nokia", container.ObjectContainer("foo"))
|
|
|
451 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
452 |
ret = cont._tail_recurse(graph)
|
|
|
453 |
self.assertEquals(ret,['default -> com', 'com -> nokia', 'nokia -> test', 'nokia -> foo', 'com -> bar'])
|
|
|
454 |
|
|
|
455 |
def test_add_children_head_recurse_with_function(self):
|
|
|
456 |
cont = container.ObjectContainer("default")
|
|
|
457 |
cont._add_to_path("com.nokia", container.ObjectContainer("test"))
|
|
|
458 |
cont._add_to_path("com.nokia", container.ObjectContainer("foo"))
|
|
|
459 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
460 |
ret = cont._head_recurse(graph)
|
|
|
461 |
self.assertEquals(ret,['nokia -> test', 'nokia -> foo', 'com -> nokia', 'com -> bar', 'default -> com'])
|
|
|
462 |
|
|
|
463 |
def test_add_children_and_find_parent(self):
|
|
|
464 |
cont = container.ObjectContainer("default", container=True)
|
|
|
465 |
cont._add(container.ObjectContainer("com",housut="test"))
|
|
|
466 |
cont._add_to_path("com.nokia", container.ObjectContainer("test"))
|
|
|
467 |
cont._add_to_path("com.nokia", container.ObjectContainer("foo"))
|
|
|
468 |
cont._add_to_path("com", container.ObjectContainer("bar"))
|
|
|
469 |
child = cont._get('com.nokia.test')
|
|
|
470 |
self.assertEquals(child._find_parent()._name, 'nokia')
|
|
|
471 |
self.assertEquals(child._find_parent(container=True)._name, 'default')
|
|
|
472 |
self.assertEquals(child._find_parent(housut="test")._name, 'com')
|
|
|
473 |
self.assertEquals(child._find_parent(__class__=container.ObjectContainer)._name, 'nokia')
|
|
|
474 |
self.assertEquals(child._find_parent(type=container.ObjectContainer)._name, 'nokia')
|
|
|
475 |
|
|
|
476 |
class TestObjectProxyContainer(unittest.TestCase):
|
|
|
477 |
def test_create_object_container_for_test(self):
|
|
|
478 |
cont = container.ObjectProxyContainer(TestC("foo"))
|
|
|
479 |
self.assertTrue(cont)
|
|
|
480 |
self.assertEquals(cont.test(),"test string")
|
|
|
481 |
|
|
|
482 |
def test_create_none_container(self):
|
|
|
483 |
cont = container.ObjectProxyContainer(None)
|
|
|
484 |
self.assertTrue(cont)
|
|
|
485 |
try:
|
|
|
486 |
cont.test()
|
|
|
487 |
self.fail("calling None succeeds?")
|
|
|
488 |
except AttributeError:
|
|
|
489 |
pass
|
|
|
490 |
|
|
|
491 |
def test_create_object_container_for_string(self):
|
|
|
492 |
cont = container.ObjectProxyContainer("Test")
|
|
|
493 |
self.assertTrue(cont)
|
|
|
494 |
self.assertEquals(cont.startswith("Test"),True)
|
|
|
495 |
|
|
|
496 |
def test_create_object_container(self):
|
|
|
497 |
cont = container.ObjectProxyContainer(TestC())
|
|
|
498 |
self.assertTrue(cont)
|
|
|
499 |
|
|
|
500 |
def test_add_child(self):
|
|
|
501 |
cont = container.ObjectProxyContainer(None)
|
|
|
502 |
obj = TestC()
|
|
|
503 |
cont._add(container.ObjectProxyContainer(obj,"test"))
|
|
|
504 |
self.assertEquals(cont._list(),['test'])
|
|
|
505 |
self.assertEquals(cont.test._obj,obj)
|
|
|
506 |
|
|
|
507 |
def test_add_child_to_path(self):
|
|
|
508 |
cont = container.ObjectProxyContainer(None)
|
|
|
509 |
obj = TestC()
|
|
|
510 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))
|
|
|
511 |
self.assertEquals(cont._list(),['com'])
|
|
|
512 |
self.assertEquals(cont.com.nokia._list(),['test'])
|
|
|
513 |
self.assertEquals(cont.com.nokia.test._obj,obj)
|
|
|
514 |
self.assertEquals(cont.com.nokia.test.test(),"test string")
|
|
|
515 |
|
|
|
516 |
def test_add_child_and_get(self):
|
|
|
517 |
cont = container.ObjectProxyContainer(None)
|
|
|
518 |
obj = TestC()
|
|
|
519 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))
|
|
|
520 |
self.assertEquals(cont._get('com.nokia.test')._obj,obj)
|
|
|
521 |
self.assertEquals(cont.com._get('nokia.test')._obj,obj)
|
|
|
522 |
self.assertEquals(cont.com.nokia._get('test')._obj,obj)
|
|
|
523 |
|
|
|
524 |
def test_add_child_and_remove_one(self):
|
|
|
525 |
cont = container.ObjectProxyContainer(None)
|
|
|
526 |
obj = TestC()
|
|
|
527 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))
|
|
|
528 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))
|
|
|
529 |
cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))
|
|
|
530 |
|
|
|
531 |
self.assertEquals(len(cont._traverse()),5)
|
|
|
532 |
cont._remove("com.nokia.foo")
|
|
|
533 |
self.assertEquals(len(cont._traverse()),4)
|
|
|
534 |
|
|
|
535 |
def test_add_child_and_remove_all(self):
|
|
|
536 |
cont = container.ObjectProxyContainer(None)
|
|
|
537 |
obj = TestC()
|
|
|
538 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))
|
|
|
539 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))
|
|
|
540 |
cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))
|
|
|
541 |
self.assertEquals(len(cont._traverse()),5)
|
|
|
542 |
for item in cont._list():
|
|
|
543 |
cont._remove(item)
|
|
|
544 |
self.assertEquals(len(cont._list()),0)
|
|
|
545 |
|
|
|
546 |
def test_add_children_and_list_all(self):
|
|
|
547 |
cont = container.ObjectProxyContainer(None)
|
|
|
548 |
obj = TestC()
|
|
|
549 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))
|
|
|
550 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))
|
|
|
551 |
cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))
|
|
|
552 |
self.assertEquals(len(cont._traverse()),5)
|
|
|
553 |
|
|
|
554 |
def test_add_children_and_traverse_and_get_path(self):
|
|
|
555 |
cont = container.ObjectProxyContainer(None,"default")
|
|
|
556 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))
|
|
|
557 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))
|
|
|
558 |
cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))
|
|
|
559 |
cont.com._list()
|
|
|
560 |
self.assertEquals(cont._traverse()[0]._path(),"default.com")
|
|
|
561 |
|
|
|
562 |
def test_add_children_and_traverse_filter_name_and_get_path(self):
|
|
|
563 |
cont = container.ObjectProxyContainer(None,"default")
|
|
|
564 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))
|
|
|
565 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))
|
|
|
566 |
cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))
|
|
|
567 |
cont.com._list()
|
|
|
568 |
ret = cont._traverse(name="^t.*$")
|
|
|
569 |
self.assertEquals(len(ret),1)
|
|
|
570 |
self.assertEquals(ret[0]._path(),"default.com.nokia.test")
|
|
3
|
571 |
# ret = cont._traverse(type=TestC)
|
|
|
572 |
# self.assertEquals(len(ret),1)
|
|
|
573 |
|
|
0
|
574 |
|
|
|
575 |
def test_add_children_and_traverse_filter_name_many(self):
|
|
|
576 |
cont = container.ObjectProxyContainer(None,"default")
|
|
|
577 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))
|
|
|
578 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))
|
|
|
579 |
cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))
|
|
|
580 |
cont.com._list()
|
|
|
581 |
ret = cont._traverse(path=".*nokia.*")
|
|
|
582 |
self.assertEquals(len(ret),3)
|
|
|
583 |
self.assertEquals(ret[0]._path(),"default.com.nokia")
|
|
|
584 |
|
|
|
585 |
def test_add_children_and_traverse_filter_class(self):
|
|
|
586 |
cont = container.ObjectProxyContainer(None,"default")
|
|
|
587 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))
|
|
|
588 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))
|
|
|
589 |
cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))
|
|
|
590 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestB(),"bee"))
|
|
|
591 |
cont.com.nokia._add(container.ObjectProxyContainer(TestB(),"vee"))
|
|
|
592 |
ret = cont._traverse(filters=[lambda x: hasattr(x,'_obj') and isinstance(x._obj, TestB)])
|
|
|
593 |
self.assertEquals(len(ret),2)
|
|
|
594 |
self.assertEquals(ret[0]._path(cont),"com.nokia.bee")
|
|
|
595 |
self.assertEquals(ret[1]._path(cont),"com.nokia.vee")
|
|
|
596 |
|
|
|
597 |
def test_add_children_and_traverse_filter_class_proxies(self):
|
|
|
598 |
cont = container.ObjectProxyContainer(None,"default")
|
|
|
599 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))
|
|
|
600 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))
|
|
|
601 |
cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))
|
|
|
602 |
cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestB(),"bee"))
|
|
|
603 |
cont.com.nokia._add(container.ObjectProxyContainer(TestB(),"vee"))
|
|
|
604 |
ret = cont._traverse(filters=[lambda x: isinstance(x, container.ObjectProxyContainer)])
|
|
|
605 |
self.assertEquals(len(ret),5)
|
|
|
606 |
self.assertEquals(ret[0]._path(cont),"com.nokia.test")
|
|
|
607 |
self.assertEquals(ret[1]._path(cont),"com.nokia.foo")
|
|
|
608 |
|
|
|
609 |
class TestLoadProxy(unittest.TestCase):
|
|
|
610 |
def test_create_load_proxy(self):
|
|
|
611 |
proxy = container.LoadProxy(importpk, container.LoadInterface())
|
|
|
612 |
proxy._load()
|
|
|
613 |
self.assertTrue(proxy._obj != None)
|
|
|
614 |
|
|
|
615 |
def test_create_load_proxy_and_get(self):
|
|
|
616 |
proxy = container.LoadProxy(importpk, container.LoadInterface())
|
|
|
617 |
self.assertEquals(proxy.list_resources(''),['test1.txt', 'test2.txt', 'test3.txt'])
|
|
|
618 |
self.assertTrue(proxy._obj != None)
|
|
|
619 |
|
|
|
620 |
def test_create_load_proxy_and_unload(self):
|
|
|
621 |
proxy = container.LoadProxy(importpk, container.LoadInterface())
|
|
|
622 |
self.assertEquals(proxy.list_resources(''),['test1.txt', 'test2.txt', 'test3.txt'])
|
|
|
623 |
proxy.set('path',"unload.pk")
|
|
|
624 |
proxy._unload()
|
|
|
625 |
self.assertTrue(proxy._obj == None)
|
|
|
626 |
proxy =None
|
|
|
627 |
proxy2 = container.LoadProxy("unload.pk", container.LoadInterface())
|
|
|
628 |
self.assertEquals(proxy2.list_resources(''),['test1.txt', 'test2.txt', 'test3.txt'])
|
|
|
629 |
os.unlink("unload.pk")
|
|
|
630 |
|
|
3
|
631 |
class TestLoadContainer(unittest.TestCase):
|
|
|
632 |
def test_create_load_container(self):
|
|
|
633 |
cont = container.LoadContainer(importpk, container.LoadInterface())
|
|
|
634 |
cont._load()
|
|
|
635 |
self.assertEquals(len(cont._objects()), 1)
|
|
|
636 |
|
|
|
637 |
def test_create_load_link__unload(self):
|
|
|
638 |
cont = container.LoadContainer(importpk, container.LoadInterface())
|
|
|
639 |
cont._load()
|
|
|
640 |
self.assertEquals(len(cont._objects()), 1)
|
|
|
641 |
cont._unload()
|
|
|
642 |
self.assertEquals(cont._container, None)
|
|
|
643 |
|
|
|
644 |
def test_create_load_link__get_objects(self):
|
|
|
645 |
cont = container.LoadContainer(importpk, container.LoadInterface())
|
|
|
646 |
self.assertEquals(len(cont._objects()), 1)
|
|
|
647 |
|
|
|
648 |
def test_create_load_link__traverse(self):
|
|
|
649 |
cont = container.LoadContainer(importpk, container.LoadInterface())
|
|
|
650 |
self.assertEquals(len(cont._traverse()), 4)
|
|
|
651 |
print cont._traverse()
|
|
|
652 |
|
|
|
653 |
def test_create_load_link__list(self):
|
|
|
654 |
cont = container.LoadContainer(importpk, container.LoadInterface())
|
|
|
655 |
self.assertEquals(os.path.basename(cont._list()[0]), 'Import_pk')
|
|
|
656 |
|
|
|
657 |
class TestLoadContainerWrite(unittest.TestCase):
|
|
|
658 |
def test_create_load_container__add_data(self):
|
|
|
659 |
cont = container.LoadContainer(importpk)
|
|
|
660 |
cont._add(container.ObjectContainer("Test"))
|
|
|
661 |
self.assertEquals(len(cont._objects()), 1)
|
|
|
662 |
|
|
|
663 |
def test_create_load_container__add_data_unload(self):
|
|
|
664 |
cont = container.LoadContainer(importpk)
|
|
|
665 |
cont._add(container.ObjectContainer("Test"))
|
|
|
666 |
self.assertEquals(len(cont._objects()), 1)
|
|
|
667 |
cont._unload()
|
|
|
668 |
|
|
|
669 |
class TestLoadLink(unittest.TestCase):
|
|
|
670 |
def test_create_load_link(self):
|
|
|
671 |
link = container.LoadLink(importpk, container.LoadInterface())
|
|
|
672 |
objs = link._load()
|
|
|
673 |
self.assertEquals(len(objs), 1)
|
|
|
674 |
|
|
|
675 |
def test_create_load_link_and_populate(self):
|
|
|
676 |
cont = container.ObjectContainer("Test")
|
|
|
677 |
link = container.LoadLink(importpk, container.LoadInterface())
|
|
|
678 |
cont._add(link)
|
|
|
679 |
link.populate()
|
|
|
680 |
self.assertEquals(len(cont._objects()), 2)
|
|
|
681 |
|
|
0
|
682 |
if __name__ == '__main__':
|
|
|
683 |
unittest.main()
|
|
|
684 |
|
|
3
|
685 |
|