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 xmlsupport
import postgissupport

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

from Thuban.Model.postgisdb import PostGISConnection, PostGISShapeStore


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.dtd"
    thubanids = [((dtd, n), (None, "id")) for n in
                 ["fileshapesource", "filetable", "jointable",
                  "derivedshapesource", "dbshapesource", "dbconnection"]]
    thubanidrefs = [((dtd, n), (None, m)) for n, m in
                    [("layer", "shapestore"),
                     ("jointable", "left"),
                     ("jointable", "right"),
                     ("derivedshapesource", "table"),
                     ("derivedshapesource", "shapesource"),
                     ("dbshapesource", "dbconn")]]
    del n, m, dtd

    def tearDown(self):
        """Call self.session.Destroy

        Test cases that create session should bind it to self.session so
        that it gets destroyed properly
        """
        if hasattr(self, "session"):
            self.session.Destroy()
            self.session = None

    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.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.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 = self.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",
                           "lat_1=0", "lat_2=20"],
                          "Layer Projection")
        layer.SetProjection(proj)
        map.AddLayer(layer)

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

        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.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"/>
                        <parameter value="lat_1=0"/>
                        <parameter value="lat_2=20"/>
                    </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("%s.thuban" % self.id())
        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.dtd">
            <map title="Test Map">
                <rasterlayer title="My RasterLayer" filename="%s"
                             visible="true">
                </rasterlayer>
            </map>
        </session>''' % os.path.join(os.pardir, 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 classifications"""
        # deliberately put an apersand in the title :)
        session = Session("Map with Classifications")
        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)
        layer2 = Layer("My Layer", layer.ShapeStore())
        map.AddLayer(layer2)

        clazz = layer.GetClassification()

        layer.SetClassificationColumn("AREA")

        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)


        clazz = layer2.GetClassification()
        layer2.SetClassificationColumn("POPYCOUN")

        # Classification with Latin 1 text
        clazz.AppendGroup(ClassGroupSingleton('\xe4\xf6\xfc', # ae, oe, ue
                                              ClassGroupProperties(),
                                              '\xdcml\xe4uts')) # Uemlaeuts


        filename = self.temp_file_name("%s.thuban" % self.id())
        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="Map with Classifications"
           xmlns="http://thuban.intevation.org/dtds/thuban-0.9.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>
                <layer title="My Layer" shapestore="D1"
                fill="None" stroke="#000000" stroke_width="1" visible="true">
                    <classification field="POPYCOUN" field_type="string">
                        <clnull label="">
                            <cldata fill="None" stroke="#000000" stroke_width="1"/>
                        </clnull>
                        <clpoint value="\xc3\xa4\xc3\xb6\xc3\xbc"
                             label="\xc3\x9cml\xc3\xa4uts">
                            <cldata fill="None" stroke="#000000" stroke_width="1"/>
                        </clpoint>
                    </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 = self.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.dtd">
            <filetable id="D1" filename="%s" filetype="DBF" title="political"/>
        </session>'''

        expected_contents = (expected_template
                             % os.path.join(os.pardir, os.pardir, "Data",
                                            "iceland", "political.dbf"))
        self.compare_xml(written_contents, expected_contents)
        self.validate_data(written_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.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)
            self.validate_data(written_contents)
        finally:
            session.Destroy()
            session = None


    def test_save_postgis(self):
        """Test saving a session with a postgis connection"""

        class NonConnection(PostGISConnection):
            """connection class that doesn't actually connect """
            def connect(self):
                pass

        class NonConnectionStore(PostGISShapeStore):
            """Shapestore that doesn't try to access the server"""
            def _fetch_table_information(self):
                pass

        session = Session("A PostGIS Session")
        try:
            dbconn = NonConnection(dbname="plugh", host="xyzzy", port="42",
                                   user="grue")
            session.AddDBConnection(dbconn)
            map = Map("Test Map")
            session.AddMap(map)
            store = NonConnectionStore(dbconn, "roads")
            session.AddShapeStore(store)
            layer = Layer("Roads to Nowhere", store)
            map.AddLayer(layer)

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

            # Read it back and compare
            file = open(filename)
            written = file.read()
            file.close()
            expected = '''<?xml version="1.0" encoding="UTF-8"?>
            <!DOCTYPE session SYSTEM "thuban-0.9.dtd">
            <session title="A PostGIS Session"
             xmlns="http://thuban.intevation.org/dtds/thuban-0.9.dtd">
                <dbconnection id="DB"
                              dbtype="postgis" dbname="plugh"
                              host="xyzzy" port="42"
                              user="grue"/>
                <dbshapesource id="roads" dbconn="DB" tablename="roads"/>
                <map title="Test Map">
                    <layer title="Roads to Nowhere"
                           shapestore="roads" visible="true"
                           stroke="#000000" stroke_width="1" fill="None"/>
                </map>
            </session>'''
            self.compare_xml(written, expected)
            self.validate_data(written)
        finally:
            session.Destroy()


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	bh	723	# Copyright (c) 2002, 2003 by Intevation GmbH
2	bh	292	# 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	bh	1245	import xmlsupport
21	bh	1638	import postgissupport
22	bh	1245
23	bh	292	import support
24			support.initthuban()
25
26	bh	1268	import dbflib
27
28			from Thuban.Lib.fileutil import relative_filename
29			from Thuban.Model.save import XMLWriter, save_session, sort_data_stores
30	bh	292	from Thuban.Model.session import Session
31			from Thuban.Model.map import Map
32	jonathan	947	from Thuban.Model.layer import Layer, RasterLayer
33	bh	292	from Thuban.Model.proj import Projection
34	bh	1268	from Thuban.Model.table import DBFTable
35			from Thuban.Model.transientdb import TransientJoinedTable
36			from Thuban.Model.data import DerivedShapeStore
37	bh	292
38	jonathan	1168	from Thuban.Model.classification import ClassGroupSingleton, ClassGroupRange, \
39			ClassGroupProperties
40	bh	292
41	jonathan	1168	from Thuban.Model.range import Range
42
43	bh	1638	from Thuban.Model.postgisdb import PostGISConnection, PostGISShapeStore
44	jonathan	1168
45	bh	1638
46	jonathan	1168	class XMLWriterTest(unittest.TestCase):
47
48			def testEncode(self):
49			"""Test XMLWriter.encode"""
50			writer = XMLWriter()
51	jonathan	1200	eq = self.assertEquals
52	jonathan	1168
53	jonathan	1200	eq(writer.encode("hello world"), "hello world")
54			eq(writer.encode(unicode("hello world")), unicode("hello world"))
55	jonathan	1173
56	jonathan	1200	eq(writer.encode("\x80\x90\xc2\x100"),
57			"\xc2\x80\xc2\x90\xc3\x82\x100")
58			eq(writer.encode(u"\x80\x90\xc2\x100"),
59			"\xc2\x80\xc2\x90\xc3\x82\x100")
60			eq(writer.encode(u"\xFF5E"), "\xc3\xbf5E")
61	jonathan	1173
62	jonathan	1200	eq(writer.encode('&"\'<>'), "&"'<>")
63			eq(writer.encode(unicode('&"\'<>')), "&"'<>")
64	jonathan	1168
65	bh	1245	class SaveSessionTest(unittest.TestCase, support.FileTestMixin,
66			xmlsupport.ValidationTest):
67	bh	292
68	bh	1664	dtd = "http://thuban.intevation.org/dtds/thuban-0.9.dtd"
69	bh	1268	thubanids = [((dtd, n), (None, "id")) for n in
70			["fileshapesource", "filetable", "jointable",
71	bh	1638	"derivedshapesource", "dbshapesource", "dbconnection"]]
72	bh	1268	thubanidrefs = [((dtd, n), (None, m)) for n, m in
73			[("layer", "shapestore"),
74			("jointable", "left"),
75			("jointable", "right"),
76			("derivedshapesource", "table"),
77	bh	1638	("derivedshapesource", "shapesource"),
78			("dbshapesource", "dbconn")]]
79	bh	1268	del n, m, dtd
80
81	bh	1677	def tearDown(self):
82			"""Call self.session.Destroy
83
84			Test cases that create session should bind it to self.session so
85			that it gets destroyed properly
86			"""
87			if hasattr(self, "session"):
88			self.session.Destroy()
89			self.session = None
90
91	bh	292	def compare_xml(self, xml1, xml2):
92	bh	1375	list1 = xmlsupport.sax_eventlist(xml1, ids = self.thubanids,
93			idrefs = self.thubanidrefs)
94			list2 = xmlsupport.sax_eventlist(xml2, ids = self.thubanids,
95			idrefs = self.thubanidrefs)
96			if list1 != list2:
97			for a, b in zip(list1, list2):
98			if a != b:
99			self.fail("%r != %r" % (a, b))
100	bh	292
101	bh	1375
102	bh	292	def testEmptySession(self):
103			"""Save an empty session"""
104			session = Session("empty session")
105			filename = self.temp_file_name("save_emptysession.thuban")
106			save_session(session, filename)
107			session.Destroy()
108
109			file = open(filename)
110			written_contents = file.read()
111			file.close()
112			self.compare_xml(written_contents,
113			'<?xml version="1.0" encoding="UTF-8"?>\n'
114	bh	1375	'<!DOCTYPE session SYSTEM "thuban-0.9.dtd">\n'
115	bh	1268	'<session title="empty session" '
116	bh	1664	'xmlns="http://thuban.intevation.org/dtds/thuban-0.9.dtd">'
117	bh	1268	'\n</session>\n')
118	bh	292
119	bh	1245	self.validate_data(written_contents)
120
121	bh	292	def testSingleLayer(self):
122			"""Save a session with a single map with a single layer"""
123			# deliberately put an apersand in the title :)
124			session = Session("single map&layer")
125			proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
126			map = Map("Test Map", projection = proj)
127			session.AddMap(map)
128			# use shapefile from the example data
129			shpfile = os.path.join(os.path.dirname(__file__),
130			os.pardir, "Data", "iceland", "political.shp")
131	bh	723	layer = Layer("My Layer", session.OpenShapefile(shpfile))
132	bh	292	map.AddLayer(layer)
133
134			filename = self.temp_file_name("save_singlemap.thuban")
135			save_session(session, filename)
136
137			file = open(filename)
138			written_contents = file.read()
139			file.close()
140	jonathan	775	expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
141	bh	1375	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
142	bh	1268	<session title="single map&layer"
143	bh	1664	xmlns="http://thuban.intevation.org/dtds/thuban-0.9.dtd">
144	bh	1268	<fileshapesource id="D1" filename="%s" filetype="shapefile"/>
145	bh	292	<map title="Test Map">
146	jonathan	755	<projection name="Unknown">
147	bh	292	<parameter value="zone=26"/>
148			<parameter value="proj=utm"/>
149			<parameter value="ellps=clrk66"/>
150			</projection>
151	bh	1268	<layer title="My Layer" shapestore="D1"
152	jonathan	775	fill="None" stroke="#000000" stroke_width="1" visible="%s"/>
153	bh	292	</map>
154	bh	1268	</session>'''
155
156	jonathan	775	expected_contents = expected_template % \
157			(os.path.join("..", "..", "Data", "iceland", "political.shp"),
158			"true")
159
160	bh	292	self.compare_xml(written_contents, expected_contents)
161
162	bh	1245	self.validate_data(written_contents)
163
164	jonathan	775	layer.SetVisible(False)
165			save_session(session, filename)
166
167			file = open(filename)
168			written_contents = file.read()
169			file.close()
170			expected_contents = expected_template % \
171			(os.path.join("..", "..", "Data", "iceland", "political.shp"),
172			"false")
173			self.compare_xml(written_contents, expected_contents)
174	bh	1245	self.validate_data(written_contents)
175	jonathan	775
176			session.Destroy()
177
178	jonathan	755	def testLayerProjection(self):
179	bh	1268	"""Test saving layers with projections"""
180	jonathan	755	# deliberately put an apersand in the title :)
181	bh	1678	session = self.session = Session("single map&layer")
182	jonathan	755	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
183			map = Map("Test Map", projection = proj)
184			session.AddMap(map)
185			# use shapefile from the example data
186			shpfile = os.path.join(os.path.dirname(__file__),
187			os.pardir, "Data", "iceland", "political.shp")
188			layer = Layer("My Layer", session.OpenShapefile(shpfile))
189	bh	1687	proj = Projection(["proj=lcc", "ellps=clrk66",
190			"lat_1=0", "lat_2=20"],
191			"Layer Projection")
192	jonathan	755	layer.SetProjection(proj)
193			map.AddLayer(layer)
194	bh	292
195	bh	1268	filename = self.temp_file_name("save_layerproj.thuban")
196	jonathan	755	save_session(session, filename)
197	bh	292
198	jonathan	755	file = open(filename)
199			written_contents = file.read()
200			file.close()
201			expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
202	bh	1375	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
203	bh	1268	<session title="single map&layer"
204	bh	1664	xmlns="http://thuban.intevation.org/dtds/thuban-0.9.dtd">
205	bh	1268	<fileshapesource id="D1" filename="%s" filetype="shapefile"/>
206	jonathan	755	<map title="Test Map">
207			<projection name="Unknown">
208			<parameter value="zone=26"/>
209			<parameter value="proj=utm"/>
210			<parameter value="ellps=clrk66"/>
211			</projection>
212	bh	1268	<layer title="My Layer" shapestore="D1"
213	jonathan	775	fill="None" stroke="#000000" stroke_width="1" visible="true">
214	jonathan	755	<projection name="Layer Projection">
215			<parameter value="proj=lcc"/>
216			<parameter value="ellps=clrk66"/>
217	bh	1687	<parameter value="lat_1=0"/>
218			<parameter value="lat_2=20"/>
219	jonathan	755	</projection>
220			</layer>
221			</map>
222			</session>''' % os.path.join("..", "..", "Data", "iceland",
223			"political.shp")
224			#print written_contents
225			#print "********************************************"
226			#print expected_contents
227			self.compare_xml(written_contents, expected_contents)
228
229	bh	1245	self.validate_data(written_contents)
230
231	jonathan	947	def testRasterLayer(self):
232			# deliberately put an apersand in the title :)
233			session = Session("single map&layer")
234			map = Map("Test Map")
235			session.AddMap(map)
236			# use shapefile from the example data
237			imgfile = os.path.join(os.path.dirname(__file__),
238			os.pardir, "Data", "iceland", "island.tif")
239			layer = RasterLayer("My RasterLayer", imgfile)
240			map.AddLayer(layer)
241	bh	1245
242	bh	1599	filename = self.temp_file_name("%s.thuban" % self.id())
243	jonathan	947	save_session(session, filename)
244			session.Destroy()
245	bh	1245
246	jonathan	947	file = open(filename)
247			written_contents = file.read()
248			file.close()
249			expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
250	bh	1375	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
251	bh	1268	<session title="single map&layer"
252	bh	1664	xmlns="http://thuban.intevation.org/dtds/thuban-0.9.dtd">
253	jonathan	947	<map title="Test Map">
254	bh	1268	<rasterlayer title="My RasterLayer" filename="%s"
255	jonathan	947	visible="true">
256			</rasterlayer>
257			</map>
258	bh	1599	</session>''' % os.path.join(os.pardir, os.pardir, "Data", "iceland",
259	jonathan	947	"island.tif")
260			#print written_contents
261			#print "********************************************"
262			#print expected_contents
263			self.compare_xml(written_contents, expected_contents)
264	jonathan	755
265	bh	1245	self.validate_data(written_contents)
266
267	jonathan	1168	def testClassifiedLayer(self):
268	bh	1417	"""Save a session with a single map with classifications"""
269	jonathan	1168	# deliberately put an apersand in the title :)
270	bh	1417	session = Session("Map with Classifications")
271	jonathan	1168	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
272			map = Map("Test Map", projection = proj)
273			session.AddMap(map)
274			# use shapefile from the example data
275			shpfile = os.path.join(os.path.dirname(__file__),
276			os.pardir, "Data", "iceland", "political.shp")
277			layer = Layer("My Layer", session.OpenShapefile(shpfile))
278			map.AddLayer(layer)
279	bh	1417	layer2 = Layer("My Layer", layer.ShapeStore())
280			map.AddLayer(layer2)
281	jonathan	755
282	jonathan	1168	clazz = layer.GetClassification()
283
284	bh	1452	layer.SetClassificationColumn("AREA")
285	jonathan	1168
286	bh	1417	clazz.AppendGroup(ClassGroupSingleton(42, ClassGroupProperties(),
287			"single"))
288			clazz.AppendGroup(ClassGroupSingleton("text", ClassGroupProperties(),
289			"single-text"))
290	jonathan	1168
291	jonathan	1357	clazz.AppendGroup(ClassGroupRange((0, 42),
292	jonathan	1168	ClassGroupProperties(),
293			"range"))
294
295			range = ClassGroupRange(Range("[0;42]"))
296			range.SetProperties(ClassGroupProperties())
297			range.SetLabel("new-range")
298			clazz.AppendGroup(range)
299
300	bh	1417
301			clazz = layer2.GetClassification()
302	bh	1452	layer2.SetClassificationColumn("POPYCOUN")
303	bh	1417
304			# Classification with Latin 1 text
305			clazz.AppendGroup(ClassGroupSingleton('\xe4\xf6\xfc', # ae, oe, ue
306			ClassGroupProperties(),
307			'\xdcml\xe4uts')) # Uemlaeuts
308
309
310			filename = self.temp_file_name("%s.thuban" % self.id())
311	jonathan	1168	save_session(session, filename)
312
313			file = open(filename)
314			written_contents = file.read()
315			file.close()
316			expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
317	bh	1375	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
318	bh	1417	<session title="Map with Classifications"
319	bh	1664	xmlns="http://thuban.intevation.org/dtds/thuban-0.9.dtd">
320	bh	1268	<fileshapesource id="D1" filename="%s" filetype="shapefile"/>
321	jonathan	1168	<map title="Test Map">
322			<projection name="Unknown">
323			<parameter value="zone=26"/>
324			<parameter value="proj=utm"/>
325			<parameter value="ellps=clrk66"/>
326			</projection>
327	bh	1268	<layer title="My Layer" shapestore="D1"
328	jonathan	1168	fill="None" stroke="#000000" stroke_width="1" visible="%s">
329			<classification field="AREA" field_type="double">
330			<clnull label="">
331			<cldata fill="None" stroke="#000000" stroke_width="1"/>
332			</clnull>
333			<clpoint value="42" label="single">
334			<cldata fill="None" stroke="#000000" stroke_width="1"/>
335			</clpoint>
336			<clpoint value="text" label="single-text">
337			<cldata fill="None" stroke="#000000" stroke_width="1"/>
338			</clpoint>
339			<clrange range="[0;42[" label="range">
340			<cldata fill="None" stroke="#000000" stroke_width="1"/>
341			</clrange>
342			<clrange range="[0;42]" label="new-range">
343			<cldata fill="None" stroke="#000000" stroke_width="1"/>
344			</clrange>
345			</classification>
346			</layer>
347	bh	1417	<layer title="My Layer" shapestore="D1"
348			fill="None" stroke="#000000" stroke_width="1" visible="true">
349			<classification field="POPYCOUN" field_type="string">
350			<clnull label="">
351			<cldata fill="None" stroke="#000000" stroke_width="1"/>
352			</clnull>
353			<clpoint value="\xc3\xa4\xc3\xb6\xc3\xbc"
354			label="\xc3\x9cml\xc3\xa4uts">
355			<cldata fill="None" stroke="#000000" stroke_width="1"/>
356			</clpoint>
357			</classification>
358			</layer>
359	jonathan	1168	</map>
360	bh	1245	</session>'''
361
362	jonathan	1168	expected_contents = expected_template % \
363			(os.path.join("..", "..", "Data", "iceland", "political.shp"),
364			"true")
365
366			#print written_contents
367			#print "********************************************"
368			#print expected_contents
369			self.compare_xml(written_contents, expected_contents)
370
371	bh	1245	self.validate_data(written_contents)
372
373	jonathan	1168	session.Destroy()
374
375	bh	1268	def test_dbf_table(self):
376			"""Test saving a session with a dbf table link"""
377	bh	1677	session = self.session = Session("a DBF Table session")
378	bh	1268	# use shapefile from the example data
379			dbffile = os.path.join(os.path.dirname(__file__),
380			os.pardir, "Data", "iceland", "political.dbf")
381			table = session.AddTable(DBFTable(dbffile))
382	jonathan	1168
383	bh	1268	filename = self.temp_file_name("save_singletable.thuban")
384			save_session(session, filename)
385
386			file = open(filename)
387			written_contents = file.read()
388			file.close()
389			expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
390	bh	1375	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
391	bh	1268	<session title="a DBF Table session"
392	bh	1664	xmlns="http://thuban.intevation.org/dtds/thuban-0.9.dtd">
393	bh	1268	<filetable id="D1" filename="%s" filetype="DBF" title="political"/>
394			</session>'''
395
396	bh	1599	expected_contents = (expected_template
397			% os.path.join(os.pardir, os.pardir, "Data",
398			"iceland", "political.dbf"))
399	bh	1268	self.compare_xml(written_contents, expected_contents)
400	bh	1640	self.validate_data(written_contents)
401	bh	1268
402			def test_joined_table(self):
403			"""Test saving a session with joined table"""
404			# Create a simple table to use in the join
405			dbffile = self.temp_file_name("save_joinedtable.dbf")
406			dbf = dbflib.create(dbffile)
407			dbf.add_field("RDTYPE", dbflib.FTInteger, 10, 0)
408			dbf.add_field("TEXT", dbflib.FTString, 10, 0)
409			dbf.write_record(0, {'RDTYPE': 8, "TEXT": "foo"})
410			dbf.write_record(1, {'RDTYPE': 2, "TEXT": "bar"})
411			dbf.write_record(2, {'RDTYPE': 3, "TEXT": "baz"})
412			dbf.close()
413
414			# Create the session and a map
415			session = Session("A Joined Table session")
416			try:
417			map = Map("Test Map")
418			session.AddMap(map)
419
420			# Add the dbf file to the session
421			dbftable = session.AddTable(DBFTable(dbffile))
422
423			# Create a layer with the shapefile to use in the join
424			shpfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
425			os.pardir, "Data", "iceland",
426			"roads-line.shp")
427			layer = Layer("My Layer", session.OpenShapefile(shpfile))
428			map.AddLayer(layer)
429
430			# Do the join
431			store = layer.ShapeStore()
432			#for col in store.Table().Columns():
433			# print col.name
434			joined = TransientJoinedTable(session.TransientDB(),
435			store.Table(), "RDLNTYPE",
436	bh	1375	dbftable, "RDTYPE",
437			outer_join = True)
438	bh	1268	store = session.AddShapeStore(DerivedShapeStore(store, joined))
439			layer.SetShapeStore(store)
440
441			# Save the session
442			filename = self.temp_file_name("save_joinedtable.thuban")
443			save_session(session, filename)
444
445			# Read it back and compare
446			file = open(filename)
447			written_contents = file.read()
448			file.close()
449			expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
450	bh	1375	<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
451	bh	1268	<session title="A Joined Table session"
452	bh	1664	xmlns="http://thuban.intevation.org/dtds/thuban-0.9.dtd">
453	bh	1268	<fileshapesource filename="%(shpfile)s"
454			filetype="shapefile" id="D142197204"/>
455			<filetable filename="%(dbffile)s"
456			title="save_joinedtable"
457			filetype="DBF" id="D141881756"/>
458			<jointable id="D142180284"
459			title="Join of roads-line and save_joinedtable"
460			leftcolumn="RDLNTYPE" left="D142197204"
461	bh	1375	rightcolumn="RDTYPE" right="D141881756"
462			jointype="LEFT OUTER" />
463	bh	1268	<derivedshapesource id="D141915644"
464			table="D142180284"
465			shapesource="D142197204"/>
466			<map title="Test Map">
467			<layer title="My Layer"
468			shapestore="D141915644" visible="true"
469			stroke="#000000" stroke_width="1" fill="None"/>
470			</map>
471			</session>'''
472
473			expected_contents = expected_template % {
474			"dbffile": relative_filename(self.temp_dir(), dbffile),
475			"shpfile": relative_filename(self.temp_dir(), shpfile)
476			}
477			self.compare_xml(written_contents, expected_contents)
478	bh	1640	self.validate_data(written_contents)
479	bh	1268	finally:
480			session.Destroy()
481			session = None
482
483
484	bh	1638	def test_save_postgis(self):
485			"""Test saving a session with a postgis connection"""
486
487			class NonConnection(PostGISConnection):
488			"""connection class that doesn't actually connect """
489			def connect(self):
490			pass
491
492			class NonConnectionStore(PostGISShapeStore):
493			"""Shapestore that doesn't try to access the server"""
494			def _fetch_table_information(self):
495			pass
496
497			session = Session("A PostGIS Session")
498			try:
499			dbconn = NonConnection(dbname="plugh", host="xyzzy", port="42",
500			user="grue")
501			session.AddDBConnection(dbconn)
502			map = Map("Test Map")
503			session.AddMap(map)
504			store = NonConnectionStore(dbconn, "roads")
505			session.AddShapeStore(store)
506			layer = Layer("Roads to Nowhere", store)
507			map.AddLayer(layer)
508
509			# Save the session
510			filename = self.temp_file_name(self.id() + ".thuban")
511			save_session(session, filename)
512
513			# Read it back and compare
514			file = open(filename)
515			written = file.read()
516			file.close()
517			expected = '''<?xml version="1.0" encoding="UTF-8"?>
518			<!DOCTYPE session SYSTEM "thuban-0.9.dtd">
519			<session title="A PostGIS Session"
520	bh	1664	xmlns="http://thuban.intevation.org/dtds/thuban-0.9.dtd">
521	bh	1638	<dbconnection id="DB"
522			dbtype="postgis" dbname="plugh"
523			host="xyzzy" port="42"
524			user="grue"/>
525			<dbshapesource id="roads" dbconn="DB" tablename="roads"/>
526			<map title="Test Map">
527			<layer title="Roads to Nowhere"
528			shapestore="roads" visible="true"
529			stroke="#000000" stroke_width="1" fill="None"/>
530			</map>
531			</session>'''
532			self.compare_xml(written, expected)
533			self.validate_data(written)
534			finally:
535			session.Destroy()
536
537
538	bh	1268	class MockDataStore:
539
540			"""A very simple data store that only has dependencies"""
541
542			def __init__(self, name, *dependencies):
543			self.name = name
544			self.dependencies = dependencies
545
546			def __repr__(self):
547			return self.name
548
549			def Dependencies(self):
550			return self.dependencies
551
552
553			class TestStoreSort(unittest.TestCase):
554
555			def check_sort(self, containers, sorted):
556			"""Check whether the list of data containers is sorted"""
557			# check whether sorted is in the right order
558			seen = {}
559			for container in sorted:
560			self.failIf(id(container) in seen,
561			"Container %r at least twice in %r" % (container,
562			sorted))
563			for dep in container.Dependencies():
564			self.assert_(id(dep) in seen,
565			"Dependency %r of %r not yet seen" % (dep,
566			container))
567			seen[id(container)] = 1
568			# check whether all of containers is in sorted
569			for container in containers:
570			self.assert_(id(container) in seen,
571			"Container %r in containers but not in sorted")
572			self.assertEquals(len(containers), len(sorted))
573
574			def test_sort_data_stores(self):
575			"""Test Thuban.Model.save.sort_data_stores"""
576			d1 = MockDataStore("d1")
577			d2 = MockDataStore("d2")
578			d3 = MockDataStore("d3", d1)
579			d4 = MockDataStore("d4", d1, d3)
580
581			containers = [d4, d1, d2, d3]
582			self.check_sort(containers, sort_data_stores(containers))
583			containers = [d1, d3, d2, d4]
584			self.check_sort(containers, sort_data_stores(containers))
585
586
587
588	bh	292	if __name__ == "__main__":
589			# Fake the __file__ global because it's needed by a test
590			import sys
591			__file__ = sys.argv[0]
592	bh	723	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision