/[thuban]/branches/WIP-pyshapelib-bramz/test/test_transientdb.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/test/test_transientdb.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 765 by bh, Tue Apr 29 12:42:14 2003 UTC revision 1041 by bh, Mon May 26 19:26:41 2003 UTC
# Line 19  import unittest Line 19  import unittest
19  import support  import support
20  support.initthuban()  support.initthuban()
21    
22  from Thuban.Model.table import DBFTable, FIELDTYPE_STRING, FIELDTYPE_INT  from Thuban.Model.table import DBFTable, MemoryTable, FIELDTYPE_STRING, \
23                                   FIELDTYPE_INT, FIELDTYPE_DOUBLE
24  from Thuban.Model.transientdb import TransientDatabase, TransientTable, \  from Thuban.Model.transientdb import TransientDatabase, TransientTable, \
25       TransientJoinedTable, AutoTransientTable       TransientJoinedTable, AutoTransientTable
26    
27    
 class SimpleTable:  
   
     """Very simple table implementation that operates on a list of tuples"""  
   
     def __init__(self, fields, data):  
         """Initialize the SimpleTable  
   
         Parameters:  
         fields -- List of (name, field_type) pairs  
         data -- List of tuples, one for each row of data  
         """  
         self.fields = fields  
         self.data = data  
   
     def field_count(self):  
         return len(self.fields)  
   
     def field_info(self, index):  
         name, type = self.fields[index]  
         return (type, name, 0, 0)  
   
     def record_count(self):  
         return len(self.data)  
   
     def read_record(self, index):  
         return dict([(self.fields[i][0], self.data[index][i])  
                       for i in range(len(self.fields))])  
   
   
28  class TestTransientTable(unittest.TestCase, support.FileTestMixin):  class TestTransientTable(unittest.TestCase, support.FileTestMixin):
29    
30      def setUp(self):      def setUp(self):
# Line 75  class TestTransientTable(unittest.TestCa Line 47  class TestTransientTable(unittest.TestCa
47          Assume that table holds the data of the file          Assume that table holds the data of the file
48          ../Data/iceland/political.dbf sample file.          ../Data/iceland/political.dbf sample file.
49          """          """
50          self.assertEquals(table.record_count(), 156)          self.assertEquals(table.NumRows(), 156)
51          self.assertEquals(table.field_count(), 8)          self.assertEquals(table.NumColumns(), 8)
52    
53          # Check one each of the possible field types. The width and          # Check one each of the possible field types.
54          # decimal precision is always 0.          columns = table.Columns()
55          self.assertEquals(table.field_info(0), ('double', 'AREA', 0, 0))          self.assertEquals(columns[0].name, 'AREA')
56          self.assertEquals(table.field_info(3), ('int', 'PONET_ID', 0, 0))          self.assertEquals(columns[0].type, FIELDTYPE_DOUBLE)
57          self.assertEquals(table.field_info(6), ('string', 'POPYCOUN', 0, 0))          self.assertEquals(columns[3].name, 'PONET_ID')
58            self.assertEquals(columns[3].type, FIELDTYPE_INT)
59            self.assertEquals(columns[6].name, 'POPYCOUN')
60            self.assertEquals(columns[6].type, FIELDTYPE_STRING)
61    
62            # HasColumn
63            self.failUnless(table.HasColumn("AREA"))
64            self.failUnless(table.HasColumn(1))
65            # HasColumn for non-exisiting columns
66            self.failIf(table.HasColumn("non_existing_name"))
67            self.failIf(table.HasColumn(100))
68    
69          # Read an `interesting' record          # Reading rows and values.
70          self.assertEquals(table.read_record(144),          self.assertEquals(table.ReadRowAsDict(144),
71                            {'POPYCOUN': 'IC', 'POPYADMIN': '', 'PONET_': 146,                            {'POPYCOUN': 'IC', 'POPYADMIN': '', 'PONET_': 146,
72                             'AREA': 19.462,                             'AREA': 19.462,
73                             'POPYTYPE': 1, 'PERIMETER': 88.518000000000001,                             'POPYTYPE': 1, 'PERIMETER': 88.518000000000001,
74                             'POPYREG': '1',                             'POPYREG': '1',
75                             'PONET_ID': 145})                             'PONET_ID': 145})
76            self.assertEquals(table.ReadValue(144, "AREA"), 19.462)
77            self.assertEquals(table.ReadValue(144, 3), 145)
78    
79          # field_range may induce a copy to the transient database.          # ValueRange may induce a copy to the transient database.
80          # Therefore we put it last so that we can execute this method          # Therefore we put it last so that we can execute this method
81          # twice to check whether the other methods still work after the          # twice to check whether the other methods still work after the
82          # copy          # copy
83          self.assertEquals(table.field_range("AREA"),          self.assertEquals(table.ValueRange("AREA"), (0.0, 19.462))
                           ((0.0, None), (19.462, None)))  
