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"))
        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			self.assertEquals(writer.encode('&"\'<>'),
87			"&"'<>")
88			self.assertEquals(writer.encode(unicode('&"\'<>')),
89			"&"'<>")
90
91	bh	292	class SaveSessionTest(unittest.TestCase, support.FileTestMixin):
92
93			def compare_xml(self, xml1, xml2):
94			self.assertEquals(sax_eventlist(xml1), sax_eventlist(xml2))
95
96			def testEmptySession(self):
97			"""Save an empty session"""
98			session = Session("empty session")
99			filename = self.temp_file_name("save_emptysession.thuban")
100			save_session(session, filename)
101			session.Destroy()
102
103			file = open(filename)
104			written_contents = file.read()
105			file.close()
106			self.compare_xml(written_contents,
107			'<?xml version="1.0" encoding="UTF-8"?>\n'
108			'<!DOCTYPE session SYSTEM "thuban.dtd">\n'
109			'<session title="empty session">\n</session>\n')
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	bh	723	layer = Layer("My Layer", session.OpenShapefile(shpfile))
122	bh	292	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	jonathan	775	expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
131	bh	292	<!DOCTYPE session SYSTEM "thuban.dtd">
132			<session title="single map&layer">
133			<map title="Test Map">
134	jonathan	755	<projection name="Unknown">
135	bh	292	<parameter value="zone=26"/>
136			<parameter value="proj=utm"/>
137			<parameter value="ellps=clrk66"/>
138			</projection>
139			<layer title="My Layer" filename="%s"
140	jonathan	775	fill="None" stroke="#000000" stroke_width="1" visible="%s"/>
141	bh	292	</map>
142	jonathan	775	</session>'''
143
144			expected_contents = expected_template % \
145			(os.path.join("..", "..", "Data", "iceland", "political.shp"),
146			"true")
147
148	jonathan	494	#print written_contents
149			#print "********************************************"
150			#print expected_contents
151	bh	292	self.compare_xml(written_contents, expected_contents)
152
153	jonathan	775	layer.SetVisible(False)
154			save_session(session, filename)
155
156			file = open(filename)
157			written_contents = file.read()
158			file.close()
159			expected_contents = expected_template % \
160			(os.path.join("..", "..", "Data", "iceland", "political.shp"),
161			"false")
162
163			#print written_contents
164			#print "********************************************"
165			#print expected_contents
166			self.compare_xml(written_contents, expected_contents)
167
168			session.Destroy()
169
170	jonathan	755	def testLayerProjection(self):
171			# deliberately put an apersand in the title :)
172			session = Session("single map&layer")
173			proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
174			map = Map("Test Map", projection = proj)
175			session.AddMap(map)
176			# use shapefile from the example data
177			shpfile = os.path.join(os.path.dirname(__file__),
178			os.pardir, "Data", "iceland", "political.shp")
179			layer = Layer("My Layer", session.OpenShapefile(shpfile))
180			proj = Projection(["proj=lcc", "ellps=clrk66"], "Layer Projection")
181			layer.SetProjection(proj)
182			map.AddLayer(layer)
183	bh	292
184	jonathan	755	filename = self.temp_file_name("save_singlemap.thuban")
185			save_session(session, filename)
186			session.Destroy()
187	bh	292
188	jonathan	755	file = open(filename)
189			written_contents = file.read()
190			file.close()
191			expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
192			<!DOCTYPE session SYSTEM "thuban.dtd">
193			<session title="single map&layer">
194			<map title="Test Map">
195			<projection name="Unknown">
196			<parameter value="zone=26"/>
197			<parameter value="proj=utm"/>
198			<parameter value="ellps=clrk66"/>
199			</projection>
200			<layer title="My Layer" filename="%s"
201	jonathan	775	fill="None" stroke="#000000" stroke_width="1" visible="true">
202	jonathan	755	<projection name="Layer Projection">
203			<parameter value="proj=lcc"/>
204			<parameter value="ellps=clrk66"/>
205			</projection>
206			</layer>
207			</map>
208			</session>''' % os.path.join("..", "..", "Data", "iceland",
209			"political.shp")
210			#print written_contents
211			#print "********************************************"
212			#print expected_contents
213			self.compare_xml(written_contents, expected_contents)
214
215
216	jonathan	947	def testRasterLayer(self):
217			# deliberately put an apersand in the title :)
218			session = Session("single map&layer")
219			map = Map("Test Map")
220			session.AddMap(map)
221			# use shapefile from the example data
222			imgfile = os.path.join(os.path.dirname(__file__),
223			os.pardir, "Data", "iceland", "island.tif")
224			layer = RasterLayer("My RasterLayer", imgfile)
225			map.AddLayer(layer)
226
227			filename = self.temp_file_name("save_singlemap.thuban")
228			save_session(session, filename)
229			session.Destroy()
230
231			file = open(filename)
232			written_contents = file.read()
233			file.close()
234			expected_contents = '''<?xml version="1.0" encoding="UTF-8"?>
235			<!DOCTYPE session SYSTEM "thuban.dtd">
236			<session title="single map&layer">
237			<map title="Test Map">
238			<rasterlayer title="My RasterLayer" filename="%s"
239			visible="true">
240			</rasterlayer>
241			</map>
242			</session>''' % os.path.join(os.path.dirname(__file__),
243			os.pardir, "Data", "iceland",
244			"island.tif")
245			#print written_contents
246			#print "********************************************"
247			#print expected_contents
248			self.compare_xml(written_contents, expected_contents)
249	jonathan	755
250	jonathan	1168	def testClassifiedLayer(self):
251			"""Save a session with a single map with a single layer
252			with a classificaton.
253			"""
254			# deliberately put an apersand in the title :)
255			session = Session("single map&layer")
256			proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
257			map = Map("Test Map", projection = proj)
258			session.AddMap(map)
259			# use shapefile from the example data
260			shpfile = os.path.join(os.path.dirname(__file__),
261			os.pardir, "Data", "iceland", "political.shp")
262			layer = Layer("My Layer", session.OpenShapefile(shpfile))
263			map.AddLayer(layer)
264	jonathan	755
265	jonathan	1168	clazz = layer.GetClassification()
266
267			clazz.SetField("AREA")
268
269			clazz.AppendGroup(ClassGroupSingleton(42,
270			ClassGroupProperties(),
271			"single"))
272			clazz.AppendGroup(ClassGroupSingleton("text",
273			ClassGroupProperties(),
274			"single-text"))
275
276			clazz.AppendGroup(ClassGroupRange(0, 42,
277			ClassGroupProperties(),
278			"range"))
279
280			range = ClassGroupRange(Range("[0;42]"))
281			range.SetProperties(ClassGroupProperties())
282			range.SetLabel("new-range")
283			clazz.AppendGroup(range)
284
285			filename = self.temp_file_name("save_singlemap.thuban")
286			save_session(session, filename)
287
288			file = open(filename)
289			written_contents = file.read()
290			file.close()
291			expected_template = '''<?xml version="1.0" encoding="UTF-8"?>
292			<!DOCTYPE session SYSTEM "thuban.dtd">
293			<session title="single map&layer">
294			<map title="Test Map">
295			<projection name="Unknown">
296			<parameter value="zone=26"/>
297			<parameter value="proj=utm"/>
298			<parameter value="ellps=clrk66"/>
299			</projection>
300			<layer title="My Layer" filename="%s"
301			fill="None" stroke="#000000" stroke_width="1" visible="%s">
302			<classification field="AREA" field_type="double">
303			<clnull label="">
304			<cldata fill="None" stroke="#000000" stroke_width="1"/>
305			</clnull>
306			<clpoint value="42" label="single">
307			<cldata fill="None" stroke="#000000" stroke_width="1"/>
308			</clpoint>
309			<clpoint value="text" label="single-text">
310			<cldata fill="None" stroke="#000000" stroke_width="1"/>
311			</clpoint>
312			<clrange range="[0;42[" label="range">
313			<cldata fill="None" stroke="#000000" stroke_width="1"/>
314			</clrange>
315			<clrange range="[0;42]" label="new-range">
316			<cldata fill="None" stroke="#000000" stroke_width="1"/>
317			</clrange>
318			</classification>
319			</layer>
320			</map>
321			</session>'''
322
323			expected_contents = expected_template % \
324			(os.path.join("..", "..", "Data", "iceland", "political.shp"),
325			"true")
326
327			#print written_contents
328			#print "********************************************"
329			#print expected_contents
330			self.compare_xml(written_contents, expected_contents)
331
332			session.Destroy()
333
334
335	bh	292	if __name__ == "__main__":
336			# Fake the __file__ global because it's needed by a test
337			import sys
338			__file__ = sys.argv[0]
339	bh	723	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision