WIP-pyshapelib-bramz/test/test_command.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 the Command class
"""

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


import unittest

import support
support.initthuban()

from Thuban.UI.command import Command, ToolCommand

class MockContext:

    pass


class BaseCommandTest(unittest.TestCase):

    def setUp(self):
        self.command_args = None

    def command(self, *args):
        """Method to use as the command function.

        Bind all args except self to self.command_args as a tuple.
        """
        self.command_args = args

    def context(self):
        """Return a context object"""
        return MockContext()

class TestCommand(BaseCommandTest):

    def test_static_command(self):
        """Test Command object with no callbacks"""
        cmd = Command("do_something", "Do Something", self.command)
        self.assertEquals(cmd.Name(), "do_something")
        self.assertEquals(cmd.Title(), "Do Something")
        self.assertEquals(cmd.HelpText(), "")
        self.assertEquals(cmd.Icon(), "")
        self.failIf(cmd.IsDynamic())
        self.failIf(cmd.IsTool())

        context = self.context()
        self.assert_(cmd.Sensitive(context))
        self.failIf(cmd.Checked(context))

        # Execute the command with just the context
        cmd.Execute(context)
        self.assertEquals(self.command_args, (context,))

        # Execute the command with additional parameters
        cmd.Execute(context, "abc")
        self.assertEquals(self.command_args, (context, "abc"))

class TestDynamicCommand(BaseCommandTest):

    def setUp(self):
        BaseCommandTest.setUp(self)
        self.is_sensitive = 0
        self.is_checked = 0
        self.dynamic_text = ""

    def sensitive(self, context):
        return self.is_sensitive

    def checked(self, context):
        return self.is_checked

    def dyntext(self, context):
        return self.dynamic_text

    def context(self):
        """Return a context object"""
        return MockContext()

    def test_dynamic_sensitivity(self):
        """Test Command object with dynamic sensitivity"""
        cmd = Command("do_something", "Do Something", self.command,
                      sensitive = self.sensitive)
        self.assert_(cmd.IsDynamic())

        context = self.context()
        self.failIf(cmd.Sensitive(context))
        self.is_sensitive = 1
        self.assert_(cmd.Sensitive(context))

    def test_dynamic_checked(self):
        """Test Command object with dynamic checked flag"""
        cmd = Command("do_something", "Do Something", self.command,
                      checked = self.checked)
        self.assert_(cmd.IsDynamic())

        context = self.context()
        self.failIf(cmd.Checked(context))
        self.is_checked = 1
        self.assert_(cmd.Checked(context))

    def test_dynamic_title(self):
        """Test Command object with dynamic title"""
        cmd = Command("do_something", "Do Something", self.command,
                      dyntext = self.dyntext)
        self.assert_(cmd.IsDynamic())
        self.assert_(cmd.HasDynText())

        context = self.context()
        self.assertEquals(cmd.DynText(context), "")
        self.dynamic_text = "A Dynamic Title"
        self.assertEquals(cmd.DynText(context), "A Dynamic Title")

    def test_tool_command(self):
        """Test ToolCommand object"""
        cmd = ToolCommand("do_something", "Do Something", self.command,
                          checked = self.checked)
        self.assert_(cmd.IsDynamic())
        self.assert_(cmd.IsTool())

if __name__ == "__main__":
    unittest.main()
1	# Copyright (c) 2002, 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 Thuban for details.
7
8	"""
9	Test the Command class
10	"""
11
12	__version__ = "$Revision$"
13	# $Source$
14	# $Id$
15
16
17	import unittest
18
19	import support
20	support.initthuban()
21
22	from Thuban.UI.command import Command, ToolCommand
23
24	class MockContext:
25
26	pass
27
28
29	class BaseCommandTest(unittest.TestCase):
30
31	def setUp(self):
32	self.command_args = None
33
34	def command(self, *args):
35	"""Method to use as the command function.
36
37	Bind all args except self to self.command_args as a tuple.
38	"""
39	self.command_args = args
40
41	def context(self):
42	"""Return a context object"""
43	return MockContext()
44
45	class TestCommand(BaseCommandTest):
46
47	def test_static_command(self):
48	"""Test Command object with no callbacks"""
49	cmd = Command("do_something", "Do Something", self.command)
50	self.assertEquals(cmd.Name(), "do_something")
51	self.assertEquals(cmd.Title(), "Do Something")
52	self.assertEquals(cmd.HelpText(), "")
53	self.assertEquals(cmd.Icon(), "")
54	self.failIf(cmd.IsDynamic())
55	self.failIf(cmd.IsTool())
56
57	context = self.context()
58	self.assert_(cmd.Sensitive(context))
59	self.failIf(cmd.Checked(context))
60
61	# Execute the command with just the context
62	cmd.Execute(context)
63	self.assertEquals(self.command_args, (context,))
64
65	# Execute the command with additional parameters
66	cmd.Execute(context, "abc")
67	self.assertEquals(self.command_args, (context, "abc"))
68
69	class TestDynamicCommand(BaseCommandTest):
70
71	def setUp(self):
72	BaseCommandTest.setUp(self)
73	self.is_sensitive = 0
74	self.is_checked = 0
75	self.dynamic_text = ""
76
77	def sensitive(self, context):
78	return self.is_sensitive
79
80	def checked(self, context):
81	return self.is_checked
82
83	def dyntext(self, context):
84	return self.dynamic_text
85
86	def context(self):
87	"""Return a context object"""
88	return MockContext()
89
90	def test_dynamic_sensitivity(self):
91	"""Test Command object with dynamic sensitivity"""
92	cmd = Command("do_something", "Do Something", self.command,
93	sensitive = self.sensitive)
94	self.assert_(cmd.IsDynamic())
95
96	context = self.context()
97	self.failIf(cmd.Sensitive(context))
98	self.is_sensitive = 1
99	self.assert_(cmd.Sensitive(context))
100
101	def test_dynamic_checked(self):
102	"""Test Command object with dynamic checked flag"""
103	cmd = Command("do_something", "Do Something", self.command,
104	checked = self.checked)
105	self.assert_(cmd.IsDynamic())
106
107	context = self.context()
108	self.failIf(cmd.Checked(context))
109	self.is_checked = 1
110	self.assert_(cmd.Checked(context))
111
112	def test_dynamic_title(self):
113	"""Test Command object with dynamic title"""
114	cmd = Command("do_something", "Do Something", self.command,
115	dyntext = self.dyntext)
116	self.assert_(cmd.IsDynamic())
117	self.assert_(cmd.HasDynText())
118
119	context = self.context()
120	self.assertEquals(cmd.DynText(context), "")
121	self.dynamic_text = "A Dynamic Title"
122	self.assertEquals(cmd.DynText(context), "A Dynamic Title")
123
124	def test_tool_command(self):
125	"""Test ToolCommand object"""
126	cmd = ToolCommand("do_something", "Do Something", self.command,
127	checked = self.checked)
128	self.assert_(cmd.IsDynamic())
129	self.assert_(cmd.IsTool())
130
131	if __name__ == "__main__":
132	unittest.main()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision