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 support
support.initthuban()

from Thuban.Model.save import XMLWriter, save_session
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.classification import ClassGroupSingleton, ClassGroupRange, \
    ClassGroupProperties

from Thuban.Model.range import Range


class SaxEventLister(xml.sax.handler.ContentHandler):

    def __init__(self):
        self.eventlist = []

    def startElementNS(self, name, qname, attrs):
        items = attrs.items()
        items.sort()
        self.eventlist.append(("start", name, qname, items))

    def endElementNS(self, name, qname):
        self.eventlist.append(("end", name, qname))


def sax_eventlist(data):
    """Return a list of SAX event generated for the XML data.
    """
    handler = SaxEventLister()
    parser = make_parser()
    parser.setContentHandler(handler)
    parser.setErrorHandler(ErrorHandler())
    parser.setFeature(xml.sax.handler.feature_namespaces, 1)

    #
    # see comment at the end of Thuban/Model/load.py
    #
    try:
        parser.setFeature(xml.sax.handler.feature_validation, 0)
        parser.setFeature(xml.sax.handler.feature_external_ges, 0)
        parser.setFeature(xml.sax.handler.feature_external_pes, 0)
    except SAXNotRecognizedException:
        pass

    inpsrc = xml.sax.InputSource()
    inpsrc.setByteStream(StringIO(data))
    parser.parse(inpsrc)

    return handler.eventlist

