June 2013 - tor-commits - lists.torproject.org

[stem/master] Adding the mock module as a test dependency
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit 606ccfbb5001d5a13bce8b7a51cea283c074f3c1 Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Jun 9 12:14:56 2013 -0700 Adding the mock module as a test dependency Mocking is hard. We've gotten a lot of mileage by writing our own mocking helpers, but they're clunky and complicated. It's about time for us to use a more standard, mature option. The pypi mock module is not only well documented, but looks to be the direction the python world is going. As of python 3.3 it's now part of the standard library. As the first step of swapping us over I'm adding it as a dependency for run_tests.py. This warns the user if it's unavailable... atagar@morrigan:~/Desktop/stem$ ./run_tests.py --unit To run stem's tests you'll need mock... https://pypi.python.org/pypi/mock/ You can get it by running 'sudo pip install mock'. --- run_tests.py | 17 +++++++++++++++++ stem/prereq.py | 20 ++++++++++++++++++++ test/settings.cfg | 1 + test/util.py | 8 ++++++++ 4 files changed, 46 insertions(+) diff --git a/run_tests.py b/run_tests.py index 6f77b0f..7bcbe5e 100755 --- a/run_tests.py +++ b/run_tests.py @@ -75,6 +75,12 @@ LOG_TYPE_ERROR = """\ TRACE, DEBUG, INFO, NOTICE, WARN, ERROR """ +MOCK_UNAVAILABLE_MSG = """\ +To run stem's tests you'll need mock... + +https://pypi.python.org/pypi/mock/ +""" + def main(): start_time = time.time() @@ -104,11 +110,22 @@ def main(): println("Nothing to run (for usage provide --help)\n") sys.exit() + if not stem.prereq.is_mock_available(): + println(MOCK_UNAVAILABLE_MSG) + + if stem.util.system.is_available('pip'): + println("You can get it by running 'sudo pip install mock'.") + elif stem.util.system.is_available('apt-get'): + println("You can get it by running 'sudo apt-get install python-mock'.") + + sys.exit(1) + test.util.run_tasks( "INITIALISING", Task("checking stem version", test.util.check_stem_version), Task("checking python version", test.util.check_python_version), Task("checking pycrypto version", test.util.check_pycrypto_version), + Task("checking mock version", test.util.check_mock_version), Task("checking pyflakes version", test.util.check_pyflakes_version), Task("checking pep8 version", test.util.check_pep8_version), Task("checking for orphaned .pyc files", test.util.clean_orphaned_pyc, (SRC_PATHS,)), diff --git a/stem/prereq.py b/stem/prereq.py index 2104cd5..148b6f8 100644 --- a/stem/prereq.py +++ b/stem/prereq.py @@ -22,6 +22,7 @@ Checks for stem dependencies. We require python 2.6 or greater (including the import sys IS_CRYPTO_AVAILABLE = None +IS_MOCK_AVAILABLE = None def check_requirements(): @@ -85,3 +86,22 @@ def is_crypto_available(): log.log_once("stem.prereq.is_crypto_available", log.INFO, msg) return IS_CRYPTO_AVAILABLE + + +def is_mock_available(): + """ + Checks if the mock module is available. + + :returns: **True** if the mock module is available and **False** otherwise + """ + + global IS_MOCK_AVAILABLE + + if IS_MOCK_AVAILABLE is None: + try: + import mock + IS_MOCK_AVAILABLE = True + except ImportError: + IS_MOCK_AVAILABLE = False + + return IS_MOCK_AVAILABLE diff --git a/test/settings.cfg b/test/settings.cfg index db318e4..96fc407 100644 --- a/test/settings.cfg +++ b/test/settings.cfg @@ -131,6 +131,7 @@ pep8.ignore E127 pyflakes.ignore stem/prereq.py => 'RSA' imported but unused pyflakes.ignore stem/prereq.py => 'asn1' imported but unused +pyflakes.ignore stem/prereq.py => 'mock' imported but unused pyflakes.ignore stem/prereq.py => 'long_to_bytes' imported but unused pyflakes.ignore stem/descriptor/__init__.py => redefinition of unused 'OrderedDict' from line 61 pyflakes.ignore stem/util/str_tools.py => redefinition of function '_to_bytes_impl' from line 51 diff --git a/test/util.py b/test/util.py index 4cdbdc2..4ab7460 100644 --- a/test/util.py +++ b/test/util.py @@ -378,6 +378,14 @@ def check_pycrypto_version(): return "missing" +def check_mock_version(): + if stem.prereq.is_mock_available(): + import mock + return mock.__version__ + else: + return "missing" + + def check_pyflakes_version(): try: import pyflakes

1 0

[stem/master] Using mock for version unit tests
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit 9109b6c078496c56b8ba1b85b0932b405be7d953 Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Jun 9 14:10:01 2013 -0700 Using mock for version unit tests First replacement of our mocking module with mock. This is actually both quite a bit cleaner, and also checks that our caching is working. --- test/unit/version.py | 27 +++++++++------------------ 1 file changed, 9 insertions(+), 18 deletions(-) diff --git a/test/unit/version.py b/test/unit/version.py index 8d15dc0..273d3e8 100644 --- a/test/unit/version.py +++ b/test/unit/version.py @@ -7,8 +7,9 @@ import unittest import stem.util.system import stem.version +from mock import patch + from stem.version import Version -from test import mocking TOR_VERSION_OUTPUT = """Mar 22 23:09:37.088 [notice] Tor v0.2.2.35 \ (git-73ff13ab3cc9570d). This is experimental software. Do not rely on it for \ @@ -17,28 +18,18 @@ Tor version 0.2.2.35 (git-73ff13ab3cc9570d).""" class TestVersion(unittest.TestCase): - def tearDown(self): - mocking.revert_mocking() - - def test_get_system_tor_version(self): - # Clear the version cache both before and after the test. Without this - # prior results short circuit the system call, and future calls will - # provide this mocked value. - - stem.version.VERSION_CACHE = {} + @patch('stem.util.system.call') + @patch.dict(stem.version.VERSION_CACHE) + def test_get_system_tor_version(self, call_mock): + call_mock.return_value = TOR_VERSION_OUTPUT.splitlines() - def _mock_call(command): - if command == "tor --version": - return TOR_VERSION_OUTPUT.splitlines() - else: - raise ValueError("stem.util.system.call received an unexpected command: %s" % command) - - mocking.mock(stem.util.system.call, _mock_call) version = stem.version.get_system_tor_version() + self.assert_versions_match(version, 0, 2, 2, 35, None, "git-73ff13ab3cc9570d") self.assertEqual("73ff13ab3cc9570d", version.git_commit) + call_mock.assert_called_once_with('tor --version') - stem.version.VERSION_CACHE = {} + self.assertEqual({'tor': version}, stem.version.VERSION_CACHE) def test_parsing(self): """

1 0

[stem/master] Using mock for tutorial unit test stdout
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit e50a62fd56aec4f5b9f96bf0828338356cc903e9 Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Jun 9 14:28:43 2013 -0700 Using mock for tutorial unit test stdout Mock's patch() docs include an example for mocking stdout. Using it for our tutorial unit tests... http://www.voidspace.org.uk/python/mock/patch.html#mock.patch --- test/unit/tutorial.py | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/test/unit/tutorial.py b/test/unit/tutorial.py index 405bca7..14050cf 100644 --- a/test/unit/tutorial.py +++ b/test/unit/tutorial.py @@ -4,9 +4,10 @@ Tests for the examples given in stem's tutorial. import io import StringIO -import sys import unittest +from mock import patch + from stem.control import Controller from stem.descriptor.reader import DescriptorReader from stem.descriptor.server_descriptor import RelayDescriptor @@ -21,19 +22,14 @@ MIRROR_MIRROR_OUTPUT = """\ class TestTutorial(unittest.TestCase): - stdout, stdout_real = None, None - def setUp(self): - self.stdout, self.stdout_real = StringIO.StringIO(), sys.stdout - sys.stdout = self.stdout - mocking.mock_method(RelayDescriptor, '_verify_digest', mocking.no_op()) def tearDown(self): mocking.revert_mocking() - sys.stdout = self.stdout_real - def test_the_little_relay_that_could(self): + @patch('sys.stdout', new_callable = StringIO.StringIO) + def test_the_little_relay_that_could(self, stdout_mock): def tutorial_example(): from stem.control import Controller @@ -61,9 +57,10 @@ class TestTutorial(unittest.TestCase): ) tutorial_example() - self.assertEqual("My Tor relay has read 33406 bytes and written 29649.\n", self.stdout.getvalue()) + self.assertEqual("My Tor relay has read 33406 bytes and written 29649.\n", stdout_mock.getvalue()) - def test_mirror_mirror_on_the_wall_1(self): + @patch('sys.stdout', new_callable = StringIO.StringIO) + def test_mirror_mirror_on_the_wall_1(self, stdout_mock): def tutorial_example(): from stem.control import Controller @@ -88,9 +85,10 @@ class TestTutorial(unittest.TestCase): ) tutorial_example() - self.assertEqual("found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n", self.stdout.getvalue()) + self.assertEqual("found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n", stdout_mock.getvalue()) - def test_mirror_mirror_on_the_wall_2(self): + @patch('sys.stdout', new_callable = StringIO.StringIO) + def test_mirror_mirror_on_the_wall_2(self, stdout_mock): def tutorial_example(): from stem.descriptor import parse_file @@ -112,9 +110,10 @@ class TestTutorial(unittest.TestCase): mocking.mock(open, mocking.return_value(test_file)) tutorial_example() - self.assertEqual("found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n", self.stdout.getvalue()) + self.assertEqual("found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n", stdout_mock.getvalue()) - def test_mirror_mirror_on_the_wall_3(self): + @patch('sys.stdout', new_callable = StringIO.StringIO) + def test_mirror_mirror_on_the_wall_3(self, stdout_mock): def tutorial_example(): from stem.descriptor.reader import DescriptorReader @@ -129,9 +128,10 @@ class TestTutorial(unittest.TestCase): ) tutorial_example() - self.assertEqual("found relay caerSidi (None)\n", self.stdout.getvalue()) + self.assertEqual("found relay caerSidi (None)\n", stdout_mock.getvalue()) - def test_mirror_mirror_on_the_wall_4(self): + @patch('sys.stdout', new_callable = StringIO.StringIO) + def test_mirror_mirror_on_the_wall_4(self, stdout_mock): def tutorial_example(): from stem.control import Controller from stem.util import str_tools @@ -187,4 +187,4 @@ class TestTutorial(unittest.TestCase): ) tutorial_example() - self.assertEqual(MIRROR_MIRROR_OUTPUT, self.stdout.getvalue()) + self.assertEqual(MIRROR_MIRROR_OUTPUT, stdout_mock.getvalue())

1 0

[stem/master] Using mock for tutorial unit tests
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit 9c0f1d37c0febbaacd2b6b73a2d094d3583869ba Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Jun 9 18:20:49 2013 -0700 Using mock for tutorial unit tests The unit tests for our tutorials are some of the ugliest we have since they make heavy use of mocks. Hence a good next step for mock. The mock module makes the controller mocking considerably nicer. That said, mock's open() mocking is crap. Their mock_open() docs... http://www.voidspace.org.uk/python/mock/helpers.html#mock.mock_open Tripped me up for well over an hour because their examples are hardcoded for the __main__ namespace (so it works when I do it in an interpretor, but not the tests). Even with that fixed the mock object it returns is buggy as hell (it's documented as supporting readlines() but that's a lie). They'd get a lot more mileage if they used an io.BytesIO instead. --- test/unit/tutorial.py | 98 +++++++++++++++---------------------------------- 1 file changed, 30 insertions(+), 68 deletions(-) diff --git a/test/unit/tutorial.py b/test/unit/tutorial.py index 14050cf..0f66a83 100644 --- a/test/unit/tutorial.py +++ b/test/unit/tutorial.py @@ -6,12 +6,11 @@ import io import StringIO import unittest -from mock import patch +from mock import Mock, patch from stem.control import Controller from stem.descriptor.reader import DescriptorReader from stem.descriptor.server_descriptor import RelayDescriptor -from stem.prereq import is_python_3 from test import mocking MIRROR_MIRROR_OUTPUT = """\ @@ -22,14 +21,9 @@ MIRROR_MIRROR_OUTPUT = """\ class TestTutorial(unittest.TestCase): - def setUp(self): - mocking.mock_method(RelayDescriptor, '_verify_digest', mocking.no_op()) - - def tearDown(self): - mocking.revert_mocking() - @patch('sys.stdout', new_callable = StringIO.StringIO) - def test_the_little_relay_that_could(self, stdout_mock): + @patch('stem.control.Controller.from_port', spec = Controller) + def test_the_little_relay_that_could(self, from_port_mock, stdout_mock): def tutorial_example(): from stem.control import Controller @@ -41,26 +35,18 @@ class TestTutorial(unittest.TestCase): print "My Tor relay has read %s bytes and written %s." % (bytes_read, bytes_written) - controller = mocking.get_object(Controller, { - 'authenticate': mocking.no_op(), - 'close': mocking.no_op(), - 'get_info': mocking.return_for_args({ - ('traffic/read',): '33406', - ('traffic/written',): '29649', - }, is_method = True), - }) - - mocking.mock( - Controller.from_port, mocking.return_value(controller), - target_module = Controller, - is_static = True, - ) + controller = from_port_mock().__enter__() + controller.get_info.side_effect = lambda arg: { + 'traffic/read': '33406', + 'traffic/written': '29649', + }[arg] tutorial_example() self.assertEqual("My Tor relay has read 33406 bytes and written 29649.\n", stdout_mock.getvalue()) @patch('sys.stdout', new_callable = StringIO.StringIO) - def test_mirror_mirror_on_the_wall_1(self, stdout_mock): + @patch('stem.control.Controller.from_port', spec = Controller) + def test_mirror_mirror_on_the_wall_1(self, from_port_mock, stdout_mock): def tutorial_example(): from stem.control import Controller @@ -70,25 +56,15 @@ class TestTutorial(unittest.TestCase): for desc in controller.get_network_statuses(): print "found relay %s (%s)" % (desc.nickname, desc.fingerprint) - controller = mocking.get_object(Controller, { - 'authenticate': mocking.no_op(), - 'close': mocking.no_op(), - 'get_network_statuses': mocking.return_value( - [mocking.get_router_status_entry_v2()], - ), - }) - - mocking.mock( - Controller.from_port, mocking.return_value(controller), - target_module = Controller, - is_static = True, - ) + controller = from_port_mock().__enter__() + controller.get_network_statuses.return_value = [mocking.get_router_status_entry_v2()] tutorial_example() self.assertEqual("found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n", stdout_mock.getvalue()) @patch('sys.stdout', new_callable = StringIO.StringIO) - def test_mirror_mirror_on_the_wall_2(self, stdout_mock): + @patch('%s.open' % __name__, create = True) + def test_mirror_mirror_on_the_wall_2(self, open_mock, stdout_mock): def tutorial_example(): from stem.descriptor import parse_file @@ -100,20 +76,16 @@ class TestTutorial(unittest.TestCase): content = True, )) - mocking.support_with(test_file) test_file.name = "/home/atagar/.tor/cached-consensus" - - if is_python_3(): - import builtins - mocking.mock(open, mocking.return_value(test_file), target_module = builtins) - else: - mocking.mock(open, mocking.return_value(test_file)) + open_mock.return_value = test_file tutorial_example() self.assertEqual("found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n", stdout_mock.getvalue()) @patch('sys.stdout', new_callable = StringIO.StringIO) - def test_mirror_mirror_on_the_wall_3(self, stdout_mock): + @patch('stem.descriptor.reader.DescriptorReader', spec = DescriptorReader) + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) + def test_mirror_mirror_on_the_wall_3(self, reader_mock, stdout_mock): def tutorial_example(): from stem.descriptor.reader import DescriptorReader @@ -121,17 +93,16 @@ class TestTutorial(unittest.TestCase): for desc in reader: print "found relay %s (%s)" % (desc.nickname, desc.fingerprint) - mocking.mock( - DescriptorReader.__iter__, - mocking.return_value(iter([mocking.get_relay_server_descriptor()])), - target_module = DescriptorReader - ) + reader = reader_mock().__enter__() + reader.__iter__.return_value = iter([mocking.get_relay_server_descriptor()]) tutorial_example() self.assertEqual("found relay caerSidi (None)\n", stdout_mock.getvalue()) @patch('sys.stdout', new_callable = StringIO.StringIO) - def test_mirror_mirror_on_the_wall_4(self, stdout_mock): + @patch('stem.control.Controller.from_port', spec = Controller) + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) + def test_mirror_mirror_on_the_wall_4(self, from_port_mock, stdout_mock): def tutorial_example(): from stem.control import Controller from stem.util import str_tools @@ -169,22 +140,13 @@ class TestTutorial(unittest.TestCase): exit_descriptor = mocking.sign_descriptor_content(exit_descriptor) exit_descriptor = RelayDescriptor(exit_descriptor) - controller = mocking.get_object(Controller, { - 'authenticate': mocking.no_op(), - 'close': mocking.no_op(), - 'get_server_descriptors': mocking.return_value([ - exit_descriptor, - mocking.get_relay_server_descriptor(), # non-exit - exit_descriptor, - exit_descriptor, - ]) - }) - - mocking.mock( - Controller.from_port, mocking.return_value(controller), - target_module = Controller, - is_static = True, - ) + controller = from_port_mock().__enter__() + controller.get_server_descriptors.return_value = [ + exit_descriptor, + mocking.get_relay_server_descriptor(), # non-exit + exit_descriptor, + exit_descriptor, + ] tutorial_example() self.assertEqual(MIRROR_MIRROR_OUTPUT, stdout_mock.getvalue())

1 0

[stem/master] Using mock for authentication unit tests
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit 1007a0a2d1963f350444c3b762cab6be8bda6eda Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Jun 10 08:30:16 2013 -0700 Using mock for authentication unit tests Mostly sorting out another thorny test that exhaustively exercises all authentication use cases. --- test/unit/connection/authentication.py | 47 +++++++++++++++----------------- 1 file changed, 22 insertions(+), 25 deletions(-) diff --git a/test/unit/connection/authentication.py b/test/unit/connection/authentication.py index bc0b44d..2157a5b 100644 --- a/test/unit/connection/authentication.py +++ b/test/unit/connection/authentication.py @@ -13,44 +13,41 @@ import unittest import stem.connection +from mock import Mock, patch + from stem.util import log from test import mocking class TestAuthenticate(unittest.TestCase): - def setUp(self): - mocking.mock(stem.connection.get_protocolinfo, mocking.no_op()) - mocking.mock(stem.connection.authenticate_none, mocking.no_op()) - mocking.mock(stem.connection.authenticate_password, mocking.no_op()) - mocking.mock(stem.connection.authenticate_cookie, mocking.no_op()) - mocking.mock(stem.connection.authenticate_safecookie, mocking.no_op()) - - def tearDown(self): - mocking.revert_mocking() - - def test_with_get_protocolinfo(self): + @patch('stem.connection.get_protocolinfo') + @patch('stem.connection.authenticate_none', Mock()) + def test_with_get_protocolinfo(self, get_protocolinfo_mock): """ Tests the authenticate() function when it needs to make a get_protocolinfo. """ # tests where get_protocolinfo succeeds - protocolinfo_response = mocking.get_protocolinfo_response( + + get_protocolinfo_mock.return_value = mocking.get_protocolinfo_response( auth_methods = (stem.connection.AuthMethod.NONE, ), ) - mocking.mock(stem.connection.get_protocolinfo, mocking.return_value(protocolinfo_response)) stem.connection.authenticate(None) # tests where get_protocolinfo raises an exception - raised_exc = stem.ProtocolError(None) - mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(raised_exc)) + + get_protocolinfo_mock.side_effect = stem.ProtocolError self.assertRaises(stem.connection.IncorrectSocketType, stem.connection.authenticate, None) - raised_exc = stem.SocketError(None) - mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(raised_exc)) + get_protocolinfo_mock.side_effect = stem.SocketError self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None) - def test_all_use_cases(self): + @patch('stem.connection.authenticate_none') + @patch('stem.connection.authenticate_password') + @patch('stem.connection.authenticate_cookie') + @patch('stem.connection.authenticate_safecookie') + def test_all_use_cases(self, authenticate_safecookie_mock, authenticate_cookie_mock, authenticate_password_mock, authenticate_none_mock): """ Does basic validation that all valid use cases for the PROTOCOLINFO input and dependent functions result in either success or a AuthenticationFailed @@ -127,26 +124,26 @@ class TestAuthenticate(unittest.TestCase): expect_success = False auth_mocks = { stem.connection.AuthMethod.NONE: - (stem.connection.authenticate_none, auth_none_exc), + (authenticate_none_mock, auth_none_exc), stem.connection.AuthMethod.PASSWORD: - (stem.connection.authenticate_password, auth_password_exc), + (authenticate_password_mock, auth_password_exc), stem.connection.AuthMethod.COOKIE: - (stem.connection.authenticate_cookie, auth_cookie_exc), + (authenticate_cookie_mock, auth_cookie_exc), stem.connection.AuthMethod.SAFECOOKIE: - (stem.connection.authenticate_safecookie, auth_cookie_exc), + (authenticate_safecookie_mock, auth_cookie_exc), } for auth_method in auth_mocks: - auth_function, raised_exc = auth_mocks[auth_method] + auth_mock, raised_exc = auth_mocks[auth_method] if not raised_exc: # Mocking this authentication method so it will succeed. If # it's among the protocolinfo methods then expect success. - mocking.mock(auth_function, mocking.no_op()) + auth_mock.side_effect = None expect_success |= auth_method in protocolinfo_auth_methods else: - mocking.mock(auth_function, mocking.raise_exception(raised_exc)) + auth_mock.side_effect = raised_exc if expect_success: stem.connection.authenticate(None, "blah", None, protocolinfo_arg)

1 0

[stem/master] Using mock for protocolinfo unit tests
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit 5089ded80aaa4fd5bc260c2b7fb5bf03e69b2133 Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Jun 10 08:50:44 2013 -0700 Using mock for protocolinfo unit tests Oooh, I like this change. --- test/unit/response/protocolinfo.py | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/test/unit/response/protocolinfo.py b/test/unit/response/protocolinfo.py index e8bc884..30b218d 100644 --- a/test/unit/response/protocolinfo.py +++ b/test/unit/response/protocolinfo.py @@ -12,6 +12,8 @@ import stem.util.proc import stem.util.system import stem.version +from mock import Mock, patch + from stem.response.protocolinfo import AuthMethod from test import mocking @@ -145,6 +147,8 @@ class TestProtocolInfoResponse(unittest.TestCase): self.assertEquals((), control_message.unknown_auth_methods) self.assertEquals(None, control_message.cookie_path) + @patch('stem.util.proc.is_available', Mock(return_value = False)) + @patch('stem.util.system.is_available', Mock(return_value = True)) def test_relative_cookie(self): """ Checks an authentication cookie with a relative path where expansion both @@ -156,30 +160,26 @@ class TestProtocolInfoResponse(unittest.TestCase): # - resolving the pid of the "tor" process # - using that to get tor's cwd - def call_mocking(command, default): + def call_function(command, default): if command == stem.util.system.GET_PID_BY_NAME_PGREP % "tor": return ["10"] elif command == stem.util.system.GET_CWD_PWDX % 10: return ["10: /tmp/foo"] - mocking.mock(stem.util.proc.is_available, mocking.return_false()) - mocking.mock(stem.util.system.is_available, mocking.return_true()) - mocking.mock(stem.util.system.call, call_mocking) + with patch('stem.util.system.call') as call_mock: + call_mock.side_effect = call_function - control_message = mocking.get_message(RELATIVE_COOKIE_PATH) - stem.response.convert("PROTOCOLINFO", control_message) + control_message = mocking.get_message(RELATIVE_COOKIE_PATH) + stem.response.convert("PROTOCOLINFO", control_message) - stem.connection._expand_cookie_path(control_message, stem.util.system.get_pid_by_name, "tor") + stem.connection._expand_cookie_path(control_message, stem.util.system.get_pid_by_name, "tor") - self.assertEquals(os.path.join("/tmp/foo", "tor-browser_en-US", "Data", "control_auth_cookie"), control_message.cookie_path) + self.assertEquals(os.path.join("/tmp/foo", "tor-browser_en-US", "Data", "control_auth_cookie"), control_message.cookie_path) # exercise cookie expansion where both calls fail (should work, just # leaving the path unexpanded) - mocking.mock(stem.util.system.call, mocking.return_none()) - control_message = mocking.get_message(RELATIVE_COOKIE_PATH) - stem.response.convert("PROTOCOLINFO", control_message) - self.assertEquals("./tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_path) - - # reset system call mocking - mocking.revert_mocking() + with patch('stem.util.system.call', Mock(return_value = None)): + control_message = mocking.get_message(RELATIVE_COOKIE_PATH) + stem.response.convert("PROTOCOLINFO", control_message) + self.assertEquals("./tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_path)

1 0

[stem/master] Using mock for event unit tests
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit f79278eec35de5520158923563256c45aa00f066 Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Jun 10 08:42:16 2013 -0700 Using mock for event unit tests We don't really need a mock in this test, guess we do so to be more faithful to the example. --- test/unit/response/events.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/test/unit/response/events.py b/test/unit/response/events.py index e41c80c..0d56309 100644 --- a/test/unit/response/events.py +++ b/test/unit/response/events.py @@ -10,6 +10,8 @@ import stem.response import stem.response.events import stem.util.log +from mock import Mock + from stem import * # enums and exceptions from test import mocking @@ -340,10 +342,7 @@ class TestEvents(unittest.TestCase): print_bw(_get_event("650 BW 15 25")) time.sleep(0.05) - controller = mocking.get_object(Controller, { - 'authenticate': mocking.no_op(), - 'add_event_listener': mocking.no_op(), - }) + controller = Mock(spec = Controller) controller.authenticate() controller.add_event_listener(print_bw, EventType.BW)

1 0

[stem/master] Using mock for controller unit tests
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit 8303c8d99ac6728367dabec3f6b2c9e43bb68c69 Author: Damian Johnson <atagar(a)torproject.org> Date: Tue Jun 11 08:43:05 2013 -0700 Using mock for controller unit tests Another heavy mock user. Nice improvements, I'm really liking this library! --- test/unit/control/controller.py | 217 ++++++++++++++++++++------------------- 1 file changed, 113 insertions(+), 104 deletions(-) diff --git a/test/unit/control/controller.py b/test/unit/control/controller.py index a0deaf1..ce25d30 100644 --- a/test/unit/control/controller.py +++ b/test/unit/control/controller.py @@ -13,10 +13,11 @@ import stem.socket import stem.util.system import stem.version +from mock import Mock, patch + from stem import InvalidArguments, InvalidRequest, ProtocolError, UnsatisfiableRequest from stem.control import _parse_circ_path, Controller, EventType from stem.exit_policy import ExitPolicy -from stem.socket import ControlSocket from test import mocking @@ -24,14 +25,11 @@ class TestControl(unittest.TestCase): def setUp(self): socket = stem.socket.ControlSocket() - mocking.mock_method(Controller, "add_event_listener", mocking.no_op()) - self.controller = Controller(socket) - mocking.revert_mocking() - - def tearDown(self): - mocking.revert_mocking() + with patch('stem.control.Controller.add_event_listener', Mock()): + self.controller = Controller(socket) - def test_get_version(self): + @patch('stem.control.Controller.get_info') + def test_get_version(self, get_info_mock): """ Exercises the get_version() method. """ @@ -40,7 +38,7 @@ class TestControl(unittest.TestCase): # Use one version for first check. version_2_1 = "0.2.1.32" version_2_1_object = stem.version.Version(version_2_1) - mocking.mock_method(Controller, "get_info", mocking.return_value(version_2_1)) + get_info_mock.return_value = version_2_1 # Return a version with a cold cache. self.assertEqual(version_2_1_object, self.controller.get_version()) @@ -48,7 +46,7 @@ class TestControl(unittest.TestCase): # Use a different version for second check. version_2_2 = "0.2.2.39" version_2_2_object = stem.version.Version(version_2_2) - mocking.mock_method(Controller, "get_info", mocking.return_value(version_2_2)) + get_info_mock.return_value = version_2_2 # Return a version with a hot cache, so it will be the old version. self.assertEqual(version_2_1_object, self.controller.get_version()) @@ -59,7 +57,7 @@ class TestControl(unittest.TestCase): self.assertEqual(version_2_2_object, self.controller.get_version()) # Raise an exception in the get_info() call. - mocking.mock_method(Controller, "get_info", mocking.raise_exception(InvalidArguments)) + get_info_mock.side_effect = InvalidArguments # Get a default value when the call fails. self.assertEqual( @@ -72,26 +70,29 @@ class TestControl(unittest.TestCase): # Give a bad version. The stem.version.Version ValueError should bubble up. version_A_42 = "0.A.42.spam" - mocking.mock_method(Controller, "get_info", mocking.return_value(version_A_42)) + get_info_mock.return_value = version_A_42 + get_info_mock.side_effect = None self.assertRaises(ValueError, self.controller.get_version) finally: # Turn caching back on before we leave. self.controller._is_caching_enabled = True - def test_get_exit_policy(self): + @patch('stem.control.Controller.get_info') + @patch('stem.control.Controller.get_conf') + def test_get_exit_policy(self, get_conf_mock, get_info_mock): """ Exercises the get_exit_policy() method. """ - mocking.mock_method(Controller, "get_conf", mocking.return_for_args({ - ("ExitPolicyRejectPrivate",): "1", - ("ExitPolicy", "multiple=True"): ["accept *:80, accept *:443", "accept 43.5.5.5,reject *:22"] - }, is_method = True)) + get_conf_mock.side_effect = lambda param, **kwargs: { + "ExitPolicyRejectPrivate": "1", + "ExitPolicy": ["accept *:80, accept *:443", "accept 43.5.5.5,reject *:22"], + }[param] - mocking.mock_method(Controller, "get_info", mocking.return_for_args({ - ("address", None): "123.45.67.89", - ("exit-policy/default",): "reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:563,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*" - }, is_method = True)) + get_info_mock.side_effect = lambda param, default = None: { + "address": "123.45.67.89", + "exit-policy/default": "reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:563,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*", + }[param] expected = ExitPolicy( 'reject 0.0.0.0/8:*', # private entries @@ -120,7 +121,9 @@ class TestControl(unittest.TestCase): self.assertEqual(expected, self.controller.get_exit_policy()) - def test_get_socks_listeners_old(self): + @patch('stem.control.Controller.get_info') + @patch('stem.control.Controller.get_conf') + def test_get_socks_listeners_old(self, get_conf_mock, get_info_mock): """ Exercises the get_socks_listeners() method as though talking to an old tor instance. @@ -129,68 +132,75 @@ class TestControl(unittest.TestCase): # An old tor raises stem.InvalidArguments for get_info about socks, but # get_socks_listeners should work anyway. - mocking.mock_method(Controller, "get_info", mocking.raise_exception(InvalidArguments)) + get_info_mock.side_effect = InvalidArguments + + get_conf_mock.side_effect = lambda param, **kwargs: { + "SocksPort": "9050", + "SocksListenAddress": ["127.0.0.1"], + }[param] - mocking.mock_method(Controller, "get_conf", mocking.return_for_args({ - ("SocksPort",): "9050", - ("SocksListenAddress", "multiple=True"): ["127.0.0.1"] - }, is_method = True)) self.assertEqual([('127.0.0.1', 9050)], self.controller.get_socks_listeners()) # Again, an old tor, but SocksListenAddress overrides the port number. - mocking.mock_method(Controller, "get_conf", mocking.return_for_args({ - ("SocksPort",): "9050", - ("SocksListenAddress", "multiple=True"): ["127.0.0.1:1112"] - }, is_method = True)) + get_conf_mock.side_effect = lambda param, **kwargs: { + "SocksPort": "9050", + "SocksListenAddress": ["127.0.0.1:1112"], + }[param] + self.assertEqual([('127.0.0.1', 1112)], self.controller.get_socks_listeners()) # Again, an old tor, but multiple listeners - mocking.mock_method(Controller, "get_conf", mocking.return_for_args({ - ("SocksPort",): "9050", - ("SocksListenAddress", "multiple=True"): ["127.0.0.1:1112", "127.0.0.1:1114"] - }, is_method = True)) + get_conf_mock.side_effect = lambda param, **kwargs: { + "SocksPort": "9050", + "SocksListenAddress": ["127.0.0.1:1112", "127.0.0.1:1114"], + }[param] + self.assertEqual([('127.0.0.1', 1112), ('127.0.0.1', 1114)], self.controller.get_socks_listeners()) # Again, an old tor, but no SOCKS listeners - mocking.mock_method(Controller, "get_conf", mocking.return_for_args({ - ("SocksPort",): "0", - ("SocksListenAddress", "multiple=True"): [] - }, is_method = True)) + get_conf_mock.side_effect = lambda param, **kwargs: { + "SocksPort": "0", + "SocksListenAddress": [], + }[param] + self.assertEqual([], self.controller.get_socks_listeners()) # Where tor provides invalid ports or addresses - mocking.mock_method(Controller, "get_conf", mocking.return_for_args({ - ("SocksPort",): "blarg", - ("SocksListenAddress", "multiple=True"): ["127.0.0.1"] - }, is_method = True)) + get_conf_mock.side_effect = lambda param, **kwargs: { + "SocksPort": "blarg", + "SocksListenAddress": ["127.0.0.1"], + }[param] + self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners) - mocking.mock_method(Controller, "get_conf", mocking.return_for_args({ - ("SocksPort",): "0", - ("SocksListenAddress", "multiple=True"): ["127.0.0.1:abc"] - }, is_method = True)) + get_conf_mock.side_effect = lambda param, **kwargs: { + "SocksPort": "0", + "SocksListenAddress": ["127.0.0.1:abc"], + }[param] + self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners) - mocking.mock_method(Controller, "get_conf", mocking.return_for_args({ - ("SocksPort",): "40", - ("SocksListenAddress", "multiple=True"): ["500.0.0.1"] - }, is_method = True)) + get_conf_mock.side_effect = lambda param, **kwargs: { + "SocksPort": "40", + "SocksListenAddress": ["500.0.0.1"], + }[param] + self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners) - def test_get_socks_listeners_new(self): + @patch('stem.control.Controller.get_info') + def test_get_socks_listeners_new(self, get_info_mock): """ Exercises the get_socks_listeners() method as if talking to a newer tor instance. """ # multiple SOCKS listeners - mocking.mock_method(Controller, "get_info", mocking.return_value( - '"127.0.0.1:1112" "127.0.0.1:1114"' - )) + + get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"' self.assertEqual( [('127.0.0.1', 1112), ('127.0.0.1', 1114)], @@ -198,7 +208,8 @@ class TestControl(unittest.TestCase): ) # no SOCKS listeners - mocking.mock_method(Controller, "get_info", mocking.return_value("")) + + get_info_mock.return_value = '' self.assertEqual([], self.controller.get_socks_listeners()) # check where GETINFO provides malformed content @@ -211,19 +222,18 @@ class TestControl(unittest.TestCase): ) for response in invalid_responses: - mocking.mock_method(Controller, "get_info", mocking.return_value(response)) + get_info_mock.return_value = response self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners) - def test_get_protocolinfo(self): + @patch('stem.connection.get_protocolinfo') + def test_get_protocolinfo(self, get_protocolinfo_mock): """ Exercises the get_protocolinfo() method. """ # use the handy mocked protocolinfo response - mocking.mock(stem.connection.get_protocolinfo, mocking.return_value( - mocking.get_protocolinfo_response() - )) + get_protocolinfo_mock.return_value = mocking.get_protocolinfo_response() # compare the str representation of these object, because the class # does not have, nor need, a direct comparison operator @@ -235,7 +245,7 @@ class TestControl(unittest.TestCase): # raise an exception in the stem.connection.get_protocolinfo() call - mocking.mock(stem.connection.get_protocolinfo, mocking.raise_exception(ProtocolError)) + get_protocolinfo_mock.side_effect = ProtocolError # get a default value when the call fails @@ -248,54 +258,53 @@ class TestControl(unittest.TestCase): self.assertRaises(ProtocolError, self.controller.get_protocolinfo) + @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False)) def test_get_user_remote(self): """ Exercise the get_user() method for a non-local socket. """ - mocking.mock_method(ControlSocket, "is_localhost", mocking.return_false()) - self.assertRaises(ValueError, self.controller.get_user) self.assertEqual(123, self.controller.get_user(123)) + @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True)) + @patch('stem.control.Controller.get_info', Mock(return_value = 'atagar')) def test_get_user_by_getinfo(self): """ Exercise the get_user() resolution via its getinfo option. """ - mocking.mock_method(ControlSocket, "is_localhost", mocking.return_true()) - mocking.mock_method(Controller, "get_info", mocking.return_value('atagar')) self.assertEqual('atagar', self.controller.get_user()) + @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True)) + @patch('stem.util.system.get_pid_by_name', Mock(return_value = 432)) + @patch('stem.util.system.get_user', Mock(return_value = 'atagar')) def test_get_user_by_system(self): """ Exercise the get_user() resolution via the system module. """ - mocking.mock_method(ControlSocket, "is_localhost", mocking.return_true()) - mocking.mock(stem.util.system.get_pid_by_name, mocking.return_value(432)) - mocking.mock(stem.util.system.get_user, mocking.return_value('atagar')) self.assertEqual('atagar', self.controller.get_user()) + @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False)) def test_get_pid_remote(self): """ Exercise the get_pid() method for a non-local socket. """ - mocking.mock_method(ControlSocket, "is_localhost", mocking.return_false()) - self.assertRaises(ValueError, self.controller.get_pid) self.assertEqual(123, self.controller.get_pid(123)) + @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True)) + @patch('stem.control.Controller.get_info', Mock(return_value = '321')) def test_get_pid_by_getinfo(self): """ Exercise the get_pid() resolution via its getinfo option. """ - mocking.mock_method(ControlSocket, "is_localhost", mocking.return_true()) - mocking.mock_method(Controller, "get_info", mocking.return_value('321')) self.assertEqual(321, self.controller.get_pid()) + @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True)) def test_get_pid_by_pid_file(self): """ Exercise the get_pid() resolution via a PidFile. @@ -304,29 +313,28 @@ class TestControl(unittest.TestCase): # It's a little inappropriate for us to be using tempfile in unit tests, # but this is more reliable than trying to mock open(). - mocking.mock_method(ControlSocket, "is_localhost", mocking.return_true()) - pid_file_path = tempfile.mkstemp()[1] try: with open(pid_file_path, 'w') as pid_file: pid_file.write('432') - mocking.mock_method(Controller, "get_conf", mocking.return_value(pid_file_path)) - self.assertEqual(432, self.controller.get_pid()) + with patch('stem.control.Controller.get_conf', Mock(return_value = pid_file_path)): + self.assertEqual(432, self.controller.get_pid()) finally: os.remove(pid_file_path) + @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True)) + @patch('stem.util.system.get_pid_by_name', Mock(return_value = 432)) def test_get_pid_by_name(self): """ Exercise the get_pid() resolution via the process name. """ - mocking.mock_method(ControlSocket, "is_localhost", mocking.return_true()) - mocking.mock(stem.util.system.get_pid_by_name, mocking.return_value(432)) self.assertEqual(432, self.controller.get_pid()) - def test_get_network_status(self): + @patch('stem.control.Controller.get_info') + def test_get_network_status(self, get_info_mock): """ Exercises the get_network_status() method. """ @@ -340,7 +348,7 @@ class TestControl(unittest.TestCase): # always return the same router status entry - mocking.mock_method(Controller, "get_info", mocking.return_value(desc)) + get_info_mock.return_value = desc # pretend to get the router status entry with its name @@ -358,7 +366,7 @@ class TestControl(unittest.TestCase): # raise an exception in the get_info() call - mocking.mock_method(Controller, "get_info", mocking.raise_exception(InvalidArguments)) + get_info_mock.side_effect = InvalidArguments # get a default value when the call fails @@ -371,25 +379,29 @@ class TestControl(unittest.TestCase): self.assertRaises(InvalidArguments, self.controller.get_network_status, nickname) - def test_event_listening(self): + @patch('stem.control.Controller.is_authenticated', Mock(return_value = True)) + @patch('stem.control.Controller._attach_listeners', Mock(return_value = ([], []))) + @patch('stem.control.Controller.get_version') + def test_event_listening(self, get_version_mock): """ Exercises the add_event_listener and remove_event_listener methods. """ # set up for failure to create any events - mocking.mock_method(Controller, "is_authenticated", mocking.return_true()) - mocking.mock_method(Controller, "_attach_listeners", mocking.return_value(([], []))) - mocking.mock_method(Controller, "get_version", mocking.return_value(stem.version.Version('0.1.0.14'))) - self.assertRaises(InvalidRequest, self.controller.add_event_listener, mocking.no_op(), EventType.BW) + + get_version_mock.return_value = stem.version.Version('0.1.0.14') + self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.BW) # set up to only fail newer events - mocking.mock_method(Controller, "get_version", mocking.return_value(stem.version.Version('0.2.0.35'))) + + get_version_mock.return_value = stem.version.Version('0.2.0.35') # EventType.BW is one of the earliest events - self.controller.add_event_listener(mocking.no_op(), EventType.BW) + + self.controller.add_event_listener(Mock(), EventType.BW) # EventType.SIGNAL was added in tor version 0.2.3.1-alpha - self.assertRaises(InvalidRequest, self.controller.add_event_listener, mocking.no_op(), EventType.SIGNAL) + self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.SIGNAL) def test_get_streams(self): """ @@ -403,20 +415,17 @@ class TestControl(unittest.TestCase): ("3", "SUCCEEDED", "4", "10.10.10.1:80") ) - responses = ["%s\r\n" % " ".join(entry) for entry in valid_streams] - - mocking.mock_method(Controller, "get_info", mocking.return_value( - "".join(responses) - )) + response = "".join(["%s\r\n" % " ".join(entry) for entry in valid_streams]) - streams = self.controller.get_streams() - self.assertEqual(len(valid_streams), len(streams)) + with patch('stem.control.Controller.get_info', Mock(return_value = response)): + streams = self.controller.get_streams() + self.assertEqual(len(valid_streams), len(streams)) - for index, stream in enumerate(streams): - self.assertEqual(valid_streams[index][0], stream.id) - self.assertEqual(valid_streams[index][1], stream.status) - self.assertEqual(valid_streams[index][2], stream.circ_id) - self.assertEqual(valid_streams[index][3], stream.target) + for index, stream in enumerate(streams): + self.assertEqual(valid_streams[index][0], stream.id) + self.assertEqual(valid_streams[index][1], stream.status) + self.assertEqual(valid_streams[index][2], stream.circ_id) + self.assertEqual(valid_streams[index][3], stream.target) def test_attach_stream(self): """ @@ -427,9 +436,9 @@ class TestControl(unittest.TestCase): # instance, it's already open). response = stem.response.ControlMessage.from_str("555 Connection is not managed by controller.\r\n") - mocking.mock_method(Controller, "msg", mocking.return_value(response)) - self.assertRaises(UnsatisfiableRequest, self.controller.attach_stream, 'stream_id', 'circ_id') + with patch('stem.control.Controller.msg', Mock(return_value = response)): + self.assertRaises(UnsatisfiableRequest, self.controller.attach_stream, 'stream_id', 'circ_id') def test_parse_circ_path(self): """

1 0

[stem/master] Dropping tempfile usage from controller unit test
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit 298a08c4b5488bf756c4dbce75ee0ebf4eeb2b0b Author: Damian Johnson <atagar(a)torproject.org> Date: Tue Jun 11 09:27:08 2013 -0700 Dropping tempfile usage from controller unit test Now that I have a better understanding of the magic behind mocking open, there's no need for us to make a temporary file in our unit tests. --- test/unit/control/controller.py | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-) diff --git a/test/unit/control/controller.py b/test/unit/control/controller.py index ce25d30..791f879 100644 --- a/test/unit/control/controller.py +++ b/test/unit/control/controller.py @@ -3,8 +3,7 @@ Unit tests for the stem.control module. The module's primarily exercised via integ tests, but a few bits lend themselves to unit testing. """ -import os -import tempfile +import io import unittest import stem.descriptor.router_status_entry @@ -305,24 +304,18 @@ class TestControl(unittest.TestCase): self.assertEqual(321, self.controller.get_pid()) @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True)) - def test_get_pid_by_pid_file(self): + @patch('stem.control.Controller.get_conf') + @patch('stem.control.open', create = True) + def test_get_pid_by_pid_file(self, open_mock, get_conf_mock): """ Exercise the get_pid() resolution via a PidFile. """ - # It's a little inappropriate for us to be using tempfile in unit tests, - # but this is more reliable than trying to mock open(). - - pid_file_path = tempfile.mkstemp()[1] - - try: - with open(pid_file_path, 'w') as pid_file: - pid_file.write('432') + get_conf_mock.return_value = '/tmp/pid_file' + open_mock.return_value = io.BytesIO('432') - with patch('stem.control.Controller.get_conf', Mock(return_value = pid_file_path)): - self.assertEqual(432, self.controller.get_pid()) - finally: - os.remove(pid_file_path) + self.assertEqual(432, self.controller.get_pid()) + open_mock.assert_called_once_with('/tmp/pid_file') @patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True)) @patch('stem.util.system.get_pid_by_name', Mock(return_value = 432))

1 0

[stem/master] Using mock for descriptor reader unit tests
by atagar＠torproject.org 14 Jun '13

14 Jun '13

commit 6c0af9db6169b7edb4eeb83f3555b9e5d6cc2d6e Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jun 12 09:32:37 2013 -0700 Using mock for descriptor reader unit tests We get to replace some icky open() mocks. Yay! --- test/unit/descriptor/reader.py | 48 +++++++++++++++++----------------------- 1 file changed, 20 insertions(+), 28 deletions(-) diff --git a/test/unit/descriptor/reader.py b/test/unit/descriptor/reader.py index bc24805..4b54fff 100644 --- a/test/unit/descriptor/reader.py +++ b/test/unit/descriptor/reader.py @@ -2,30 +2,17 @@ Unit tests for stem.descriptor.reader. """ -import StringIO +import io import unittest import stem.descriptor.reader -import stem.prereq -import test.mocking as mocking - -def _mock_open(content): - test_content = StringIO.StringIO(content) - mocking.support_with(test_content) - - if stem.prereq.is_python_3(): - import builtins - mocking.mock(builtins.open, mocking.return_value(test_content), builtins) - else: - mocking.mock(open, mocking.return_value(test_content)) +from mock import patch class TestDescriptorReader(unittest.TestCase): - def tearDown(self): - mocking.revert_mocking() - - def test_load_processed_files(self): + @patch('stem.descriptor.reader.open', create = True) + def test_load_processed_files(self, open_mock): """ Successful load of content. """ @@ -48,49 +35,54 @@ class TestDescriptorReader(unittest.TestCase): "/dir/after empty line": 12345, } - _mock_open("\n".join(test_lines)) + open_mock.return_value = io.BytesIO("\n".join(test_lines)) self.assertEquals(expected_value, stem.descriptor.reader.load_processed_files("")) - def test_load_processed_files_empty(self): + @patch('stem.descriptor.reader.open', create = True) + def test_load_processed_files_empty(self, open_mock): """ Tests the load_processed_files() function with an empty file. """ - _mock_open("") + open_mock.return_value = io.BytesIO("") self.assertEquals({}, stem.descriptor.reader.load_processed_files("")) - def test_load_processed_files_no_file(self): + @patch('stem.descriptor.reader.open', create = True) + def test_load_processed_files_no_file(self, open_mock): """ Tests the load_processed_files() function content that is malformed because it is missing the file path. """ - _mock_open(" 12345") + open_mock.return_value = io.BytesIO(" 12345") self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, "") - def test_load_processed_files_no_timestamp(self): + @patch('stem.descriptor.reader.open', create = True) + def test_load_processed_files_no_timestamp(self, open_mock): """ Tests the load_processed_files() function content that is malformed because it is missing the timestamp. """ - _mock_open("/dir/file ") + open_mock.return_value = io.BytesIO("/dir/file ") self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, "") - def test_load_processed_files_malformed_file(self): + @patch('stem.descriptor.reader.open', create = True) + def test_load_processed_files_malformed_file(self, open_mock): """ Tests the load_processed_files() function content that is malformed because it has an invalid file path. """ - _mock_open("not_an_absolute_file 12345") + open_mock.return_value = io.BytesIO("not_an_absolute_file 12345") self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, "") - def test_load_processed_files_malformed_timestamp(self): + @patch('stem.descriptor.reader.open', create = True) + def test_load_processed_files_malformed_timestamp(self, open_mock): """ Tests the load_processed_files() function content that is malformed because it has a non-numeric timestamp. """ - _mock_open("/dir/file 123a") + open_mock.return_value = io.BytesIO("/dir/file 123a") self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, "")

1 0