WIP-pyshapelib-bramz/test/test_selection.py

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

"""
Test cases for Thuban.UI.selection
"""

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

import os
import unittest

import support
support.initthuban()

from Thuban.Model.session import Session
from Thuban.Model.map import Map
from Thuban.Model.layer import Layer
from Thuban.UI.selection import Selection
from Thuban.UI.messages import LAYER_SELECTED, SHAPES_SELECTED


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

    def setUp(self):
        """Instantiate a selection.

        Test cases implemented in this class can access the selection as
        self.selection.

        Also, subscribe self.subscribe_with_params to some of the
        selection's messages.

        Finally, create a list self.to_destroy with objects to be
        destroyes by calling their destroy method in tearDown() for
        objects created in test cases that need to be destroyed.
        """
        self.clear_messages()
        self.selection = Selection()
        for channel in (LAYER_SELECTED, SHAPES_SELECTED):
            self.selection.Subscribe(channel, self.subscribe_with_params,
                                     channel)
        self.to_destroy = [self.selection]

    def tearDown(self):
        """Destroy all objects in self.to_destroy and clear the message list"""
        for obj in self.to_destroy:
            obj.Destroy()
        self.clear_messages()

    def get_layer(self):
        """Return a layer to have something to test with"""
        layer = Layer("Selection Test Layer",
                      os.path.join("..", "Data", "iceland", "roads-line.shp"))
        self.to_destroy.append(layer)
        return layer

    def test_instatiation(self):
        """Test initial state of the selection"""
        self.assertEquals(self.selection.SelectedLayer(), None)
        self.assertEquals(self.selection.SelectedShapes(), [])
        self.failIf(self.selection.HasSelectedLayer())

    #
    #   SelectLayer Tests
    #

    def test_select_layer_without_current_selection(self):
        """Test Selection.SelectLayer() without current selection"""
        layer = self.get_layer()

        self.selection.SelectLayer(layer)
        # After selecting a layer, no shapes are selected
        self.assertEquals(self.selection.SelectedLayer(), layer)
        self.failUnless(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [])
        # Since no shape was selected, only a LAYER_SELECTED message
        # should have been issued.
        self.check_messages([(layer, LAYER_SELECTED)])

    def test_select_currently_selected_layer(self):
        """Test Selection.SelectLayer(<currently selected layer>)"""
        layer = self.get_layer()

        self.selection.SelectLayer(layer)
        self.clear_messages()
        self.selection.SelectLayer(layer)

        # After selecting a layer, no shapes are selected
        self.assertEquals(self.selection.SelectedLayer(), layer)
        self.failUnless(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [])
        # Since nothing has changed, really, no messages should have
        # been issued
        self.check_messages([])

    def test_select_layer_with_previous_selection(self):
        """Test Selection.SelectLayer() with previous selection"""
        self.selection.SelectShapes(self.get_layer(), [0])
        self.clear_messages()

        layer = self.get_layer()
        self.selection.SelectLayer(layer)

        # After selecting a layer, no shapes are selected
        self.assertEquals(self.selection.SelectedLayer(), layer)
        self.failUnless(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [])
        # Since a shape and a layer was selected, a LAYER_SELECTED and a
        # SHAPES_SELECTED message should have been issued.
        self.check_messages([(layer, LAYER_SELECTED),
                             (layer, [], SHAPES_SELECTED)])

    def test_select_layer_with_None(self):
        """Test Selection.SelectLayer(None)

        Calling SelectLayer with None should deselect it.
        """
        self.selection.SelectShapes(self.get_layer(), [0])
        self.clear_messages()
        self.selection.SelectLayer(None)

        # After selecting a layer, no shapes are selected
        self.assertEquals(self.selection.SelectedLayer(), None)
        self.failIf(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [])
        # Since no shape was selected, only a LAYER_SELECTED message
        # should have been issued.
        self.check_messages([(None, LAYER_SELECTED),
                             (None, [], SHAPES_SELECTED)])

    #
    #   SelectShapes Tests
    #

    def test_select_new_layer_and_new_shape(self):
        """Test Selection.SelectShapes(<new layer>, <new shapes>)"""
        layer = self.get_layer()

        self.selection.SelectShapes(layer, [0, 3, 1])

        self.assertEquals(self.selection.SelectedLayer(), layer)
        self.failUnless(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [0, 1, 3])
        self.check_messages([(layer, LAYER_SELECTED),
                             (layer, [0, 1, 3], SHAPES_SELECTED)])

    def test_select_old_layer_and_old_shape(self):
        """Test Selection.SelectShape(<old layer>, <old shapes>)"""
        layer = self.get_layer()

        self.selection.SelectShapes(layer, [0, 10, 2])
        self.clear_messages()
        # Deliberate use a different order of the shape ids to check
        # whether they're still considered equal
        self.selection.SelectShapes(layer, [2, 0, 10])

        # Selecting an already selected layer and shapes should not
        # result in any messages but still have the right layer and
        # shapes selected
        self.assertEquals(self.selection.SelectedLayer(), layer)
        self.failUnless(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [0, 2, 10])
        self.check_messages([])

    def test_select_old_layer_and_new_shape(self):
        """Test Selection.SelectShapes(<old layer>, <new shape>)"""
        layer = self.get_layer()

        self.selection.SelectShapes(layer, [0])
        self.clear_messages()
        self.selection.SelectShapes(layer, [1])

        # Selecting a different shape in the already selected layer
        # should only produce a SHAPES_SELECTED message
        # After selecting a shape, both a shape and a layer are selected
        self.assertEquals(self.selection.SelectedLayer(), layer)
        self.failUnless(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [1])
        self.check_messages([(layer, [1], SHAPES_SELECTED)])

    #
    #   Adding Shapes Tests
    #

    def test_add_shapes_new_layer_new_shapes(self):
        """Test Selection.SelectShapes(<same layer>, <new shapes>, add = 1)"""
        layer = self.get_layer()

        self.selection.SelectShapes(layer, [10, 7], add = 1)

        self.assertEquals(self.selection.SelectedLayer(), layer)
        self.failUnless(self.selection.HasSelectedLayer())
        # The list of selected shapes will be sorted in ascending order
        self.assertEquals(self.selection.SelectedShapes(), [7, 10])
        self.check_messages([(layer, LAYER_SELECTED),
                             (layer, [7, 10], SHAPES_SELECTED)])

    def test_add_shapes_same_layer_new_shapes(self):
        """Test Selection.SelectShapes(<same layer>, <new shapes>, add = 1)"""
        layer = self.get_layer()

        self.selection.SelectShapes(layer, [0, 6, 5])
        self.clear_messages()

        self.selection.SelectShapes(layer, [10, 7], add = 1)

        self.assertEquals(self.selection.SelectedLayer(), layer)
        self.failUnless(self.selection.HasSelectedLayer())
        # The list of selected shapes will be sorted in ascending order
        self.assertEquals(self.selection.SelectedShapes(), [0, 5, 6, 7, 10])
        self.check_messages([(layer, [0, 5, 6, 7, 10], SHAPES_SELECTED)])

    def test_add_shapes_same_layer_already_selected_shapes(self):
        """Test Selection.SelectShapes(<same layer>, <some old shapes>, add=1)
        """
        layer = self.get_layer()

        self.selection.SelectShapes(layer, [0, 6, 5])
        self.clear_messages()

        self.selection.SelectShapes(layer, [6, 0], add = 1)

        self.assertEquals(self.selection.SelectedLayer(), layer)
        self.failUnless(self.selection.HasSelectedLayer())
        # The list of selected shapes will be sorted in ascending order
        self.assertEquals(self.selection.SelectedShapes(), [0, 5, 6])
        self.check_messages([])

    #
    #   ClearSelection Tests
    #

    def test_clear_selection(self):
        """Test Selection.ClearSelection() when nothing is selected"""
        self.selection.ClearSelection()

        # After clearing the selection nothing is selected
        self.assertEquals(self.selection.SelectedLayer(), None)
        self.failIf(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [])
        # No messages should have been sent because the selection
        # doesn't have changed due to the ClearSelection()
        self.check_messages([])

    def test_clear_selection_with_selected_layer(self):
        """Test Selection.ClearSelection() when a layer is selected"""
        self.selection.ClearSelection()

        self.selection.SelectLayer(self.get_layer())
        self.clear_messages()
        self.selection.ClearSelection()

        # After clearing the selection nothing is selected
        self.assertEquals(self.selection.SelectedLayer(), None)
        self.failIf(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [])
        # No messages should have been sent because the selection
        # doesn't have changed due to the ClearSelection()
        self.check_messages([(None, LAYER_SELECTED)])

    def test_clear_selection_with_selected_shape(self):
        """Test Selection.ClearSelection() when a layer is selected"""
        self.selection.ClearSelection()

        self.selection.SelectShapes(self.get_layer(), [0])
        self.clear_messages()
        self.selection.ClearSelection()

        # After clearing the selection nothing is selected
        self.assertEquals(self.selection.SelectedLayer(), None)
        self.failIf(self.selection.HasSelectedLayer())
        self.assertEquals(self.selection.SelectedShapes(), [])
        # No messages should have been sent because the selection
        # doesn't have changed due to the ClearSelection()
        self.check_messages([(None, LAYER_SELECTED),
                             (None, [], SHAPES_SELECTED)])


