WIP-pyshapelib-bramz/test/test_save.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 saving a thuban session as XML
"""

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

import os
import unittest
from StringIO import StringIO

import xml.sax
import xml.sax.handler
from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException

import xmlsupport

import support
support.initthuban()

import dbflib

from Thuban.Lib.fileutil import relative_filename
from Thuban.Model.save import XMLWriter, save_session, sort_data_stores
from Thuban.Model.session import Session
from Thuban.Model.map import Map
from Thuban.Model.layer import Layer, RasterLayer
from Thuban.Model.proj import Projection
from Thuban.Model.table import DBFTable
from Thuban.Model.transientdb import TransientJoinedTable
from Thuban.Model.data import DerivedShapeStore

from Thuban.Model.classification import ClassGroupSingleton, ClassGroupRange, \
    ClassGroupProperties

from Thuban.Model.range import Range


class XMLWriterTest(unittest.TestCase):

    def testEncode(self):
        """Test XMLWriter.encode"""
        writer = XMLWriter()
        eq = self.assertEquals

        eq(writer.encode("hello world"), "hello world")
        eq(writer.encode(unicode("hello world")), unicode("hello world"))

        eq(writer.encode("\x80\x90\xc2\x100"), 
                         "\xc2\x80\xc2\x90\xc3\x82\x100")
        eq(writer.encode(u"\x80\x90\xc2\x100"), 
                         "\xc2\x80\xc2\x90\xc3\x82\x100")
        eq(writer.encode(u"\xFF5E"), "\xc3\xbf5E")

        eq(writer.encode('&"\'<>'), "&amp;&quot;&apos;&lt;&gt;")
        eq(writer.encode(unicode('&"\'<>')), "&amp;&quot;&apos;&lt;&gt;")

class SaveSessionTest(unittest.TestCase, support.FileTestMixin,
                      xmlsupport.ValidationTest):

    dtd = "http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd"
    thubanids = [((dtd, n), (None, "id")) for n in
                 ["fileshapesource", "filetable", "jointable",
                  "derivedshapesource"]]
    thubanidrefs = [((dtd, n), (None, m)) for n, m in
                    [("layer", "shapestore"),
                     ("jointable", "left"),
                     ("jointable", "right"),
                     ("derivedshapesource", "table"),
                     ("derivedshapesource", "shapesource")]]
    del n, m, dtd

    def compare_xml(self, xml1, xml2):
        list1 = xmlsupport.sax_eventlist(xml1, ids = self.thubanids,
                                         idrefs = self.thubanidrefs)
        list2 = xmlsupport.sax_eventlist(xml2, ids = self.thubanids,
                                         idrefs = self.thubanidrefs)
        if list1 != list2:
            for a, b in zip(list1, list2):
                if a != b:
                    self.fail("%r != %r" % (a, b))


    def testEmptySession(self):
        """Save an empty session"""
        session = Session("empty session")
        filename = self.temp_file_name("save_emptysession.thuban")
        save_session(session, filename)
        session.Destroy()

        file = open(filename)
        written_contents = file.read()
        file.close()
        self.compare_xml(written_contents,
                         '<?xml version="1.0" encoding="UTF-8"?>\n'
                         '<!DOCTYPE session SYSTEM "thuban-0.9.dtd">\n'
                         '<session title="empty session" '
         'xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">'
                         '\n</session>\n')

        self.validate_data(written_contents)

    def testSingleLayer(self):
        """Save a session with a single map with a single layer"""
        # deliberately put an apersand in the title :)
        session = Session("single map&layer")
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        map = Map("Test Map", projection = proj)
        session.AddMap(map)
        # use shapefile from the example data
        shpfile = os.path.join(os.path.dirname(__file__),
                               os.pardir, "Data", "iceland", "political.shp")
        layer = Layer("My Layer", session.OpenShapefile(shpfile))
        map.AddLayer(layer)

        filename = self.temp_file_name("save_singlemap.thuban")
        save_session(session, filename)

        file = open(filename)
        written_contents = file.read()
        file.close()
        expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE session SYSTEM "thuban-0.9.dtd">
        <session title="single map&amp;layer"
           xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
            <fileshapesource id="D1" filename="%s" filetype="shapefile"/>
            <map title="Test Map">
                <projection name="Unknown">
                    <parameter value="zone=26"/>
                    <parameter value="proj=utm"/>
                    <parameter value="ellps=clrk66"/>
                </projection>
                <layer title="My Layer" shapestore="D1"
                fill="None" stroke="#000000" stroke_width="1" visible="%s"/>
            </map>
        </session>'''

        expected_contents = expected_template % \
            (os.path.join("..", "..", "Data", "iceland", "political.shp"),
             "true")

        self.compare_xml(written_contents, expected_contents)

        self.validate_data(written_contents)

        layer.SetVisible(False)
        save_session(session, filename)

        file = open(filename)
        written_contents = file.read()
        file.close()
        expected_contents = expected_template % \
            (os.path.join("..", "..", "Data", "iceland", "political.shp"),
             "false")
        self.compare_xml(written_contents, expected_contents)
        self.validate_data(written_contents)

        session.Destroy()

    def testLayerProjection(self):
        """Test saving layers with projections"""
        # deliberately put an apersand in the title :)
        session = Session("single map&layer")
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        map = Map("Test Map", projection = proj)
        session.AddMap(map)
        # use shapefile from the example data
        shpfile = os.path.join(os.path.dirname(__file__),
                               os.pardir, "Data", "iceland", "political.shp")
        layer = Layer("My Layer", session.OpenShapefile(shpfile))
        proj = Projection(["proj=lcc", "ellps=clrk66"], "Layer Projection")
        layer.SetProjection(proj)
        map.AddLayer(layer)

        filename = self.temp_file_name("save_layerproj.thuban")
        save_session(session, filename)
        session.Destroy()

        file = open(filename)
        written_contents = file.read()
        file.close()
        expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE session SYSTEM "thuban-0.9.dtd">
        <session title="single map&amp;layer"
           xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
            <fileshapesource id="D1" filename="%s" filetype="shapefile"/>
            <map title="Test Map">
                <projection name="Unknown">
                    <parameter value="zone=26"/>
                    <parameter value="proj=utm"/>
                    <parameter value="ellps=clrk66"/>
                </projection>
                <layer title="My Layer" shapestore="D1"
                fill="None" stroke="#000000" stroke_width="1" visible="true">
                    <projection name="Layer Projection">
                        <parameter value="proj=lcc"/>
                        <parameter value="ellps=clrk66"/>
                    </projection>
                </layer>
            </map>
        </session>''' % os.path.join("..", "..", "Data", "iceland",
                                     "political.shp")
        #print written_contents
        #print "********************************************"
        #print expected_contents
        self.compare_xml(written_contents, expected_contents)

        self.validate_data(written_contents)

    def testRasterLayer(self):
        # deliberately put an apersand in the title :)
        session = Session("single map&layer")
        map = Map("Test Map")
        session.AddMap(map)
        # use shapefile from the example data
        imgfile = os.path.join(os.path.dirname(__file__),
                               os.pardir, "Data", "iceland", "island.tif")
        layer = RasterLayer("My RasterLayer", imgfile)
        map.AddLayer(layer)

        filename = self.temp_file_name("save_singlemap.thuban")
        save_session(session, filename)
        session.Destroy()

        file = open(filename)
        written_contents = file.read()
        file.close()
        expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE session SYSTEM "thuban-0.9.dtd">
        <session title="single map&amp;layer"
           xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
            <map title="Test Map">
                <rasterlayer title="My RasterLayer" filename="%s"
                             visible="true">
                </rasterlayer>
            </map>
        </session>''' % os.path.join(os.path.dirname(__file__),
                                     os.pardir, "Data", "iceland",
                                     "island.tif")
        #print written_contents
        #print "********************************************"
        #print expected_contents
        self.compare_xml(written_contents, expected_contents)

        self.validate_data(written_contents)

    def testClassifiedLayer(self):
        """Save a session with a single map with a single layer
           with a classificaton.
        """
        # deliberately put an apersand in the title :)
        session = Session("single map&layer")
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        map = Map("Test Map", projection = proj)
        session.AddMap(map)
        # use shapefile from the example data
        shpfile = os.path.join(os.path.dirname(__file__),
                               os.pardir, "Data", "iceland", "political.shp")
        layer = Layer("My Layer", session.OpenShapefile(shpfile))
        map.AddLayer(layer)

        clazz = layer.GetClassification()

        clazz.SetFieldInfo("AREA", None)

        clazz.AppendGroup(ClassGroupSingleton(42, 
                                           ClassGroupProperties(),
                                           "single"))
        clazz.AppendGroup(ClassGroupSingleton("text", 
                                           ClassGroupProperties(),
                                           "single-text"))

        clazz.AppendGroup(ClassGroupRange((0, 42),
                                           ClassGroupProperties(),
                                           "range"))

        range = ClassGroupRange(Range("[0;42]"))
        range.SetProperties(ClassGroupProperties())
        range.SetLabel("new-range")
        clazz.AppendGroup(range)

        filename = self.temp_file_name("save_singlemap.thuban")
        save_session(session, filename)

        file = open(filename)
        written_contents = file.read()
        file.close()
        expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE session SYSTEM "thuban-0.9.dtd">
        <session title="single map&amp;layer"
           xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
            <fileshapesource id="D1" filename="%s" filetype="shapefile"/>
            <map title="Test Map">
                <projection name="Unknown">
                    <parameter value="zone=26"/>
                    <parameter value="proj=utm"/>
                    <parameter value="ellps=clrk66"/>
                </projection>
                <layer title="My Layer" shapestore="D1"
                fill="None" stroke="#000000" stroke_width="1" visible="%s">
                    <classification field="AREA" field_type="double">
                        <clnull label="">
                            <cldata fill="None" stroke="#000000" stroke_width="1"/>
                        </clnull>
                        <clpoint value="42" label="single">
                            <cldata fill="None" stroke="#000000" stroke_width="1"/>
                        </clpoint>
                        <clpoint value="text" label="single-text">
                            <cldata fill="None" stroke="#000000" stroke_width="1"/>
                        </clpoint>
                        <clrange range="[0;42[" label="range">
                            <cldata fill="None" stroke="#000000" stroke_width="1"/>
                        </clrange>
                        <clrange range="[0;42]" label="new-range">
                            <cldata fill="None" stroke="#000000" stroke_width="1"/>
                        </clrange>
                    </classification>
                </layer>
            </map>
        </session>'''

        expected_contents = expected_template % \
            (os.path.join("..", "..", "Data", "iceland", "political.shp"),
             "true")

        #print written_contents
        #print "********************************************"
        #print expected_contents
        self.compare_xml(written_contents, expected_contents)

        self.validate_data(written_contents)

        session.Destroy()

    def test_dbf_table(self):
        """Test saving a session with a dbf table link"""
        session = Session("a DBF Table session")
        # use shapefile from the example data
        dbffile = os.path.join(os.path.dirname(__file__),
                               os.pardir, "Data", "iceland", "political.dbf")
        table = session.AddTable(DBFTable(dbffile))

        filename = self.temp_file_name("save_singletable.thuban")
        save_session(session, filename)

        file = open(filename)
        written_contents = file.read()
        file.close()
        expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE session SYSTEM "thuban-0.9.dtd">
        <session title="a DBF Table session"
           xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
            <filetable id="D1" filename="%s" filetype="DBF" title="political"/>
        </session>'''

        expected_contents = expected_template % dbffile
        self.compare_xml(written_contents, expected_contents)

    def test_joined_table(self):
        """Test saving a session with joined table"""
        # Create a simple table to use in the join
        dbffile = self.temp_file_name("save_joinedtable.dbf")
        dbf = dbflib.create(dbffile)
        dbf.add_field("RDTYPE", dbflib.FTInteger, 10, 0)
        dbf.add_field("TEXT", dbflib.FTString, 10, 0)
        dbf.write_record(0, {'RDTYPE': 8, "TEXT": "foo"})
        dbf.write_record(1, {'RDTYPE': 2, "TEXT": "bar"})
        dbf.write_record(2, {'RDTYPE': 3, "TEXT": "baz"})
        dbf.close()

        # Create the session and a map
        session = Session("A Joined Table session")
        try:
            map = Map("Test Map")
            session.AddMap(map)

            # Add the dbf file to the session
            dbftable = session.AddTable(DBFTable(dbffile))

            # Create a layer with the shapefile to use in the join
            shpfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
                                   os.pardir, "Data", "iceland",
                                   "roads-line.shp")
            layer = Layer("My Layer", session.OpenShapefile(shpfile))
            map.AddLayer(layer)

            # Do the join
            store = layer.ShapeStore()
            #for col in store.Table().Columns():
            #    print col.name
            joined = TransientJoinedTable(session.TransientDB(),
                                          store.Table(), "RDLNTYPE",
                                          dbftable, "RDTYPE",
                                          outer_join = True)
            store = session.AddShapeStore(DerivedShapeStore(store, joined))
            layer.SetShapeStore(store)

            # Save the session
            filename = self.temp_file_name("save_joinedtable.thuban")
            save_session(session, filename)

            # Read it back and compare
            file = open(filename)
            written_contents = file.read()
            file.close()
            expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
            <!DOCTYPE session SYSTEM "thuban-0.9.dtd">
            <session title="A Joined Table session"
             xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
                <fileshapesource filename="%(shpfile)s"
                                 filetype="shapefile" id="D142197204"/>
                <filetable filename="%(dbffile)s"
                           title="save_joinedtable"
                           filetype="DBF" id="D141881756"/>
                <jointable id="D142180284"
                           title="Join of roads-line and save_joinedtable"
                           leftcolumn="RDLNTYPE" left="D142197204"
                           rightcolumn="RDTYPE" right="D141881756"
                           jointype="LEFT OUTER" />
                <derivedshapesource id="D141915644"
                                    table="D142180284"
                                    shapesource="D142197204"/>
                <map title="Test Map">
                    <layer title="My Layer"
                           shapestore="D141915644" visible="true"
                           stroke="#000000" stroke_width="1" fill="None"/>
                </map>
            </session>'''

            expected_contents = expected_template % {
                "dbffile": relative_filename(self.temp_dir(), dbffile),
                "shpfile": relative_filename(self.temp_dir(), shpfile)
                }
            self.compare_xml(written_contents, expected_contents)
        finally:
            session.Destroy()
            session = None


class MockDataStore:

    """A very simple data store that only has dependencies"""

    def __init__(self, name, *dependencies):
        self.name = name
        self.dependencies = dependencies

    def __repr__(self):
        return self.name

    def Dependencies(self):
        return self.dependencies


class TestStoreSort(unittest.TestCase):

    def check_sort(self, containers, sorted):
        """Check whether the list of data containers is sorted"""
        # check whether sorted is in the right order
        seen = {}
        for container in sorted:
            self.failIf(id(container) in seen,
                        "Container %r at least twice in %r" % (container,
                                                               sorted))
            for dep in container.Dependencies():
                self.assert_(id(dep) in seen,
                             "Dependency %r of %r not yet seen" % (dep,
                                                                   container))
            seen[id(container)] = 1
        # check whether all of containers is in sorted
        for container in containers:
            self.assert_(id(container) in seen,
                         "Container %r in containers but not in sorted")
        self.assertEquals(len(containers), len(sorted))

    def test_sort_data_stores(self):
        """Test Thuban.Model.save.sort_data_stores"""
        d1 = MockDataStore("d1")
        d2 = MockDataStore("d2")
        d3 = MockDataStore("d3", d1)
        d4 = MockDataStore("d4", d1, d3)

        containers = [d4, d1, d2, d3]
        self.check_sort(containers, sort_data_stores(containers))
        containers = [d1, d3, d2, d4]
        self.check_sort(containers, sort_data_stores(containers))


if __name__ == "__main__":
    # Fake the __file__ global because it's needed by a test
    import sys
    __file__ = sys.argv[0]
    support.run_tests()
1	# 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 saving a thuban session as XML
10	"""
11
12	__version__ = "$Revision$"
13	# $Source$
14	# $Id$
15
16	import os
17	import unittest
18	from StringIO import StringIO
19
20	import xml.sax
21	import xml.sax.handler
22	from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException
23
24	import xmlsupport
25
26	import support
27	support.initthuban()
28
29	import dbflib
30
31	from Thuban.Lib.fileutil import relative_filename
32	from Thuban.Model.save import XMLWriter, save_session, sort_data_stores
33	from Thuban.Model.session import Session
34	from Thuban.Model.map import Map
35	from Thuban.Model.layer import Layer, RasterLayer
36	from Thuban.Model.proj import Projection
37	from Thuban.Model.table import DBFTable
38	from Thuban.Model.transientdb import TransientJoinedTable
39	from Thuban.Model.data import DerivedShapeStore
40
41	from Thuban.Model.classification import ClassGroupSingleton, ClassGroupRange, \
42	ClassGroupProperties
43
44	from Thuban.Model.range import Range
45
46
47	class XMLWriterTest(unittest.TestCase):
48
49	def testEncode(self):
50	"""Test XMLWriter.encode"""
51	writer = XMLWriter()
52	eq = self.assertEquals
53
54	eq(writer.encode("hello world"), "hello world")
55	eq(writer.encode(unicode("hello world")), unicode("hello world"))
56
57	eq(writer.encode("\x80\x90\xc2\x100"),
58	"\xc2\x80\xc2\x90\xc3\x82\x100")
59	eq(writer.encode(u"\x80\x90\xc2\x100"),
60	"\xc2\x80\xc2\x90\xc3\x82\x100")
61	eq(writer.encode(u"\xFF5E"), "\xc3\xbf5E")
62
63	eq(writer.encode('&"\'<>'), "&"'<>")
64	eq(writer.encode(unicode('&"\'<>')), "&"'<>")
65
66	class SaveSessionTest(unittest.TestCase, support.FileTestMixin,
67	xmlsupport.ValidationTest):
68
69	dtd = "http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd"
70	thubanids = [((dtd, n), (None, "id")) for n in
71	["fileshapesource", "filetable", "jointable",
72	"derivedshapesource"]]
73	thubanidrefs = [((dtd, n), (None, m)) for n, m in
74	[("layer", "shapestore"),
75	("jointable", "left"),
76	("jointable", "right"),
77	("derivedshapesource", "table"),
78	("derivedshapesource", "shapesource")]]
79	del n, m, dtd
80
81	def compare_xml(self, xml1, xml2):
82	list1 = xmlsupport.sax_eventlist(xml1, ids = self.thubanids,
83	idrefs = self.thubanidrefs)
84	list2 = xmlsupport.sax_eventlist(xml2, ids = self.thubanids,
85	idrefs = self.thubanidrefs)
86	if list1 != list2:
87	for a, b in zip(list1, list2):
88	if a != b:
89	self.fail("%r != %r" % (a, b))
90
91
92	def testEmptySession(self):
93	"""Save an empty session"""
94	session = Session("empty session")
95	filename = self.temp_file_name("save_emptysession.thuban")
96	save_session(session, filename)
97	session.Destroy()
98
99	file = open(filename)
100	written_contents = file.read()
101	file.close()
102	self.compare_xml(written_contents,
103	'<?xml version="1.0" encoding="UTF-8"?>\n'
104	'<!DOCTYPE session SYSTEM "thuban-0.9.dtd">\n'
105	'<session title="empty session" '
106	'xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">'
107	'\n</session>\n')
108
109	self.validate_data(written_contents)
110
111	def testSingleLayer(self):
112	"""Save a session with a single map with a single layer"""
113	# deliberately put an apersand in the title :)
114	session = Session("single map&layer")
115	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
116	map = Map("Test Map", projection = proj)
117	session.AddMap(map)
118	# use shapefile from the example data
119	shpfile = os.path.join(os.path.dirname(__file__),
120	os.pardir, "Data", "iceland", "political.shp")
121	layer = Layer("My Layer", session.OpenShapefile(shpfile))
122	map.AddLayer(layer)
123
124	filename = self.temp_file_name("save_singlemap.thuban")
125	save_session(session, filename)
126
127	file = open(filename)
128	written_contents = file.read()
129	file.close()
130	expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
131	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
132	<session title="single map&layer"
133	xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
134	<fileshapesource id="D1" filename="%s" filetype="shapefile"/>
135	<map title="Test Map">
136	<projection name="Unknown">
137	<parameter value="zone=26"/>
138	<parameter value="proj=utm"/>
139	<parameter value="ellps=clrk66"/>
140	</projection>
141	<layer title="My Layer" shapestore="D1"
142	fill="None" stroke="#000000" stroke_width="1" visible="%s"/>
143	</map>
144	</session>'''
145
146	expected_contents = expected_template % \
147	(os.path.join("..", "..", "Data", "iceland", "political.shp"),
148	"true")
149
150	self.compare_xml(written_contents, expected_contents)
151
152	self.validate_data(written_contents)
153
154	layer.SetVisible(False)
155	save_session(session, filename)
156
157	file = open(filename)
158	written_contents = file.read()
159	file.close()
160	expected_contents = expected_template % \
161	(os.path.join("..", "..", "Data", "iceland", "political.shp"),
162	"false")
163	self.compare_xml(written_contents, expected_contents)
164	self.validate_data(written_contents)
165
166	session.Destroy()
167
168	def testLayerProjection(self):
169	"""Test saving layers with projections"""
170	# deliberately put an apersand in the title :)
171	session = Session("single map&layer")
172	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
173	map = Map("Test Map", projection = proj)
174	session.AddMap(map)
175	# use shapefile from the example data
176	shpfile = os.path.join(os.path.dirname(__file__),
177	os.pardir, "Data", "iceland", "political.shp")
178	layer = Layer("My Layer", session.OpenShapefile(shpfile))
179	proj = Projection(["proj=lcc", "ellps=clrk66"], "Layer Projection")
180	layer.SetProjection(proj)
181	map.AddLayer(layer)
182
183	filename = self.temp_file_name("save_layerproj.thuban")
184	save_session(session, filename)
185	session.Destroy()
186
187	file = open(filename)
188	written_contents = file.read()
189	file.close()
190	expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
191	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
192	<session title="single map&layer"
193	xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
194	<fileshapesource id="D1" filename="%s" filetype="shapefile"/>
195	<map title="Test Map">
196	<projection name="Unknown">
197	<parameter value="zone=26"/>
198	<parameter value="proj=utm"/>
199	<parameter value="ellps=clrk66"/>
200	</projection>
201	<layer title="My Layer" shapestore="D1"
202	fill="None" stroke="#000000" stroke_width="1" visible="true">
203	<projection name="Layer Projection">
204	<parameter value="proj=lcc"/>
205	<parameter value="ellps=clrk66"/>
206	</projection>
207	</layer>
208	</map>
209	</session>''' % os.path.join("..", "..", "Data", "iceland",
210	"political.shp")
211	#print written_contents
212	#print "********************************************"
213	#print expected_contents
214	self.compare_xml(written_contents, expected_contents)
215
216	self.validate_data(written_contents)
217
218	def testRasterLayer(self):
219	# deliberately put an apersand in the title :)
220	session = Session("single map&layer")
221	map = Map("Test Map")
222	session.AddMap(map)
223	# use shapefile from the example data
224	imgfile = os.path.join(os.path.dirname(__file__),
225	os.pardir, "Data", "iceland", "island.tif")
226	layer = RasterLayer("My RasterLayer", imgfile)
227	map.AddLayer(layer)
228
229	filename = self.temp_file_name("save_singlemap.thuban")
230	save_session(session, filename)
231	session.Destroy()
232
233	file = open(filename)
234	written_contents = file.read()
235	file.close()
236	expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
237	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
238	<session title="single map&layer"
239	xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
240	<map title="Test Map">
241	<rasterlayer title="My RasterLayer" filename="%s"
242	visible="true">
243	</rasterlayer>
244	</map>
245	</session>''' % os.path.join(os.path.dirname(__file__),
246	os.pardir, "Data", "iceland",
247	"island.tif")
248	#print written_contents
249	#print "********************************************"
250	#print expected_contents
251	self.compare_xml(written_contents, expected_contents)
252
253	self.validate_data(written_contents)
254
255	def testClassifiedLayer(self):
256	"""Save a session with a single map with a single layer
257	with a classificaton.
258	"""
259	# deliberately put an apersand in the title :)
260	session = Session("single map&layer")
261	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
262	map = Map("Test Map", projection = proj)
263	session.AddMap(map)
264	# use shapefile from the example data
265	shpfile = os.path.join(os.path.dirname(__file__),
266	os.pardir, "Data", "iceland", "political.shp")
267	layer = Layer("My Layer", session.OpenShapefile(shpfile))
268	map.AddLayer(layer)
269
270	clazz = layer.GetClassification()
271
272	clazz.SetFieldInfo("AREA", None)
273
274	clazz.AppendGroup(ClassGroupSingleton(42,
275	ClassGroupProperties(),
276	"single"))
277	clazz.AppendGroup(ClassGroupSingleton("text",
278	ClassGroupProperties(),
279	"single-text"))
280
281	clazz.AppendGroup(ClassGroupRange((0, 42),
282	ClassGroupProperties(),
283	"range"))
284
285	range = ClassGroupRange(Range("[0;42]"))
286	range.SetProperties(ClassGroupProperties())
287	range.SetLabel("new-range")
288	clazz.AppendGroup(range)
289
290	filename = self.temp_file_name("save_singlemap.thuban")
291	save_session(session, filename)
292
293	file = open(filename)
294	written_contents = file.read()
295	file.close()
296	expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
297	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
298	<session title="single map&layer"
299	xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
300	<fileshapesource id="D1" filename="%s" filetype="shapefile"/>
301	<map title="Test Map">
302	<projection name="Unknown">
303	<parameter value="zone=26"/>
304	<parameter value="proj=utm"/>
305	<parameter value="ellps=clrk66"/>
306	</projection>
307	<layer title="My Layer" shapestore="D1"
308	fill="None" stroke="#000000" stroke_width="1" visible="%s">
309	<classification field="AREA" field_type="double">
310	<clnull label="">
311	<cldata fill="None" stroke="#000000" stroke_width="1"/>
312	</clnull>
313	<clpoint value="42" label="single">
314	<cldata fill="None" stroke="#000000" stroke_width="1"/>
315	</clpoint>
316	<clpoint value="text" label="single-text">
317	<cldata fill="None" stroke="#000000" stroke_width="1"/>
318	</clpoint>
319	<clrange range="[0;42[" label="range">
320	<cldata fill="None" stroke="#000000" stroke_width="1"/>
321	</clrange>
322	<clrange range="[0;42]" label="new-range">
323	<cldata fill="None" stroke="#000000" stroke_width="1"/>
324	</clrange>
325	</classification>
326	</layer>
327	</map>
328	</session>'''
329
330	expected_contents = expected_template % \
331	(os.path.join("..", "..", "Data", "iceland", "political.shp"),
332	"true")
333
334	#print written_contents
335	#print "********************************************"
336	#print expected_contents
337	self.compare_xml(written_contents, expected_contents)
338
339	self.validate_data(written_contents)
340
341	session.Destroy()
342
343	def test_dbf_table(self):
344	"""Test saving a session with a dbf table link"""
345	session = Session("a DBF Table session")
346	# use shapefile from the example data
347	dbffile = os.path.join(os.path.dirname(__file__),
348	os.pardir, "Data", "iceland", "political.dbf")
349	table = session.AddTable(DBFTable(dbffile))
350
351	filename = self.temp_file_name("save_singletable.thuban")
352	save_session(session, filename)
353
354	file = open(filename)
355	written_contents = file.read()
356	file.close()
357	expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
358	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
359	<session title="a DBF Table session"
360	xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
361	<filetable id="D1" filename="%s" filetype="DBF" title="political"/>
362	</session>'''
363
364	expected_contents = expected_template % dbffile
365	self.compare_xml(written_contents, expected_contents)
366
367	def test_joined_table(self):
368	"""Test saving a session with joined table"""
369	# Create a simple table to use in the join
370	dbffile = self.temp_file_name("save_joinedtable.dbf")
371	dbf = dbflib.create(dbffile)
372	dbf.add_field("RDTYPE", dbflib.FTInteger, 10, 0)
373	dbf.add_field("TEXT", dbflib.FTString, 10, 0)
374	dbf.write_record(0, {'RDTYPE': 8, "TEXT": "foo"})
375	dbf.write_record(1, {'RDTYPE': 2, "TEXT": "bar"})
376	dbf.write_record(2, {'RDTYPE': 3, "TEXT": "baz"})
377	dbf.close()
378
379	# Create the session and a map
380	session = Session("A Joined Table session")
381	try:
382	map = Map("Test Map")
383	session.AddMap(map)
384
385	# Add the dbf file to the session
386	dbftable = session.AddTable(DBFTable(dbffile))
387
388	# Create a layer with the shapefile to use in the join
389	shpfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
390	os.pardir, "Data", "iceland",
391	"roads-line.shp")
392	layer = Layer("My Layer", session.OpenShapefile(shpfile))
393	map.AddLayer(layer)
394
395	# Do the join
396	store = layer.ShapeStore()
397	#for col in store.Table().Columns():
398	# print col.name
399	joined = TransientJoinedTable(session.TransientDB(),
400	store.Table(), "RDLNTYPE",
401	dbftable, "RDTYPE",
402	outer_join = True)
403	store = session.AddShapeStore(DerivedShapeStore(store, joined))
404	layer.SetShapeStore(store)
405
406	# Save the session
407	filename = self.temp_file_name("save_joinedtable.thuban")
408	save_session(session, filename)
409
410	# Read it back and compare
411	file = open(filename)
412	written_contents = file.read()
413	file.close()
414	expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
415	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
416	<session title="A Joined Table session"
417	xmlns="http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd">
418	<fileshapesource filename="%(shpfile)s"
419	filetype="shapefile" id="D142197204"/>
420	<filetable filename="%(dbffile)s"
421	title="save_joinedtable"
422	filetype="DBF" id="D141881756"/>
423	<jointable id="D142180284"
424	title="Join of roads-line and save_joinedtable"
425	leftcolumn="RDLNTYPE" left="D142197204"
426	rightcolumn="RDTYPE" right="D141881756"
427	jointype="LEFT OUTER" />
428	<derivedshapesource id="D141915644"
429	table="D142180284"
430	shapesource="D142197204"/>
431	<map title="Test Map">
432	<layer title="My Layer"
433	shapestore="D141915644" visible="true"
434	stroke="#000000" stroke_width="1" fill="None"/>
435	</map>
436	</session>'''
437
438	expected_contents = expected_template % {
439	"dbffile": relative_filename(self.temp_dir(), dbffile),
440	"shpfile": relative_filename(self.temp_dir(), shpfile)
441	}
442	self.compare_xml(written_contents, expected_contents)
443	finally:
444	session.Destroy()
445	session = None
446
447
448	class MockDataStore:
449
450	"""A very simple data store that only has dependencies"""
451
452	def __init__(self, name, *dependencies):
453	self.name = name
454	self.dependencies = dependencies
455
456	def __repr__(self):
457	return self.name
458
459	def Dependencies(self):
460	return self.dependencies
461
462
463	class TestStoreSort(unittest.TestCase):
464
465	def check_sort(self, containers, sorted):
466	"""Check whether the list of data containers is sorted"""
467	# check whether sorted is in the right order
468	seen = {}
469	for container in sorted:
470	self.failIf(id(container) in seen,
471	"Container %r at least twice in %r" % (container,
472	sorted))
473	for dep in container.Dependencies():
474	self.assert_(id(dep) in seen,
475	"Dependency %r of %r not yet seen" % (dep,
476	container))
477	seen[id(container)] = 1
478	# check whether all of containers is in sorted
479	for container in containers:
480	self.assert_(id(container) in seen,
481	"Container %r in containers but not in sorted")
482	self.assertEquals(len(containers), len(sorted))
483
484	def test_sort_data_stores(self):
485	"""Test Thuban.Model.save.sort_data_stores"""
486	d1 = MockDataStore("d1")
487	d2 = MockDataStore("d2")
488	d3 = MockDataStore("d3", d1)
489	d4 = MockDataStore("d4", d1, d3)
490
491	containers = [d4, d1, d2, d3]
492	self.check_sort(containers, sort_data_stores(containers))
493	containers = [d1, d3, d2, d4]
494	self.check_sort(containers, sort_data_stores(containers))
495
496
497
498	if __name__ == "__main__":
499	# Fake the __file__ global because it's needed by a test
500	import sys
501	__file__ = sys.argv[0]
502	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision