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


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.dbf")


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