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
import dbflib


def table_to_dbf(table, filename):
    """Create the dbf file filename from the table"""
    dbf = dbflib.create(filename)

    dbflib_fieldtypes = {FIELDTYPE_STRING: dbflib.FTString,
                         FIELDTYPE_INT: dbflib.FTInteger,
                         FIELDTYPE_DOUBLE: dbflib.FTDouble}

    for col in table.Columns():
        if col.type == FIELDTYPE_DOUBLE:
            prec = 10
        else:
            prec = 0
        dbf.add_field(col.name, dbflib_fieldtypes[col.type], 20, prec)

    for i in range(table.NumRows()):
        record = table.ReadRowAsDict(i)
        dbf.write_record(i, record)
    dbf.close()


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)


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