test/test_cola_model_serialization.py

   1 #!/usr/bin/env python
   2 """Tests model serialization methods"""
   3 import os
   4 import sys
   5 import unittest
   6
   7 from PyQt4 import QtCore
   8
   9 from cola import observer
  10 from cola import serializer
  11 from cola.models import observable
  12 from cola.models import base
  13
  14 import helper
  15
  16
  17 class InnerModel(base.BaseModel):
  18     def __init__(self):
  19         base.BaseModel.__init__(self)
  20         self.foo = 'bar'
  21
  22
  23 class NestedModel(observable.ObservableModel):
  24     def __init__(self):
  25         observable.ObservableModel.__init__(self)
  26         self.inner = InnerModel()
  27         self.innerlist = []
  28         self.innerlist.append(InnerModel())
  29         self.innerlist.append([InnerModel()])
  30         self.innerlist.append([[InnerModel()]])
  31         self.innerlist.append([[[InnerModel(),InnerModel()]]])
  32         self.innerlist.append({'foo': InnerModel()})
  33
  34
  35 class ModelObserver(observer.Observer):
  36     def __init__(self, model):
  37         observer.Observer.__init__(self, model)
  38
  39
  40 class TestSaveRestore(helper.TmpPathTestCase):
  41     def setUp(self):
  42         """Create a nested model for testing"""
  43         helper.TmpPathTestCase.setUp(self)
  44         self.nested = NestedModel()
  45         self.nested_observer = ModelObserver(self.nested)
  46         path = self.test_path('test.data')
  47         # save & reconstitute
  48         serializer.save(self.nested, path)
  49         self.clone = serializer.load(path)
  50
  51     def test_cloned_class(self):
  52         """Test equality for __class__"""
  53         self.failUnless( str(NestedModel) ==
  54                          str(self.clone.__class__) )
  55
  56     def test_inner_cloned_class(self):
  57         """Test an inner clone's __class__"""
  58         self.failUnless( str(InnerModel) ==
  59                          str(self.clone.inner.__class__) )
  60
  61     def test_cloned_list_item(self):
  62         """Test a list item's __class__"""
  63         self.failUnless( str(self.clone.inner.__class__) ==
  64                          str(self.clone.innerlist[0].__class__) )
  65
  66     def test_list_2deep(self):
  67         """Test a list-inside-a-list"""
  68         self.failUnless( str(InnerModel) ==
  69                          str(self.clone.innerlist[1][0].__class__) )
  70
  71     def test_list_3deep(self):
  72         """Test a 3-deep nested list"""
  73         self.failUnless( str(InnerModel) ==
  74                          str(self.clone.innerlist[2][0][0].__class__))
  75
  76     def test_list_4deep(self):
  77         """Test a 4-deep nested list"""
  78         self.failUnless( str(InnerModel) ==
  79                          str(self.clone.innerlist[3][0][0][0].__class__))
  80
  81     def test_dict_in_list(self):
  82         """Test a dict inside a list"""
  83         self.failUnless( str(dict) ==
  84                          str(self.clone.innerlist[4].__class__))
  85
  86     def test_obj_in_dict_in_list(self):
  87         """Test an object instance inside a dict inside a list"""
  88         self.failUnless( str(InnerModel) ==
  89                          str(self.clone.innerlist[-1]["foo"].__class__))
  90
  91     def test_clone_of_clone(self):
  92         """Test cloning a reconstructed object with an attached observer."""
  93         clone = serializer.clone(self.clone)
  94         self.assertTrue(len(clone.observers) == 0)
  95         self.assertTrue(clone.notification_enabled)
  96         self.assertEqual(clone.__class__, self.clone.__class__)
  97
  98 if __name__ == '__main__':
  99     unittest.main()