84    
85          unique = table.GetUniqueValues("PONET_ID")          unique = table.UniqueValues("PONET_ID")
86          unique.sort()          unique.sort()
87          self.assertEquals(unique, range(1, 157))          self.assertEquals(unique, range(1, 157))
88    
# Line 117  class TestTransientTable(unittest.TestCa Line 100  class TestTransientTable(unittest.TestCa
100          # The transient_table method should return the table itself          # The transient_table method should return the table itself
101          self.assert_(table is table.transient_table())          self.assert_(table is table.transient_table())
102    
103            # The title is simply copied over from the original table
104            self.assertEquals(table.Title(), orig_table.Title())
105    
106            # The TransientTable class itself doesn't implement the
107            # Dependencies method, so we don't test it.
108    
109    
110      def test_auto_transient_table(self):      def test_auto_transient_table(self):
111          """Test AutoTransientTable(dbftable)          """Test AutoTransientTable(dbftable)
# Line 136  class TestTransientTable(unittest.TestCa Line 125  class TestTransientTable(unittest.TestCa
125          self.run_iceland_political_tests(table)          self.run_iceland_political_tests(table)
126          self.run_iceland_political_tests(table)          self.run_iceland_political_tests(table)
127    
128        def test_auto_transient_table_query(self):
129            """Test AutoTransientTable.SimpleQuery()"""
130            orig_table = DBFTable(os.path.join("..", "Data", "iceland",
131                                               "political.dbf"))
132            table = AutoTransientTable(self.transientdb, orig_table)
133            # Only a simple test here. The AutoTransientTable simply
134            # delegates to its transient table so it should be OK that the
135            # real test for it is in test_transient_table_query. However,
136            # it's important to check that the column handling works
137            # correctly because the AutoTransientTable and it's underlying
138            # transient table use different column object types.
139            self.assertEquals(table.SimpleQuery(table.Column("AREA"), ">", 10.0),
140                              [144])
141    
142            # test using a Column object as the right parameter
143            self.assertEquals(table.SimpleQuery(table.Column("POPYTYPE"),
144                                                "==",
145                                                table.Column("POPYREG")),
146                              range(156))
147    
148        def test_auto_transient_table_dependencies(self):
149            """Test AutoTransientTable.Dependencies()"""
150            orig_table = DBFTable(os.path.join("..", "Data", "iceland",
151                                               "political.dbf"))
152            table = AutoTransientTable(self.transientdb, orig_table)
153            self.assertEquals(table.Dependencies(), (orig_table,))
154    
155        def test_auto_transient_table_title(self):
156            """Test AutoTransientTable.Title()"""
157            orig_table = DBFTable(os.path.join("..", "Data", "iceland",
158                                               "political.dbf"))
159            table = AutoTransientTable(self.transientdb, orig_table)
160            # The title is of course the same as that of the original table
161            self.assertEquals(table.Title(), orig_table.Title())
162    
163      def test_transient_joined_table(self):      def test_transient_joined_table(self):
164          """Test TransientJoinedTable"""          """Test TransientJoinedTable"""
165          simple = SimpleTable([("type", FIELDTYPE_STRING),          simple = MemoryTable([("type", FIELDTYPE_STRING),
166                                ("code", FIELDTYPE_INT)],                                ("code", FIELDTYPE_INT)],
167                               [("OTHER/UNKNOWN", 0),                               [("OTHER/UNKNOWN", 0),
168                                ("RUINS", 1),                                ("RUINS", 1),
# Line 155  class TestTransientTable(unittest.TestCa Line 178  class TestTransientTable(unittest.TestCa
178          table = TransientJoinedTable(self.transientdb, landmarks, "CLPTLABEL",          table = TransientJoinedTable(self.transientdb, landmarks, "CLPTLABEL",
179                                       auto, "type")                                       auto, "type")
180    
181          self.assertEquals(table.record_count(), 34)          self.assertEquals(table.NumRows(), 34)
182          self.assertEquals(table.field_count(), 8)          self.assertEquals(table.NumColumns(), 8)
183          self.assertEquals(table.field_info(0), ('double', 'AREA', 0, 0))          self.assertEquals(table.Column(0).type, FIELDTYPE_DOUBLE)
184          self.assertEquals(table.field_info(7), ('int', 'code', 0, 0))          self.assertEquals(table.Column(0).name, 'AREA')
185          self.assertEquals(table.field_info(4), ('string', 'CLPTLABEL', 0, 0))          self.assertEquals(table.Column(7).type, FIELDTYPE_INT)
186            self.assertEquals(table.Column(7).name, 'code')
187            self.assertEquals(table.Column(4).type, FIELDTYPE_STRING)
188            self.assertEquals(table.Column(4).name, 'CLPTLABEL')
189            # HasColumn
190            self.failUnless(table.HasColumn("AREA"))
191            self.failUnless(table.HasColumn(1))
192            # HasColumn for non-exisiting columns
193            self.failIf(table.HasColumn("non_existing_name"))
194            self.failIf(table.HasColumn(100))
195    
196          # Read an `interesting' record          # Reading rows and values
197          self.assertEquals(table.read_record(22),          self.assertEquals(table.ReadRowAsDict(22),
198                            {'PERIMETER': 0.0, 'CLPOINT_': 23,                            {'PERIMETER': 0.0, 'CLPOINT_': 23,
199                             'AREA': 0.0, 'CLPTLABEL': 'RUINS',                             'AREA': 0.0, 'CLPTLABEL': 'RUINS',
200                             'CLPOINT_ID': 38, 'CLPTFLAG': 0,                             'CLPOINT_ID': 38, 'CLPTFLAG': 0,
201                             'code': 1, 'type': 'RUINS'})                             'code': 1, 'type': 'RUINS'})
202            self.assertEquals(table.ReadValue(22, "type"), 'RUINS')
203            self.assertEquals(table.ReadValue(22, 7), 1)
204    
205          # The transient_table method should return the table itself          # The transient_table method should return the table itself
206          self.assert_(table is table.transient_table())          self.assert_(table is table.transient_table())
207    
208            # The TransientJoinedTable depends on both input tables
209            self.assertEquals(table.Dependencies(), (landmarks, auto))
210    
211            # The title is constructed from the titles of the input tables.
212            self.assertEquals(table.Title(),
213                              "Join of %s and %s" % (landmarks.Title(),
214                                                     auto.Title()))
215    
216    
217        def test_transient_table_read_twice(self):
218            """Test TransientTable.ReadRowAsDict() reading the same record twice"""
219            simple = MemoryTable([("type", FIELDTYPE_STRING),
220                                  ("code", FIELDTYPE_INT)],
221                                 [("OTHER/UNKNOWN", 0),
222                                  ("RUINS", 1),
223                                  ("FARM", 2),
224                                  ("BUILDING", 3),
225                                  ("HUT", 4),
226                                  ("LIGHTHOUSE", 5)])
227            table = TransientTable(self.transientdb, simple)
228    
229            # There was a bug where reading the same record twice would
230            # raise an exception in the second call because of an
231            # unitialized local variable, so for passing the test it's
232            # enough if reading simply succeeds. OTOH, while we're at it we
233            # might as well check whether the results are equal anyway :)
234            result1 = table.ReadRowAsDict(3)
235            result2 = table.ReadRowAsDict(3)
236            self.assertEquals(result1, result2)
237    
238    
239        def test_transient_table_query(self):
240            """Test TransientTable.SimpleQuery()"""
241            simple = MemoryTable([("type", FIELDTYPE_STRING),
242                                  ("value", FIELDTYPE_DOUBLE),
243                                  ("code", FIELDTYPE_INT)],
244                                 [("OTHER/UNKNOWN", -1.5, 11),
245                                  ("RUINS", 0.0, 1),
246                                  ("FARM", 3.141, 2),
247                                  ("BUILDING", 2.5, 3),
248                                  ("HUT", 1e6, 4),
249                                  ("LIGHTHOUSE", -0.01, 5)])
250            table = TransientTable(self.transientdb, simple)
251    
252            # A column and a value
253            self.assertEquals(table.SimpleQuery(table.Column(0), "==", "RUINS"),
254                              [1])
255            self.assertEquals(table.SimpleQuery(table.Column(2), "!=", 2),
256                              [0, 1, 3, 4, 5])
257            self.assertEquals(table.SimpleQuery(table.Column(1), "<", 1.0),
258                              [0, 1, 5])
259            self.assertEquals(table.SimpleQuery(table.Column(1), "<=", -1.5),
260                              [0])
261            self.assertEquals(table.SimpleQuery(table.Column(2), ">", 3),
262                              [0, 4, 5])
263            self.assertEquals(table.SimpleQuery(table.Column(2), ">=", 3),
264                              [0, 3, 4, 5])
265    
266            # Two columns as operands
267            self.assertEquals(table.SimpleQuery(table.Column(1),
268                                                "<=", table.Column(2)),
269                              [0, 1, 3, 5])
270    
271            # Test whether invalid operators raise a ValueError
272            self.assertRaises(ValueError,
273                              table.SimpleQuery,
274                              table.Column(1), "<<", table.Column(2))
275    
276    
277  if __name__ == "__main__":  if __name__ == "__main__":
Legend:
Removed from v.765  
changed lines
  Added in v.1041
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26