Package elisa :: Package core :: Package tests :: Module test_view
[hide private]
[frames] | no frames]

Source Code for Module elisa.core.tests.test_view

  1  # Elisa - Home multimedia server 
  2  # Copyright (C) 2006-2008 Fluendo Embedded S.L. (www.fluendo.com). 
  3  # All rights reserved. 
  4  # 
  5  # This file is available under one of two license agreements. 
  6  # 
  7  # This file is licensed under the GPL version 3. 
  8  # See "LICENSE.GPL" in the root of this distribution including a special 
  9  # exception to use Elisa with Fluendo's plugins. 
 10  # 
 11  # The GPL part of Elisa is also available under a commercial licensing 
 12  # agreement from Fluendo. 
 13  # See "LICENSE.Elisa" in the root directory of this distribution package 
 14  # for details on that license. 
 15   
 16  from elisa.core.tests.elisa_test_case import ElisaTestCase 
 17  from elisa.core import plugin, config 
 18  from elisa.core.frontend import Frontend 
 19  from elisa.base_components.model import Model 
 20  from elisa.base_components.controller import Controller 
 21  from elisa.base_components.view import View 
 22  from elisa.base_components.view import ControllerNotSupported 
 23   
24 -class FooModel(Model):
25 - def __init__(self):
26 Model.__init__(self) 27 self.path = "base_test:foo_model"
28
29 -class BarModel(Model):
30 - def __init__(self):
31 Model.__init__(self) 32 self.path = "base_test:bar_model"
33
34 -class FooController(Controller):
35 36 supported_models = ("base_test:foo_model",) 37
38 - def __init__(self):
39 Controller.__init__(self) 40 self.path = "base_test:foo_controller"
41
42 -class BarController(Controller):
43 44 supported_models = ("base_test:bar_model",) 45
46 - def __init__(self):
47 Controller.__init__(self) 48 self.path = "base_test:bar_controller"
49
50 -class FooView(View):
51 52 supported_controllers = ("base_test:foo_controller",) 53 bindings = {"controller_child1": "view_child1", 54 "controller_child2": ["view_child2", "view_child3"]} 55
56 - def __init__(self):
57 View.__init__(self) 58 self.reset()
59
60 - def reset(self):
61 self.old_controller = False 62 self.new_controller = False 63 self.old_frontend = False 64 self.new_frontend = False
65
66 - def controller_changed(self, old_controller, new_controller):
67 self.old_controller = old_controller 68 self.new_controller = new_controller
69
70 - def frontend_changed(self, old_frontend, new_frontend):
71 self.old_frontend = old_frontend 72 self.new_frontend = new_frontend
73
74 -class BarView(FooView):
75 76 supported_controllers = ("base_test:bar_controller",)
77
78 -class BaseTest(plugin.Plugin):
79 components = {'foo_model': {'path': FooModel}, 80 'bar_model': {'path': BarModel}, 81 'foo_controller': {'path': FooController}, 82 'bar_controller': {'path': BarController}, 83 'foo_view': {'path': FooView}, 84 'bar_view': {'path': BarView},}
85 86 MAPPINGS="""\ 87 [base_test:bar_model] 88 supported_controllers = ['base_test:bar_controller',] 89 controller = 'base_test:bar_controller' 90 supported_views = ['base_test:bar_view'] 91 view = 'base_test:bar_view' 92 """ 93 94
95 -class TestView(ElisaTestCase):
96
97 - def setUp(self):
98 ElisaTestCase.setUp(self) 99 100 from elisa.core import common 101 plugin_registry = common.application.plugin_registry 102 plugin_registry.register_plugin(BaseTest) 103 104 self._foo = FooView() 105 self._foo.initialize() 106 self._bar = BarView() 107 self._bar.initialize()
108
109 - def test_frontend_changed(self):
110 # no frontend assigned 111 self.failUnlessEqual(self._foo.frontend, None) 112 113 cfg = config.Config('no_file', MAPPINGS) 114 frontend = Frontend(cfg) 115 116 # gives a frontend to foo 117 self._foo.frontend = frontend 118 self.failUnlessEqual(self._foo.frontend, frontend) 119 self.failUnlessEqual(self._foo.old_frontend, None) 120 self.failUnlessEqual(self._foo.new_frontend, frontend) 121 122 # ... or None 123 self._foo.reset() 124 self._foo.frontend = None 125 self.failUnlessEqual(self._foo.frontend, None) 126 self.failUnlessEqual(self._foo.old_frontend, frontend) 127 self.failUnlessEqual(self._foo.new_frontend, None) 128 129 # ... or again a real frontend 130 self._foo.reset() 131 self._foo.frontend = frontend 132 self.failUnlessEqual(self._foo.frontend, frontend) 133 self.failUnlessEqual(self._foo.old_frontend, None) 134 self.failUnlessEqual(self._foo.new_frontend, frontend) 135 136 # ... twice the same 137 self._foo.reset() 138 self._foo.frontend = frontend 139 self.failUnlessEqual(self._foo.frontend, frontend) 140 self.failUnlessEqual(self._foo.old_frontend, False) 141 self.failUnlessEqual(self._foo.new_frontend, False)
142
144 # no frontend assigned 145 self.failUnlessEqual(self._foo.frontend, None) 146 self.failUnlessEqual(self._bar.frontend, None) 147 148 frontend = Frontend() 149 150 # gives a frontend to foo 151 self._foo.frontend = frontend 152 self.failUnlessEqual(self._foo.frontend, frontend) 153 self.failUnlessEqual(self._foo.old_frontend, None) 154 self.failUnlessEqual(self._foo.new_frontend, frontend) 155 156 # frontend must be passed to view's children 157 # ... whether it is a real frontend 158 self._bar.parent = self._foo 159 self.failUnlessEqual(self._bar.frontend, frontend) 160 self.failUnlessEqual(self._bar.old_frontend, None) 161 self.failUnlessEqual(self._bar.new_frontend, frontend) 162 163 # ... or None 164 self._foo.reset() 165 self._bar.reset() 166 self._foo.frontend = None 167 self.failUnlessEqual(self._foo.frontend, None) 168 self.failUnlessEqual(self._foo.old_frontend, frontend) 169 self.failUnlessEqual(self._foo.new_frontend, None) 170 self.failUnlessEqual(self._bar.frontend, None) 171 self.failUnlessEqual(self._bar.old_frontend, frontend) 172 self.failUnlessEqual(self._bar.new_frontend, None) 173 174 # ... or again a real frontend 175 self._foo.reset() 176 self._bar.reset() 177 self._foo.frontend = frontend 178 self.failUnlessEqual(self._foo.frontend, frontend) 179 self.failUnlessEqual(self._foo.old_frontend, None) 180 self.failUnlessEqual(self._foo.new_frontend, frontend) 181 self.failUnlessEqual(self._bar.frontend, frontend) 182 self.failUnlessEqual(self._bar.old_frontend, None) 183 self.failUnlessEqual(self._bar.new_frontend, frontend) 184 185 # ... twice the same 186 self._foo.reset() 187 self._bar.reset() 188 self._foo.frontend = frontend 189 self.failUnlessEqual(self._foo.frontend, frontend) 190 self.failUnlessEqual(self._foo.old_frontend, False) 191 self.failUnlessEqual(self._foo.new_frontend, False) 192 self.failUnlessEqual(self._bar.frontend, frontend) 193 self.failUnlessEqual(self._bar.old_frontend, False) 194 self.failUnlessEqual(self._bar.new_frontend, False) 195 196 197 # changing the frontend of a view which has a parent 198 # with a different frontend is impossible 199 def set_frontend(view, frontend): 200 view.frontend = frontend
201 202 self._foo.reset() 203 self._bar.reset() 204 self.failUnlessRaises(Exception, reset_frontend, self._bar, Frontend()) 205 self.failUnlessRaises(Exception, reset_frontend, self._bar, None) 206 207 # ... and nothing should change 208 self.failUnlessEqual(self._foo.frontend, frontend) 209 self.failUnlessEqual(self._foo.old_frontend, False) 210 self.failUnlessEqual(self._foo.new_frontend, False) 211 self.failUnlessEqual(self._bar.frontend, frontend) 212 self.failUnlessEqual(self._bar.old_frontend, False) 213 self.failUnlessEqual(self._bar.new_frontend, False)
214 215 test_frontend_inheritance.skip = "should be implemented for bound views" 216 217
218 - def test_controller_changed(self):
219 # tests with a supported controller 220 controller = FooController() 221 self._foo.controller = controller 222 self.failUnlessEqual(self._foo.controller, controller) 223 self.failUnlessEqual(self._foo.old_controller, None) 224 self.failUnlessEqual(self._foo.new_controller, controller) 225 226 # re-assigning the same controller should not do anything 227 self._foo.reset() 228 self._foo.controller = controller 229 self.failUnlessEqual(self._foo.controller, controller) 230 self.failUnlessEqual(self._foo.old_controller, False) 231 self.failUnlessEqual(self._foo.new_controller, False) 232 233 # assigning a different controller 234 self._foo.reset() 235 controller2 = FooController() 236 self._foo.controller = controller2 237 self.failUnlessEqual(self._foo.controller, controller2) 238 self.failUnlessEqual(self._foo.old_controller, controller) 239 self.failUnlessEqual(self._foo.new_controller, controller2) 240 241 # disconnecting the controller 242 self._foo.reset() 243 self._foo.controller = None 244 self.failUnlessEqual(self._foo.controller, None) 245 self.failUnlessEqual(self._foo.old_controller, controller2) 246 self.failUnlessEqual(self._foo.new_controller, None) 247 248 249 # assigning a non supported controller 250 self._foo.reset() 251 252 def set_controller(view, controller): 253 view.controller = controller
254 255 controller = BarController() 256 self.failUnlessRaises(ControllerNotSupported, set_controller, self._foo, controller) 257 self.failUnlessEqual(self._foo.controller, None) 258 self.failUnlessEqual(self._foo.old_controller, False) 259 self.failUnlessEqual(self._foo.new_controller, False) 260 261 # TODO: good candidate for generic testing of custom Views
262 - def test_supported_controllers(self):
263 self.assertEquals(type(self._foo.supported_controllers), tuple) 264 for s in self._foo.supported_controllers: 265 self.assertEquals(type(s), str) 266 267 def set_controller(view, controller): 268 view.controller = controller
269 270 # assigning a supported controller should work 271 controller = FooController() 272 set_controller(self._foo, controller) 273 274 # assigning a non supported controller should raise an exception 275 controller = BarController() 276 self.failUnlessRaises(ControllerNotSupported, set_controller, self._foo, controller) 277 278
279 - def test_bindings_controller_set_first(self):
280 cfg = config.Config('no_file', MAPPINGS) 281 frontend = Frontend(cfg) 282 self._foo.frontend = frontend 283 284 # connect a supported controller itself connected to a model 285 controller = FooController() 286 controller.initialize() 287 model = FooModel() 288 controller.model = model 289 self._foo.controller = controller 290 291 # adding bound attributes to the controller 292 # ... a controller 293 child_controller = BarController() 294 child_controller.initialize() 295 child_controller.model = BarModel() 296 297 controller.controller_child1 = child_controller 298 self.failUnless(isinstance(self._foo.view_child1, 299 BarView)) 300 301 # FIXME: this is unfortunately not so easy; there is no notification 302 # of attribute removal in the Observable/Observer protocol defined in 303 # Elisa. However, this is not a very common use case. 304 """ 305 delattr(controller, "controller_child1") 306 self.failUnlessRaises(AttributeError, getattr, self._foo, 307 "view_child1") 308 """ 309 310 # ... an object which is not a controller 311 value = 123 312 controller.controller_child1 = value 313 self.failUnlessEqual(self._foo.view_child1, value) 314 315 controller.controller_child1 = "test" 316 self.failUnlessEqual(self._foo.view_child1, "test") 317 318 # ... or even None 319 controller.controller_child1 = None 320 self.failUnlessEqual(self._foo.view_child1, None)
321 322
323 - def test_bindings_not_bound_attributes(self):
324 cfg = config.Config('no_file', MAPPINGS) 325 frontend = Frontend(cfg) 326 self._foo.frontend = frontend 327 328 # connect a supported controller 329 controller = FooController() 330 self._foo.controller = controller 331 332 # adding not bound attributes to the controller 333 # remove them 334 controller.not_bound1 = 123 335 controller.not_bound2 = BarController() 336 337 self.failUnlessRaises(AttributeError, getattr, self._foo, 338 "view_child1") 339 self.failUnlessRaises(AttributeError, getattr, self._foo, 340 "view_child2") 341 self.failUnlessRaises(AttributeError, getattr, self._foo, 342 "view_child3")
343
344 - def test_bindings_controller_set_after(self):
345 cfg = config.Config('no_file', MAPPINGS) 346 frontend = Frontend(cfg) 347 self._foo.frontend = frontend 348 349 # create a supported controller but does not connect it with the view 350 # yet 351 controller = FooController() 352 controller.initialize() 353 model = FooModel() 354 controller.model = model 355 356 # adding bound attributes to the controller 357 # ... a controller 358 child_controller = BarController() 359 child_controller.initialize() 360 child_controller.model = BarModel() 361 362 controller.controller_child1 = child_controller 363 self.failUnlessRaises(AttributeError, getattr, self._foo, 364 "view_child1") 365 # connect the controller 366 self._foo.controller = controller 367 self.failUnless(isinstance(self._foo.view_child1, 368 BarView)) 369 370 371 # disconnect the controller 372 self._foo.controller = None 373 self.failUnlessRaises(AttributeError, getattr, self._foo, 374 "view_child1") 375 376 377 # ... an object which is not a controller 378 controller.controller_child1 = "test" 379 self.failUnlessRaises(AttributeError, getattr, self._foo, 380 "view_child1") 381 382 # connect the controller 383 self._foo.controller = controller 384 self.failUnlessEqual(self._foo.view_child1, "test")
385 386 387
388 - def test_bindings_without_frontend(self):
389 # connect a supported controller itself connected to a model 390 controller = FooController() 391 controller.initialize() 392 model = FooModel() 393 controller.model = model 394 self._foo.controller = controller 395 396 # without a frontend adding a child controller should fail 397 self.failUnlessRaises(Exception, setattr, controller, "controller_child1", 398 BarController()) 399 400 # it should work as usual for everything else 401 # ... an object which is not a controller 402 value = 123 403 controller.controller_child1 = value 404 self.failUnlessEqual(self._foo.view_child1, value) 405 406 controller.controller_child1 = "test" 407 self.failUnlessEqual(self._foo.view_child1, "test") 408 409 # ... or even None 410 controller.controller_child1 = None 411 self.failUnlessEqual(self._foo.view_child1, None)
412 413
414 - def test_multiple_bindings(self):
415 cfg = config.Config('no_file', MAPPINGS) 416 frontend = Frontend(cfg) 417 self._foo.frontend = frontend 418 419 # connect a supported controller 420 controller = FooController() 421 self._foo.controller = controller 422 423 # adding bound attributes to the controller 424 # ... a controller 425 child_controller = BarController() 426 child_controller.initialize() 427 child_controller.model = BarModel() 428 429 controller.controller_child2 = child_controller 430 self.failUnless(isinstance(self._foo.view_child2, 431 BarView)) 432 self.failUnless(isinstance(self._foo.view_child3, 433 BarView)) 434 435 436 # disconnect the controller 437 self._foo.controller = None 438 self.failUnlessRaises(AttributeError, getattr, self._foo, 439 "view_child2") 440 self.failUnlessRaises(AttributeError, getattr, self._foo, 441 "view_child3")
442