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.models.observable import ObservableModel
  10 from cola.observer import Observer
  11
  12 import helper
  13 from helper import InnerModel
  14 from helper import NestedModel
  15
  16 class ModelObserver(Observer, QtCore.QObject):
  17     def __init__(self, model):
  18         Observer.__init__(self, model)
  19         QtCore.QObject.__init__(self)
  20
  21 class TestSaveRestore(unittest.TestCase):
  22     def setUp(self):
  23         """Create a nested model for testing"""
  24         helper.create_dir()
  25         self.nested = NestedModel()
  26         self.nested_observer = ModelObserver(self.nested)
  27         path = os.path.join(helper.get_dir(), 'test.data')
  28         # save & reconstitute
  29         self.nested.save(path)
  30         self.clone = ObservableModel.instance(path)
  31         self.clone_observer = ModelObserver(self.clone)
  32
  33     def tearDown(self):
  34         """Remove test directories"""
  35         testdir = helper.get_dir()
  36         if os.path.exists(testdir):
  37             helper.remove_dir()
  38
  39     def test_cloned_class(self):
  40         """Test equality for __class__"""
  41         self.failUnless( str(NestedModel) ==
  42                          str(self.clone.__class__) )
  43
  44     def test_inner_cloned_class(self):
  45         """Test an inner clone's __class__"""
  46         self.failUnless( str(InnerModel) ==
  47                          str(self.clone.inner.__class__) )
  48
  49     def test_cloned_list_item(self):
  50         """Test a list item's __class__"""
  51         self.failUnless( str(self.clone.inner.__class__) ==
  52                          str(self.clone.innerlist[0].__class__) )
  53
  54     def test_list_2deep(self):
  55         """Test a list-inside-a-list"""
  56         self.failUnless( str(InnerModel) ==
  57                          str(self.clone.innerlist[1][0].__class__) )
  58
  59     def test_list_3deep(self):
  60         """Test a 3-deep nested list"""
  61         self.failUnless( str(InnerModel) ==
  62                          str(self.clone.innerlist[2][0][0].__class__))
  63
  64     def test_list_4deep(self):
  65         """Test a 4-deep nested list"""
  66         self.failUnless( str(InnerModel) ==
  67                          str(self.clone.innerlist[3][0][0][0].__class__))
  68
  69     def test_dict_in_list(self):
  70         """Test a dict inside a list"""
  71         self.failUnless( str(dict) ==
  72                          str(self.clone.innerlist[4].__class__))
  73
  74     def test_obj_in_dict_in_list(self):
  75         """Test an object instance inside a dict inside a list"""
  76         self.failUnless( str(InnerModel) ==
  77                          str(self.clone.innerlist[-1]["foo"].__class__))
  78
  79     def test_clone_of_clone(self):
  80         """Test cloning a reconstructed object with an attached observer."""
  81         clone = self.clone.clone()
  82         self.assertTrue(len(clone.observers) == 0)
  83         self.assertTrue(clone.notification_enabled)
  84         self.assertEqual(clone.__class__, self.clone.__class__)
  85
  86 if __name__ == '__main__':
  87     unittest.main()