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))

    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_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_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	bh	1371	def test_table_to_dbf_long_col_names(self):
56			"""Test table_to_dbf with long column names."""
57			memtable = MemoryTable([("SOME_STRING", FIELDTYPE_STRING),
58			("SOME_LONG_COLNAME", FIELDTYPE_DOUBLE),
59			("SOME_LONG_COLNAME_2", FIELDTYPE_DOUBLE)],
60			[("UNKNOWN", 0.0, 0.0),
61			("Foo", 1.0, 0.0),
62			("Foo", 478.23482182999999, 0.0),
63			("bar", -2.25, 1.0)])
64	bh	1042
65	bh	1371	filename = self.temp_file_name("test_table_to_dbf_long_col_names.dbf")
66			table_to_dbf(memtable, filename)
67
68			dbf = dbflib.DBFFile(filename)
69			self.assertEquals(dbf.read_record(3),
70			{'SOME_STRIN': "bar", 'SOME_LONG_': -2.25,
71			'SOME_LONG1': 1.0})
72
73
74	bh	818	class TestDBFTable(unittest.TestCase, support.FileTestMixin):
75
76			def setUp(self):
77			"""Create a new dbf file. The name is in self.filename"""
78			simple = MemoryTable([("type", FIELDTYPE_STRING),
79			("value", FIELDTYPE_DOUBLE),
80			("code", FIELDTYPE_INT)],
81			[("UNKNOWN", 0.0, 0),
82			("Foo", 0.5, -1),
83			("Foo", 0.25, 100),
84			("bar", 1e10, 17)])
85
86			self.filename = self.temp_file_name("test_dbf_read.dbf")
87			table_to_dbf(simple, self.filename)
88
89			def test_num_rows(self):
90			"""Test DBFTable.NumRows()"""
91			table = DBFTable(self.filename)
92			self.assertEquals(table.NumRows(), 4)
93
94			def test_num_columns(self):
95			"""Test DBFTable.NumColumns()"""
96			table = DBFTable(self.filename)
97			self.assertEquals(table.NumColumns(), 3)
98
99			def test_columns(self):
100			"""Test DBFTable.Columns()"""
101			table = DBFTable(self.filename)
102			columns = table.Columns()
103			self.assertEquals(columns[0].name, "type")
104			self.assertEquals(columns[0].type, FIELDTYPE_STRING)
105			self.assertEquals(columns[1].name, "value")
106			self.assertEquals(columns[1].type, FIELDTYPE_DOUBLE)
107			self.assertEquals(columns[2].name, "code")
108			self.assertEquals(columns[2].type, FIELDTYPE_INT)
109
110			def test_column(self):
111			"""Test DBFTable.Column()"""
112			table = DBFTable(self.filename)
113			# The Column method can be called with either an index or a name
114			col = table.Column(2)
115			self.assertEquals(col.name, "code")
116			self.assertEquals(col.type, FIELDTYPE_INT)
117			col = table.Column("value")
118			self.assertEquals(col.name, "value")
119			self.assertEquals(col.type, FIELDTYPE_DOUBLE)
120
121	bh	839	def test_has_column(self):
122			"""Test DBFTable.HasColumn()"""
123			table = DBFTable(self.filename)
124			# HasColumn
125			self.failUnless(table.HasColumn("value"))
126			self.failUnless(table.HasColumn(2))
127			# HasColumn for non-exisiting columns
128			self.failIf(table.HasColumn("non_existing_name"))
129			self.failIf(table.HasColumn(100))
130
131	bh	818	def test_read_row_as_dict(self):
132			"""Test DBFTable.ReadRowAsDict()"""
133			table = DBFTable(self.filename)
134			self.assertEquals(table.ReadRowAsDict(1),
135			{"type": "Foo", "value": 0.5, "code": -1})
136
137			def test_read_value(self):
138			"""Test DBFTable.ReadValue()"""
139			table = DBFTable(self.filename)
140			# The column in ReadValue may be given as either name or index
141			self.assertEquals(table.ReadValue(2, 0), "Foo")
142			self.assertEquals(table.ReadValue(3, "code"), 17)
143
144			def test_value_range(self):
145			"""Test DBFTable.ValueRange()"""
146			table = DBFTable(self.filename)
147			self.assertEquals(table.ValueRange("code"), (-1, 100))
148			self.assertEquals(table.ValueRange(1), (0, 1e10))
149
150			def test_unique_values(self):
151			"""Test DBFTable.UniqueValues()"""
152			table = DBFTable(self.filename)
153
154			# The column can be specified by name or index
155			self.assertEquals(table.UniqueValues("type"),
156			["Foo", "UNKNOWN", "bar"])
157			self.assertEquals(table.UniqueValues(2), [-1, 0, 17, 100])
158
159	bh	984	def test_dependencies(self):
160			"""Test DBFTable.Dependencies()"""
161			# A DBFTable doesn't have dependencies
162			table = DBFTable(self.filename)
163			self.assertEquals(len(table.Dependencies()), 0)
164
165	bh	994	def test_filename(self):
166			"""Test DBFTable.FileName()"""
167			# A DBFTable doesn't have dependencies
168			table = DBFTable(self.filename)
169			self.assertEquals(table.FileName(), self.filename)
170
171	bh	998	def test_title(self):
172			"""Test DBFTable.Title()"""
173			# A DBFTable doesn't have dependencies
174			table = DBFTable(self.filename)
175	bh	1078	self.assertEquals(table.Title(), "test_dbf_read")
176	bh	994
177	bh	998
178	bh	818	class TestDBFTableWriting(unittest.TestCase, support.FileTestMixin):
179
180			def test_write(self):
181			"""Test DBFTable.write_record()"""
182			eq = self.assertEquals
183
184			# First create a DBF file
185	bh	994	dbffilename = self.temp_file_name("dbftable_write.dbf")
186	bh	818	dbf = dbflib.create(dbffilename)
187			dbf.add_field("NAME", dbflib.FTString, 20, 0)
188			dbf.add_field("INT", dbflib.FTInteger, 10, 0)
189			dbf.add_field("FLOAT", dbflib.FTDouble, 10, 4)
190			dbf.write_record(0, {'NAME': "Weatherwax", "INT":1,
191			"FLOAT":3.1415926535})
192			dbf.close()
193
194			# Create the table
195			table = DBFTable(dbffilename)
196			record = table.ReadRowAsDict(0)
197			# The FLOAT value is different from above because of rounding
198			eq(record, {'NAME': "Weatherwax", "INT":1, "FLOAT":3.1415999999999999})
199
200			# change only one field
201			table.write_record(0, {"NAME": "Ogg"})
202			# check whether it has been written immediately
203			dbf = dbflib.DBFFile(dbffilename)
204			control = dbf.read_record(0)
205			eq(control, {'NAME': "Ogg", "INT":1, "FLOAT":3.1415999999999999})
206			dbf.close()
207
208			# check whether the table itself returns the new value
209			eq(table.ReadRowAsDict(0),
210			{'NAME': "Ogg", "INT":1, "FLOAT":3.1415999999999999})
211
212			# Check whether we can specify the record as a tuple
213			table.write_record(0, ("Garlick", 2, 1.5))
214			eq(table.ReadRowAsDict(0), {"NAME": "Garlick", "INT": 2, "FLOAT": 1.5})
215
216			table.Destroy()
217
218
219			if __name__ == "__main__":
220			support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision