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	bh	334	# 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	jonathan	584	MAP_PROJECTION_CHANGED, MAP_LAYERS_CHANGED, \
24			LAYER_VISIBILITY_CHANGED, LAYER_CHANGED
25	bh	334	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	jonathan	584	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	bh	334	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	jonathan	409	self.poly_layer.GetClassification().SetDefaultFill(Color(0.0, 0.5, 1.0))
156	bh	334	self.assert_(self.session.WasModified())
157	jonathan	584	self.check_messages([(self.poly_layer, LAYER_CHANGED),
158	bh	334	(self.session, CHANGED)])
159
160			def test_forwarding_stroke(self):
161			"""Test Session's forwarding of Layer.SetStroke messages"""
162	jonathan	409	self.poly_layer.GetClassification().\
163	jonathan	482	SetDefaultLineColor(Color(0.0, 0.5, 1.0))
164	bh	334	self.assert_(self.session.WasModified())
165	jonathan	584	self.check_messages([(self.poly_layer, LAYER_CHANGED),
166	bh	334	(self.session, CHANGED)])
167
168			def test_forwarding_stroke_width(self):
169			"""Test Session's forwarding of Layer.SetStrokeWidth messages"""
170	jonathan	482	self.poly_layer.GetClassification().SetDefaultLineWidth(3)
171	bh	334	self.assert_(self.session.WasModified())
172	jonathan	584	self.check_messages([(self.poly_layer, LAYER_CHANGED),
173	bh	334	(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	jonathan	482	self.poly_layer.GetClassification().SetDefaultLineWidth(3)
197	bh	334	self.assert_(self.session.WasModified())
198			self.session.UnsetModified()
199			self.failIf(self.session.WasModified())
200	jonathan	584	self.check_messages([(self.poly_layer, LAYER_CHANGED),
201	bh	334	(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