tor-commits June 2013

tor-commits@lists.torproject.org

19 participants
1571 discussions

[stem/master] Using mock for process integ tests
by atagar＠torproject.org 13 Jun '13

13 Jun '13

commit 625472df56748195c5b0474209278dd57a66c338 Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jun 12 19:38:11 2013 -0700 Using mock for process integ tests --- test/integ/process.py | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/test/integ/process.py b/test/integ/process.py index 3429adf..f6a862a 100644 --- a/test/integ/process.py +++ b/test/integ/process.py @@ -2,7 +2,6 @@ Tests the stem.process functions with various use cases. """ -import os import shutil import subprocess import tempfile @@ -16,12 +15,7 @@ import stem.util.system import stem.version import test.runner -from test import mocking - - -def _kill_process(process): - process.kill() - process.communicate() # block until its definitely gone +from mock import patch class TestProcess(unittest.TestCase): @@ -29,7 +23,6 @@ class TestProcess(unittest.TestCase): self.data_directory = tempfile.mkdtemp() def tearDown(self): - mocking.revert_mocking() shutil.rmtree(self.data_directory) def test_launch_tor_with_config(self): @@ -67,7 +60,8 @@ class TestProcess(unittest.TestCase): if control_socket: control_socket.close() - _kill_process(tor_process) + tor_process.kill() + tor_process.communicate() def test_launch_tor_with_timeout(self): """ @@ -86,7 +80,8 @@ class TestProcess(unittest.TestCase): if not (runtime > 2 and runtime < 3): self.fail("Test should have taken 2-3 seconds, took %i instead" % runtime) - def test_take_ownership_via_pid(self): + @patch('os.getpid') + def test_take_ownership_via_pid(self, getpid_mock): """ Checks that the tor process quits after we do if we set take_ownership. To test this we spawn a process and trick tor into thinking that it is us. @@ -101,7 +96,7 @@ class TestProcess(unittest.TestCase): return sleep_process = subprocess.Popen(['sleep', '60']) - mocking.mock(os.getpid, mocking.return_value(str(sleep_process.pid)), target_module = os) + getpid_mock.return_value = str(sleep_process.pid) tor_process = stem.process.launch_tor_with_config( tor_cmd = test.runner.get_runner().get_tor_command(), @@ -116,7 +111,8 @@ class TestProcess(unittest.TestCase): # Kill the sleep command. Tor should quit shortly after. - _kill_process(sleep_process) + sleep_process.kill() + sleep_process.communicate() # tor polls for the process every fifteen seconds so this may take a # while...

1 0

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

13 Jun '13

commit 8e90c1029e650536cf07ee42ddeb06300f0aa002 Author: Damian Johnson <atagar(a)torproject.org> Date: Tue Jun 11 09:09:05 2013 -0700 Using mock for proc unit tests Now that I have a rough understanding of the open mock it's quite a bit nicer than our prior version (which got especially icky for python 3 compatability). --- test/unit/util/proc.py | 104 ++++++++++++++++++++++++------------------------ 1 file changed, 51 insertions(+), 53 deletions(-) diff --git a/test/unit/util/proc.py b/test/unit/util/proc.py index 0a6c0a0..4ee598b 100644 --- a/test/unit/util/proc.py +++ b/test/unit/util/proc.py @@ -2,80 +2,84 @@ Unit testing code for the stem.util.proc functions. """ -import os import StringIO import unittest -import stem.prereq +from mock import Mock, patch from stem.util import proc from test import mocking class TestProc(unittest.TestCase): - def tearDown(self): - mocking.revert_mocking() - - def test_get_system_start_time(self): + @patch('stem.util.proc._get_line') + def test_get_system_start_time(self, get_line_mock): """ Tests the get_system_start_time function. """ - mocking.mock(proc._get_line, mocking.return_for_args({ + get_line_mock.side_effect = lambda *params: { ('/proc/stat', 'btime', 'system start time'): 'btime 1001001', - })) + }[params] self.assertEquals(1001001, proc.get_system_start_time()) - def test_get_physical_memory(self): + @patch('stem.util.proc._get_line') + def test_get_physical_memory(self, get_line_mock): """ Tests the get_physical_memory function. """ - mocking.mock(proc._get_line, mocking.return_for_args({ + get_line_mock.side_effect = lambda *params: { ('/proc/meminfo', 'MemTotal:', 'system physical memory'): 'MemTotal: 12345 kB', - })) + }[params] self.assertEquals((12345 * 1024), proc.get_physical_memory()) - def test_get_cwd(self): + @patch('os.readlink') + def test_get_cwd(self, readlink_mock): """ Tests the get_cwd function with a given pid. """ - mocking.mock(os.readlink, mocking.return_for_args({ - ('/proc/24019/cwd',): '/home/directory/TEST' - }), os) + readlink_mock.side_effect = lambda param: { + '/proc/24019/cwd': '/home/directory/TEST' + }[param] self.assertEquals('/home/directory/TEST', proc.get_cwd(24019)) - def test_get_uid(self): + @patch('stem.util.proc._get_line') + def test_get_uid(self, get_line_mock): """ Tests the get_uid function with a given pid. """ for test_value in [(24019, 11111), (0, 22222)]: pid, uid = test_value - mocking.mock(proc._get_line, mocking.return_for_args({ - ("/proc/%s/status" % pid, 'Uid:', 'uid'): 'Uid: %s' % uid - })) + + get_line_mock.side_effect = lambda *params: { + ("/proc/%s/status" % pid, 'Uid:', 'uid'): 'Uid: %s' % uid, + }[params] self.assertEquals(uid, proc.get_uid(pid)) - def test_get_memory_usage(self): + @patch('stem.util.proc._get_lines') + def test_get_memory_usage(self, get_lines_mock): """ Tests the get_memory_usage function with a given pid. """ - mocking.mock(proc._get_lines, mocking.return_for_args({ + get_lines_mock.side_effect = lambda *params: { ('/proc/1111/status', ('VmRSS:', 'VmSize:'), 'memory usage'): {'VmRSS:': 'VmRSS: 100 kB', 'VmSize:': 'VmSize: 1800 kB'} - })) + }[params] self.assertEqual((0, 0), proc.get_memory_usage(0)) self.assertEqual((100 * 1024, 1800 * 1024), proc.get_memory_usage(1111)) - def test_get_stats(self): + @patch('stem.util.proc._get_line') + @patch('stem.util.proc.get_system_start_time', Mock(return_value = 10)) + def test_get_stats(self, get_line_mock): """ Tests get_stats() with all combinations of stat_type arguments. """ @@ -91,12 +95,11 @@ class TestProc(unittest.TestCase): stat_path = "/proc/24062/stat" stat = '1 (test_program) 2 3 4 5 6 7 8 9 10 11 12 13.0 14.0 15 16 17 18 19 20 21.0 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43' - mocking.mock(proc.get_system_start_time, mocking.return_value(10)) - # tests the case where no stat_types are specified - mocking.mock(proc._get_line, mocking.return_for_args({ + + get_line_mock.side_effect = lambda *params: { (stat_path, '24062', 'process '): stat - })) + }[params] self.assertEquals((), proc.get_stats(24062)) @@ -109,9 +112,9 @@ class TestProc(unittest.TestCase): args, response = zip(*stats) - mocking.mock(proc._get_line, mocking.return_for_args({ + get_line_mock.side_effect = lambda *params: { (stat_path, '24062', 'process %s' % ', '.join(args)): stat - })) + }[params] self.assertEquals(response, proc.get_stats(24062, *args)) @@ -130,45 +133,40 @@ class TestProc(unittest.TestCase): elif arg == 'stime': response += ('0',) - mocking.mock(proc._get_line, mocking.return_for_args({ + get_line_mock.side_effect = lambda *params: { ('/proc/0/stat', '0', 'process %s' % ', '.join(args)): stat - })) + }[params] self.assertEquals(response, proc.get_stats(0, *args)) - def test_get_connections(self): + @patch('os.listdir') + @patch('os.readlink') + @patch('stem.util.proc.open', create = True) + def test_get_connections(self, open_mock, readlink_mock, listdir_mock): """ Tests the get_connections function. """ pid = 1111 - mocking.mock(os.listdir, mocking.return_for_args({ - ('/proc/%s/fd' % pid,): ['1', '2', '3', '4'], - }), os) + listdir_mock.side_effect = lambda param: { + '/proc/%s/fd' % pid: ['1', '2', '3', '4'], + }[param] - mocking.mock(os.readlink, mocking.return_for_args({ - ('/proc/%s/fd/1' % pid,): 'socket:[99999999]', - ('/proc/%s/fd/2' % pid,): 'socket:[IIIIIIII]', - ('/proc/%s/fd/3' % pid,): 'pipe:[30303]', - ('/proc/%s/fd/4' % pid,): 'pipe:[40404]', - }), os) + readlink_mock.side_effect = lambda param: { + '/proc/%s/fd/1' % pid: 'socket:[99999999]', + '/proc/%s/fd/2' % pid: 'socket:[IIIIIIII]', + '/proc/%s/fd/3' % pid: 'pipe:[30303]', + '/proc/%s/fd/4' % pid: 'pipe:[40404]', + }[param] tcp = '\n 0: 11111111:1111 22222222:2222 01 44444444:44444444 55:55555555 66666666 1111 8 99999999' udp = '\n A: BBBBBBBB:BBBB CCCCCCCC:CCCC DD EEEEEEEE:EEEEEEEE FF:FFFFFFFF GGGGGGGG 1111 H IIIIIIII' - if stem.prereq.is_python_3(): - import builtins - - mocking.mock(builtins.open, mocking.return_for_args({ - ('/proc/net/tcp',): StringIO.StringIO(tcp), - ('/proc/net/udp',): StringIO.StringIO(udp) - }), builtins) - else: - mocking.mock(open, mocking.return_for_args({ - ('/proc/net/tcp',): StringIO.StringIO(tcp), - ('/proc/net/udp',): StringIO.StringIO(udp) - })) + open_mock.side_effect = lambda param: { + '/proc/net/tcp': StringIO.StringIO(tcp), + '/proc/net/udp': StringIO.StringIO(udp) + }[param] # tests the edge case of pid = 0 self.assertEquals([], proc.get_connections(0))

1 0

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

13 Jun '13

commit 33eeb9bbcc4a877d02f227d9f9b76a4631f3053e Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jun 12 09:14:43 2013 -0700 Using mock for system unit tests Pretty much a drop-in replacement for these. --- test/unit/util/system.py | 124 +++++++++++++++++++++++++++------------------- 1 file changed, 72 insertions(+), 52 deletions(-) diff --git a/test/unit/util/system.py b/test/unit/util/system.py index a7b3d9b..628ab71 100644 --- a/test/unit/util/system.py +++ b/test/unit/util/system.py @@ -7,15 +7,12 @@ system running the tests. import functools import ntpath -import os -import platform import posixpath import unittest -import stem.util.proc +from mock import Mock, patch from stem.util import system -from test import mocking # Base responses for the get_pid_by_name tests. The 'success' and # 'multiple_results' entries are filled in by tests. @@ -109,15 +106,9 @@ def mock_call(base_cmd, responses): class TestSystem(unittest.TestCase): - def setUp(self): - mocking.mock(stem.util.proc.is_available, mocking.return_false()) - mocking.mock(system.is_available, mocking.return_true()) - mocking.mock(system.call, mocking.return_none()) - - def tearDown(self): - mocking.revert_mocking() - - def test_is_running(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_is_running(self, call_mock): """ Exercises multiple use cases for the is_running function. """ @@ -126,7 +117,7 @@ class TestSystem(unittest.TestCase): running_commands = [u"irssi", u"moc", u"tor", u"ps", u" firefox "] for ps_cmd in (system.IS_RUNNING_PS_LINUX, system.IS_RUNNING_PS_BSD): - mocking.mock(system.call, mock_call(ps_cmd, running_commands)) + call_mock.side_effect = mock_call(ps_cmd, running_commands) self.assertTrue(system.is_running("irssi")) self.assertTrue(system.is_running("moc")) @@ -136,11 +127,15 @@ class TestSystem(unittest.TestCase): self.assertEqual(False, system.is_running("something_else")) # mock both calls failing - mocking.mock(system.call, mocking.return_none()) + + call_mock.return_value = None + call_mock.side_effect = None self.assertFalse(system.is_running("irssi")) self.assertEquals(None, system.is_running("irssi")) - def test_get_pid_by_name_pgrep(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_pid_by_name_pgrep(self, call_mock): """ Tests the get_pid_by_name function with pgrep responses. """ @@ -148,7 +143,7 @@ class TestSystem(unittest.TestCase): responses = dict(GET_PID_BY_NAME_BASE_RESULTS) responses["success"] = ["1111"] responses["multiple_results"] = ["123", "456", "789"] - mocking.mock(system.call, mock_call(system.GET_PID_BY_NAME_PGREP, responses)) + call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PGREP, responses) for test_input in responses: expected_response = 1111 if test_input == "success" else None @@ -156,7 +151,9 @@ class TestSystem(unittest.TestCase): self.assertEquals([123, 456, 789], system.get_pid_by_name("multiple_results", multiple = True)) - def test_get_pid_by_name_pidof(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_pid_by_name_pidof(self, call_mock): """ Tests the get_pid_by_name function with pidof responses. """ @@ -164,7 +161,7 @@ class TestSystem(unittest.TestCase): responses = dict(GET_PID_BY_NAME_BASE_RESULTS) responses["success"] = ["1111"] responses["multiple_results"] = ["123 456 789"] - mocking.mock(system.call, mock_call(system.GET_PID_BY_NAME_PIDOF, responses)) + call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PIDOF, responses) for test_input in responses: expected_response = 1111 if test_input == "success" else None @@ -172,16 +169,18 @@ class TestSystem(unittest.TestCase): self.assertEquals([123, 456, 789], system.get_pid_by_name("multiple_results", multiple = True)) - def test_get_pid_by_name_ps_linux(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_bsd', Mock(return_value = False)) + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_pid_by_name_ps_linux(self, call_mock): """ Tests the get_pid_by_name function with the linux variant of ps. """ - mocking.mock(system.is_bsd, mocking.return_false()) responses = dict(GET_PID_BY_NAME_BASE_RESULTS) responses["success"] = ["PID", " 1111"] responses["multiple_results"] = ["PID", " 123", " 456", " 789"] - mocking.mock(system.call, mock_call(system.GET_PID_BY_NAME_PS_LINUX, responses)) + call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PS_LINUX, responses) for test_input in responses: expected_response = 1111 if test_input == "success" else None @@ -189,22 +188,26 @@ class TestSystem(unittest.TestCase): self.assertEquals([123, 456, 789], system.get_pid_by_name("multiple_results", multiple = True)) - def test_get_pid_by_name_ps_bsd(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_bsd', Mock(return_value = True)) + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_pid_by_name_ps_bsd(self, call_mock): """ Tests the get_pid_by_name function with the bsd variant of ps. """ - mocking.mock(system.is_bsd, mocking.return_true()) - mocking.mock(system.call, mock_call(system.GET_PID_BY_NAME_PS_BSD, GET_PID_BY_NAME_PS_BSD)) + call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PS_BSD, GET_PID_BY_NAME_PS_BSD) self.assertEquals(1, system.get_pid_by_name("launchd")) self.assertEquals(11, system.get_pid_by_name("DirectoryService")) self.assertEquals(None, system.get_pid_by_name("blarg")) - mocking.mock(system.call, mock_call(system.GET_PID_BY_NAME_PS_BSD, GET_PID_BY_NAME_PS_BSD_MULTIPLE)) + call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PS_BSD, GET_PID_BY_NAME_PS_BSD_MULTIPLE) self.assertEquals([1, 41], system.get_pid_by_name("launchd", multiple = True)) - def test_get_pid_by_name_lsof(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_pid_by_name_lsof(self, call_mock): """ Tests the get_pid_by_name function with lsof responses. """ @@ -212,7 +215,7 @@ class TestSystem(unittest.TestCase): responses = dict(GET_PID_BY_NAME_BASE_RESULTS) responses["success"] = ["1111"] responses["multiple_results"] = ["123", "456", "789"] - mocking.mock(system.call, mock_call(system.GET_PID_BY_NAME_LSOF, responses)) + call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_LSOF, responses) for test_input in responses: expected_response = 1111 if test_input == "success" else None @@ -220,51 +223,63 @@ class TestSystem(unittest.TestCase): self.assertEquals([123, 456, 789], system.get_pid_by_name("multiple_results", multiple = True)) - def test_get_pid_by_port_netstat(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_pid_by_port_netstat(self, call_mock): """ Tests the get_pid_by_port function with a netstat response. """ - mocking.mock(system.call, mock_call(system.GET_PID_BY_PORT_NETSTAT, GET_PID_BY_PORT_NETSTAT_RESULTS)) + call_mock.side_effect = mock_call(system.GET_PID_BY_PORT_NETSTAT, GET_PID_BY_PORT_NETSTAT_RESULTS) self.assertEquals(1641, system.get_pid_by_port(9051)) self.assertEquals(1641, system.get_pid_by_port("9051")) self.assertEquals(None, system.get_pid_by_port(631)) self.assertEquals(None, system.get_pid_by_port(123)) - def test_get_pid_by_port_sockstat(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_pid_by_port_sockstat(self, call_mock): """ Tests the get_pid_by_port function with a sockstat response. """ - mocking.mock(system.call, mock_call(system.GET_PID_BY_PORT_SOCKSTAT % 9051, GET_PID_BY_PORT_SOCKSTAT_RESULTS)) + call_mock.side_effect = mock_call(system.GET_PID_BY_PORT_SOCKSTAT % 9051, GET_PID_BY_PORT_SOCKSTAT_RESULTS) self.assertEquals(4397, system.get_pid_by_port(9051)) self.assertEquals(4397, system.get_pid_by_port("9051")) self.assertEquals(None, system.get_pid_by_port(123)) - def test_get_pid_by_port_lsof(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_pid_by_port_lsof(self, call_mock): """ Tests the get_pid_by_port function with a lsof response. """ - mocking.mock(system.call, mock_call(system.GET_PID_BY_PORT_LSOF, GET_PID_BY_PORT_LSOF_RESULTS)) + call_mock.side_effect = mock_call(system.GET_PID_BY_PORT_LSOF, GET_PID_BY_PORT_LSOF_RESULTS) self.assertEquals(1745, system.get_pid_by_port(9051)) self.assertEquals(1745, system.get_pid_by_port("9051")) self.assertEquals(329, system.get_pid_by_port(80)) self.assertEquals(None, system.get_pid_by_port(123)) - def test_get_pid_by_open_file_lsof(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_pid_by_open_file_lsof(self, call_mock): """ Tests the get_pid_by_open_file function with a lsof response. """ lsof_query = system.GET_PID_BY_FILE_LSOF % "/tmp/foo" - mocking.mock(system.call, mock_call(lsof_query, ["4762"])) + call_mock.side_effect = mock_call(lsof_query, ["4762"]) self.assertEquals(4762, system.get_pid_by_open_file("/tmp/foo")) - mocking.mock(system.call, mocking.return_value([])) + call_mock.return_value = [] + call_mock.side_effect = None self.assertEquals(None, system.get_pid_by_open_file("/tmp/somewhere_else")) - def test_get_cwd_pwdx(self): + @patch('stem.util.system.call') + @patch('stem.util.proc.is_available', Mock(return_value = False)) + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_cwd_pwdx(self, call_mock): """ Tests the get_cwd function with a pwdx response. """ @@ -276,13 +291,16 @@ class TestSystem(unittest.TestCase): "7878": None, } - mocking.mock(system.call, mock_call(system.GET_CWD_PWDX, responses)) + call_mock.side_effect = mock_call(system.GET_CWD_PWDX, responses) for test_input in responses: expected_response = "/home/atagar" if test_input == "3799" else None self.assertEquals(expected_response, system.get_cwd(test_input)) - def test_get_cwd_lsof(self): + @patch('stem.util.system.call') + @patch('stem.util.proc.is_available', Mock(return_value = False)) + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_cwd_lsof(self, call_mock): """ Tests the get_cwd function with a lsof response. """ @@ -293,13 +311,15 @@ class TestSystem(unittest.TestCase): "7878": [], } - mocking.mock(system.call, mock_call(system.GET_CWD_LSOF, responses)) + call_mock.side_effect = mock_call(system.GET_CWD_LSOF, responses) for test_input in responses: expected_response = "/Users/atagar/tor/src/or" if test_input == "75717" else None self.assertEquals(expected_response, system.get_cwd(test_input)) - def test_get_bsd_jail_id(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_bsd_jail_id(self, call_mock): """ Tests the get_bsd_jail_id function. """ @@ -313,25 +333,29 @@ class TestSystem(unittest.TestCase): "6666": [] } - mocking.mock(system.call, mock_call(system.GET_BSD_JAIL_ID_PS, responses)) + call_mock.side_effect = mock_call(system.GET_BSD_JAIL_ID_PS, responses) for test_input in responses: expected_response = 1 if test_input == "1111" else 0 self.assertEquals(expected_response, system.get_bsd_jail_id(test_input)) - def test_get_bsd_jail_path(self): + @patch('stem.util.system.call') + @patch('stem.util.system.is_available', Mock(return_value = True)) + def test_get_bsd_jail_path(self, call_mock): """ Tests the get_bsd_jail_path function. """ # check when we don't have a jail - mocking.mock(system.call, mocking.return_value([])) + call_mock.return_value = [] self.assertEquals(None, system.get_bsd_jail_path(1)) - mocking.mock(system.call, mock_call(system.GET_BSD_JAIL_PATH % '1', GET_BSD_JAIL_PATH_RESULTS)) + call_mock.side_effect = mock_call(system.GET_BSD_JAIL_PATH % '1', GET_BSD_JAIL_PATH_RESULTS) self.assertEquals("/usr/jails/tor-jail", system.get_bsd_jail_path(1)) + @patch('platform.system', Mock(return_value = 'Linux')) + @patch('os.path.join', Mock(side_effect = posixpath.join)) def test_expand_path_unix(self): """ Tests the expand_path function. This does not exercise home directory @@ -339,9 +363,6 @@ class TestSystem(unittest.TestCase): tests). """ - mocking.mock(platform.system, mocking.return_value("Linux")) - mocking.mock(os.path.join, posixpath.join, os.path) - self.assertEquals("", system.expand_path("")) self.assertEquals("/tmp", system.expand_path("/tmp")) self.assertEquals("/tmp", system.expand_path("/tmp/")) @@ -350,6 +371,8 @@ class TestSystem(unittest.TestCase): self.assertEquals("/tmp/foo", system.expand_path("foo", "/tmp")) self.assertEquals("/tmp/foo", system.expand_path("./foo", "/tmp")) + @patch('platform.system', Mock(return_value = 'Windows')) + @patch('os.path.join', Mock(side_effect = ntpath.join)) def test_expand_path_windows(self): """ Tests the expand_path function on windows. This does not exercise @@ -357,9 +380,6 @@ class TestSystem(unittest.TestCase): (that's left to integ tests). """ - mocking.mock(platform.system, mocking.return_value("Windows")) - mocking.mock(os.path.join, ntpath.join, os.path) - self.assertEquals("", system.expand_path("")) self.assertEquals("C:\\tmp", system.expand_path("C:\\tmp")) self.assertEquals("C:\\tmp", system.expand_path("C:\\tmp\\"))

1 0

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

13 Jun '13

commit 320d3ba383ab32ec4cecfc4158e9c7336df11c1e Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jun 12 19:26:06 2013 -0700 Using mock for server descriptor unit tests --- test/unit/descriptor/server_descriptor.py | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/test/unit/descriptor/server_descriptor.py b/test/unit/descriptor/server_descriptor.py index 02ec64c..c679588 100644 --- a/test/unit/descriptor/server_descriptor.py +++ b/test/unit/descriptor/server_descriptor.py @@ -11,23 +11,17 @@ import stem.exit_policy import stem.prereq import stem.util.str_tools +from mock import Mock, patch + from stem.descriptor.server_descriptor import RelayDescriptor, BridgeDescriptor -from test.mocking import no_op, \ - mock_method, \ - revert_mocking, \ - get_relay_server_descriptor, \ +from test.mocking import get_relay_server_descriptor, \ get_bridge_server_descriptor, \ CRYPTO_BLOB class TestServerDescriptor(unittest.TestCase): - def setUp(self): - mock_method(RelayDescriptor, '_verify_digest', no_op()) - - def tearDown(self): - revert_mocking() - + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) def test_minimal_relay_descriptor(self): """ Basic sanity check that we can parse a relay server descriptor with minimal @@ -41,6 +35,7 @@ class TestServerDescriptor(unittest.TestCase): self.assertEquals(None, desc.fingerprint) self.assertTrue(CRYPTO_BLOB in desc.onion_key) + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) def test_with_opt(self): """ Includes an 'opt <keyword> <value>' entry. @@ -49,6 +44,7 @@ class TestServerDescriptor(unittest.TestCase): desc = get_relay_server_descriptor({"opt": "contact www.atagar.com/contact/"}) self.assertEquals(b"www.atagar.com/contact/", desc.contact) + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) def test_unrecognized_line(self): """ Includes unrecognized content in the descriptor. @@ -151,6 +147,7 @@ class TestServerDescriptor(unittest.TestCase): desc_text = get_relay_server_descriptor({"opt": "protocols Link 1 2"}, content = True) self._expect_invalid_attr(desc_text, "circuit_protocols") + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) def test_published_leap_year(self): """ Constructs with a published entry for a leap year, and when the date is @@ -172,6 +169,7 @@ class TestServerDescriptor(unittest.TestCase): desc_text = get_relay_server_descriptor({"published": "2012-01-01"}, content = True) self._expect_invalid_attr(desc_text, "published") + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) def test_read_and_write_history(self): """ Parses a read-history and write-history entry. This is now a deprecated @@ -195,6 +193,7 @@ class TestServerDescriptor(unittest.TestCase): self.assertEquals(900, attr[1]) self.assertEquals(expected_values, attr[2]) + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) def test_read_history_empty(self): """ Parses a read-history with an empty value. @@ -206,6 +205,7 @@ class TestServerDescriptor(unittest.TestCase): self.assertEquals(900, desc.read_history_interval) self.assertEquals([], desc.read_history_values) + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) def test_annotations(self): """ Checks that content before a descriptor are parsed as annotations. @@ -266,6 +266,7 @@ class TestServerDescriptor(unittest.TestCase): desc_text = get_relay_server_descriptor({"opt fingerprint": fingerprint}, content = True) self._expect_invalid_attr(desc_text, "fingerprint", fingerprint.replace(" ", "")) + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) def test_ipv6_policy(self): """ Checks a 'ipv6-policy' line. @@ -275,6 +276,7 @@ class TestServerDescriptor(unittest.TestCase): desc = get_relay_server_descriptor({"ipv6-policy": "accept 22-23,53,80,110"}) self.assertEquals(expected, desc.exit_policy_v6) + @patch('stem.descriptor.server_descriptor.RelayDescriptor._verify_digest', Mock()) def test_ntor_onion_key(self): """ Checks a 'ntor-onion-key' line.

1 0

[stem/master] Dropping mock from descriptor reader integ test
by atagar＠torproject.org 13 Jun '13

13 Jun '13

commit 21cd260745a1b824c908e3eacac4083fe16750a6 Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jun 12 19:42:48 2013 -0700 Dropping mock from descriptor reader integ test I was gonna migrate this call over but it looks to be unneeded. Test passes so guess we probably replaced the problematic descriptor content with a real descriptor. --- test/integ/descriptor/reader.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/test/integ/descriptor/reader.py b/test/integ/descriptor/reader.py index f0fa7d2..99ce78d 100644 --- a/test/integ/descriptor/reader.py +++ b/test/integ/descriptor/reader.py @@ -11,7 +11,6 @@ import time import unittest import stem.descriptor.reader -import test.mocking import test.runner from stem.util import system @@ -87,8 +86,6 @@ class SkipListener: class TestDescriptorReader(unittest.TestCase): def tearDown(self): - test.mocking.revert_mocking() - # cleans up 'processed file' listings that we made test_listing_path = _get_processed_files_path() @@ -395,8 +392,6 @@ class TestDescriptorReader(unittest.TestCase): plaintext non-descriptor files. """ - test.mocking.mock_method(stem.descriptor.server_descriptor.RelayDescriptor, '_validate_content', test.mocking.no_op()) - skip_listener = SkipListener() reader = stem.descriptor.reader.DescriptorReader(DESCRIPTOR_TEST_DATA) reader.register_skip_listener(skip_listener.listener)

1 0

[stem/master] Dropping mock from server descriptor integ test
by atagar＠torproject.org 13 Jun '13

13 Jun '13

commit 98fd433b09c2449e5ea6dc6d381e729ba32a6099 Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jun 12 19:44:34 2013 -0700 Dropping mock from server descriptor integ test Well, that's odd. We revert mocking in these integ tests but never use it. Oh well. --- test/integ/descriptor/server_descriptor.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/test/integ/descriptor/server_descriptor.py b/test/integ/descriptor/server_descriptor.py index 7779951..4b837f7 100644 --- a/test/integ/descriptor/server_descriptor.py +++ b/test/integ/descriptor/server_descriptor.py @@ -11,16 +11,12 @@ import stem.descriptor import stem.descriptor.server_descriptor import stem.exit_policy import stem.version -import test.mocking import test.runner from test.integ.descriptor import get_resource class TestServerDescriptor(unittest.TestCase): - def tearDown(self): - test.mocking.revert_mocking() - def test_metrics_descriptor(self): """ Parses and checks our results against a server descriptor from metrics.

1 0

[stem/master] Dropping homemade mocking functions
by atagar＠torproject.org 13 Jun '13

13 Jun '13

commit 35b44e3c7d5090806922cd0775775bb2985f8a9b Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jun 12 21:48:44 2013 -0700 Dropping homemade mocking functions Done replacing our mocking methods with the mock module. It's nice to finally be able to drop these... --- test/mocking.py | 315 ------------------------------------------------------- 1 file changed, 315 deletions(-) diff --git a/test/mocking.py b/test/mocking.py index 3b165d8..35edf81 100644 --- a/test/mocking.py +++ b/test/mocking.py @@ -10,22 +10,7 @@ calling :func:`test.mocking.revert_mocking`. :: - mock - replaces a function with an alternative implementation - mock_method - replaces a method with an alternative implementation - revert_mocking - reverts any changes made by the mock function - get_real_function - provides the non-mocked version of a function get_all_combinations - provides all combinations of attributes - support_with - makes object be compatible for use via the 'with' keyword - get_object - get an arbitrary mock object of any class - - Mocking Functions - no_op - does nothing - return_value - returns a given value - return_true - returns True - return_false - returns False - return_none - returns None - return_for_args - return based on the input arguments - raise_exception - raises an exception when called Instance Constructors get_message - stem.response.ControlMessage @@ -56,7 +41,6 @@ calling :func:`test.mocking.revert_mocking`. import base64 import hashlib -import inspect import itertools import stem.descriptor.extrainfo_descriptor @@ -68,18 +52,6 @@ import stem.prereq import stem.response import stem.util.str_tools -# Once we've mocked a function we can't rely on its __module__ or __name__ -# attributes, so instead we associate a unique 'mock_id' attribute that maps -# back to the original attributes. - -MOCK_ID = itertools.count(0) - -# mock_id => (module, function_name, original_function, is_static) - -MOCK_STATE = {} - -BUILTIN_TYPE = type(open) - CRYPTO_BLOB = """ MIGJAoGBAJv5IIWQ+WDWYUdyA/0L8qbIkEVH/cwryZWoIaPAzINfrw1WfNZGtBmg skFtXhOHHqTRN4GPPrZsAIUOQGzQtGb66IQgT4tO/pj+P6QmSCCdTfhvGfgTCsC+ @@ -204,261 +176,6 @@ NETWORK_STATUS_DOCUMENT_FOOTER = ( ) -def no_op(): - def _no_op(*args, **kwargs): - pass - - return _no_op - - -def return_value(value): - def _return_value(*args, **kwargs): - return value - - return _return_value - - -def return_true(): - return return_value(True) - - -def return_false(): - return return_value(False) - - -def return_none(): - return return_value(None) - - -def return_for_args(args_to_return_value, default = None, is_method = False): - """ - Returns a value if the arguments to it match something in a given - 'argument => return value' mapping. Otherwise, a default function - is called with the arguments. - - The mapped argument is a tuple (not a list) of parameters to a function or - method. Positional arguments must be in the order used to call the mocked - function, and keyword arguments must be strings of the form 'k=v'. Keyword - arguments **must** appear in alphabetical order. For example... - - :: - - mocking.mock("get_answer", mocking.return_for_args({ - ("breakfast_menu",): "spam", - ("lunch_menu",): "eggs and spam", - (42,): ["life", "universe", "everything"], - })) - - mocking.mock("align_text", mocking.return_for_args({ - ("Stem", "alignment=left", "size=10"): "Stem ", - ("Stem", "alignment=center", "size=10"): " Stem ", - ("Stem", "alignment=right", "size=10"): " Stem", - })) - - mocking.mock_method(Controller, "new_circuit", mocking.return_for_args({ - (): "1", - ("path=['718BCEA286B531757ACAFF93AE04910EA73DE617', " + \ - "'30BAB8EE7606CBD12F3CC269AE976E0153E7A58D', " + \ - "'2765D8A8C4BBA3F89585A9FFE0E8575615880BEB']",): "2" - ("path=['1A', '2B', '3C']", "purpose=controller"): "3" - }, is_method = True)) - - :param dict args_to_return_value: mapping of arguments to the value we should provide - :param functor default: returns the value of this function if the args don't - match something that we have, we raise a ValueError by default - :param bool is_method: handles this like a method, removing the 'self' - reference - """ - - def _return_value(*args, **kwargs): - # strip off the 'self' if we're mocking a method - if args and is_method: - args = args[1:] if len(args) > 2 else [args[1]] - - if kwargs: - args.extend(["%s=%s" % (k, kwargs[k]) for k in sorted(kwargs.keys())]) - - args = tuple(args) - - if args in args_to_return_value: - return args_to_return_value[args] - elif default is None: - arg_label = ", ".join([str(v) for v in args]) - arg_keys = ", ".join([str(v) for v in args_to_return_value.keys()]) - raise ValueError("Unrecognized argument sent for return_for_args(). Got '%s' but we only recognize '%s'." % (arg_label, arg_keys)) - else: - return default(args) - - return _return_value - - -def raise_exception(exception): - def _raise(*args, **kwargs): - raise exception - - return _raise - - -def support_with(obj): - """ - Provides no-op support for the 'with' keyword, adding __enter__ and __exit__ - methods to the object. The __enter__ provides the object itself and __exit__ - does nothing. - - :param object obj: object to support the 'with' keyword - - :returns: input object - """ - - if not hasattr(obj, "__enter__"): - setattr(obj, "__enter__", return_value(obj)) - - if not hasattr(obj, "__exit__"): - setattr(obj, "__exit__", no_op()) - - return obj - - -def mock(target, mock_call, target_module = None, is_static = False): - """ - Mocks the given function, saving the initial implementation so it can be - reverted later. - - The target_module only needs to be set if the results of - 'inspect.getmodule(target)' doesn't match the module that we want to mock - (for instance, the 'os' module provides the platform module that it wraps - like 'postix', which won't work). - - :param function target: function to be mocked - :param functor mock_call: mocking to replace the function with - :param module target_module: module that this is mocking, this defaults to the inspected value - :param bool is_static: handles this like a static method of the target_module if True - """ - - if hasattr(target, "mock_id"): - # we're overriding an already mocked function - mocking_id = getattr(target, "mock_id") - target_module, target_function, _, _ = MOCK_STATE[mocking_id] - else: - # this is a new mocking, save the original state - mocking_id = MOCK_ID.next() - target_module = target_module or inspect.getmodule(target) - target_function = target.__name__ - MOCK_STATE[mocking_id] = (target_module, target_function, target, is_static) - - mock_wrapper = lambda *args, **kwargs: mock_call(*args, **kwargs) - setattr(mock_wrapper, "mock_id", mocking_id) - - # mocks the function with this wrapper - - if is_static: - setattr(target_module, target_function, staticmethod(mock_wrapper)) - else: - setattr(target_module, target_function, mock_wrapper) - - -def mock_method(target_class, method_name, mock_call): - """ - Mocks the given method in target_class in a similar fashion as mock() - does for functions. For instance... - - :: - - >>> mock_method(stem.control.Controller, "is_feature_enabled", mocking.return_true()) - >>> controller.is_feature_enabled("VERBOSE_EVENTS") - True - - :: - - "VERBOSE_EVENTS" does not exist and can never be True, but the mocked - "is_feature_enabled" will always return True, regardless. - - :param class target_class: class with the method we want to mock - :param str method_name: name of the method to be mocked - :param functor mock_call: mocking to replace the method - """ - - # Ideally callers could call us with just the method, for instance like... - # mock_method(MyClass.foo, mocking.return_true()) - # - # However, while classes reference the methods they have the methods - # themselves don't reference the class. This is unfortunate because it means - # that we need to know both the class and method we're replacing. - - target_method = getattr(target_class, method_name) - - if hasattr(target_method, "mock_id"): - # we're overriding an already mocked method - mocking_id = target_method.mock_id - _, target_method, _, _ = MOCK_STATE[mocking_id] - else: - # this is a new mocking, save the original state - mocking_id = MOCK_ID.next() - MOCK_STATE[mocking_id] = (target_class, method_name, target_method, False) - - mock_wrapper = lambda *args, **kwargs: mock_call(*args, **kwargs) - setattr(mock_wrapper, "mock_id", mocking_id) - - # mocks the function with this wrapper - setattr(target_class, method_name, mock_wrapper) - - -def revert_mocking(): - """ - Reverts any mocking done by this function. - """ - - # Reverting mocks in reverse order. If we properly reuse mock_ids then this - # shouldn't matter, but might as well be safe. - - mock_ids = MOCK_STATE.keys() - mock_ids.sort() - mock_ids.reverse() - - for mock_id in mock_ids: - module, function, impl, is_static = MOCK_STATE[mock_id] - - # Python 3.x renamed __builtin__ to builtins. Ideally we'd account for - # this with a simple 'import __builtin__ as builtins' but that somehow - # makes the following check fail. Haven't a clue why. - - if stem.prereq.is_python_3(): - import builtins - builtin_module = builtins - else: - import __builtin__ - builtin_module = __builtin__ - - if is_static: - impl = staticmethod(impl) - - if module == builtin_module: - setattr(builtin_module, function, impl) - else: - setattr(module, function, impl) - - del MOCK_STATE[mock_id] - - MOCK_STATE.clear() - - -def get_real_function(function): - """ - Provides the original, non-mocked implementation for a function or method. - This simply returns the current implementation if it isn't being mocked. - - :param function function: function to look up the original implementation of - - :returns: original implementation of the function - """ - - if hasattr(function, "mock_id"): - mocking_id = getattr(function, "mock_id") - return MOCK_STATE[mocking_id][2] - else: - return function - - def get_all_combinations(attr, include_empty = False): """ Provides an iterator for all combinations of a set of attributes. For @@ -496,38 +213,6 @@ def get_all_combinations(attr, include_empty = False): yield item -def get_object(object_class, methods = None): - """ - Provides a mock instance of an arbitrary class. Its methods are mocked with - the given replacements, and calling any others will result in an exception. - - :param class object_class: class that we're making an instance of - :param dict methods: mapping of method names to their mocked implementation - - :returns: stem.control.Controller instance - """ - - if methods is None: - methods = {} - - mock_methods = {} - - for method_name in dir(object_class): - if method_name in methods: - mock_methods[method_name] = methods[method_name] - elif method_name.startswith('__') and method_name.endswith('__'): - pass # messing with most private methods makes for a broken mock object - else: - mock_methods[method_name] = raise_exception(ValueError("Unexpected call of '%s' on a mock object" % method_name)) - - # makes it so our constructor won't need any arguments - mock_methods['__init__'] = no_op() - - mock_class = type('MockClass', (object_class,), mock_methods) - - return mock_class() - - def get_message(content, reformat = True): """ Provides a ControlMessage with content modified to be parsable. This makes

1 0

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

13 Jun '13

commit f38959c05a5dbedcf4a90ed5fc6c1f9809ca5d62 Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jun 12 19:53:35 2013 -0700 Using mock for protocolinfo integ tests --- test/integ/response/protocolinfo.py | 33 ++++++++++++++++----------------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/test/integ/response/protocolinfo.py b/test/integ/response/protocolinfo.py index b7ef46a..98f0c03 100644 --- a/test/integ/response/protocolinfo.py +++ b/test/integ/response/protocolinfo.py @@ -11,18 +11,12 @@ import stem.util.system import stem.version import test.runner -from test import mocking +from mock import Mock, patch + from test.integ.util.system import filter_system_call class TestProtocolInfo(unittest.TestCase): - def setUp(self): - mocking.mock(stem.util.proc.is_available, mocking.return_false()) - mocking.mock(stem.util.system.is_available, mocking.return_true()) - - def tearDown(self): - mocking.revert_mocking() - def test_parsing(self): """ Makes a PROTOCOLINFO query and processes the response for our control @@ -47,6 +41,8 @@ class TestProtocolInfo(unittest.TestCase): self.assert_matches_test_config(protocolinfo_response) + @patch('stem.util.proc.is_available', Mock(return_value = False)) + @patch('stem.util.system.is_available', Mock(return_value = True)) def test_get_protocolinfo_path_expansion(self): """ If we're running with the 'RELATIVE' target then test_parsing() will @@ -62,30 +58,33 @@ class TestProtocolInfo(unittest.TestCase): return if test.runner.Torrc.PORT in test.runner.get_runner().get_options(): - cwd_by_port_lookup_prefixes = ( + lookup_prefixes = ( stem.util.system.GET_PID_BY_PORT_NETSTAT, stem.util.system.GET_PID_BY_PORT_SOCKSTAT % "", stem.util.system.GET_PID_BY_PORT_LSOF, stem.util.system.GET_CWD_PWDX % "", "lsof -a -p ") - mocking.mock(stem.util.system.call, filter_system_call(cwd_by_port_lookup_prefixes)) control_socket = stem.socket.ControlPort(port = test.runner.CONTROL_PORT) else: - cwd_by_socket_lookup_prefixes = ( + lookup_prefixes = ( stem.util.system.GET_PID_BY_FILE_LSOF % "", stem.util.system.GET_CWD_PWDX % "", "lsof -a -p ") - mocking.mock(stem.util.system.call, filter_system_call(cwd_by_socket_lookup_prefixes)) control_socket = stem.socket.ControlSocketFile(test.runner.CONTROL_SOCKET_PATH) - protocolinfo_response = stem.connection.get_protocolinfo(control_socket) - self.assert_matches_test_config(protocolinfo_response) + call_replacement = filter_system_call(lookup_prefixes) - # we should have a usable socket at this point - self.assertTrue(control_socket.is_alive()) - control_socket.close() + with patch('stem.util.system.call') as call_mock: + call_mock.side_effect = call_replacement + + protocolinfo_response = stem.connection.get_protocolinfo(control_socket) + self.assert_matches_test_config(protocolinfo_response) + + # we should have a usable socket at this point + self.assertTrue(control_socket.is_alive()) + control_socket.close() def test_multiple_protocolinfo_calls(self): """

1 0

[stem/master] Python3 mock compatability
by atagar＠torproject.org 13 Jun '13

13 Jun '13

commit c7ac81546dcdf1fb9639fdbf0e4997e8ee39ba38 Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jun 12 21:59:41 2013 -0700 Python3 mock compatability Ahhh, more unicode vs bytes joy. --- test/unit/control/controller.py | 2 +- test/unit/descriptor/reader.py | 26 +++++++++++++------------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/test/unit/control/controller.py b/test/unit/control/controller.py index 791f879..de079e4 100644 --- a/test/unit/control/controller.py +++ b/test/unit/control/controller.py @@ -312,7 +312,7 @@ class TestControl(unittest.TestCase): """ get_conf_mock.return_value = '/tmp/pid_file' - open_mock.return_value = io.BytesIO('432') + open_mock.return_value = io.BytesIO(b'432') self.assertEqual(432, self.controller.get_pid()) open_mock.assert_called_once_with('/tmp/pid_file') diff --git a/test/unit/descriptor/reader.py b/test/unit/descriptor/reader.py index 4b54fff..826f436 100644 --- a/test/unit/descriptor/reader.py +++ b/test/unit/descriptor/reader.py @@ -18,13 +18,13 @@ class TestDescriptorReader(unittest.TestCase): """ test_lines = ( - "/dir/ 0", - "/dir/file 12345", - "/dir/file with spaces 7138743", - " /dir/with extra space 12345 ", - " \t ", - "", - "/dir/after empty line 12345", + u"/dir/ 0", + u"/dir/file 12345", + u"/dir/file with spaces 7138743", + u" /dir/with extra space 12345 ", + u" \t ", + u"", + u"/dir/after empty line 12345", ) expected_value = { @@ -35,7 +35,7 @@ class TestDescriptorReader(unittest.TestCase): "/dir/after empty line": 12345, } - open_mock.return_value = io.BytesIO("\n".join(test_lines)) + open_mock.return_value = io.StringIO(u"\n".join(test_lines)) self.assertEquals(expected_value, stem.descriptor.reader.load_processed_files("")) @patch('stem.descriptor.reader.open', create = True) @@ -44,7 +44,7 @@ class TestDescriptorReader(unittest.TestCase): Tests the load_processed_files() function with an empty file. """ - open_mock.return_value = io.BytesIO("") + open_mock.return_value = io.StringIO(u"") self.assertEquals({}, stem.descriptor.reader.load_processed_files("")) @patch('stem.descriptor.reader.open', create = True) @@ -54,7 +54,7 @@ class TestDescriptorReader(unittest.TestCase): it is missing the file path. """ - open_mock.return_value = io.BytesIO(" 12345") + open_mock.return_value = io.StringIO(u" 12345") self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, "") @patch('stem.descriptor.reader.open', create = True) @@ -64,7 +64,7 @@ class TestDescriptorReader(unittest.TestCase): it is missing the timestamp. """ - open_mock.return_value = io.BytesIO("/dir/file ") + open_mock.return_value = io.StringIO(u"/dir/file ") self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, "") @patch('stem.descriptor.reader.open', create = True) @@ -74,7 +74,7 @@ class TestDescriptorReader(unittest.TestCase): it has an invalid file path. """ - open_mock.return_value = io.BytesIO("not_an_absolute_file 12345") + open_mock.return_value = io.StringIO(u"not_an_absolute_file 12345") self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, "") @patch('stem.descriptor.reader.open', create = True) @@ -84,5 +84,5 @@ class TestDescriptorReader(unittest.TestCase): it has a non-numeric timestamp. """ - open_mock.return_value = io.BytesIO("/dir/file 123a") + open_mock.return_value = io.StringIO(u"/dir/file 123a") self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, "")

1 0

[stem/master] Accounting for GetInfoResponse entries having bytes
by atagar＠torproject.org 13 Jun '13

13 Jun '13

commit 2b634a98e16c3b2437cab27c7198acd6a738fd13 Author: Damian Johnson <atagar(a)torproject.org> Date: Thu Jun 13 09:30:07 2013 -0700 Accounting for GetInfoResponse entries having bytes Oops. I forgot to update this test when we switched the entries attribute to bytes in commit a94f1f0. --- test/unit/response/control_message.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/unit/response/control_message.py b/test/unit/response/control_message.py index 33b2008..435bed7 100644 --- a/test/unit/response/control_message.py +++ b/test/unit/response/control_message.py @@ -42,7 +42,7 @@ class TestControlMessage(unittest.TestCase): msg = stem.response.ControlMessage.from_str(GETINFO_VERSION, "GETINFO") self.assertTrue(isinstance(msg, stem.response.getinfo.GetInfoResponse)) - self.assertEqual({'version': '0.2.2.23-alpha (git-b85eb949b528f4d7)'}, msg.entries) + self.assertEqual({'version': b'0.2.2.23-alpha (git-b85eb949b528f4d7)'}, msg.entries) def test_ok_response(self): """

1 0

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits June 2013