def test_get_connections(self): """ Tests the get_connections function. """ pid = 1111 mocking.mock(os.listdir, mocking.return_for_args({ ('/proc/%s/fd' % pid,): ['1', '2', '3', '4'], }), os) 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) 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' mocking.mock(open, mocking.return_for_args({ ('/proc/net/tcp',): StringIO.StringIO(tcp), ('/proc/net/udp',): StringIO.StringIO(udp) })) # tests the edge case of pid = 0 self.assertEquals([], proc.get_connections(0)) expected_results = [ ('17.17.17.17', 4369, '34.34.34.34', 8738), ('187.187.187.187', 48059, '204.204.204.204', 52428), ] self.assertEquals(expected_results, proc.get_connections(pid))
def test_get_stats(self): """ Tests get_stats() with all combinations of stat_type arguments. """ # list of all combinations of args with respective return values stat_combinations = mocking.get_all_combinations([ ('command', 'test_program'), ('utime', '0.13'), ('stime', '0.14'), ('start time', '10.21'), ]) 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({ (stat_path, '24062', 'process '): stat })) self.assertEquals((), proc.get_stats(24062)) for stats in stat_combinations: # the stats variable is... # [(arg1, resp1), (arg2, resp2)...] # # but we need... # (arg1, arg2...), (resp1, resp2...). args, response = zip(*stats) mocking.mock(proc._get_line, mocking.return_for_args({ (stat_path, '24062', 'process %s' % ', '.join(args)): stat })) self.assertEquals(response, proc.get_stats(24062, *args)) # tests the case where pid = 0 if 'start time' in args: response = 10 else: response = () for arg in args: if arg == 'command': response += ('sched',) elif arg == 'utime': response += ('0',) elif arg == 'stime': response += ('0',) mocking.mock(proc._get_line, mocking.return_for_args({ ('/proc/0/stat', '0', 'process %s' % ', '.join(args)): stat })) self.assertEquals(response, proc.get_stats(0, *args))
def test_get_exit_policy(self): """ 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)) 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)) expected = ExitPolicy( 'reject 0.0.0.0/8:*', # private entries 'reject 169.254.0.0/16:*', 'reject 127.0.0.0/8:*', 'reject 192.168.0.0/16:*', 'reject 10.0.0.0/8:*', 'reject 172.16.0.0/12:*', 'reject 123.45.67.89:*', # relay's public address 'accept *:80', # finally we get to our ExitPolicy 'accept *:443', 'accept 43.5.5.5:*', 'reject *:22', 'reject *:25', # default policy 'reject *:119', 'reject *:135-139', 'reject *:445', 'reject *:563', 'reject *:1214', 'reject *:4661-4666', 'reject *:6346-6429', 'reject *:6699', 'reject *:6881-6999', 'accept *:*', ) self.assertEqual(expected, self.controller.get_exit_policy())
def test_the_little_relay_that_could(self): def tutorial_example(): from stem.control import Controller with Controller.from_port(control_port = 9051) as controller: controller.authenticate() # provide the password here if you set one bytes_read = controller.get_info("traffic/read") bytes_written = controller.get_info("traffic/written") 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, ) tutorial_example() self.assertEqual("My Tor relay has read 33406 bytes and written 29649.\n", self.stdout.getvalue())
def test_get_socks_listeners_old(self): """ Exercises the get_socks_listeners() method as though talking to an old tor instance. """ # 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)) 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)) 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)) 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)) 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)) 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)) 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)) self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)
def test_get_cwd(self): """ Tests the get_cwd function with a given pid. """ mocking.mock(os.readlink, mocking.return_for_args({ ('/proc/24019/cwd',): '/home/directory/TEST' }), os) self.assertEquals('/home/directory/TEST', proc.get_cwd(24019))
def test_get_physical_memory(self): """ Tests the get_physical_memory function. """ mocking.mock(proc._get_line, mocking.return_for_args({ ('/proc/meminfo', 'MemTotal:', 'system physical memory'): 'MemTotal: 12345 kB', })) self.assertEquals((12345 * 1024), proc.get_physical_memory())
def test_get_system_start_time(self): """ Tests the get_system_start_time function. """ mocking.mock(proc._get_line, mocking.return_for_args({ ('/proc/stat', 'btime', 'system start time'): 'btime 1001001', })) self.assertEquals(1001001, proc.get_system_start_time())
def test_get_connections(self): """ Tests the get_connections function. """ pid = 1111 mocking.mock(os.listdir, mocking.return_for_args({ ('/proc/%s/fd' % pid,): ['1', '2', '3', '4'], }), os) 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) 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) })) # tests the edge case of pid = 0 self.assertEquals([], proc.get_connections(0)) expected_results = [ ('17.17.17.17', 4369, '34.34.34.34', 8738), ('187.187.187.187', 48059, '204.204.204.204', 52428), ] self.assertEquals(expected_results, proc.get_connections(pid))
def test_get_exit_policy(self): """ 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)) 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)) expected = ExitPolicy( 'reject 0.0.0.0/8:*', # private entries 'reject 169.254.0.0/16:*', 'reject 127.0.0.0/8:*', 'reject 192.168.0.0/16:*', 'reject 10.0.0.0/8:*', 'reject 172.16.0.0/12:*', 'reject 123.45.67.89:*', # relay's public address 'accept *:80', # finally we get to our ExitPolicy 'accept *:443', 'accept 43.5.5.5:*', 'reject *:22', 'reject *:25', # default policy 'reject *:119', 'reject *:135-139', 'reject *:445', 'reject *:563', 'reject *:1214', 'reject *:4661-4666', 'reject *:6346-6429', 'reject *:6699', 'reject *:6881-6999', 'accept *:*', ) self.assertEqual(expected, self.controller.get_exit_policy())
def test_get_memory_usage(self): """ Tests the get_memory_usage function with a given pid. """ mocking.mock(proc._get_lines, mocking.return_for_args({ ('/proc/1111/status', ('VmRSS:', 'VmSize:'), 'memory usage'): {'VmRSS:': 'VmRSS: 100 kB', 'VmSize:': 'VmSize: 1800 kB'} })) self.assertEqual((0, 0), proc.get_memory_usage(0)) self.assertEqual((100 * 1024, 1800 * 1024), proc.get_memory_usage(1111))
def test_get_uid(self): """ 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 })) self.assertEquals(uid, proc.get_uid(pid))
def test_the_little_relay_that_could(self): def tutorial_example(): from stem.control import Controller with Controller.from_port(control_port=9051) as controller: controller.authenticate( ) # provide the password here if you set one bytes_read = controller.get_info("traffic/read") bytes_written = controller.get_info("traffic/written") 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, ) tutorial_example() self.assertEqual( "My Tor relay has read 33406 bytes and written 29649.\n", self.stdout.getvalue())
def test_the_little_relay_that_could(self): from stem.control import Controller controller = mocking.get_object(Controller, { 'authenticate': mocking.no_op(), 'close': mocking.no_op(), 'get_info': mocking.return_for_args({ 'traffic/read': '1234', 'traffic/written': '5678', }), }) controller.authenticate() bytes_read = controller.get_info("traffic/read") bytes_written = controller.get_info("traffic/written") expected_line = "My Tor relay has read 1234 bytes and written 5678." printed_line = "My Tor relay has read %s bytes and written %s." % (bytes_read, bytes_written) self.assertEqual(expected_line, printed_line) controller.close()
def test_the_little_relay_that_could(self): from stem.control import Controller controller = mocking.get_object(Controller, { 'authenticate': mocking.no_op(), 'close': mocking.no_op(), 'get_info': mocking.return_for_args({ ('traffic/read',): '1234', ('traffic/written',): '5678', }, is_method = True), }) controller.authenticate() bytes_read = controller.get_info("traffic/read") bytes_written = controller.get_info("traffic/written") expected_line = "My Tor relay has read 1234 bytes and written 5678." printed_line = "My Tor relay has read %s bytes and written %s." % (bytes_read, bytes_written) self.assertEqual(expected_line, printed_line) controller.close()