WIP-pyshapelib-bramz/test/test_dbf_table.py

# Copyright (c) 2002, 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Test the DBFTable class
"""

__version__ = "$Revision$"
# $Source$
# $Id$


import os
import unittest

import support
support.initthuban()

from Thuban.Model.table import DBFTable, MemoryTable, \
     FIELDTYPE_DOUBLE, FIELDTYPE_INT, FIELDTYPE_STRING, \
     table_to_dbf
import dbflib

class TestTableToDBF(unittest.TestCase, support.FileTestMixin):

    def test_table_to_dbf(self):
        """Test table_to_dbf"""
        memtable = MemoryTable([("type", FIELDTYPE_STRING),
                                ("value", FIELDTYPE_DOUBLE),
                                ("code", FIELDTYPE_INT)],
                               [("UNKNOWN", 0.0, 0),
                                ("Foo", 0.5, -1),
                                ("Foo", 1.0/256, 100),
                                ("bar", 1e10, 17)])

        filename = self.temp_file_name("test_table_to_dbf.dbf")
        table_to_dbf(memtable, filename)

        dbf = dbflib.DBFFile(filename)
        self.assertEquals(dbf.read_record(2),
                          {'code': 100, 'type': 'Foo', 'value': 0.00390625})
        self.assertEquals(dbf.field_count(), 3)
        self.assertEquals(dbf.record_count(), 4)
        self.assertEquals(dbf.field_info(0),
                          (dbflib.FTString, "type", 7, 0))
        self.assertEquals(dbf.field_info(1),
                          (dbflib.FTDouble, "value", 24, 12))
        self.assertEquals(dbf.field_info(2),
                          (dbflib.FTInteger, "code", 3, 0))

        # save selected rows
        table_to_dbf(memtable, filename, [1, 3])

        dbf = dbflib.DBFFile(filename)
        self.assertEquals(dbf.read_record(0),
                          {'code': -1, 'type': 'Foo', 'value': 0.5})
        self.assertEquals(dbf.field_count(), 3)
        self.assertEquals(dbf.record_count(), 2)
        self.assertEquals(dbf.field_info(0),
                          (dbflib.FTString, "type", 7, 0))
        self.assertEquals(dbf.field_info(1),
                          (dbflib.FTDouble, "value", 24, 12))
        self.assertEquals(dbf.field_info(2),
                          (dbflib.FTInteger, "code", 3, 0))

    def test_table_to_dbf_long_col_names(self):
        """Test table_to_dbf with long column names."""
        memtable = MemoryTable([("SOME_STRING", FIELDTYPE_STRING),
                                ("SOME_LONG_COLNAME", FIELDTYPE_DOUBLE),
                                ("SOME_LONG_COLNAME_2", FIELDTYPE_DOUBLE)],
                               [("UNKNOWN", 0.0, 0.0),
                                ("Foo", 1.0, 0.0),
                                ("Foo", 478.23482182999999, 0.0),
                                ("bar", -2.25, 1.0)])

        filename = self.temp_file_name("test_table_to_dbf_long_col_names.dbf")
        table_to_dbf(memtable, filename)

        dbf = dbflib.DBFFile(filename)
        self.assertEquals(dbf.read_record(3),
                          {'SOME_STRIN': "bar", 'SOME_LONG_': -2.25,
                           'SOME_LONG1': 1.0})

class TestDBFTable(unittest.TestCase, support.FileTestMixin):

    def setUp(self):
        """Create a new dbf file. The name is in self.filename"""
        simple = MemoryTable([("type", FIELDTYPE_STRING),
                              ("value", FIELDTYPE_DOUBLE),
                              ("code", FIELDTYPE_INT)],
                             [("UNKNOWN", 0.0, 0),
                              ("Foo", 0.5, -1),
                              ("Foo", 0.25, 100),
                              ("bar", 1e10, 17)])

        self.filename = self.temp_file_name("test_dbf_read.dbf")
        table_to_dbf(simple, self.filename)

    def test_num_rows(self):
        """Test DBFTable.NumRows()"""
        table = DBFTable(self.filename)
        self.assertEquals(table.NumRows(), 4)

    def test_num_columns(self):
        """Test DBFTable.NumColumns()"""
        table = DBFTable(self.filename)
        self.assertEquals(table.NumColumns(), 3)

    def test_columns(self):
        """Test DBFTable.Columns()"""
        table = DBFTable(self.filename)
        columns = table.Columns()
        self.assertEquals(columns[0].name, "type")
        self.assertEquals(columns[0].type, FIELDTYPE_STRING)
        self.assertEquals(columns[1].name, "value")
        self.assertEquals(columns[1].type, FIELDTYPE_DOUBLE)
        self.assertEquals(columns[2].name, "code")
        self.assertEquals(columns[2].type, FIELDTYPE_INT)

    def test_column(self):
        """Test DBFTable.Column()"""
        table = DBFTable(self.filename)
        # The Column method can be called with either an index or a name
        col = table.Column(2)
        self.assertEquals(col.name, "code")
        self.assertEquals(col.type, FIELDTYPE_INT)
        col = table.Column("value")
        self.assertEquals(col.name, "value")
        self.assertEquals(col.type, FIELDTYPE_DOUBLE)

    def test_has_column(self):
        """Test DBFTable.HasColumn()"""
        table = DBFTable(self.filename)
        # HasColumn
        self.failUnless(table.HasColumn("value"))
        self.failUnless(table.HasColumn(2))
        # HasColumn for non-exisiting columns
        self.failIf(table.HasColumn("non_existing_name"))
        self.failIf(table.HasColumn(100))

    def test_read_row_as_dict(self):
        """Test DBFTable.ReadRowAsDict()"""
        table = DBFTable(self.filename)
        self.assertEquals(table.ReadRowAsDict(1),
                          {"type": "Foo", "value": 0.5, "code": -1})

    def test_read_row_as_dict_row_count_mode(self):
        """Test DBFTable.ReadRowAsDict() row count address mode"""
        table = DBFTable(self.filename)
        self.assertEquals(table.ReadRowAsDict(1, row_is_ordinal = 1),
                          {"type": "Foo", "value": 0.5, "code": -1})

    def test_read_value(self):
        """Test DBFTable.ReadValue()"""
        table = DBFTable(self.filename)
        # The column in ReadValue may be given as either name or index
        self.assertEquals(table.ReadValue(2, 0), "Foo")
        self.assertEquals(table.ReadValue(3, "code"), 17)

    def test_read_value_row_count_mode(self):
        """Test DBFTable.ReadValue() row count address mode"""
        table = DBFTable(self.filename)
        # The column in ReadValue may be given as either name or index
        self.assertEquals(table.ReadValue(2, 0, row_is_ordinal = 1), "Foo")
        self.assertEquals(table.ReadValue(3, "code", row_is_ordinal = 1), 17)

    def test_row_id_to_ordinal(self):
        """Test DBFTable.RowIdToOrdinal()"""
        table = DBFTable(self.filename)
        self.assertEquals(table.RowIdToOrdinal(5), 5)

    def test_row_oridnal_to_id(self):
        """Test DBFTable.RowOrdinalToId()"""
        table = DBFTable(self.filename)
        self.assertEquals(table.RowOrdinalToId(5), 5)

    def test_value_range(self):
        """Test DBFTable.ValueRange()"""
        table = DBFTable(self.filename)
        self.assertEquals(table.ValueRange("code"), (-1, 100))
        self.assertEquals(table.ValueRange(1), (0, 1e10))

    def test_unique_values(self):
        """Test DBFTable.UniqueValues()"""
        table = DBFTable(self.filename)

        # The column can be specified by name or index
        self.assertEquals(table.UniqueValues("type"),
                          ["Foo", "UNKNOWN", "bar"])
        self.assertEquals(table.UniqueValues(2), [-1, 0, 17, 100])

    def test_dependencies(self):
        """Test DBFTable.Dependencies()"""
        # A DBFTable doesn't have dependencies
        table = DBFTable(self.filename)
        self.assertEquals(len(table.Dependencies()), 0)

    def test_filename(self):
        """Test DBFTable.FileName()"""
        # A DBFTable doesn't have dependencies
        table = DBFTable(self.filename)
        self.assertEquals(table.FileName(), self.filename)

    def test_title(self):
        """Test DBFTable.Title()"""
        # A DBFTable doesn't have dependencies
        table = DBFTable(self.filename)
        self.assertEquals(table.Title(), "test_dbf_read")


class TestDBFTableWriting(unittest.TestCase, support.FileTestMixin):

    def test_write(self):
        """Test DBFTable.write_record()"""
        eq = self.assertEquals

        # First create a DBF file
        dbffilename = self.temp_file_name("dbftable_write.dbf")
        dbf = dbflib.create(dbffilename)
        dbf.add_field("NAME", dbflib.FTString, 20, 0)
        dbf.add_field("INT", dbflib.FTInteger, 10, 0)
        dbf.add_field("FLOAT", dbflib.FTDouble, 10, 4)
        dbf.write_record(0, {'NAME': "Weatherwax", "INT":1,
                             "FLOAT":3.1415926535})
        dbf.close()

        # Create the table
        table = DBFTable(dbffilename)
        record = table.ReadRowAsDict(0)
        # The FLOAT value is different from above because of rounding
        eq(record, {'NAME': "Weatherwax", "INT":1, "FLOAT":3.1415999999999999})

        # change only one field
        table.write_record(0, {"NAME": "Ogg"})
        # check whether it has been written immediately
        dbf = dbflib.DBFFile(dbffilename)
        control = dbf.read_record(0)
        eq(control, {'NAME': "Ogg", "INT":1, "FLOAT":3.1415999999999999})
        dbf.close()

        # check whether the table itself returns the new value
        eq(table.ReadRowAsDict(0),
           {'NAME': "Ogg", "INT":1, "FLOAT":3.1415999999999999})

        # Check whether we can specify the record as a tuple
        table.write_record(0, ("Garlick", 2, 1.5))
        eq(table.ReadRowAsDict(0), {"NAME": "Garlick", "INT": 2, "FLOAT": 1.5})

        table.Destroy()


if __name__ == "__main__":
    support.run_tests()
1	bh	818	# Copyright (c) 2002, 2003 by Intevation GmbH
2			# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			"""
9			Test the DBFTable class
10			"""
11
12			__version__ = "$Revision$"
13			# $Source$
14			# $Id$
15
16
17			import os
18			import unittest
19
20			import support
21			support.initthuban()
22
23			from Thuban.Model.table import DBFTable, MemoryTable, \
24	frank	1028	FIELDTYPE_DOUBLE, FIELDTYPE_INT, FIELDTYPE_STRING, \
25			table_to_dbf
26	bh	818	import dbflib
27
28	bh	1042	class TestTableToDBF(unittest.TestCase, support.FileTestMixin):
29	bh	818
30	bh	1042	def test_table_to_dbf(self):
31	bh	1371	"""Test table_to_dbf"""
32	bh	1042	memtable = MemoryTable([("type", FIELDTYPE_STRING),
33			("value", FIELDTYPE_DOUBLE),
34			("code", FIELDTYPE_INT)],
35			[("UNKNOWN", 0.0, 0),
36			("Foo", 0.5, -1),
37			("Foo", 1.0/256, 100),
38			("bar", 1e10, 17)])
39
40			filename = self.temp_file_name("test_table_to_dbf.dbf")
41			table_to_dbf(memtable, filename)
42
43			dbf = dbflib.DBFFile(filename)
44			self.assertEquals(dbf.read_record(2),
45			{'code': 100, 'type': 'Foo', 'value': 0.00390625})
46			self.assertEquals(dbf.field_count(), 3)
47			self.assertEquals(dbf.record_count(), 4)
48			self.assertEquals(dbf.field_info(0),
49			(dbflib.FTString, "type", 7, 0))
50			self.assertEquals(dbf.field_info(1),
51			(dbflib.FTDouble, "value", 24, 12))
52			self.assertEquals(dbf.field_info(2),
53			(dbflib.FTInteger, "code", 3, 0))
54
55	jonathan	1399	# save selected rows
56			table_to_dbf(memtable, filename, [1, 3])
57
58			dbf = dbflib.DBFFile(filename)
59			self.assertEquals(dbf.read_record(0),
60			{'code': -1, 'type': 'Foo', 'value': 0.5})
61			self.assertEquals(dbf.field_count(), 3)
62			self.assertEquals(dbf.record_count(), 2)
63			self.assertEquals(dbf.field_info(0),
64			(dbflib.FTString, "type", 7, 0))
65			self.assertEquals(dbf.field_info(1),
66			(dbflib.FTDouble, "value", 24, 12))
67			self.assertEquals(dbf.field_info(2),
68			(dbflib.FTInteger, "code", 3, 0))
69
70	bh	1371	def test_table_to_dbf_long_col_names(self):
71			"""Test table_to_dbf with long column names."""
72			memtable = MemoryTable([("SOME_STRING", FIELDTYPE_STRING),
73			("SOME_LONG_COLNAME", FIELDTYPE_DOUBLE),
74			("SOME_LONG_COLNAME_2", FIELDTYPE_DOUBLE)],
75			[("UNKNOWN", 0.0, 0.0),
76			("Foo", 1.0, 0.0),
77			("Foo", 478.23482182999999, 0.0),
78			("bar", -2.25, 1.0)])
79	bh	1042
80	bh	1371	filename = self.temp_file_name("test_table_to_dbf_long_col_names.dbf")
81			table_to_dbf(memtable, filename)
82
83			dbf = dbflib.DBFFile(filename)
84			self.assertEquals(dbf.read_record(3),
85			{'SOME_STRIN': "bar", 'SOME_LONG_': -2.25,
86			'SOME_LONG1': 1.0})
87
88	bh	818	class TestDBFTable(unittest.TestCase, support.FileTestMixin):
89
90			def setUp(self):
91			"""Create a new dbf file. The name is in self.filename"""
92			simple = MemoryTable([("type", FIELDTYPE_STRING),
93			("value", FIELDTYPE_DOUBLE),
94			("code", FIELDTYPE_INT)],
95			[("UNKNOWN", 0.0, 0),
96			("Foo", 0.5, -1),
97			("Foo", 0.25, 100),
98			("bar", 1e10, 17)])
99
100			self.filename = self.temp_file_name("test_dbf_read.dbf")
101			table_to_dbf(simple, self.filename)
102
103			def test_num_rows(self):
104			"""Test DBFTable.NumRows()"""
105			table = DBFTable(self.filename)
106			self.assertEquals(table.NumRows(), 4)
107
108			def test_num_columns(self):
109			"""Test DBFTable.NumColumns()"""
110			table = DBFTable(self.filename)
111			self.assertEquals(table.NumColumns(), 3)
112
113			def test_columns(self):
114			"""Test DBFTable.Columns()"""
115			table = DBFTable(self.filename)
116			columns = table.Columns()
117			self.assertEquals(columns[0].name, "type")
118			self.assertEquals(columns[0].type, FIELDTYPE_STRING)
119			self.assertEquals(columns[1].name, "value")
120			self.assertEquals(columns[1].type, FIELDTYPE_DOUBLE)
121			self.assertEquals(columns[2].name, "code")
122			self.assertEquals(columns[2].type, FIELDTYPE_INT)
123
124			def test_column(self):
125			"""Test DBFTable.Column()"""
126			table = DBFTable(self.filename)
127			# The Column method can be called with either an index or a name
128			col = table.Column(2)
129			self.assertEquals(col.name, "code")
130			self.assertEquals(col.type, FIELDTYPE_INT)
131			col = table.Column("value")
132			self.assertEquals(col.name, "value")
133			self.assertEquals(col.type, FIELDTYPE_DOUBLE)
134
135	bh	839	def test_has_column(self):
136			"""Test DBFTable.HasColumn()"""
137			table = DBFTable(self.filename)
138			# HasColumn
139			self.failUnless(table.HasColumn("value"))
140			self.failUnless(table.HasColumn(2))
141			# HasColumn for non-exisiting columns
142			self.failIf(table.HasColumn("non_existing_name"))
143			self.failIf(table.HasColumn(100))
144
145	bh	818	def test_read_row_as_dict(self):
146			"""Test DBFTable.ReadRowAsDict()"""
147			table = DBFTable(self.filename)
148			self.assertEquals(table.ReadRowAsDict(1),
149			{"type": "Foo", "value": 0.5, "code": -1})
150
151	bh	1662	def test_read_row_as_dict_row_count_mode(self):
152			"""Test DBFTable.ReadRowAsDict() row count address mode"""
153			table = DBFTable(self.filename)
154			self.assertEquals(table.ReadRowAsDict(1, row_is_ordinal = 1),
155			{"type": "Foo", "value": 0.5, "code": -1})
156
157	bh	818	def test_read_value(self):
158			"""Test DBFTable.ReadValue()"""
159			table = DBFTable(self.filename)
160			# The column in ReadValue may be given as either name or index
161			self.assertEquals(table.ReadValue(2, 0), "Foo")
162			self.assertEquals(table.ReadValue(3, "code"), 17)
163
164	bh	1662	def test_read_value_row_count_mode(self):
165			"""Test DBFTable.ReadValue() row count address mode"""
166			table = DBFTable(self.filename)
167			# The column in ReadValue may be given as either name or index
168			self.assertEquals(table.ReadValue(2, 0, row_is_ordinal = 1), "Foo")
169			self.assertEquals(table.ReadValue(3, "code", row_is_ordinal = 1), 17)
170
171			def test_row_id_to_ordinal(self):
172			"""Test DBFTable.RowIdToOrdinal()"""
173			table = DBFTable(self.filename)
174			self.assertEquals(table.RowIdToOrdinal(5), 5)
175
176			def test_row_oridnal_to_id(self):
177			"""Test DBFTable.RowOrdinalToId()"""
178			table = DBFTable(self.filename)
179			self.assertEquals(table.RowOrdinalToId(5), 5)
180
181	bh	818	def test_value_range(self):
182			"""Test DBFTable.ValueRange()"""
183			table = DBFTable(self.filename)
184			self.assertEquals(table.ValueRange("code"), (-1, 100))
185			self.assertEquals(table.ValueRange(1), (0, 1e10))
186
187			def test_unique_values(self):
188			"""Test DBFTable.UniqueValues()"""
189			table = DBFTable(self.filename)
190
191			# The column can be specified by name or index
192			self.assertEquals(table.UniqueValues("type"),
193			["Foo", "UNKNOWN", "bar"])
194			self.assertEquals(table.UniqueValues(2), [-1, 0, 17, 100])
195
196	bh	984	def test_dependencies(self):
197			"""Test DBFTable.Dependencies()"""
198			# A DBFTable doesn't have dependencies
199			table = DBFTable(self.filename)
200			self.assertEquals(len(table.Dependencies()), 0)
201
202	bh	994	def test_filename(self):
203			"""Test DBFTable.FileName()"""
204			# A DBFTable doesn't have dependencies
205			table = DBFTable(self.filename)
206			self.assertEquals(table.FileName(), self.filename)
207
208	bh	998	def test_title(self):
209			"""Test DBFTable.Title()"""
210			# A DBFTable doesn't have dependencies
211			table = DBFTable(self.filename)
212	bh	1078	self.assertEquals(table.Title(), "test_dbf_read")
213	bh	994
214	bh	998
215	bh	818	class TestDBFTableWriting(unittest.TestCase, support.FileTestMixin):
216
217			def test_write(self):
218			"""Test DBFTable.write_record()"""
219			eq = self.assertEquals
220
221			# First create a DBF file
222	bh	994	dbffilename = self.temp_file_name("dbftable_write.dbf")
223	bh	818	dbf = dbflib.create(dbffilename)
224			dbf.add_field("NAME", dbflib.FTString, 20, 0)
225			dbf.add_field("INT", dbflib.FTInteger, 10, 0)
226			dbf.add_field("FLOAT", dbflib.FTDouble, 10, 4)
227			dbf.write_record(0, {'NAME': "Weatherwax", "INT":1,
228			"FLOAT":3.1415926535})
229			dbf.close()
230
231			# Create the table
232			table = DBFTable(dbffilename)
233			record = table.ReadRowAsDict(0)
234			# The FLOAT value is different from above because of rounding
235			eq(record, {'NAME': "Weatherwax", "INT":1, "FLOAT":3.1415999999999999})
236
237			# change only one field
238			table.write_record(0, {"NAME": "Ogg"})
239			# check whether it has been written immediately
240			dbf = dbflib.DBFFile(dbffilename)
241			control = dbf.read_record(0)
242			eq(control, {'NAME': "Ogg", "INT":1, "FLOAT":3.1415999999999999})
243			dbf.close()
244
245			# check whether the table itself returns the new value
246			eq(table.ReadRowAsDict(0),
247			{'NAME': "Ogg", "INT":1, "FLOAT":3.1415999999999999})
248
249			# Check whether we can specify the record as a tuple
250			table.write_record(0, ("Garlick", 2, 1.5))
251			eq(table.ReadRowAsDict(0), {"NAME": "Garlick", "INT": 2, "FLOAT": 1.5})
252
253			table.Destroy()
254
255
256			if __name__ == "__main__":
257			support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision