WIP-pyshapelib-bramz/test/test_base.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 TitledObject and Modifiable
"""

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

import unittest

import support
support.initthuban()

from Thuban.Model.base import TitledObject, Modifiable
from Thuban.Model.messages import TITLE_CHANGED, CHANGED
from Thuban.Lib.connector import Publisher

SOMETHING_ELSE = "SOMETHING_ELSE"

class SomeTitledObject(TitledObject, Publisher):

    """TitledObject for test purposes.

    TitledObject is not used directly. It's a mixin to be used together
    with Publisher.
    """

class SomeModifiable(Modifiable):

    """Modifiable for test purposes.

    Modifiable is intended to be used as a base class for classes that
    need to inform other classes when they change and that have to keep
    track of whether they have changed. Thus we use a derived class for
    testing that provides some methods that simulate modificatios.
    """

    def do_something(self):
        """Call self.changed without parameters"""
        self.changed()

    def do_something_else(self):
        """Call self.changed with a message parameter"""
        self.changed(SOMETHING_ELSE)


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

    """Base class for test cases that use SubscriberMixin.

    Just provide the default implementations of setUp and tearDown.
    """

    def setUp(self):
        """Clear the list of received messages"""
        self.clear_messages()

    def tearDown(self):
        """Clear the list of received messages"""
        self.clear_messages()


class TestTitledObject(SubscriberTest):

    """Test cases for TitledObject"""

    def test_titled_object(self):
        """Test TitledObject"""
        titled = SomeTitledObject("Some Title")
        titled.Subscribe(TITLE_CHANGED,
                         self.subscribe_with_params, TITLE_CHANGED)

        self.assertEquals(titled.Title(), "Some Title")

        titled.SetTitle("New Title")
        self.assertEquals(titled.Title(), "New Title")

        self.check_messages([(titled, TITLE_CHANGED)])


class TestModifiable(SubscriberTest):

    """Test cases for Modifiable"""

    def setUp(self):
        """Extend the inherited method to create a Modifiable instance.

        Bind the Modifiable instance (actually an instance of
        SomeModifiable) to self.modifiable and subscribe to its CHANGED
        and SOMETHING_ELSE channels.
        """
        SubscriberTest.setUp(self)
        self.modifiable = SomeModifiable()
        self.modifiable.Subscribe(CHANGED, self.subscribe_with_params, CHANGED)
        self.modifiable.Subscribe(SOMETHING_ELSE,
                                  self.subscribe_with_params, SOMETHING_ELSE)

    def tearDown(self):
        """Extend the inherited method to explicitly destroy self.modifiable.
        """
        self.modifiable.Destroy()
        SubscriberTest.tearDown(self)

    def test_initial_state(self):
        """Test Modifiable initial state"""
        # initially a modifiable is unmodified
        self.failIf(self.modifiable.WasModified())
        # this test should not have resulted in any messages
        self.check_messages([])

    def test_silent_change(self):
        """Test Modifiable method which doesn't issue messages"""
        self.modifiable.do_something()
        # Now it should be modified and we should not have received any
        # message
        self.assert_(self.modifiable.WasModified())
        self.check_messages([])

    def test_unset_modified(self):
        """Test Modifiable.UnsetModified.

        Test whether the UnsetModified does in fact clear the modified
        flag and whether it issues a CHANGED message if it changes the
        modified flag from true to false.
        """
        # We start with an unmodified object, so when we call
        # UnsetModified now it shouldn't result in any message.
        self.modifiable.UnsetModified()
        self.check_messages([])
        self.failIf(self.modifiable.WasModified())

        # Call a method that modifies the object silently.
        self.modifiable.do_something()
        self.check_messages([])
        self.assert_(self.modifiable.WasModified())

        # when we now call UnsetModified it should result in a CHANGED
        # message
        self.modifiable.UnsetModified()
        self.check_messages([(CHANGED,)])
        self.failIf(self.modifiable.WasModified())

    def test_issuing_change(self):
        """Test Modifiable method that issues messages"""
        self.modifiable.do_something_else()
        # Now it should be modified and we should have received a
        # CHANGED message
        self.check_messages([(SOMETHING_ELSE,)])
        self.assert_(self.modifiable.WasModified())


if __name__ == "__main__":
    unittest.main()
1	bh	327	# 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 TitledObject and Modifiable
10			"""
11
12			__version__ = "$Revision$"
13			# $Source$
14			# $Id$
15
16			import unittest
17
18			import support
19			support.initthuban()
20
21			from Thuban.Model.base import TitledObject, Modifiable
22			from Thuban.Model.messages import TITLE_CHANGED, CHANGED
23			from Thuban.Lib.connector import Publisher
24
25			SOMETHING_ELSE = "SOMETHING_ELSE"
26
27			class SomeTitledObject(TitledObject, Publisher):
28
29			"""TitledObject for test purposes.
30
31			TitledObject is not used directly. It's a mixin to be used together
32			with Publisher.
33			"""
34
35			class SomeModifiable(Modifiable):
36
37			"""Modifiable for test purposes.
38
39			Modifiable is intended to be used as a base class for classes that
40			need to inform other classes when they change and that have to keep
41			track of whether they have changed. Thus we use a derived class for
42			testing that provides some methods that simulate modificatios.
43			"""
44
45			def do_something(self):
46			"""Call self.changed without parameters"""
47			self.changed()
48
49			def do_something_else(self):
50			"""Call self.changed with a message parameter"""
51			self.changed(SOMETHING_ELSE)
52
53
54			class SubscriberTest(unittest.TestCase, support.SubscriberMixin):
55
56			"""Base class for test cases that use SubscriberMixin.
57
58			Just provide the default implementations of setUp and tearDown.
59			"""
60
61			def setUp(self):
62			"""Clear the list of received messages"""
63			self.clear_messages()
64
65			def tearDown(self):
66			"""Clear the list of received messages"""
67			self.clear_messages()
68
69
70			class TestTitledObject(SubscriberTest):
71
72			"""Test cases for TitledObject"""
73
74			def test_titled_object(self):
75			"""Test TitledObject"""
76			titled = SomeTitledObject("Some Title")
77			titled.Subscribe(TITLE_CHANGED,
78			self.subscribe_with_params, TITLE_CHANGED)
79
80			self.assertEquals(titled.Title(), "Some Title")
81
82			titled.SetTitle("New Title")
83			self.assertEquals(titled.Title(), "New Title")
84
85			self.check_messages([(titled, TITLE_CHANGED)])
86
87
88			class TestModifiable(SubscriberTest):
89
90			"""Test cases for Modifiable"""
91
92			def setUp(self):
93			"""Extend the inherited method to create a Modifiable instance.
94
95			Bind the Modifiable instance (actually an instance of
96			SomeModifiable) to self.modifiable and subscribe to its CHANGED
97			and SOMETHING_ELSE channels.
98			"""
99			SubscriberTest.setUp(self)
100			self.modifiable = SomeModifiable()
101			self.modifiable.Subscribe(CHANGED, self.subscribe_with_params, CHANGED)
102			self.modifiable.Subscribe(SOMETHING_ELSE,
103			self.subscribe_with_params, SOMETHING_ELSE)
104
105			def tearDown(self):
106			"""Extend the inherited method to explicitly destroy self.modifiable.
107			"""
108			self.modifiable.Destroy()
109			SubscriberTest.tearDown(self)
110
111			def test_initial_state(self):
112			"""Test Modifiable initial state"""
113			# initially a modifiable is unmodified
114			self.failIf(self.modifiable.WasModified())
115			# this test should not have resulted in any messages
116			self.check_messages([])
117
118			def test_silent_change(self):
119			"""Test Modifiable method which doesn't issue messages"""
120			self.modifiable.do_something()
121			# Now it should be modified and we should not have received any
122			# message
123			self.assert_(self.modifiable.WasModified())
124			self.check_messages([])
125
126			def test_unset_modified(self):
127			"""Test Modifiable.UnsetModified.
128
129			Test whether the UnsetModified does in fact clear the modified
130			flag and whether it issues a CHANGED message if it changes the
131			modified flag from true to false.
132			"""
133			# We start with an unmodified object, so when we call
134			# UnsetModified now it shouldn't result in any message.
135			self.modifiable.UnsetModified()
136			self.check_messages([])
137			self.failIf(self.modifiable.WasModified())
138
139			# Call a method that modifies the object silently.
140			self.modifiable.do_something()
141			self.check_messages([])
142			self.assert_(self.modifiable.WasModified())
143
144			# when we now call UnsetModified it should result in a CHANGED
145			# message
146			self.modifiable.UnsetModified()
147			self.check_messages([(CHANGED,)])
148			self.failIf(self.modifiable.WasModified())
149
150			def test_issuing_change(self):
151			"""Test Modifiable method that issues messages"""
152			self.modifiable.do_something_else()
153			# Now it should be modified and we should have received a
154			# CHANGED message
155			self.check_messages([(SOMETHING_ELSE,)])
156			self.assert_(self.modifiable.WasModified())
157
158
159
160			if __name__ == "__main__":
161			unittest.main()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision