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

Source Code for Module elisa.core.tests.test_controller

  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.backend import Backend 
 19  from elisa.base_components.model import Model 
 20  from elisa.base_components.controller import Controller 
 21  from elisa.base_components.controller import ModelNotSupported 
 22   
 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 bindings = {"model_child1": "controller_child1", 38 "model_child2": ["controller_child2", "controller_child3"]} 39
40 - def __init__(self):
41 Controller.__init__(self) 42 self.reset()
43
44 - def reset(self):
45 self.old_model = False 46 self.new_model = False 47 self.old_backend = False 48 self.new_backend = False
49
50 - def model_changed(self, old_model, new_model):
51 self.old_model = old_model 52 self.new_model = new_model
53
54 - def backend_changed(self, old_backend, new_backend):
55 self.old_backend = old_backend 56 self.new_backend = new_backend
57
58 -class BarController(FooController):
59 60 supported_models = ("base_test:bar_model",)
61
62 -class BaseTest(plugin.Plugin):
63 components = {'foo_model': {'path': FooModel}, 64 'bar_model': {'path': BarModel}, 65 'foo_controller': {'path': FooController}, 66 'bar_controller': {'path': BarController},}
67 68 MAPPINGS="""\ 69 [base_test:bar_model] 70 supported_controllers = ['base_test:bar_controller',] 71 controller = 'base_test:bar_controller' 72 supported_views = ['base_test:bar_view'] 73 view = 'base_test:bar_view' 74 """ 75 76
77 -class TestController(ElisaTestCase):
78
79 - def setUp(self):
80 ElisaTestCase.setUp(self) 81 82 from elisa.core import common 83 plugin_registry = common.application.plugin_registry 84 plugin_registry.register_plugin(BaseTest) 85 86 self._foo = FooController() 87 self._foo.initialize() 88 self._bar = BarController() 89 self._bar.initialize()
90
91 - def test_backend_changed(self):
92 # no backend assigned 93 self.failUnlessEqual(self._foo.backend, None) 94 95 backend = Backend() 96 97 # gives a backend to foo 98 self._foo.backend = backend 99 self.failUnlessEqual(self._foo.backend, backend) 100 self.failUnlessEqual(self._foo.old_backend, None) 101 self.failUnlessEqual(self._foo.new_backend, backend) 102 103 # ... or None 104 self._foo.reset() 105 self._foo.backend = None 106 self.failUnlessEqual(self._foo.backend, None) 107 self.failUnlessEqual(self._foo.old_backend, backend) 108 self.failUnlessEqual(self._foo.new_backend, None) 109 110 # ... or again a real backend 111 self._foo.reset() 112 self._foo.backend = backend 113 self.failUnlessEqual(self._foo.backend, backend) 114 self.failUnlessEqual(self._foo.old_backend, None) 115 self.failUnlessEqual(self._foo.new_backend, backend) 116 117 # ... twice the same 118 self._foo.reset() 119 self._foo.backend = backend 120 self.failUnlessEqual(self._foo.backend, backend) 121 self.failUnlessEqual(self._foo.old_backend, False) 122 self.failUnlessEqual(self._foo.new_backend, False)
123
124 - def test_backend_inheritance(self):
125 # no backend assigned 126 self.failUnlessEqual(self._foo.backend, None) 127 self.failUnlessEqual(self._bar.backend, None) 128 129 backend = Backend() 130 131 # gives a backend to foo 132 self._foo.backend = backend 133 self.failUnlessEqual(self._foo.backend, backend) 134 self.failUnlessEqual(self._foo.old_backend, None) 135 self.failUnlessEqual(self._foo.new_backend, backend) 136 137 # backend must be passed to controller's children 138 # ... whether it is a real backend 139 self._bar.parent = self._foo 140 self.failUnlessEqual(self._bar.backend, backend) 141 self.failUnlessEqual(self._bar.old_backend, None) 142 self.failUnlessEqual(self._bar.new_backend, backend) 143 144 # ... or None 145 self._foo.reset() 146 self._bar.reset() 147 self._foo.backend = None 148 self.failUnlessEqual(self._foo.backend, None) 149 self.failUnlessEqual(self._foo.old_backend, backend) 150 self.failUnlessEqual(self._foo.new_backend, None) 151 self.failUnlessEqual(self._bar.backend, None) 152 self.failUnlessEqual(self._bar.old_backend, backend) 153 self.failUnlessEqual(self._bar.new_backend, None) 154 155 # ... or again a real backend 156 self._foo.reset() 157 self._bar.reset() 158 self._foo.backend = backend 159 self.failUnlessEqual(self._foo.backend, backend) 160 self.failUnlessEqual(self._foo.old_backend, None) 161 self.failUnlessEqual(self._foo.new_backend, backend) 162 self.failUnlessEqual(self._bar.backend, backend) 163 self.failUnlessEqual(self._bar.old_backend, None) 164 self.failUnlessEqual(self._bar.new_backend, backend) 165 166 # ... twice the same 167 self._foo.reset() 168 self._bar.reset() 169 self._foo.backend = backend 170 self.failUnlessEqual(self._foo.backend, backend) 171 self.failUnlessEqual(self._foo.old_backend, False) 172 self.failUnlessEqual(self._foo.new_backend, False) 173 self.failUnlessEqual(self._bar.backend, backend) 174 self.failUnlessEqual(self._bar.old_backend, False) 175 self.failUnlessEqual(self._bar.new_backend, False) 176 177 178 # changing the backend of a controller which has a parent 179 # with a different backend is impossible 180 def set_backend(controller, backend): 181 controller.backend = backend
182 183 self._foo.reset() 184 self._bar.reset() 185 self.failUnlessRaises(Exception, reset_backend, self._bar, Backend()) 186 self.failUnlessRaises(Exception, reset_backend, self._bar, None) 187 188 # ... and nothing should change 189 self.failUnlessEqual(self._foo.backend, backend) 190 self.failUnlessEqual(self._foo.old_backend, False) 191 self.failUnlessEqual(self._foo.new_backend, False) 192 self.failUnlessEqual(self._bar.backend, backend) 193 self.failUnlessEqual(self._bar.old_backend, False) 194 self.failUnlessEqual(self._bar.new_backend, False)
195 196 test_backend_inheritance.skip = "should be implemented for bound controllers" 197 198
199 - def test_model_changed(self):
200 # tests with a supported model 201 model = FooModel() 202 self._foo.model = model 203 self.failUnlessEqual(self._foo.model, model) 204 self.failUnlessEqual(self._foo.old_model, None) 205 self.failUnlessEqual(self._foo.new_model, model) 206 207 # re-assigning the same model should not do anything 208 self._foo.reset() 209 self._foo.model = model 210 self.failUnlessEqual(self._foo.model, model) 211 self.failUnlessEqual(self._foo.old_model, False) 212 self.failUnlessEqual(self._foo.new_model, False) 213 214 # assigning a different model 215 self._foo.reset() 216 model2 = FooModel() 217 self._foo.model = model2 218 self.failUnlessEqual(self._foo.model, model2) 219 self.failUnlessEqual(self._foo.old_model, model) 220 self.failUnlessEqual(self._foo.new_model, model2) 221 222 # disconnecting the model 223 self._foo.reset() 224 self._foo.model = None 225 self.failUnlessEqual(self._foo.model, None) 226 self.failUnlessEqual(self._foo.old_model, model2) 227 self.failUnlessEqual(self._foo.new_model, None) 228 229 230 # assigning a non supported model 231 self._foo.reset() 232 233 def set_model(controller, model): 234 controller.model = model
235 236 model = BarModel() 237 self.failUnlessRaises(ModelNotSupported, set_model, self._foo, model) 238 self.failUnlessEqual(self._foo.model, None) 239 self.failUnlessEqual(self._foo.old_model, False) 240 self.failUnlessEqual(self._foo.new_model, False) 241 242 # TODO: good candidate for generic testing of custom Controllers
243 - def test_supported_models(self):
244 self.assertEquals(type(self._foo.supported_models), tuple) 245 for s in self._foo.supported_models: 246 self.assertEquals(type(s), str) 247 248 def set_model(controller, model): 249 controller.model = model
250 251 # assigning a supported model should work 252 model = FooModel() 253 set_model(self._foo, model) 254 255 # assigning a non supported model should raise an exception 256 model = BarModel() 257 self.failUnlessRaises(ModelNotSupported, set_model, self._foo, model) 258 259 # TODO: good candidate for generic testing of custom Controllers
260 - def test_handle_input(self):
261 # TODO: should generate random InputEvents, send them to 262 # Controller.handle_input and check that the result is a boolean 263 pass
264 test_handle_input.skip = "not implemented yet" 265
266 - def test_bindings_model_set_first(self):
267 cfg = config.Config('no_file', MAPPINGS) 268 backend = Backend(cfg) 269 self._foo.backend = backend 270 271 # connect a supported model 272 model = FooModel() 273 self._foo.model = model 274 275 # adding bound attributes to the model 276 # ... a model 277 model.model_child1 = BarModel() 278 self.failUnless(isinstance(self._foo.controller_child1, 279 BarController)) 280 281 # FIXME: this is unfortunately not so easy; there is no notification 282 # of attribute removal in the Observable/Observer protocol defined in 283 # Elisa. However, this is not a very common use case. 284 """ 285 delattr(model, "model_child1") 286 self.failUnlessRaises(AttributeError, getattr, self._foo, 287 "controller_child1") 288 """ 289 290 # ... an object which is not a model 291 value = 123 292 model.model_child1 = value 293 self.failUnlessEqual(self._foo.controller_child1, value) 294 295 model.model_child1 = "test" 296 self.failUnlessEqual(self._foo.controller_child1, "test") 297 298 # ... or even None 299 model.model_child1 = None 300 self.failUnlessEqual(self._foo.controller_child1, None)
301 302
303 - def test_bindings_not_bound_attributes(self):
304 cfg = config.Config('no_file', MAPPINGS) 305 backend = Backend(cfg) 306 self._foo.backend = backend 307 308 # connect a supported model 309 model = FooModel() 310 self._foo.model = model 311 312 # adding not bound attributes to the model 313 # remove them 314 model.not_bound1 = 123 315 model.not_bound2 = BarModel() 316 317 self.failUnlessRaises(AttributeError, getattr, self._foo, 318 "controller_child1") 319 self.failUnlessRaises(AttributeError, getattr, self._foo, 320 "controller_child2") 321 self.failUnlessRaises(AttributeError, getattr, self._foo, 322 "controller_child3")
323
324 - def test_bindings_model_set_after(self):
325 cfg = config.Config('no_file', MAPPINGS) 326 backend = Backend(cfg) 327 self._foo.backend = backend 328 329 # create a supported model but does not connect it with the controller 330 model = FooModel() 331 332 # adding bound attributes to the model 333 # ... a model 334 model.model_child1 = BarModel() 335 self.failUnlessRaises(AttributeError, getattr, self._foo, 336 "controller_child1") 337 # connect the model 338 self._foo.model = model 339 self.failUnless(isinstance(self._foo.controller_child1, 340 BarController)) 341 342 343 # disconnect the model 344 self._foo.model = None 345 self.failUnlessRaises(AttributeError, getattr, self._foo, 346 "controller_child1") 347 348 349 # ... an object which is not a model 350 model.model_child1 = "test" 351 self.failUnlessRaises(AttributeError, getattr, self._foo, 352 "controller_child1") 353 354 # connect the model 355 self._foo.model = model 356 self.failUnlessEqual(self._foo.controller_child1, "test")
357 358 359
360 - def test_bindings_without_backend(self):
361 # connect a supported model 362 model = FooModel() 363 self._foo.model = model 364 365 # without a backend adding a child model should fail 366 self.failUnlessRaises(Exception, setattr, model, "model_child1", 367 BarModel()) 368 369 # it should work as usual for everything else 370 # ... an object which is not a model 371 value = 123 372 model.model_child1 = value 373 self.failUnlessEqual(self._foo.controller_child1, value) 374 375 model.model_child1 = "test" 376 self.failUnlessEqual(self._foo.controller_child1, "test") 377 378 # ... or even None 379 model.model_child1 = None 380 self.failUnlessEqual(self._foo.controller_child1, None)
381 382
383 - def test_multiple_bindings(self):
384 cfg = config.Config('no_file', MAPPINGS) 385 backend = Backend(cfg) 386 self._foo.backend = backend 387 388 # connect a supported model 389 model = FooModel() 390 self._foo.model = model 391 392 # adding bound attributes to the model 393 # ... a model 394 model.model_child2 = BarModel() 395 self.failUnless(isinstance(self._foo.controller_child2, 396 BarController)) 397 self.failUnless(isinstance(self._foo.controller_child3, 398 BarController)) 399 400 401 # disconnect the model 402 self._foo.model = None 403 self.failUnlessRaises(AttributeError, getattr, self._foo, 404 "controller_child2") 405 self.failUnlessRaises(AttributeError, getattr, self._foo, 406 "controller_child3")
407