if __name__ == "__main__":
    unittest.main()
1	bh	536	# Copyright (C) 2003 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 the software for details.
7
8			"""
9			Test cases for Thuban.UI.selection
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.session import Session
23			from Thuban.Model.map import Map
24			from Thuban.Model.layer import Layer
25			from Thuban.UI.selection import Selection
26			from Thuban.UI.messages import LAYER_SELECTED, SHAPES_SELECTED
27
28
29			class TestSelection(unittest.TestCase, support.SubscriberMixin):
30
31			def setUp(self):
32			"""Instantiate a selection.
33
34			Test cases implemented in this class can access the selection as
35			self.selection.
36
37			Also, subscribe self.subscribe_with_params to some of the
38			selection's messages.
39
40			Finally, create a list self.to_destroy with objects to be
41			destroyes by calling their destroy method in tearDown() for
42			objects created in test cases that need to be destroyed.
43			"""
44			self.clear_messages()
45			self.selection = Selection()
46			for channel in (LAYER_SELECTED, SHAPES_SELECTED):
47			self.selection.Subscribe(channel, self.subscribe_with_params,
48			channel)
49			self.to_destroy = [self.selection]
50
51			def tearDown(self):
52			"""Destroy all objects in self.to_destroy and clear the message list"""
53			for obj in self.to_destroy:
54			obj.Destroy()
55			self.clear_messages()
56
57			def get_layer(self):
58			"""Return a layer to have something to test with"""
59			layer = Layer("Selection Test Layer",
60			os.path.join("..", "Data", "iceland", "roads-line.shp"))
61			self.to_destroy.append(layer)
62			return layer
63
64			def test_instatiation(self):
65			"""Test initial state of the selection"""
66			self.assertEquals(self.selection.SelectedLayer(), None)
67			self.assertEquals(self.selection.SelectedShapes(), [])
68			self.failIf(self.selection.HasSelectedLayer())
69
70			#
71			# SelectLayer Tests
72			#
73
74			def test_select_layer_without_current_selection(self):
75			"""Test Selection.SelectLayer() without current selection"""
76			layer = self.get_layer()
77
78			self.selection.SelectLayer(layer)
79			# After selecting a layer, no shapes are selected
80			self.assertEquals(self.selection.SelectedLayer(), layer)
81			self.failUnless(self.selection.HasSelectedLayer())
82			self.assertEquals(self.selection.SelectedShapes(), [])
83			# Since no shape was selected, only a LAYER_SELECTED message
84			# should have been issued.
85			self.check_messages([(layer, LAYER_SELECTED)])
86
87			def test_select_currently_selected_layer(self):
88			"""Test Selection.SelectLayer(<currently selected layer>)"""
89			layer = self.get_layer()
90
91			self.selection.SelectLayer(layer)
92			self.clear_messages()
93			self.selection.SelectLayer(layer)
94
95			# After selecting a layer, no shapes are selected
96			self.assertEquals(self.selection.SelectedLayer(), layer)
97			self.failUnless(self.selection.HasSelectedLayer())
98			self.assertEquals(self.selection.SelectedShapes(), [])
99			# Since nothing has changed, really, no messages should have
100			# been issued
101			self.check_messages([])
102
103			def test_select_layer_with_previous_selection(self):
104			"""Test Selection.SelectLayer() with previous selection"""
105			self.selection.SelectShapes(self.get_layer(), [0])
106			self.clear_messages()
107
108			layer = self.get_layer()
109			self.selection.SelectLayer(layer)
110
111			# After selecting a layer, no shapes are selected
112			self.assertEquals(self.selection.SelectedLayer(), layer)
113			self.failUnless(self.selection.HasSelectedLayer())
114			self.assertEquals(self.selection.SelectedShapes(), [])
115			# Since a shape and a layer was selected, a LAYER_SELECTED and a
116			# SHAPES_SELECTED message should have been issued.
117			self.check_messages([(layer, LAYER_SELECTED),
118			(layer, [], SHAPES_SELECTED)])
119
120			def test_select_layer_with_None(self):
121			"""Test Selection.SelectLayer(None)
122
123			Calling SelectLayer with None should deselect it.
124			"""
125			self.selection.SelectShapes(self.get_layer(), [0])
126			self.clear_messages()
127			self.selection.SelectLayer(None)
128
129			# After selecting a layer, no shapes are selected
130			self.assertEquals(self.selection.SelectedLayer(), None)
131			self.failIf(self.selection.HasSelectedLayer())
132			self.assertEquals(self.selection.SelectedShapes(), [])
133			# Since no shape was selected, only a LAYER_SELECTED message
134			# should have been issued.
135			self.check_messages([(None, LAYER_SELECTED),
136			(None, [], SHAPES_SELECTED)])
137
138			#
139			# SelectShapes Tests
140			#
141
142			def test_select_new_layer_and_new_shape(self):
143			"""Test Selection.SelectShapes(<new layer>, <new shapes>)"""
144			layer = self.get_layer()
145
146			self.selection.SelectShapes(layer, [0, 3, 1])
147
148			self.assertEquals(self.selection.SelectedLayer(), layer)
149			self.failUnless(self.selection.HasSelectedLayer())
150			self.assertEquals(self.selection.SelectedShapes(), [0, 1, 3])
151			self.check_messages([(layer, LAYER_SELECTED),
152			(layer, [0, 1, 3], SHAPES_SELECTED)])
153
154			def test_select_old_layer_and_old_shape(self):
155			"""Test Selection.SelectShape(<old layer>, <old shapes>)"""
156			layer = self.get_layer()
157
158			self.selection.SelectShapes(layer, [0, 10, 2])
159			self.clear_messages()
160			# Deliberate use a different order of the shape ids to check
161			# whether they're still considered equal
162			self.selection.SelectShapes(layer, [2, 0, 10])
163
164			# Selecting an already selected layer and shapes should not
165			# result in any messages but still have the right layer and
166			# shapes selected
167			self.assertEquals(self.selection.SelectedLayer(), layer)
168			self.failUnless(self.selection.HasSelectedLayer())
169			self.assertEquals(self.selection.SelectedShapes(), [0, 2, 10])
170			self.check_messages([])
171
172			def test_select_old_layer_and_new_shape(self):
173			"""Test Selection.SelectShapes(<old layer>, <new shape>)"""
174			layer = self.get_layer()
175
176			self.selection.SelectShapes(layer, [0])
177			self.clear_messages()
178			self.selection.SelectShapes(layer, [1])
179
180			# Selecting a different shape in the already selected layer
181			# should only produce a SHAPES_SELECTED message
182			# After selecting a shape, both a shape and a layer are selected
183			self.assertEquals(self.selection.SelectedLayer(), layer)
184			self.failUnless(self.selection.HasSelectedLayer())
185			self.assertEquals(self.selection.SelectedShapes(), [1])
186			self.check_messages([(layer, [1], SHAPES_SELECTED)])
187
188			#
189			# Adding Shapes Tests
190			#
191
192			def test_add_shapes_new_layer_new_shapes(self):
193			"""Test Selection.SelectShapes(<same layer>, <new shapes>, add = 1)"""
194			layer = self.get_layer()
195
196			self.selection.SelectShapes(layer, [10, 7], add = 1)
197
198			self.assertEquals(self.selection.SelectedLayer(), layer)
199			self.failUnless(self.selection.HasSelectedLayer())
200			# The list of selected shapes will be sorted in ascending order
201			self.assertEquals(self.selection.SelectedShapes(), [7, 10])
202			self.check_messages([(layer, LAYER_SELECTED),
203			(layer, [7, 10], SHAPES_SELECTED)])
204
205			def test_add_shapes_same_layer_new_shapes(self):
206			"""Test Selection.SelectShapes(<same layer>, <new shapes>, add = 1)"""
207			layer = self.get_layer()
208
209			self.selection.SelectShapes(layer, [0, 6, 5])
210			self.clear_messages()
211
212			self.selection.SelectShapes(layer, [10, 7], add = 1)
213
214			self.assertEquals(self.selection.SelectedLayer(), layer)
215			self.failUnless(self.selection.HasSelectedLayer())
216			# The list of selected shapes will be sorted in ascending order
217			self.assertEquals(self.selection.SelectedShapes(), [0, 5, 6, 7, 10])
218			self.check_messages([(layer, [0, 5, 6, 7, 10], SHAPES_SELECTED)])
219
220			def test_add_shapes_same_layer_already_selected_shapes(self):
221			"""Test Selection.SelectShapes(<same layer>, <some old shapes>, add=1)
222			"""
223			layer = self.get_layer()
224
225			self.selection.SelectShapes(layer, [0, 6, 5])
226			self.clear_messages()
227
228			self.selection.SelectShapes(layer, [6, 0], add = 1)
229
230			self.assertEquals(self.selection.SelectedLayer(), layer)
231			self.failUnless(self.selection.HasSelectedLayer())
232			# The list of selected shapes will be sorted in ascending order
233			self.assertEquals(self.selection.SelectedShapes(), [0, 5, 6])
234			self.check_messages([])
235
236			#
237			# ClearSelection Tests
238			#
239
240			def test_clear_selection(self):
241			"""Test Selection.ClearSelection() when nothing is selected"""
242			self.selection.ClearSelection()
243
244			# After clearing the selection nothing is selected
245			self.assertEquals(self.selection.SelectedLayer(), None)
246			self.failIf(self.selection.HasSelectedLayer())
247			self.assertEquals(self.selection.SelectedShapes(), [])
248			# No messages should have been sent because the selection
249			# doesn't have changed due to the ClearSelection()
250			self.check_messages([])
251
252			def test_clear_selection_with_selected_layer(self):
253			"""Test Selection.ClearSelection() when a layer is selected"""
254			self.selection.ClearSelection()
255
256			self.selection.SelectLayer(self.get_layer())
257			self.clear_messages()
258			self.selection.ClearSelection()
259
260			# After clearing the selection nothing is selected
261			self.assertEquals(self.selection.SelectedLayer(), None)
262			self.failIf(self.selection.HasSelectedLayer())
263			self.assertEquals(self.selection.SelectedShapes(), [])
264			# No messages should have been sent because the selection
265			# doesn't have changed due to the ClearSelection()
266			self.check_messages([(None, LAYER_SELECTED)])
267
268			def test_clear_selection_with_selected_shape(self):
269			"""Test Selection.ClearSelection() when a layer is selected"""
270			self.selection.ClearSelection()
271
272			self.selection.SelectShapes(self.get_layer(), [0])
273			self.clear_messages()
274			self.selection.ClearSelection()
275
276			# After clearing the selection nothing is selected
277			self.assertEquals(self.selection.SelectedLayer(), None)
278			self.failIf(self.selection.HasSelectedLayer())
279			self.assertEquals(self.selection.SelectedShapes(), [])
280			# No messages should have been sent because the selection
281			# doesn't have changed due to the ClearSelection()
282			self.check_messages([(None, LAYER_SELECTED),
283			(None, [], SHAPES_SELECTED)])
284
285
286			if __name__ == "__main__":
287			unittest.main()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision