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