class XMLWriterTest(unittest.TestCase):

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

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

        writer.encode("\x80\x90\xc2\x100")
        writer.encode(u"\x80\x90\xc2\x100")
        writer.encode(u"\xFF5E")

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

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

    def compare_xml(self, xml1, xml2):
        self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))

    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.dtd">\n'
                         '<session title="empty session">\n</session>\n')

    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.dtd">
        <session title="single map&amp;layer">
            <map title="Test Map">
                <projection name="Unknown">
                    <parameter value="zone=26"/>
                    <parameter value="proj=utm"/>
                    <parameter value="ellps=clrk66"/>
                </projection>
                <layer title="My Layer" filename="%s"
                fill="None" stroke="#000000" stroke_width="1" visible="%s"/>
            </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)

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

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

        session.Destroy()

    def testLayerProjection(self):
        # 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_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.dtd">
        <session title="single map&amp;layer">
            <map title="Test Map">
                <projection name="Unknown">
                    <parameter value="zone=26"/>
                    <parameter value="proj=utm"/>
                    <parameter value="ellps=clrk66"/>
                </projection>
                <layer title="My Layer" filename="%s"
                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)

        
    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.dtd">
        <session title="single map&amp;layer">
            <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)

    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.SetField("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)

        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.dtd">
        <session title="single map&amp;layer">
            <map title="Test Map">
                <projection name="Unknown">
                    <parameter value="zone=26"/>
                    <parameter value="proj=utm"/>
                    <parameter value="ellps=clrk66"/>
                </projection>
                <layer title="My Layer" filename="%s"
                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)

        session.Destroy()


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			import xml.sax
21			import xml.sax.handler
22	jonathan	530	from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException
23	bh	292
24			import support
25			support.initthuban()
26
27	jonathan	1168	from Thuban.Model.save import XMLWriter, save_session
28	bh	292	from Thuban.Model.session import Session
29			from Thuban.Model.map import Map
30	jonathan	947	from Thuban.Model.layer import Layer, RasterLayer
31	bh	292	from Thuban.Model.proj import Projection
32
33	jonathan	1168	from Thuban.Model.classification import ClassGroupSingleton, ClassGroupRange, \
34			ClassGroupProperties
35	bh	292
36	jonathan	1168	from Thuban.Model.range import Range
37
38
39	bh	292	class SaxEventLister(xml.sax.handler.ContentHandler):
40
41			def __init__(self):
42			self.eventlist = []
43
44			def startElementNS(self, name, qname, attrs):
45			items = attrs.items()
46			items.sort()
47			self.eventlist.append(("start", name, qname, items))
48
49			def endElementNS(self, name, qname):
50			self.eventlist.append(("end", name, qname))
51
52
53			def sax_eventlist(data):
54			"""Return a list of SAX event generated for the XML data.
55			"""
56			handler = SaxEventLister()
57			parser = make_parser()
58			parser.setContentHandler(handler)
59			parser.setErrorHandler(ErrorHandler())
60			parser.setFeature(xml.sax.handler.feature_namespaces, 1)
61
62	jonathan	530	#
63			# see comment at the end of Thuban/Model/load.py
64			#
65			try:
66			parser.setFeature(xml.sax.handler.feature_validation, 0)
67			parser.setFeature(xml.sax.handler.feature_external_ges, 0)
68			parser.setFeature(xml.sax.handler.feature_external_pes, 0)
69			except SAXNotRecognizedException:
70			pass
71
72	bh	292	inpsrc = xml.sax.InputSource()
73			inpsrc.setByteStream(StringIO(data))
74			parser.parse(inpsrc)
75
76			return handler.eventlist
77
78	jonathan	1168	class XMLWriterTest(unittest.TestCase):
79
80			def testEncode(self):
81			"""Test XMLWriter.encode"""
82			writer = XMLWriter()
83
84			writer.encode("hello world")
85			writer.encode(unicode("hello world"))
86	jonathan	1173
87			writer.encode("\x80\x90\xc2\x100")
88			writer.encode(u"\x80\x90\xc2\x100")
89			writer.encode(u"\xFF5E")
90
91	jonathan	1168	self.assertEquals(writer.encode('&"\'<>'),
92			"&"'<>")
93			self.assertEquals(writer.encode(unicode('&"\'<>')),
94			"&"'<>")
95
96	bh	292	class SaveSessionTest(unittest.TestCase, support.FileTestMixin):
97
98			def compare_xml(self, xml1, xml2):
99			self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))
100
101			def testEmptySession(self):
102			"""Save an empty session"""
103			session = Session("empty session")
104			filename = self.temp_file_name("save_emptysession.thuban")
105			save_session(session, filename)
106			session.Destroy()
107
108			file = open(filename)
109			written_contents = file.read()
110			file.close()
111			self.compare_xml(written_contents,
112			'<?xml version="1.0" encoding="UTF-8"?>\n'
113			'<!DOCTYPE session SYSTEM "thuban.dtd">\n'
114			'<session title="empty session">\n</session>\n')
115
116			def testSingleLayer(self):
117			"""Save a session with a single map with a single layer"""
118			# deliberately put an apersand in the title :)
119			session = Session("single map&layer")
120			proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
121			map = Map("Test Map", projection = proj)
122			session.AddMap(map)
123			# use shapefile from the example data
124			shpfile = os.path.join(os.path.dirname(__file__),
125			os.pardir, "Data", "iceland", "political.shp")
126	bh	723	layer = Layer("My Layer", session.OpenShapefile(shpfile))
127	bh	292	map.AddLayer(layer)
128
129			filename = self.temp_file_name("save_singlemap.thuban")
130			save_session(session, filename)
131
132			file = open(filename)
133			written_contents = file.read()
134			file.close()
135	jonathan	775	expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
136	bh	292	<!DOCTYPE session SYSTEM "thuban.dtd">
137			<session title="single map&layer">
138			<map title="Test Map">
139	jonathan	755	<projection name="Unknown">
140	bh	292	<parameter value="zone=26"/>
141			<parameter value="proj=utm"/>
142			<parameter value="ellps=clrk66"/>
143			</projection>
144			<layer title="My Layer" filename="%s"
145	jonathan	775	fill="None" stroke="#000000" stroke_width="1" visible="%s"/>
146	bh	292	</map>
147	jonathan	775	</session>'''
148
149			expected_contents = expected_template % \
150			(os.path.join("..", "..", "Data", "iceland", "political.shp"),
151			"true")
152
153	jonathan	494	#print written_contents
154			#print "********************************************"
155			#print expected_contents
156	bh	292	self.compare_xml(written_contents, expected_contents)
157
158	jonathan	775	layer.SetVisible(False)
159			save_session(session, filename)
160
161			file = open(filename)
162			written_contents = file.read()
163			file.close()
164			expected_contents = expected_template % \
165			(os.path.join("..", "..", "Data", "iceland", "political.shp"),
166			"false")
167
168			#print written_contents
169			#print "********************************************"
170			#print expected_contents
171			self.compare_xml(written_contents, expected_contents)
172
173			session.Destroy()
174
175	jonathan	755	def testLayerProjection(self):
176			# deliberately put an apersand in the title :)
177			session = Session("single map&layer")
178			proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
179			map = Map("Test Map", projection = proj)
180			session.AddMap(map)
181			# use shapefile from the example data
182			shpfile = os.path.join(os.path.dirname(__file__),
183			os.pardir, "Data", "iceland", "political.shp")
184			layer = Layer("My Layer", session.OpenShapefile(shpfile))
185			proj = Projection(["proj=lcc", "ellps=clrk66"], "Layer Projection")
186			layer.SetProjection(proj)
187			map.AddLayer(layer)
188	bh	292
189	jonathan	755	filename = self.temp_file_name("save_singlemap.thuban")
190			save_session(session, filename)
191			session.Destroy()
192	bh	292
193	jonathan	755	file = open(filename)
194			written_contents = file.read()
195			file.close()
196			expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
197			<!DOCTYPE session SYSTEM "thuban.dtd">
198			<session title="single map&layer">
199			<map title="Test Map">
200			<projection name="Unknown">
201			<parameter value="zone=26"/>
202			<parameter value="proj=utm"/>
203			<parameter value="ellps=clrk66"/>
204			</projection>
205			<layer title="My Layer" filename="%s"
206	jonathan	775	fill="None" stroke="#000000" stroke_width="1" visible="true">
207	jonathan	755	<projection name="Layer Projection">
208			<parameter value="proj=lcc"/>
209			<parameter value="ellps=clrk66"/>
210			</projection>
211			</layer>
212			</map>
213			</session>''' % os.path.join("..", "..", "Data", "iceland",
214			"political.shp")
215			#print written_contents
216			#print "********************************************"
217			#print expected_contents
218			self.compare_xml(written_contents, expected_contents)
219
220
221	jonathan	947	def testRasterLayer(self):
222			# deliberately put an apersand in the title :)
223			session = Session("single map&layer")
224			map = Map("Test Map")
225			session.AddMap(map)
226			# use shapefile from the example data
227			imgfile = os.path.join(os.path.dirname(__file__),
228			os.pardir, "Data", "iceland", "island.tif")
229			layer = RasterLayer("My RasterLayer", imgfile)
230			map.AddLayer(layer)
231
232			filename = self.temp_file_name("save_singlemap.thuban")
233			save_session(session, filename)
234			session.Destroy()
235
236			file = open(filename)
237			written_contents = file.read()
238			file.close()
239			expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
240			<!DOCTYPE session SYSTEM "thuban.dtd">
241			<session title="single map&layer">
242			<map title="Test Map">
243			<rasterlayer title="My RasterLayer" filename="%s"
244			visible="true">
245			</rasterlayer>
246			</map>
247			</session>''' % os.path.join(os.path.dirname(__file__),
248			os.pardir, "Data", "iceland",
249			"island.tif")
250			#print written_contents
251			#print "********************************************"
252			#print expected_contents
253			self.compare_xml(written_contents, expected_contents)
254	jonathan	755
255	jonathan	1168	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	jonathan	755
270	jonathan	1168	clazz = layer.GetClassification()
271
272			clazz.SetField("AREA")
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.dtd">
298			<session title="single map&layer">
299			<map title="Test Map">
300			<projection name="Unknown">
301			<parameter value="zone=26"/>
302			<parameter value="proj=utm"/>
303			<parameter value="ellps=clrk66"/>
304			</projection>
305			<layer title="My Layer" filename="%s"
306			fill="None" stroke="#000000" stroke_width="1" visible="%s">
307			<classification field="AREA" field_type="double">
308			<clnull label="">
309			<cldata fill="None" stroke="#000000" stroke_width="1"/>
310			</clnull>
311			<clpoint value="42" label="single">
312			<cldata fill="None" stroke="#000000" stroke_width="1"/>
313			</clpoint>
314			<clpoint value="text" label="single-text">
315			<cldata fill="None" stroke="#000000" stroke_width="1"/>
316			</clpoint>
317			<clrange range="[0;42[" label="range">
318			<cldata fill="None" stroke="#000000" stroke_width="1"/>
319			</clrange>
320			<clrange range="[0;42]" label="new-range">
321			<cldata fill="None" stroke="#000000" stroke_width="1"/>
322			</clrange>
323			</classification>
324			</layer>
325			</map>
326			</session>'''
327
328			expected_contents = expected_template % \
329			(os.path.join("..", "..", "Data", "iceland", "political.shp"),
330			"true")
331
332			#print written_contents
333			#print "********************************************"
334			#print expected_contents
335			self.compare_xml(written_contents, expected_contents)
336
337			session.Destroy()
338
339
340	bh	292	if __name__ == "__main__":
341			# Fake the __file__ global because it's needed by a test
342			import sys
343			__file__ = sys.argv[0]
344	bh	723	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision