WIP-pyshapelib-bramz/test/test_session.py

# Copyright (c) 2002 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Test the Session class
"""

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

import os
import unittest

import support
support.initthuban()

from Thuban.Model.messages import CHANGED, MAPS_CHANGED, FILENAME_CHANGED, \
     MAP_PROJECTION_CHANGED, MAP_LAYERS_CHANGED, \
     LAYER_VISIBILITY_CHANGED, LAYER_CHANGED
from Thuban.Model.session import Session
from Thuban.Model.map import Map
from Thuban.Model.layer import Layer
from Thuban.Model.proj import Projection
from Thuban.Model.color import Color


class TestSessionSimple(unittest.TestCase):

    """Very simple test cases for Session"""

    def test_initial_state(self):
        """Test Session's initial state"""
        session = Session("Test Session")
        self.assertEquals(session.Title(), "Test Session")
        self.assertEquals(session.Maps(), [])
        self.assertEquals(session.filename, None)
        self.failIf(session.HasMaps())
        self.failIf(session.WasModified())
        session.Destroy()


class TestSessionBase(unittest.TestCase, support.SubscriberMixin):

    """Base class for Session test cases that test the messages"""

    def setUp(self):
        """
        Clear the message list, create a session and subscribe to its messages

        Bind the session to self.session.
        """
        self.clear_messages()

        # Create a Session and subscribe to all interesting channels.
        self.session = Session("Test Session")
        for channel in (CHANGED, 
                        MAPS_CHANGED,  
                        FILENAME_CHANGED,
                        MAP_PROJECTION_CHANGED, 
                        MAP_LAYERS_CHANGED,
                        LAYER_VISIBILITY_CHANGED, 
                        LAYER_CHANGED):
            self.session.Subscribe(channel,
                                   self.subscribe_with_params, channel)

    def tearDown(self):
        """Destroy self.session and clear the message list"""
        self.session.Destroy()
        self.clear_messages()


class TestSessionMessages(TestSessionBase):

    """Simple Session test cases that test messges"""

    def test_add_map(self):
        """Test Session.AddMap"""
        self.failIf(self.session.WasModified())
        map = Map("Some Map")
        self.session.AddMap(map)
        self.assert_(self.session.HasMaps())
        self.assert_(self.session.WasModified())
        self.assertEquals(self.session.Maps(), [map])
        self.check_messages([(MAPS_CHANGED,),
                             (self.session, CHANGED)])

    def test_set_filename(self):
        """Test Session.SetFilename"""
        self.session.SetFilename("session_set_filename_test")
        self.session.filename = "session_set_filename_test"
        self.check_messages([(FILENAME_CHANGED,),
                             (self.session, CHANGED)])


class TestSessionWithContent(TestSessionBase):

    """Session test cases that start with a filled session."""

    def setUp(self):
        """Extend the inherited method to add a non-empty map to self.session
        """
        TestSessionBase.setUp(self)
        self.arc_layer = Layer("Roads",
                               os.path.join("..", "Data", "iceland",
                                            "roads-line.shp"))
        self.poly_layer = Layer("Political",
                                os.path.join("..", "Data", "iceland",
                                             "political.shp"))
        self.map = Map("A Map")
        self.map.AddLayer(self.arc_layer)
        self.map.AddLayer(self.poly_layer)
        self.session.AddMap(self.map)
        self.session.UnsetModified()
        self.clear_messages()

    def test_remove_map(self):
        """Test Session.RemoveMap"""
        self.session.RemoveMap(self.map)
        self.assert_(self.session.WasModified())
        self.failIf(self.session.HasMaps())
        self.check_messages([(MAPS_CHANGED,),
                             (self.session, CHANGED)])

    def test_tree_info(self):
        """Test Session.TreeInfo"""
        self.assertEquals(self.session.TreeInfo(),
                          ('Session: Test Session',
                           ['Filename:',
                            'Unmodified',
                            self.map]))

    def test_forward_map_projection(self):
        """Test Session forwarding of Map.SetProjection messages"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        self.map.SetProjection(proj)
        self.check_messages([(self.map, MAP_PROJECTION_CHANGED),
                             (self.session, CHANGED)])
        self.assert_(self.session.WasModified())

    def test_forward_map_projection(self):
        """Test Session forwarding of Map.SetProjection messages"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        self.map.SetProjection(proj)
        self.assert_(self.session.WasModified())
        self.check_messages([(self.map, MAP_PROJECTION_CHANGED),
                             (self.session, CHANGED)])

    def test_forwarding_fill(self):
        """Test Session's forwarding of Layer.SetFill messages"""
        self.poly_layer.GetClassification().SetDefaultFill(Color(0.0, 0.5, 1.0))
        self.assert_(self.session.WasModified())
        self.check_messages([(self.poly_layer, LAYER_CHANGED),
                             (self.session, CHANGED)])

    def test_forwarding_stroke(self):
        """Test Session's forwarding of Layer.SetStroke messages"""
        self.poly_layer.GetClassification().\
            SetDefaultLineColor(Color(0.0, 0.5, 1.0))
        self.assert_(self.session.WasModified())
        self.check_messages([(self.poly_layer, LAYER_CHANGED),
                             (self.session, CHANGED)])

    def test_forwarding_stroke_width(self):
        """Test Session's forwarding of Layer.SetStrokeWidth messages"""
        self.poly_layer.GetClassification().SetDefaultLineWidth(3)
        self.assert_(self.session.WasModified())
        self.check_messages([(self.poly_layer, LAYER_CHANGED),
                             (self.session, CHANGED)])

    def test_forwarding_visibility(self):
        """Test Session's forwarding of Layer.SetVisible messages"""
        self.poly_layer.SetVisible(0)
        # Currently changing the visibility of a layer doesn't change
        # the modification flag.
        self.failIf(self.session.WasModified())
        self.check_messages([(self.poly_layer, LAYER_VISIBILITY_CHANGED),
                             (self.session, CHANGED)])

    def test_unset_modified_map(self):
        """Test Session.UnsetModified with map level changes"""
        self.failIf(self.session.WasModified())
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        self.map.SetProjection(proj)
        self.assert_(self.session.WasModified())
        self.session.UnsetModified()
        self.failIf(self.session.WasModified())

    def test_unset_modified_layer(self):
        """Test Session.UnsetModified with layer level changes"""
        self.failIf(self.session.WasModified())
        self.poly_layer.GetClassification().SetDefaultLineWidth(3)
        self.assert_(self.session.WasModified())
        self.session.UnsetModified()
        self.failIf(self.session.WasModified())
        self.check_messages([(self.poly_layer, LAYER_CHANGED),
                             (self.session, CHANGED),
                             (CHANGED,)])


if __name__ == "__main__":
    unittest.main()
1	# Copyright (c) 2002 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[email protected]>
4	#
5	# This program is free software under the GPL (>=v2)
6	# Read the file COPYING coming with Thuban for details.
7
8	"""
9	Test the Session class
10	"""
11
12	__version__ = "$Revision$"
13	# $Source$
14	# $Id$
15
16	import os
17	import unittest
18
19	import support
20	support.initthuban()
21
22	from Thuban.Model.messages import CHANGED, MAPS_CHANGED, FILENAME_CHANGED, \
23	MAP_PROJECTION_CHANGED, MAP_LAYERS_CHANGED, \
24	LAYER_VISIBILITY_CHANGED, LAYER_CHANGED
25	from Thuban.Model.session import Session
26	from Thuban.Model.map import Map
27	from Thuban.Model.layer import Layer
28	from Thuban.Model.proj import Projection
29	from Thuban.Model.color import Color
30
31
32	class TestSessionSimple(unittest.TestCase):
33
34	"""Very simple test cases for Session"""
35
36	def test_initial_state(self):
37	"""Test Session's initial state"""
38	session = Session("Test Session")
39	self.assertEquals(session.Title(), "Test Session")
40	self.assertEquals(session.Maps(), [])
41	self.assertEquals(session.filename, None)
42	self.failIf(session.HasMaps())
43	self.failIf(session.WasModified())
44	session.Destroy()
45
46
47	class TestSessionBase(unittest.TestCase, support.SubscriberMixin):
48
49	"""Base class for Session test cases that test the messages"""
50
51	def setUp(self):
52	"""
53	Clear the message list, create a session and subscribe to its messages
54
55	Bind the session to self.session.
56	"""
57	self.clear_messages()
58
59	# Create a Session and subscribe to all interesting channels.
60	self.session = Session("Test Session")
61	for channel in (CHANGED,
62	MAPS_CHANGED,
63	FILENAME_CHANGED,
64	MAP_PROJECTION_CHANGED,
65	MAP_LAYERS_CHANGED,
66	LAYER_VISIBILITY_CHANGED,
67	LAYER_CHANGED):
68	self.session.Subscribe(channel,
69	self.subscribe_with_params, channel)
70
71	def tearDown(self):
72	"""Destroy self.session and clear the message list"""
73	self.session.Destroy()
74	self.clear_messages()
75
76
77	class TestSessionMessages(TestSessionBase):
78
79	"""Simple Session test cases that test messges"""
80
81	def test_add_map(self):
82	"""Test Session.AddMap"""
83	self.failIf(self.session.WasModified())
84	map = Map("Some Map")
85	self.session.AddMap(map)
86	self.assert_(self.session.HasMaps())
87	self.assert_(self.session.WasModified())
88	self.assertEquals(self.session.Maps(), [map])
89	self.check_messages([(MAPS_CHANGED,),
90	(self.session, CHANGED)])
91
92	def test_set_filename(self):
93	"""Test Session.SetFilename"""
94	self.session.SetFilename("session_set_filename_test")
95	self.session.filename = "session_set_filename_test"
96	self.check_messages([(FILENAME_CHANGED,),
97	(self.session, CHANGED)])
98
99
100	class TestSessionWithContent(TestSessionBase):
101
102	"""Session test cases that start with a filled session."""
103
104	def setUp(self):
105	"""Extend the inherited method to add a non-empty map to self.session
106	"""
107	TestSessionBase.setUp(self)
108	self.arc_layer = Layer("Roads",
109	os.path.join("..", "Data", "iceland",
110	"roads-line.shp"))
111	self.poly_layer = Layer("Political",
112	os.path.join("..", "Data", "iceland",
113	"political.shp"))
114	self.map = Map("A Map")
115	self.map.AddLayer(self.arc_layer)
116	self.map.AddLayer(self.poly_layer)
117	self.session.AddMap(self.map)
118	self.session.UnsetModified()
119	self.clear_messages()
120
121	def test_remove_map(self):
122	"""Test Session.RemoveMap"""
123	self.session.RemoveMap(self.map)
124	self.assert_(self.session.WasModified())
125	self.failIf(self.session.HasMaps())
126	self.check_messages([(MAPS_CHANGED,),
127	(self.session, CHANGED)])
128
129	def test_tree_info(self):
130	"""Test Session.TreeInfo"""
131	self.assertEquals(self.session.TreeInfo(),
132	('Session: Test Session',
133	['Filename:',
134	'Unmodified',
135	self.map]))
136
137	def test_forward_map_projection(self):
138	"""Test Session forwarding of Map.SetProjection messages"""
139	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
140	self.map.SetProjection(proj)
141	self.check_messages([(self.map, MAP_PROJECTION_CHANGED),
142	(self.session, CHANGED)])
143	self.assert_(self.session.WasModified())
144
145	def test_forward_map_projection(self):
146	"""Test Session forwarding of Map.SetProjection messages"""
147	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
148	self.map.SetProjection(proj)
149	self.assert_(self.session.WasModified())
150	self.check_messages([(self.map, MAP_PROJECTION_CHANGED),
151	(self.session, CHANGED)])
152
153	def test_forwarding_fill(self):
154	"""Test Session's forwarding of Layer.SetFill messages"""
155	self.poly_layer.GetClassification().SetDefaultFill(Color(0.0, 0.5, 1.0))
156	self.assert_(self.session.WasModified())
157	self.check_messages([(self.poly_layer, LAYER_CHANGED),
158	(self.session, CHANGED)])
159
160	def test_forwarding_stroke(self):
161	"""Test Session's forwarding of Layer.SetStroke messages"""
162	self.poly_layer.GetClassification().\
163	SetDefaultLineColor(Color(0.0, 0.5, 1.0))
164	self.assert_(self.session.WasModified())
165	self.check_messages([(self.poly_layer, LAYER_CHANGED),
166	(self.session, CHANGED)])
167
168	def test_forwarding_stroke_width(self):
169	"""Test Session's forwarding of Layer.SetStrokeWidth messages"""
170	self.poly_layer.GetClassification().SetDefaultLineWidth(3)
171	self.assert_(self.session.WasModified())
172	self.check_messages([(self.poly_layer, LAYER_CHANGED),
173	(self.session, CHANGED)])
174
175	def test_forwarding_visibility(self):
176	"""Test Session's forwarding of Layer.SetVisible messages"""
177	self.poly_layer.SetVisible(0)
178	# Currently changing the visibility of a layer doesn't change
179	# the modification flag.
180	self.failIf(self.session.WasModified())
181	self.check_messages([(self.poly_layer, LAYER_VISIBILITY_CHANGED),
182	(self.session, CHANGED)])
183
184	def test_unset_modified_map(self):
185	"""Test Session.UnsetModified with map level changes"""
186	self.failIf(self.session.WasModified())
187	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
188	self.map.SetProjection(proj)
189	self.assert_(self.session.WasModified())
190	self.session.UnsetModified()
191	self.failIf(self.session.WasModified())
192
193	def test_unset_modified_layer(self):
194	"""Test Session.UnsetModified with layer level changes"""
195	self.failIf(self.session.WasModified())
196	self.poly_layer.GetClassification().SetDefaultLineWidth(3)
197	self.assert_(self.session.WasModified())
198	self.session.UnsetModified()
199	self.failIf(self.session.WasModified())
200	self.check_messages([(self.poly_layer, LAYER_CHANGED),
201	(self.session, CHANGED),
202	(CHANGED,)])
203
204
205	if __name__ == "__main__":
206	unittest.main()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision