From cbd404d56e231ea5419f07795a12d7082dd70ec4 Mon Sep 17 00:00:00 2001 From: Sergey Shepelev Date: Thu, 24 Apr 2014 17:51:27 +0400 Subject: [PATCH] python3 compatibility - __next__ for iterator interface - six.next() to get next item - list(dict.keys()) - popen2.popen4 -> subprocess - s2b -> b"..." literals - deprecated assertEquals -> assertEqual - hub_test test_fork using run_python - 1L -> 1 long literal - many PEP-8 fixes --- eventlet/greenio.py | 2 +- eventlet/greenpool.py | 13 ++-- eventlet/hubs/selects.py | 11 +-- eventlet/pool.py | 24 ++++--- eventlet/processes.py | 48 +++++++------ eventlet/tpool.py | 62 ++++++++++++----- tests/__init__.py | 5 -- tests/api_test.py | 30 ++++---- tests/backdoor_test.py | 6 +- tests/convenience_test.py | 67 +++++++++--------- tests/db_pool_test.py | 60 ++++++++-------- tests/debug_test.py | 6 +- tests/greenio_test.py | 137 ++++++++++++++++++++----------------- tests/greenpool_test.py | 108 +++++++++++++++++------------ tests/greenthread_test.py | 26 +++---- tests/hub_test.py | 44 +++--------- tests/hub_test_fork.py | 25 +++++++ tests/mysqldb_test.py | 8 ++- tests/pools_test.py | 50 +++++++------- tests/processes_test.py | 8 +-- tests/queue_test.py | 54 +++++++-------- tests/ssl_test.py | 14 ++-- tests/test__coros_queue.py | 50 +++++++------- tests/test__pool.py | 18 ++--- tests/thread_test.py | 6 +- tests/tpool_test.py | 78 +++++++++++---------- tests/wsgi_test.py | 58 ++++++++-------- tests/zmq_test.py | 23 +++---- 28 files changed, 564 insertions(+), 477 deletions(-) create mode 100644 tests/hub_test_fork.py diff --git a/eventlet/greenio.py b/eventlet/greenio.py index 0295577..6ffba9b 100644 --- a/eventlet/greenio.py +++ b/eventlet/greenio.py @@ -9,10 +9,10 @@ import warnings from eventlet.support import get_errno, six from eventlet.hubs import trampoline -BUFFER_SIZE = 4096 __all__ = ['GreenSocket', 'GreenPipe', 'shutdown_safe'] +BUFFER_SIZE = 4096 CONNECT_ERR = set((errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK)) CONNECT_SUCCESS = set((0, errno.EISCONN)) if sys.platform[:3] == "win": diff --git a/eventlet/greenpool.py b/eventlet/greenpool.py index fb157b8..fd78ba0 100644 --- a/eventlet/greenpool.py +++ b/eventlet/greenpool.py @@ -11,6 +11,7 @@ __all__ = ['GreenPool', 'GreenPile'] DEBUG = True + class GreenPool(object): """The GreenPool class is a pool of green threads. """ @@ -102,7 +103,8 @@ class GreenPool(object): self._spawn_n_impl(function, args, kwargs, None) else: self.sem.acquire() - g = greenthread.spawn_n(self._spawn_n_impl, + g = greenthread.spawn_n( + self._spawn_n_impl, function, args, kwargs, True) if not self.coroutines_running: self.no_coros_running = event.Event() @@ -111,8 +113,8 @@ class GreenPool(object): def waitall(self): """Waits until all greenthreads in the pool are finished working.""" assert greenthread.getcurrent() not in self.coroutines_running, \ - "Calling waitall() from within one of the "\ - "GreenPool's greenthreads will never terminate." + "Calling waitall() from within one of the " \ + "GreenPool's greenthreads will never terminate." if self.running(): self.no_coros_running.wait() @@ -197,7 +199,7 @@ class GreenPile(object): def spawn(self, func, *args, **kw): """Runs *func* in its own green thread, with the result available by iterating over the GreenPile object.""" - self.used = True + self.used = True self.counter += 1 try: gt = self.pool.spawn(func, *args, **kw) @@ -218,6 +220,8 @@ class GreenPile(object): return self.waiters.get().wait() finally: self.counter -= 1 + __next__ = next + # this is identical to GreenPile but it blocks on spawn if the results # aren't consumed, and it doesn't generate its own StopIteration exception, @@ -236,3 +240,4 @@ class GreenMap(GreenPile): return val finally: self.counter -= 1 + __next__ = next diff --git a/eventlet/hubs/selects.py b/eventlet/hubs/selects.py index f4b63fd..77ae245 100644 --- a/eventlet/hubs/selects.py +++ b/eventlet/hubs/selects.py @@ -1,7 +1,7 @@ import sys import errno from eventlet import patcher -from eventlet.support import get_errno, clear_sys_exc_info +from eventlet.support import get_errno, clear_sys_exc_info, six select = patcher.original('select') time = patcher.original('time') @@ -12,12 +12,14 @@ try: except AttributeError: BAD_SOCK = set((errno.EBADF,)) + class Hub(BaseHub): def _remove_bad_fds(self): """ Iterate through fds, removing the ones that are bad per the operating system. """ - for fd in self.listeners[READ].keys() + self.listeners[WRITE].keys(): + all_fds = list(self.listeners[READ]) + list(self.listeners[WRITE]) + for fd in all_fds: try: select.select([fd], [], [], 0) except select.error as e: @@ -31,8 +33,9 @@ class Hub(BaseHub): if seconds: time.sleep(seconds) return + all_fds = list(readers) + list(writers) try: - r, w, er = select.select(readers.keys(), writers.keys(), readers.keys() + writers.keys(), seconds) + r, w, er = select.select(readers.keys(), writers.keys(), all_fds, seconds) except select.error as e: if get_errno(e) == errno.EINTR: return @@ -45,7 +48,7 @@ class Hub(BaseHub): for fileno in er: readers.get(fileno, noop).cb(fileno) writers.get(fileno, noop).cb(fileno) - + for listeners, events in ((readers, r), (writers, w)): for fileno in events: try: diff --git a/eventlet/pool.py b/eventlet/pool.py index a286365..be9db8f 100644 --- a/eventlet/pool.py +++ b/eventlet/pool.py @@ -2,6 +2,7 @@ from __future__ import print_function from eventlet import coros, proc, api from eventlet.semaphore import Semaphore +from eventlet.support import six import warnings warnings.warn( @@ -190,6 +191,7 @@ class Pool(object): millions of items.) >>> from eventlet import coros + >>> from eventlet.support import six >>> import string >>> pool = coros.CoroutinePool(max_size=5) >>> pausers = [coros.Event() for x in range(2)] @@ -206,39 +208,39 @@ class Pool(object): items individually to illustrate timing) >>> step = iter(pool.generate_results(quicktask, string.ascii_lowercase)) - >>> print(step.next()) + >>> print(six.next(step)) returning a returning b returning c a - >>> print(step.next()) + >>> print(six.next(step)) b - >>> print(step.next()) + >>> print(six.next(step)) c - >>> print(step.next()) + >>> print(six.next(step)) returning d returning e returning f d >>> pausers[0].send("A") - >>> print(step.next()) + >>> print(six.next(step)) e - >>> print(step.next()) + >>> print(six.next(step)) f - >>> print(step.next()) + >>> print(six.next(step)) A woke up with A returning g returning h returning i g - >>> print("".join([step.next() for x in range(3)])) + >>> print("".join([six.next(step) for x in range(3)])) returning j returning k returning l returning m hij >>> pausers[1].send("B") - >>> print("".join([step.next() for x in range(4)])) + >>> print("".join([six.next(step) for x in range(4)])) B woke up with B returning n returning o @@ -255,7 +257,7 @@ class Pool(object): # but if we launched no coroutines with that queue as the destination, # we could end up waiting a very long time. try: - index, args = tuples.next() + index, args = six.next(tuples) except StopIteration: return # From this point forward, 'args' is the current arguments tuple and @@ -297,7 +299,7 @@ class Pool(object): # which to send() the result. self._execute(q, function, args, {}) # We've consumed that args tuple, advance to next. - index, args = tuples.next() + index, args = six.next(tuples) # Okay, we've filled up the pool again, yield a result -- which # will probably wait for a coroutine to complete. Although we do # have q.ready(), so we could iterate without waiting, we avoid diff --git a/eventlet/processes.py b/eventlet/processes.py index e16fde7..544acc1 100644 --- a/eventlet/processes.py +++ b/eventlet/processes.py @@ -1,23 +1,22 @@ import warnings warnings.warn("eventlet.processes is deprecated in favor of " - "eventlet.green.subprocess, which is API-compatible with the standard " - " library subprocess module.", - DeprecationWarning, stacklevel=2) - + "eventlet.green.subprocess, which is API-compatible with the standard " + " library subprocess module.", + DeprecationWarning, stacklevel=2) import errno import os -import popen2 import signal -from eventlet import api -from eventlet import pools -from eventlet import greenio +import eventlet +from eventlet import greenio, pools +from eventlet.green import subprocess class DeadProcess(RuntimeError): pass + def cooperative_wait(pobj, check_interval=0.01): """ Waits for a child process to exit, returning the status code. @@ -34,7 +33,7 @@ def cooperative_wait(pobj, check_interval=0.01): status = pobj.poll() if status >= 0: return status - api.sleep(check_interval) + eventlet.sleep(check_interval) except OSError as e: if e.errno == errno.ECHILD: # no child process, this happens if the child process @@ -48,7 +47,8 @@ def cooperative_wait(pobj, check_interval=0.01): class Process(object): """Construct Process objects, then call read, and write on them.""" process_number = 0 - def __init__(self, command, args, dead_callback=lambda:None): + + def __init__(self, command, args, dead_callback=None): self.process_number = self.process_number + 1 Process.process_number = self.process_number self.command = command @@ -59,14 +59,20 @@ class Process(object): def run(self): self.dead = False self.started = False - self.popen4 = None + self.proc = None - ## We use popen4 so that read() will read from either stdout or stderr - self.popen4 = popen2.Popen4([self.command] + self.args) - child_stdout_stderr = self.popen4.fromchild - child_stdin = self.popen4.tochild - self.child_stdout_stderr = greenio.GreenPipe(child_stdout_stderr, child_stdout_stderr.mode, 0) - self.child_stdin = greenio.GreenPipe(child_stdin, child_stdin.mode, 0) + args = [self.command] + args.extend(self.args) + self.proc = subprocess.Popen( + args=args, + shell=False, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + close_fds=True, + ) + self.child_stdout_stderr = self.proc.stdout + self.child_stdin = self.proc.stdin self.sendall = self.child_stdin.write self.send = self.child_stdin.write @@ -75,7 +81,7 @@ class Process(object): self._read_first_result = False def wait(self): - return cooperative_wait(self.popen4) + return cooperative_wait(self.proc) def dead_callback(self): self.wait() @@ -128,13 +134,13 @@ class Process(object): self.child_stdin.close() def kill(self, sig=None): - if sig == None: + if sig is None: sig = signal.SIGTERM pid = self.getpid() os.kill(pid, sig) def getpid(self): - return self.popen4.pid + return self.proc.pid class ProcessPool(pools.Pool): @@ -157,7 +163,7 @@ class ProcessPool(pools.Pool): def put(self, item): if not item.dead: - if item.popen4.poll() != -1: + if item.proc.poll() != -1: item.dead_callback() else: pools.Pool.put(self, item) diff --git a/eventlet/tpool.py b/eventlet/tpool.py index f92e9ec..f4075ac 100644 --- a/eventlet/tpool.py +++ b/eventlet/tpool.py @@ -16,6 +16,7 @@ import imp import os import sys +import traceback from eventlet import event, greenio, greenthread, patcher, timeout from eventlet.support import six @@ -32,12 +33,13 @@ Empty = Queue_module.Empty __all__ = ['execute', 'Proxy', 'killall'] -QUIET=True +QUIET = True _rfile = _wfile = None _bytetosend = ' '.encode() + def _signal_t2e(): _wfile.write(_bytetosend) _wfile.flush() @@ -45,9 +47,10 @@ def _signal_t2e(): _reqq = None _rspq = None + def tpool_trampoline(): global _rspq - while(True): + while True: try: _c = _rfile.read(1) assert _c @@ -55,7 +58,7 @@ def tpool_trampoline(): break # will be raised when pipe is closed while not _rspq.empty(): try: - (e,rv) = _rspq.get(block=False) + (e, rv) = _rspq.get(block=False) e.send(rv) e = rv = None except Empty: @@ -65,31 +68,32 @@ def tpool_trampoline(): SYS_EXCS = (KeyboardInterrupt, SystemExit) EXC_CLASSES = (Exception, timeout.Timeout) + def tworker(): global _rspq while(True): try: msg = _reqq.get() except AttributeError: - return # can't get anything off of a dud queue + return # can't get anything off of a dud queue if msg is None: return - (e,meth,args,kwargs) = msg + (e, meth, args, kwargs) = msg rv = None try: - rv = meth(*args,**kwargs) + rv = meth(*args, **kwargs) except SYS_EXCS: raise except EXC_CLASSES: rv = sys.exc_info() # test_leakage_from_tracebacks verifies that the use of # exc_info does not lead to memory leaks - _rspq.put((e,rv)) + _rspq.put((e, rv)) msg = meth = args = kwargs = e = rv = None _signal_t2e() -def execute(meth,*args, **kwargs): +def execute(meth, *args, **kwargs): """ Execute *meth* in a Python thread, blocking the current coroutine/ greenthread until the method completes. @@ -109,16 +113,15 @@ def execute(meth,*args, **kwargs): return meth(*args, **kwargs) e = event.Event() - _reqq.put((e,meth,args,kwargs)) + _reqq.put((e, meth, args, kwargs)) rv = e.wait() - if isinstance(rv,tuple) \ - and len(rv) == 3 \ - and isinstance(rv[1],EXC_CLASSES): - import traceback - (c,e,tb) = rv + if isinstance(rv, tuple) \ + and len(rv) == 3 \ + and isinstance(rv[1], EXC_CLASSES): + (c, e, tb) = rv if not QUIET: - traceback.print_exception(c,e,tb) + traceback.print_exception(c, e, tb) traceback.print_stack() six.reraise(c, e, tb) return rv @@ -136,15 +139,16 @@ def proxy_call(autowrap, f, *args, **kwargs): that don't need to be called in a separate thread, but which return objects that should be Proxy wrapped. """ - if kwargs.pop('nonblocking',False): + if kwargs.pop('nonblocking', False): rv = f(*args, **kwargs) else: - rv = execute(f,*args,**kwargs) + rv = execute(f, *args, **kwargs) if isinstance(rv, autowrap): return Proxy(rv, autowrap) else: return rv + class Proxy(object): """ a simple proxy-wrapper of any object that comes with a @@ -166,7 +170,7 @@ class Proxy(object): of strings, which represent the names of attributes that should be wrapped in Proxy objects when accessed. """ - def __init__(self, obj,autowrap=(), autowrap_names=()): + def __init__(self, obj, autowrap=(), autowrap_names=()): self._obj = obj self._autowrap = autowrap self._autowrap_names = autowrap_names @@ -177,6 +181,7 @@ class Proxy(object): if isinstance(f, self._autowrap) or attr_name in self._autowrap_names: return Proxy(f, self._autowrap) return f + def doit(*args, **kwargs): result = proxy_call(self._autowrap, f, *args, **kwargs) if attr_name in self._autowrap_names and not isinstance(result, Proxy): @@ -189,19 +194,25 @@ class Proxy(object): # explicitly def __getitem__(self, key): return proxy_call(self._autowrap, self._obj.__getitem__, key) + def __setitem__(self, key, value): return proxy_call(self._autowrap, self._obj.__setitem__, key, value) + def __deepcopy__(self, memo=None): return proxy_call(self._autowrap, self._obj.__deepcopy__, memo) + def __copy__(self, memo=None): return proxy_call(self._autowrap, self._obj.__copy__, memo) + def __call__(self, *a, **kw): if '__call__' in self._autowrap_names: return Proxy(proxy_call(self._autowrap, self._obj, *a, **kw)) else: return proxy_call(self._autowrap, self._obj, *a, **kw) + def __enter__(self): return proxy_call(self._autowrap, self._obj.__enter__) + def __exit__(self, *exc): return proxy_call(self._autowrap, self._obj.__exit__, *exc) @@ -210,31 +221,43 @@ class Proxy(object): # wrapped object in such a way that they would block def __eq__(self, rhs): return self._obj == rhs + def __hash__(self): return self._obj.__hash__() + def __repr__(self): return self._obj.__repr__() + def __str__(self): return self._obj.__str__() + def __len__(self): return len(self._obj) + def __nonzero__(self): return bool(self._obj) + # Python3 __bool__ = __nonzero__ + def __iter__(self): it = iter(self._obj) if it == self._obj: return self else: return Proxy(it) + def next(self): return proxy_call(self._autowrap, self._obj.next) + # Python3 + __next__ = next _nthreads = int(os.environ.get('EVENTLET_THREADPOOL_SIZE', 20)) _threads = [] _coro = None _setup_already = False + + def setup(): global _rfile, _wfile, _threads, _coro, _setup_already, _rspq, _reqq if _setup_already: @@ -257,7 +280,7 @@ def setup(): csock.connect(('localhost', sock.getsockname()[1])) nsock, addr = sock.accept() _rfile = greenio.GreenSocket(csock).makefile('rb', 0) - _wfile = nsock.makefile('wb',0) + _wfile = nsock.makefile('wb', 0) _reqq = Queue(maxsize=-1) _rspq = Queue(maxsize=-1) @@ -295,6 +318,7 @@ def killall(): _rspq = None _setup_already = False + def set_num_threads(nthreads): global _nthreads _nthreads = nthreads diff --git a/tests/__init__.py b/tests/__init__.py index 66eb5b0..2234f0d 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -22,11 +22,6 @@ from eventlet import tpool main = unittest.main -def s2b(s): - """portable way to convert string to bytes. In 3.x socket.send and recv require bytes""" - return s.encode() - - def skipped(func): """ Decorator that marks a function as skipped. Uses nose's SkipTest exception if installed. Without nose, this will count skipped tests as passing tests.""" diff --git a/tests/api_test.py b/tests/api_test.py index 3ed98a8..2ee0886 100644 --- a/tests/api_test.py +++ b/tests/api_test.py @@ -4,12 +4,12 @@ from unittest import TestCase, main import warnings import eventlet +from eventlet import greenio, util, hubs, greenthread, spawn +from tests import skip_if_no_ssl + warnings.simplefilter('ignore', DeprecationWarning) from eventlet import api warnings.simplefilter('default', DeprecationWarning) -from eventlet import greenio, util, hubs, greenthread, spawn - -from tests import skip_if_no_ssl def check_hub(): @@ -57,7 +57,7 @@ class TestApi(TestCase): client.close() assert fd.readline() == b'hello\n' - assert fd.read() == '' + assert fd.read() == b'' fd.close() check_hub() @@ -85,7 +85,7 @@ class TestApi(TestCase): assert fd.readline() == b'hello\r\n' try: - self.assertEquals('', fd.read(10)) + self.assertEqual(b'', fd.read(10)) except greenio.SSL.ZeroReturnError: # if it's a GreenSSL object it'll do this pass @@ -147,9 +147,7 @@ class TestApi(TestCase): def test_named(self): named_foo = api.named('tests.api_test.Foo') - self.assertEquals( - named_foo.__name__, - "Foo") + self.assertEqual(named_foo.__name__, "Foo") def test_naming_missing_class(self): self.assertRaises( @@ -171,19 +169,25 @@ class TestApi(TestCase): # thus after the function's done, the control will go to the parent api.sleep(0) state.append('finished') + g = api.spawn(test) - api.sleep(DELAY/2) - self.assertEquals(state, ['start']) + api.sleep(DELAY / 2) + self.assertEqual(state, ['start']) api.kill(g) # will not get there, unless switching is explicitly scheduled by kill - self.assertEquals(state, ['start', 'except']) + self.assertEqual(state, ['start', 'except']) api.sleep(DELAY) - self.assertEquals(state, ['start', 'except', 'finished']) + self.assertEqual(state, ['start', 'except', 'finished']) def test_nested_with_timeout(self): def func(): return api.with_timeout(0.2, api.sleep, 2, timeout_value=1) - self.assertRaises(api.TimeoutError, api.with_timeout, 0.1, func) + + try: + api.with_timeout(0.1, func) + self.fail(u'Expected api.TimeoutError') + except api.TimeoutError: + pass class Foo(object): diff --git a/tests/backdoor_test.py b/tests/backdoor_test.py index 8c6a424..5df6d35 100644 --- a/tests/backdoor_test.py +++ b/tests/backdoor_test.py @@ -18,11 +18,11 @@ class BackdoorTest(LimitedTestCase): f.readline() # build info f.readline() # help info self.assert_(b'InteractiveConsole' in f.readline()) - self.assertEquals(b'>>> ', f.read(4)) + self.assertEqual(b'>>> ', f.read(4)) f.write(b'print("hi")\n') f.flush() - self.assertEquals(b'hi\n', f.readline()) - self.assertEquals(b'>>> ', f.read(4)) + self.assertEqual(b'hi\n', f.readline()) + self.assertEqual(b'>>> ', f.read(4)) f.close() client.close() serv.kill() diff --git a/tests/convenience_test.py b/tests/convenience_test.py index 82b58eb..1a2beda 100644 --- a/tests/convenience_test.py +++ b/tests/convenience_test.py @@ -1,10 +1,10 @@ import os import eventlet -from eventlet import event +from eventlet import debug, event from eventlet.green import socket from eventlet.support import six -from tests import LimitedTestCase, s2b, skip_if_no_ssl +from tests import LimitedTestCase, skip_if_no_ssl certificate_file = os.path.join(os.path.dirname(__file__), 'test_server.crt') @@ -14,43 +14,40 @@ private_key_file = os.path.join(os.path.dirname(__file__), 'test_server.key') class TestServe(LimitedTestCase): def setUp(self): super(TestServe, self).setUp() - from eventlet import debug debug.hub_exceptions(False) def tearDown(self): super(TestServe, self).tearDown() - from eventlet import debug debug.hub_exceptions(True) def test_exiting_server(self): # tests that the server closes the client sock on handle() exit - def closer(sock,addr): + def closer(sock, addr): pass l = eventlet.listen(('localhost', 0)) gt = eventlet.spawn(eventlet.serve, l, closer) client = eventlet.connect(('localhost', l.getsockname()[1])) - client.sendall(s2b('a')) + client.sendall(b'a') self.assertFalse(client.recv(100)) gt.kill() - def test_excepting_server(self): # tests that the server closes the client sock on handle() exception - def crasher(sock,addr): + def crasher(sock, addr): sock.recv(1024) 0//0 l = eventlet.listen(('localhost', 0)) gt = eventlet.spawn(eventlet.serve, l, crasher) client = eventlet.connect(('localhost', l.getsockname()[1])) - client.sendall(s2b('a')) + client.sendall(b'a') self.assertRaises(ZeroDivisionError, gt.wait) self.assertFalse(client.recv(100)) def test_excepting_server_already_closed(self): # same as above but with explicit clsoe before crash - def crasher(sock,addr): + def crasher(sock, addr): sock.recv(1024) sock.close() 0//0 @@ -58,14 +55,15 @@ class TestServe(LimitedTestCase): l = eventlet.listen(('localhost', 0)) gt = eventlet.spawn(eventlet.serve, l, crasher) client = eventlet.connect(('localhost', l.getsockname()[1])) - client.sendall(s2b('a')) + client.sendall(b'a') self.assertRaises(ZeroDivisionError, gt.wait) self.assertFalse(client.recv(100)) def test_called_for_each_connection(self): hits = [0] + def counter(sock, addr): - hits[0]+=1 + hits[0] += 1 l = eventlet.listen(('localhost', 0)) gt = eventlet.spawn(eventlet.serve, l, counter) for i in six.moves.range(100): @@ -76,8 +74,9 @@ class TestServe(LimitedTestCase): def test_blocking(self): l = eventlet.listen(('localhost', 0)) - x = eventlet.with_timeout(0.01, - eventlet.serve, l, lambda c,a: None, + x = eventlet.with_timeout( + 0.01, + eventlet.serve, l, lambda c, a: None, timeout_value="timeout") self.assertEqual(x, "timeout") @@ -86,50 +85,56 @@ class TestServe(LimitedTestCase): raise eventlet.StopServe() l = eventlet.listen(('localhost', 0)) # connect to trigger a call to stopit - gt = eventlet.spawn(eventlet.connect, - ('localhost', l.getsockname()[1])) + gt = eventlet.spawn(eventlet.connect, ('localhost', l.getsockname()[1])) eventlet.serve(l, stopit) gt.wait() def test_concurrency(self): evt = event.Event() + def waiter(sock, addr): - sock.sendall(s2b('hi')) + sock.sendall(b'hi') evt.wait() l = eventlet.listen(('localhost', 0)) - gt = eventlet.spawn(eventlet.serve, l, waiter, 5) + eventlet.spawn(eventlet.serve, l, waiter, 5) + def test_client(): c = eventlet.connect(('localhost', l.getsockname()[1])) # verify the client is connected by getting data - self.assertEquals(s2b('hi'), c.recv(2)) + self.assertEqual(b'hi', c.recv(2)) return c - clients = [test_client() for i in range(5)] + [test_client() for i in range(5)] # very next client should not get anything - x = eventlet.with_timeout(0.01, + x = eventlet.with_timeout( + 0.01, test_client, timeout_value="timed out") - self.assertEquals(x, "timed out") + self.assertEqual(x, "timed out") @skip_if_no_ssl def test_wrap_ssl(self): - server = eventlet.wrap_ssl(eventlet.listen(('localhost', 0)), - certfile=certificate_file, - keyfile=private_key_file, server_side=True) + server = eventlet.wrap_ssl( + eventlet.listen(('localhost', 0)), + certfile=certificate_file, keyfile=private_key_file, + server_side=True) port = server.getsockname()[1] - def handle(sock,addr): + + def handle(sock, addr): sock.sendall(sock.recv(1024)) raise eventlet.StopServe() + eventlet.spawn(eventlet.serve, server, handle) client = eventlet.wrap_ssl(eventlet.connect(('localhost', port))) client.sendall("echo") - self.assertEquals("echo", client.recv(1024)) + self.assertEqual("echo", client.recv(1024)) def test_socket_reuse(self): - lsock1 = eventlet.listen(('localhost',0)) + lsock1 = eventlet.listen(('localhost', 0)) port = lsock1.getsockname()[1] + def same_socket(): - return eventlet.listen(('localhost',port)) - self.assertRaises(socket.error,same_socket) + return eventlet.listen(('localhost', port)) + + self.assertRaises(socket.error, same_socket) lsock1.close() assert same_socket() - diff --git a/tests/db_pool_test.py b/tests/db_pool_test.py index 160f53a..5c486ba 100644 --- a/tests/db_pool_test.py +++ b/tests/db_pool_test.py @@ -265,19 +265,19 @@ class DBConnectionPool(DBTester): conn = self.pool._unwrap_connection(self.connection) self.assert_(not isinstance(conn, db_pool.GenericConnectionWrapper)) - self.assertEquals(None, self.pool._unwrap_connection(None)) - self.assertEquals(None, self.pool._unwrap_connection(1)) + self.assertEqual(None, self.pool._unwrap_connection(None)) + self.assertEqual(None, self.pool._unwrap_connection(1)) # testing duck typing here -- as long as the connection has a # _base attribute, it should be unwrappable x = Mock() x._base = 'hi' - self.assertEquals('hi', self.pool._unwrap_connection(x)) + self.assertEqual('hi', self.pool._unwrap_connection(x)) conn.close() def test_safe_close(self): self.pool._safe_close(self.connection, quiet=True) - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) self.pool._safe_close(None) self.pool._safe_close(1) @@ -301,7 +301,7 @@ class DBConnectionPool(DBTester): self.pool = self.create_pool(max_size=2, max_idle=0) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) def test_zero_max_age(self): self.pool.put(self.connection) @@ -309,7 +309,7 @@ class DBConnectionPool(DBTester): self.pool = self.create_pool(max_size=2, max_age=0) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) @skipped def test_max_idle(self): @@ -320,19 +320,19 @@ class DBConnectionPool(DBTester): self.pool = self.create_pool(max_size=2, max_idle=0.02) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) eventlet.sleep(0.01) # not long enough to trigger the idle timeout - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) eventlet.sleep(0.01) # idle timeout should have fired but done nothing - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) eventlet.sleep(0.03) # long enough to trigger idle timeout for real - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) @skipped def test_max_idle_many(self): @@ -344,11 +344,11 @@ class DBConnectionPool(DBTester): self.connection, conn2 = self.pool.get(), self.pool.get() self.connection.close() eventlet.sleep(0.01) - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) conn2.close() - self.assertEquals(len(self.pool.free_items), 2) + self.assertEqual(len(self.pool.free_items), 2) eventlet.sleep(0.02) # trigger cleanup of conn1 but not conn2 - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) @skipped def test_max_age(self): @@ -359,14 +359,14 @@ class DBConnectionPool(DBTester): self.pool = self.create_pool(max_size=2, max_age=0.05) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) eventlet.sleep(0.01) # not long enough to trigger the age timeout - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) eventlet.sleep(0.05) # long enough to trigger age timeout - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) @skipped def test_max_age_many(self): @@ -377,13 +377,13 @@ class DBConnectionPool(DBTester): self.pool = self.create_pool(max_size=2, max_age=0.15) self.connection, conn2 = self.pool.get(), self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) eventlet.sleep(0) # not long enough to trigger the age timeout - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) eventlet.sleep(0.2) # long enough to trigger age timeout - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) conn2.close() # should not be added to the free items - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) def test_waiters_get_woken(self): # verify that when there's someone waiting on an empty pool @@ -394,8 +394,8 @@ class DBConnectionPool(DBTester): self.pool = self.create_pool(max_size=1, max_age=0) self.connection = self.pool.get() - self.assertEquals(self.pool.free(), 0) - self.assertEquals(self.pool.waiting(), 0) + self.assertEqual(self.pool.free(), 0) + self.assertEqual(self.pool.waiting(), 0) e = event.Event() def retrieve(pool, ev): c = pool.get() @@ -403,14 +403,14 @@ class DBConnectionPool(DBTester): eventlet.spawn(retrieve, self.pool, e) eventlet.sleep(0) # these two sleeps should advance the retrieve eventlet.sleep(0) # coroutine until it's waiting in get() - self.assertEquals(self.pool.free(), 0) - self.assertEquals(self.pool.waiting(), 1) + self.assertEqual(self.pool.free(), 0) + self.assertEqual(self.pool.waiting(), 1) self.pool.put(self.connection) timer = eventlet.Timeout(1) conn = e.wait() timer.cancel() - self.assertEquals(self.pool.free(), 0) - self.assertEquals(self.pool.waiting(), 0) + self.assertEqual(self.pool.free(), 0) + self.assertEqual(self.pool.waiting(), 0) self.pool.put(conn) @skipped @@ -440,7 +440,7 @@ class DBConnectionPool(DBTester): # not lose any connections self.pool = self.create_pool(max_size=1, module=RaisingDBModule()) self.assertRaises(RuntimeError, self.pool.get) - self.assertEquals(self.pool.free(), 1) + self.assertEqual(self.pool.free(), 1) class DummyConnection(object): diff --git a/tests/debug_test.py b/tests/debug_test.py index e509c65..da6d7ab 100644 --- a/tests/debug_test.py +++ b/tests/debug_test.py @@ -3,7 +3,7 @@ from unittest import TestCase from eventlet import debug from eventlet.support import six -from tests import LimitedTestCase, main, s2b +from tests import LimitedTestCase, main import eventlet @@ -113,7 +113,7 @@ class TestDebug(LimitedTestCase): try: gt = eventlet.spawn(hurl, client_2) eventlet.sleep(0) - client.send(s2b(' ')) + client.send(b' ') eventlet.sleep(0) # allow the "hurl" greenlet to trigger the KeyError # not sure why the extra context switch is needed @@ -124,7 +124,7 @@ class TestDebug(LimitedTestCase): debug.hub_exceptions(False) # look for the KeyError exception in the traceback self.assert_('KeyError: 1' in fake.getvalue(), - "Traceback not in:\n" + fake.getvalue()) + "Traceback not in:\n" + fake.getvalue()) if __name__ == "__main__": main() diff --git a/tests/greenio_test.py b/tests/greenio_test.py index e167446..3432767 100644 --- a/tests/greenio_test.py +++ b/tests/greenio_test.py @@ -1,18 +1,26 @@ -import socket as _orig_sock -from tests import LimitedTestCase, skip_with_pyevent, main, skipped, s2b, skip_if, skip_on_windows -from eventlet import event, greenio, debug -from eventlet.hubs import get_hub -from eventlet.green import select, socket, time, ssl -from eventlet.support import get_errno - import array import errno import eventlet -import gc import fcntl +import gc import os +import shutil +import socket as _orig_sock import sys -import tempfile, shutil +import tempfile + +from eventlet import event, greenio, debug +from eventlet.hubs import get_hub +from eventlet.green import select, socket, time, ssl +from eventlet.support import get_errno, six +from tests import ( + LimitedTestCase, main, + skip_with_pyevent, skipped, skip_if, skip_on_windows, +) + + +if six.PY3: + buffer = memoryview def bufsized(sock, size=1): @@ -35,17 +43,17 @@ def min_buf_size(): def using_epoll_hub(_f): - try: - return 'epolls' in type(get_hub()).__module__ - except Exception: - return False + try: + return 'epolls' in type(get_hub()).__module__ + except Exception: + return False def using_kqueue_hub(_f): - try: - return 'kqueue' in type(get_hub()).__module__ - except Exception: - return False + try: + return 'kqueue' in type(get_hub()).__module__ + except Exception: + return False class TestGreenSocket(LimitedTestCase): @@ -95,7 +103,7 @@ class TestGreenSocket(LimitedTestCase): gs = greenio.GreenSocket(s) e = gs.connect_ex(('192.0.2.1', 80)) if not e in (errno.EHOSTUNREACH, errno.ENETUNREACH): - self.assertEquals(e, errno.EAGAIN) + self.assertEqual(e, errno.EAGAIN) def test_recv_timeout(self): listener = greenio.GreenSocket(socket.socket()) @@ -142,7 +150,7 @@ class TestGreenSocket(LimitedTestCase): self.assertEqual(e.args[0], 'timed out') def test_recvfrom_into_timeout(self): - buf = buffer(array.array('B')) + buf = array.array('B') gs = greenio.GreenSocket( socket.socket(socket.AF_INET, socket.SOCK_DGRAM)) @@ -157,7 +165,7 @@ class TestGreenSocket(LimitedTestCase): self.assertEqual(e.args[0], 'timed out') def test_recv_into_timeout(self): - buf = buffer(array.array('B')) + buf = array.array('B') listener = greenio.GreenSocket(socket.socket()) listener.bind(('', 0)) @@ -209,7 +217,7 @@ class TestGreenSocket(LimitedTestCase): client.connect(addr) try: client.settimeout(0.00001) - msg = s2b("A") * 100000 # large enough number to overwhelm most buffers + msg = b"A" * 100000 # large enough number to overwhelm most buffers total_sent = 0 # want to exceed the size of the OS buffer so it'll block in a @@ -245,7 +253,7 @@ class TestGreenSocket(LimitedTestCase): client.connect(addr) try: - msg = s2b("A") * (8 << 20) + msg = b"A" * (8 << 20) # want to exceed the size of the OS buffer so it'll block client.sendall(msg) @@ -265,10 +273,10 @@ class TestGreenSocket(LimitedTestCase): conn, addr = listener.accept() fd = conn.makefile('w') conn.close() - fd.write('hello\n') + fd.write(b'hello\n') fd.close() self.assertWriteToClosedFileRaises(fd) - self.assertRaises(socket.error, conn.send, s2b('b')) + self.assertRaises(socket.error, conn.send, b'b') finally: listener.close() @@ -278,12 +286,12 @@ class TestGreenSocket(LimitedTestCase): try: conn, addr = listener.accept() fd = conn.makefile('w') - fd.write('hello') + fd.write(b'hello') fd.close() - conn.send(s2b('\n')) + conn.send(b'\n') conn.close() self.assertWriteToClosedFileRaises(fd) - self.assertRaises(socket.error, conn.send, s2b('b')) + self.assertRaises(socket.error, conn.send, b'b') finally: listener.close() @@ -292,8 +300,8 @@ class TestGreenSocket(LimitedTestCase): client.connect(('127.0.0.1', server.getsockname()[1])) fd = client.makefile() client.close() - assert fd.readline() == 'hello\n' - assert fd.read() == '' + assert fd.readline() == b'hello\n' + assert fd.read() == b'' fd.close() server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) @@ -320,7 +328,7 @@ class TestGreenSocket(LimitedTestCase): try: conn, addr = listener.accept() conn = conn.makefile('w') - conn.write('hello\n') + conn.write(b'hello\n') conn.close() gc.collect() self.assertWriteToClosedFileRaises(conn) @@ -336,13 +344,13 @@ class TestGreenSocket(LimitedTestCase): client.connect(('127.0.0.1', server.getsockname()[1])) fd = client.makefile() client.close() - assert fd.read() == 'hello\n' - assert fd.read() == '' + assert fd.read() == b'hello\n' + assert fd.read() == b'' killer.wait() def test_full_duplex(self): - large_data = s2b('*') * 10 * min_buf_size() + large_data = b'*' * 10 * min_buf_size() listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM) listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) listener.bind(('127.0.0.1', 0)) @@ -356,7 +364,7 @@ class TestGreenSocket(LimitedTestCase): result = sock.recv(len(large_data)) while len(result) < len(large_data): result += sock.recv(len(large_data)) - self.assertEquals(result, large_data) + self.assertEqual(result, large_data) def server(): (sock, addr) = listener.accept() @@ -364,10 +372,10 @@ class TestGreenSocket(LimitedTestCase): send_large_coro = eventlet.spawn(send_large, sock) eventlet.sleep(0) result = sock.recv(10) - expected = s2b('hello world') + expected = b'hello world' while len(result) < len(expected): result += sock.recv(10) - self.assertEquals(result, expected) + self.assertEqual(result, expected) send_large_coro.wait() server_evt = eventlet.spawn(server) @@ -376,7 +384,7 @@ class TestGreenSocket(LimitedTestCase): bufsized(client) large_evt = eventlet.spawn(read_large, client) eventlet.sleep(0) - client.sendall(s2b('hello world')) + client.sendall(b'hello world') server_evt.wait() large_evt.wait() client.close() @@ -393,8 +401,8 @@ class TestGreenSocket(LimitedTestCase): def sender(listener): (sock, addr) = listener.accept() sock = bufsized(sock, size=bufsize) - sock.sendall(s2b('x') * many_bytes) - sock.sendall(s2b('y') * second_bytes) + sock.sendall(b'x' * many_bytes) + sock.sendall(b'y' * second_bytes) listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM) listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) @@ -447,12 +455,13 @@ class TestGreenSocket(LimitedTestCase): eventlet.sleep(0.02) wrap_wfile.write('hi') s2.close() - evt.send('sent via event') + evt.send(b'sent via event') evt = event.Event() eventlet.spawn(sender, evt) - eventlet.sleep(0) # lets the socket enter accept mode, which - # is necessary for connect to succeed on windows + # lets the socket enter accept mode, which + # is necessary for connect to succeed on windows + eventlet.sleep(0) try: # try and get some data off of this pipe # but bail before any is sent @@ -466,7 +475,7 @@ class TestGreenSocket(LimitedTestCase): pass result = evt.wait() - self.assertEquals(result, 'sent via event') + self.assertEqual(result, b'sent via event') server.close() client.close() @@ -476,7 +485,7 @@ class TestGreenSocket(LimitedTestCase): def handle(sock, addr): sock.recv(1) - sock.sendall("a") + sock.sendall(b"a") raise eventlet.StopServe() listener = eventlet.listen(('127.0.0.1', 0)) @@ -489,7 +498,7 @@ class TestGreenSocket(LimitedTestCase): a = eventlet.spawn(reader, s) eventlet.sleep(0) self.assertRaises(RuntimeError, s.recv, 1) - s.sendall('b') + s.sendall(b'b') a.wait() @skip_with_pyevent @@ -500,7 +509,7 @@ class TestGreenSocket(LimitedTestCase): sock = eventlet.connect(address) while True: try: - sock.sendall('hello world') + sock.sendall(b'hello world') except socket.error as e: if get_errno(e) == errno.EPIPE: return @@ -628,8 +637,8 @@ class TestGreenPipe(LimitedTestCase): for i in range(5): line = rf.readline() eventlet.sleep(0.01) - self.assertEquals(line, one_line) - self.assertEquals(rf.readline(), '') + self.assertEqual(line, one_line) + self.assertEqual(rf.readline(), '') def test_pipe_read(self): # ensure that 'readline' works properly on GreenPipes when data is not @@ -654,10 +663,10 @@ class TestGreenPipe(LimitedTestCase): eventlet.sleep(0) line = r.readline() - self.assertEquals(line, 'line\n') + self.assertEqual(line, 'line\n') line = r.readline() - self.assertEquals(line, 'line\r\n') + self.assertEqual(line, 'line\r\n') gt.wait() @@ -678,26 +687,27 @@ class TestGreenPipe(LimitedTestCase): for i in range(65): buf = r.read(1024) expected = 1024 * chr(i) - self.assertEquals(buf, expected, + self.assertEqual( + buf, expected, "expected=%r..%r, found=%r..%r iter=%d" % (expected[:4], expected[-4:], buf[:4], buf[-4:], i)) gt.wait() def test_seek_on_buffered_pipe(self): f = greenio.GreenPipe(self.tempdir + "/TestFile", 'w+', 1024) - self.assertEquals(f.tell(), 0) + self.assertEqual(f.tell(), 0) f.seek(0, 2) - self.assertEquals(f.tell(), 0) + self.assertEqual(f.tell(), 0) f.write('1234567890') f.seek(0, 2) - self.assertEquals(f.tell(), 10) + self.assertEqual(f.tell(), 10) f.seek(0) value = f.read(1) self.assertEqual(value, '1') - self.assertEquals(f.tell(), 1) + self.assertEqual(f.tell(), 1) value = f.read(1) self.assertEqual(value, '2') - self.assertEquals(f.tell(), 2) + self.assertEqual(f.tell(), 2) f.seek(0, 1) self.assertEqual(f.readline(), '34567890') f.seek(-5, 1) @@ -711,7 +721,7 @@ class TestGreenPipe(LimitedTestCase): f = greenio.GreenPipe(self.tempdir + "/TestFile", 'w+', 1024) f.write('1234567890') f.truncate(9) - self.assertEquals(f.tell(), 9) + self.assertEqual(f.tell(), 9) class TestGreenIoLong(LimitedTestCase): @@ -762,7 +772,7 @@ class TestGreenIoLong(LimitedTestCase): bufsized(client, size=sendsize) else: bufsized(client) - client.sendall(s2b('*') * sendsize) + client.sendall(b'*' * sendsize) client.close() server_coro.wait() listener.close() @@ -831,7 +841,7 @@ class TestGreenIoStarvation(LimitedTestCase): bufsized(client, size=sendsize) for i in range(sendloops): - client.sendall(s2b('*') * sendsize) + client.sendall(b'*' * sendsize) client.close() os._exit(0) @@ -864,12 +874,15 @@ class TestGreenIoStarvation(LimitedTestCase): # assert that the last task started before the first task ended # (our no-starvation condition) - assert starttimes[-1] < endtimes[0], "Not overlapping: starts %s ends %s" % (starttimes, endtimes) + assert starttimes[-1] < endtimes[0], \ + "Not overlapping: starts %s ends %s" % (starttimes, endtimes) maxstartdiff = starttimes[-1] - starttimes[0] - assert maxstartdiff * 2 < runlengths[0], "Largest difference in starting times more than twice the shortest running time!" - assert runlengths[0] * 2 > runlengths[-1], "Longest runtime more than twice as long as shortest!" + assert maxstartdiff * 2 < runlengths[0], \ + "Largest difference in starting times more than twice the shortest running time!" + assert runlengths[0] * 2 > runlengths[-1], \ + "Longest runtime more than twice as long as shortest!" def test_set_nonblocking(): diff --git a/tests/greenpool_test.py b/tests/greenpool_test.py index efdc5ed..90b2bfa 100644 --- a/tests/greenpool_test.py +++ b/tests/greenpool_test.py @@ -1,11 +1,9 @@ import gc -import itertools import os import random import eventlet -from eventlet import debug -from eventlet import hubs, greenpool, coros, event +from eventlet import hubs, greenpool, event, pools from eventlet.support import greenlets as greenlet, six import tests @@ -17,7 +15,7 @@ def passthru(a): def passthru2(a, b): eventlet.sleep(0.01) - return a,b + return a, b def raiser(exc): @@ -31,24 +29,28 @@ class GreenPool(tests.LimitedTestCase): for i in range(10): waiters.append(p.spawn(passthru, i)) results = [waiter.wait() for waiter in waiters] - self.assertEquals(results, list(range(10))) + self.assertEqual(results, list(range(10))) def test_spawn_n(self): p = greenpool.GreenPool(4) results_closure = [] + def do_something(a): eventlet.sleep(0.01) results_closure.append(a) + for i in range(10): p.spawn(do_something, i) p.waitall() - self.assertEquals(results_closure, list(range(10))) + self.assertEqual(results_closure, list(range(10))) def test_waiting(self): pool = greenpool.GreenPool(1) done = event.Event() + def consume(): done.wait() + def waiter(pool): gt = pool.spawn(consume) gt.wait() @@ -74,9 +76,11 @@ class GreenPool(tests.LimitedTestCase): def test_multiple_coros(self): evt = event.Event() results = [] + def producer(): results.append('prod') evt.send() + def consumer(): results.append('cons1') evt.wait() @@ -86,25 +90,29 @@ class GreenPool(tests.LimitedTestCase): done = pool.spawn(consumer) pool.spawn_n(producer) done.wait() - self.assertEquals(['cons1', 'prod', 'cons2'], results) + self.assertEqual(['cons1', 'prod', 'cons2'], results) def test_timer_cancel(self): # this test verifies that local timers are not fired # outside of the context of the spawn timer_fired = [] + def fire_timer(): timer_fired.append(True) + def some_work(): hubs.get_hub().schedule_call_local(0, fire_timer) + pool = greenpool.GreenPool(2) worker = pool.spawn(some_work) worker.wait() eventlet.sleep(0) eventlet.sleep(0) - self.assertEquals(timer_fired, []) + self.assertEqual(timer_fired, []) def test_reentrant(self): pool = greenpool.GreenPool(1) + def reenter(): waiter = pool.spawn(lambda a: a, 'reenter') self.assertEqual('reenter', waiter.wait()) @@ -113,17 +121,20 @@ class GreenPool(tests.LimitedTestCase): outer_waiter.wait() evt = event.Event() + def reenter_async(): pool.spawn_n(lambda a: a, 'reenter') evt.send('done') pool.spawn_n(reenter_async) - self.assertEquals('done', evt.wait()) + self.assertEqual('done', evt.wait()) def assert_pool_has_free(self, pool, num_free): - self.assertEquals(pool.free(), num_free) + self.assertEqual(pool.free(), num_free) + def wait_long_time(e): e.wait() + timer = eventlet.Timeout(1) try: evt = event.Event() @@ -150,12 +161,14 @@ class GreenPool(tests.LimitedTestCase): def test_resize(self): pool = greenpool.GreenPool(2) evt = event.Event() + def wait_long_time(e): e.wait() + pool.spawn(wait_long_time, evt) pool.spawn(wait_long_time, evt) - self.assertEquals(pool.free(), 0) - self.assertEquals(pool.running(), 2) + self.assertEqual(pool.free(), 0) + self.assertEqual(pool.running(), 2) self.assert_pool_has_free(pool, 0) # verify that the pool discards excess items put into it @@ -167,28 +180,28 @@ class GreenPool(tests.LimitedTestCase): eventlet.sleep(0) eventlet.sleep(0) - self.assertEquals(pool.free(), 1) - self.assertEquals(pool.running(), 0) + self.assertEqual(pool.free(), 1) + self.assertEqual(pool.running(), 0) self.assert_pool_has_free(pool, 1) # resize larger and assert that there are more free items pool.resize(2) - self.assertEquals(pool.free(), 2) - self.assertEquals(pool.running(), 0) + self.assertEqual(pool.free(), 2) + self.assertEqual(pool.running(), 0) self.assert_pool_has_free(pool, 2) def test_pool_smash(self): # The premise is that a coroutine in a Pool tries to get a token out # of a token pool but times out before getting the token. We verify # that neither pool is adversely affected by this situation. - from eventlet import pools pool = greenpool.GreenPool(1) tp = pools.TokenPool(max_size=1) - token = tp.get() # empty out the pool + tp.get() # empty out the pool + def do_receive(tp): timer = eventlet.Timeout(0, RuntimeError()) try: - t = tp.get() + tp.get() self.fail("Shouldn't have recieved anything from the pool") except RuntimeError: return 'timed out' @@ -198,7 +211,7 @@ class GreenPool(tests.LimitedTestCase): # the spawn makes the token pool expect that coroutine, but then # immediately cuts bait e1 = pool.spawn(do_receive, tp) - self.assertEquals(e1.wait(), 'timed out') + self.assertEqual(e1.wait(), 'timed out') # the pool can get some random item back def send_wakeup(tp): @@ -210,18 +223,20 @@ class GreenPool(tests.LimitedTestCase): def resume(): return 'resumed' e2 = pool.spawn(resume) - self.assertEquals(e2.wait(), 'resumed') + self.assertEqual(e2.wait(), 'resumed') # we should be able to get out the thing we put in there, too - self.assertEquals(tp.get(), 'wakeup') + self.assertEqual(tp.get(), 'wakeup') gt.wait() def test_spawn_n_2(self): p = greenpool.GreenPool(2) self.assertEqual(p.free(), 2) r = [] + def foo(a): r.append(a) + gt = p.spawn(foo, 1) self.assertEqual(p.free(), 1) gt.wait() @@ -239,9 +254,9 @@ class GreenPool(tests.LimitedTestCase): self.assertEqual(r, [1]) p.spawn_n(foo, 4) - self.assertEqual(set(r), set([1,2,3])) + self.assertEqual(set(r), set([1, 2, 3])) eventlet.sleep(0) - self.assertEqual(set(r), set([1,2,3,4])) + self.assertEqual(set(r), set([1, 2, 3, 4])) def test_exceptions(self): p = greenpool.GreenPool(2) @@ -259,7 +274,7 @@ class GreenPool(tests.LimitedTestCase): def test_imap(self): p = greenpool.GreenPool(4) result_list = list(p.imap(passthru, range(10))) - self.assertEquals(result_list, list(range(10))) + self.assertEqual(result_list, list(range(10))) def test_empty_imap(self): p = greenpool.GreenPool(4) @@ -269,38 +284,40 @@ class GreenPool(tests.LimitedTestCase): def test_imap_nonefunc(self): p = greenpool.GreenPool(4) result_list = list(p.imap(None, range(10))) - self.assertEquals(result_list, [(x,) for x in range(10)]) + self.assertEqual(result_list, [(x,) for x in range(10)]) def test_imap_multi_args(self): p = greenpool.GreenPool(4) result_list = list(p.imap(passthru2, range(10), range(10, 20))) - self.assertEquals(result_list, list(zip(range(10), range(10,20)))) + self.assertEqual(result_list, list(zip(range(10), range(10, 20)))) def test_imap_raises(self): # testing the case where the function raises an exception; # both that the caller sees that exception, and that the iterator # continues to be usable to get the rest of the items p = greenpool.GreenPool(4) + def raiser(item): if item == 1 or item == 7: raise RuntimeError("intentional error") else: return item + it = p.imap(raiser, range(10)) results = [] while True: try: - results.append(it.next()) + results.append(six.next(it)) except RuntimeError: results.append('r') except StopIteration: break - self.assertEquals(results, [0,'r',2,3,4,5,6,'r',8,9]) + self.assertEqual(results, [0, 'r', 2, 3, 4, 5, 6, 'r', 8, 9]) def test_starmap(self): p = greenpool.GreenPool(4) result_list = list(p.starmap(passthru, [(x,) for x in range(10)])) - self.assertEquals(result_list, list(range(10))) + self.assertEqual(result_list, list(range(10))) def test_waitall_on_nothing(self): p = greenpool.GreenPool() @@ -318,7 +335,7 @@ class GreenPile(tests.LimitedTestCase): for i in range(10): p.spawn(passthru, i) result_list = list(p) - self.assertEquals(result_list, list(range(10))) + self.assertEqual(result_list, list(range(10))) def test_pile_spawn_times_out(self): p = greenpool.GreenPile(4) @@ -329,28 +346,32 @@ class GreenPile(tests.LimitedTestCase): self.assertRaises(eventlet.Timeout, p.spawn, passthru, "time out") # verify that the spawn breakage didn't interrupt the sequence # and terminates properly - for i in range(4,10): + for i in range(4, 10): p.spawn(passthru, i) - self.assertEquals(list(p), list(range(10))) + self.assertEqual(list(p), list(range(10))) def test_constructing_from_pool(self): pool = greenpool.GreenPool(2) pile1 = greenpool.GreenPile(pool) pile2 = greenpool.GreenPile(pool) + def bunch_of_work(pile, unique): for i in range(10): pile.spawn(passthru, i + unique) + eventlet.spawn(bunch_of_work, pile1, 0) eventlet.spawn(bunch_of_work, pile2, 100) eventlet.sleep(0) - self.assertEquals(list(pile2), list(range(100,110))) - self.assertEquals(list(pile1), list(range(10))) + self.assertEqual(list(pile2), list(range(100, 110))) + self.assertEqual(list(pile1), list(range(10))) class StressException(Exception): pass r = random.Random(0) + + def pressure(arg): while r.random() < 0.5: eventlet.sleep(r.random() * 0.001) @@ -359,18 +380,22 @@ def pressure(arg): else: raise StressException(arg) + def passthru(arg): while r.random() < 0.5: eventlet.sleep(r.random() * 0.001) return arg + class Stress(tests.LimitedTestCase): # tests will take extra-long - TEST_TIMEOUT=60 + TEST_TIMEOUT = 60 + @tests.skip_unless(os.environ.get('RUN_STRESS_TESTS') == 'YES') def spawn_order_check(self, concurrency): # checks that piles are strictly ordered p = greenpool.GreenPile(concurrency) + def makework(count, unique): for i in six.moves.range(count): token = (unique, i) @@ -380,13 +405,13 @@ class Stress(tests.LimitedTestCase): eventlet.spawn(makework, iters, 1) eventlet.spawn(makework, iters, 2) eventlet.spawn(makework, iters, 3) - p.spawn(pressure, (0,0)) + p.spawn(pressure, (0, 0)) latest = [-1] * 4 received = 0 it = iter(p) while True: try: - i = it.next() + i = six.next(it) except StressException as exc: i = exc.args[0] except StopIteration: @@ -398,7 +423,7 @@ class Stress(tests.LimitedTestCase): self.assert_(latest[unique] < order) latest[unique] = order for l in latest[1:]: - self.assertEquals(l, iters - 1) + self.assertEqual(l, iters - 1) @tests.skip_unless(os.environ.get('RUN_STRESS_TESTS') == 'YES') def test_ordering_5(self): @@ -417,7 +442,7 @@ class Stress(tests.LimitedTestCase): latest = -1 while True: try: - i = it.next() + i = six.next(it) except StopIteration: break @@ -433,7 +458,7 @@ class Stress(tests.LimitedTestCase): objs_created = len(gc.get_objects()) - initial_obj_count self.assert_(objs_created < 25 * concurrency, objs_created) # make sure we got to the end - self.assertEquals(latest, count - 1) + self.assertEqual(latest, count - 1) @tests.skip_unless(os.environ.get('RUN_STRESS_TESTS') == 'YES') def test_imap_50(self): @@ -445,7 +470,6 @@ class Stress(tests.LimitedTestCase): @tests.skip_unless(os.environ.get('RUN_STRESS_TESTS') == 'YES') def test_with_intpool(self): - from eventlet import pools class IntPool(pools.Pool): def create(self): self.current_integer = getattr(self, 'current_integer', 0) + 1 diff --git a/tests/greenthread_test.py b/tests/greenthread_test.py index 3433373..9f0be11 100644 --- a/tests/greenthread_test.py +++ b/tests/greenthread_test.py @@ -27,22 +27,22 @@ class Spawn(LimitedTestCase, Asserts): def test_simple(self): gt = greenthread.spawn(passthru, 1, b=2) - self.assertEquals(gt.wait(), ((1,),{'b':2})) - self.assertEquals(_g_results, [((1,),{'b':2})]) + self.assertEqual(gt.wait(), ((1,),{'b':2})) + self.assertEqual(_g_results, [((1,),{'b':2})]) def test_n(self): gt = greenthread.spawn_n(passthru, 2, b=3) self.assert_(not gt.dead) greenthread.sleep(0) self.assert_(gt.dead) - self.assertEquals(_g_results, [((2,),{'b':3})]) + self.assertEqual(_g_results, [((2,),{'b':3})]) def test_kill(self): gt = greenthread.spawn(passthru, 6) greenthread.kill(gt) self.assert_dead(gt) greenthread.sleep(0.001) - self.assertEquals(_g_results, []) + self.assertEqual(_g_results, []) greenthread.kill(gt) self.assert_dead(gt) @@ -51,7 +51,7 @@ class Spawn(LimitedTestCase, Asserts): gt.kill() self.assert_dead(gt) greenthread.sleep(0.001) - self.assertEquals(_g_results, []) + self.assertEqual(_g_results, []) gt.kill() self.assert_dead(gt) @@ -60,7 +60,7 @@ class Spawn(LimitedTestCase, Asserts): greenthread.kill(gt) self.assert_dead(gt) greenthread.sleep(0.001) - self.assertEquals(_g_results, []) + self.assertEqual(_g_results, []) greenthread.kill(gt) self.assert_dead(gt) @@ -72,8 +72,8 @@ class Spawn(LimitedTestCase, Asserts): results.append(kw) gt = greenthread.spawn(passthru, 5) gt.link(link_func, 4, b=5) - self.assertEquals(gt.wait(), ((5,), {})) - self.assertEquals(results, [gt, (4,), {'b':5}]) + self.assertEqual(gt.wait(), ((5,), {})) + self.assertEqual(results, [gt, (4,), {'b':5}]) def test_link_after_exited(self): results = [] @@ -82,9 +82,9 @@ class Spawn(LimitedTestCase, Asserts): results.append(a) results.append(kw) gt = greenthread.spawn(passthru, 5) - self.assertEquals(gt.wait(), ((5,), {})) + self.assertEqual(gt.wait(), ((5,), {})) gt.link(link_func, 4, b=5) - self.assertEquals(results, [gt, (4,), {'b':5}]) + self.assertEqual(results, [gt, (4,), {'b':5}]) def test_link_relinks(self): # test that linking in a linked func doesn't cause infinite recursion. @@ -99,12 +99,12 @@ class Spawn(LimitedTestCase, Asserts): gt = greenthread.spawn(passthru) gt.link(link_func) gt.wait() - self.assertEquals(called, [True]) + self.assertEqual(called, [True]) class SpawnAfter(Spawn): def test_basic(self): gt = greenthread.spawn_after(0.1, passthru, 20) - self.assertEquals(gt.wait(), ((20,), {})) + self.assertEqual(gt.wait(), ((20,), {})) def test_cancel(self): gt = greenthread.spawn_after(0.1, passthru, 21) @@ -115,7 +115,7 @@ class SpawnAfter(Spawn): gt = greenthread.spawn_after(0, waiter, 22) greenthread.sleep(0) gt.cancel() - self.assertEquals(gt.wait(), 22) + self.assertEqual(gt.wait(), 22) def test_kill_already_started(self): gt = greenthread.spawn_after(0, waiter, 22) diff --git a/tests/hub_test.py b/tests/hub_test.py index a3aae7f..b7f307d 100644 --- a/tests/hub_test.py +++ b/tests/hub_test.py @@ -1,12 +1,12 @@ from __future__ import with_statement import sys +import tests from tests import LimitedTestCase, main, skip_with_pyevent, skip_if_no_itimer, skip_unless from tests.patcher_test import ProcessBase import time import eventlet from eventlet import hubs -from eventlet.green import socket from eventlet.event import Event from eventlet.semaphore import Semaphore from eventlet.support import greenlets, six @@ -108,7 +108,7 @@ class TestScheduleCall(LimitedTestCase): hubs.get_hub().schedule_call_global(DELAY, lst.append, 2) while len(lst) < 3: eventlet.sleep(DELAY) - self.assertEquals(lst, [1, 2, 3]) + self.assertEqual(lst, [1, 2, 3]) class TestDebug(LimitedTestCase): @@ -250,6 +250,8 @@ class TestHubBlockingDetector(LimitedTestCase): class TestSuspend(LimitedTestCase): TEST_TIMEOUT = 3 + longMessage = True + maxDiff = None def test_suspend_doesnt_crash(self): import os @@ -279,8 +281,8 @@ except eventlet.Timeout: os.kill(p.pid, signal.SIGSTOP) # suspend and resume to generate EINTR os.kill(p.pid, signal.SIGCONT) output, _ = p.communicate() - lines = [l for l in output.split("\n") if l] - self.assert_("exited correctly" in lines[-1]) + lines = output.decode('utf-8', 'replace').splitlines() + self.assert_("exited correctly" in lines[-1], output) shutil.rmtree(self.tempdir) @@ -293,39 +295,13 @@ class TestBadFilenos(LimitedTestCase): self.assertRaises(ValueError, select.select, [-1], [], []) -class TestFork(ProcessBase): +class TestFork(LimitedTestCase): @skip_with_pyevent def test_fork(self): - new_mod = """ -import os -import eventlet -server = eventlet.listen(('localhost', 12345)) -t = eventlet.Timeout(0.01) -try: - new_sock, address = server.accept() -except eventlet.Timeout as t: - pass - -pid = os.fork() -if not pid: - t = eventlet.Timeout(0.1) - try: - new_sock, address = server.accept() - except eventlet.Timeout as t: - print("accept blocked") - -else: - kpid, status = os.wait() - assert kpid == pid - assert status == 0 - print("child died ok") -""" - self.write_to_tempfile("newmod", new_mod) - output, lines = self.launch_subprocess('newmod.py') - self.assertEqual(len(lines), 3, output) - self.assert_("accept blocked" in lines[0]) - self.assert_("child died ok" in lines[1]) + output = tests.run_python('tests/hub_test_fork.py') + lines = output.splitlines() + self.assertEqual(lines, ["accept blocked", "child died ok"], output) class TestDeadRunLoop(LimitedTestCase): diff --git a/tests/hub_test_fork.py b/tests/hub_test_fork.py new file mode 100644 index 0000000..f886a96 --- /dev/null +++ b/tests/hub_test_fork.py @@ -0,0 +1,25 @@ +# no standard tests in this file, ignore +__test__ = False + +if __name__ == '__main__': + import os + import eventlet + server = eventlet.listen(('localhost', 12345)) + t = eventlet.Timeout(0.01) + try: + new_sock, address = server.accept() + except eventlet.Timeout as t: + pass + + pid = os.fork() + if not pid: + t = eventlet.Timeout(0.1) + try: + new_sock, address = server.accept() + except eventlet.Timeout as t: + print("accept blocked") + else: + kpid, status = os.wait() + assert kpid == pid + assert status == 0 + print("child died ok") diff --git a/tests/mysqldb_test.py b/tests/mysqldb_test.py index cfc9940..c4a77b0 100644 --- a/tests/mysqldb_test.py +++ b/tests/mysqldb_test.py @@ -122,14 +122,18 @@ class TestMySQLdb(LimitedTestCase): gt = eventlet.spawn(tick) curs.execute("select 1") rows = curs.fetchall() - self.assertEqual(rows, ((1L,),)) + self.assertEqual(len(rows), 1) + self.assertEqual(len(rows[0]), 1) + self.assertEqual(rows[0][0], 1) self.assert_(counter[0] > 0, counter[0]) gt.kill() def assert_cursor_works(self, cursor): cursor.execute("select 1") rows = cursor.fetchall() - self.assertEqual(rows, ((1L,),)) + self.assertEqual(len(rows), 1) + self.assertEqual(len(rows[0]), 1) + self.assertEqual(rows[0][0], 1) self.assert_cursor_yields(cursor) def assert_connection_works(self, conn): diff --git a/tests/pools_test.py b/tests/pools_test.py index f53d018..7ace0dc 100644 --- a/tests/pools_test.py +++ b/tests/pools_test.py @@ -28,17 +28,17 @@ class TestIntPool(TestCase): # with self.pool.some_api_name() as thing: # # do stuff - self.assertEquals(self.pool.get(), 1) - self.assertEquals(self.pool.get(), 2) - self.assertEquals(self.pool.get(), 3) - self.assertEquals(self.pool.get(), 4) + self.assertEqual(self.pool.get(), 1) + self.assertEqual(self.pool.get(), 2) + self.assertEqual(self.pool.get(), 3) + self.assertEqual(self.pool.get(), 4) def test_free(self): - self.assertEquals(self.pool.free(), 4) + self.assertEqual(self.pool.free(), 4) gotten = self.pool.get() - self.assertEquals(self.pool.free(), 3) + self.assertEqual(self.pool.free(), 3) self.pool.put(gotten) - self.assertEquals(self.pool.free(), 4) + self.assertEqual(self.pool.free(), 4) def test_exhaustion(self): waiter = Queue(0) @@ -53,7 +53,7 @@ class TestIntPool(TestCase): one, two, three, four = ( self.pool.get(), self.pool.get(), self.pool.get(), self.pool.get()) - self.assertEquals(self.pool.free(), 0) + self.assertEqual(self.pool.free(), 0) # Let consumer run; nothing will be in the pool, so he will wait eventlet.sleep(0) @@ -62,7 +62,7 @@ class TestIntPool(TestCase): self.pool.put(one) # wait for the consumer - self.assertEquals(waiter.get(), one) + self.assertEqual(waiter.get(), one) def test_blocks_on_pool(self): waiter = Queue(0) @@ -72,7 +72,7 @@ class TestIntPool(TestCase): self.pool.get() self.pool.get() # No one should be waiting yet. - self.assertEquals(self.pool.waiting(), 0) + self.assertEqual(self.pool.waiting(), 0) # The call to the next get will unschedule this routine. self.pool.get() # So this put should never be called. @@ -81,13 +81,13 @@ class TestIntPool(TestCase): killable = eventlet.spawn(greedy) # no one should be waiting yet. - self.assertEquals(self.pool.waiting(), 0) + self.assertEqual(self.pool.waiting(), 0) ## Wait for greedy eventlet.sleep(0) ## Greedy should be blocking on the last get - self.assertEquals(self.pool.waiting(), 1) + self.assertEqual(self.pool.waiting(), 1) ## Send will never be called, so balance should be 0. self.assertFalse(not waiter.full()) @@ -100,8 +100,8 @@ class TestIntPool(TestCase): one, two = self.pool.get(), self.pool.get() self.pool.put(one) self.pool.put(two) - self.assertEquals(self.pool.get(), one) - self.assertEquals(self.pool.get(), two) + self.assertEqual(self.pool.get(), one) + self.assertEqual(self.pool.get(), two) def test_putting_to_queue(self): timer = eventlet.Timeout(0.1) @@ -128,17 +128,17 @@ class TestIntPool(TestCase): pool = IntPool(max_size=2) a = pool.get() b = pool.get() - self.assertEquals(pool.free(), 0) + self.assertEqual(pool.free(), 0) # verify that the pool discards excess items put into it pool.resize(1) pool.put(a) pool.put(b) - self.assertEquals(pool.free(), 1) + self.assertEqual(pool.free(), 1) # resize larger and assert that there are more free items pool.resize(2) - self.assertEquals(pool.free(), 2) + self.assertEqual(pool.free(), 2) def test_create_contention(self): creates = [0] @@ -151,14 +151,14 @@ class TestIntPool(TestCase): def do_get(): x = p.get() - self.assertEquals(x, "slept") + self.assertEqual(x, "slept") p.put(x) gp = eventlet.GreenPool() for i in six.moves.range(100): gp.spawn_n(do_get) gp.waitall() - self.assertEquals(creates[0], 4) + self.assertEqual(creates[0], 4) class TestAbstract(TestCase): @@ -176,11 +176,11 @@ class TestIntPool2(TestCase): self.pool = IntPool(min_size=3, max_size=3) def test_something(self): - self.assertEquals(len(self.pool.free_items), 3) + self.assertEqual(len(self.pool.free_items), 3) ## Cover the clause in get where we get from the free list instead of creating ## an item on get gotten = self.pool.get() - self.assertEquals(gotten, 1) + self.assertEqual(gotten, 1) class TestOrderAsStack(TestCase): @@ -193,8 +193,8 @@ class TestOrderAsStack(TestCase): one, two = self.pool.get(), self.pool.get() self.pool.put(one) self.pool.put(two) - self.assertEquals(self.pool.get(), two) - self.assertEquals(self.pool.get(), one) + self.assertEqual(self.pool.get(), two) + self.assertEqual(self.pool.get(), one) class RaisePool(pools.Pool): @@ -208,9 +208,9 @@ class TestCreateRaises(TestCase): self.pool = RaisePool(max_size=3) def test_it(self): - self.assertEquals(self.pool.free(), 3) + self.assertEqual(self.pool.free(), 3) self.assertRaises(RuntimeError, self.pool.get) - self.assertEquals(self.pool.free(), 3) + self.assertEqual(self.pool.free(), 3) ALWAYS = RuntimeError('I always fail') diff --git a/tests/processes_test.py b/tests/processes_test.py index 0169739..a5eef89 100644 --- a/tests/processes_test.py +++ b/tests/processes_test.py @@ -20,7 +20,7 @@ class TestEchoPool(LimitedTestCase): result = proc.read() finally: self.pool.put(proc) - self.assertEquals(result, 'hello\n') + self.assertEqual(result, 'hello\n') @skip_on_windows def test_read_eof(self): @@ -34,7 +34,7 @@ class TestEchoPool(LimitedTestCase): @skip_on_windows def test_empty_echo(self): p = processes.Process('echo', ['-n']) - self.assertEquals('', p.read()) + self.assertEqual('', p.read()) self.assertRaises(processes.DeadProcess, p.read) @@ -56,7 +56,7 @@ class TestCatPool(LimitedTestCase): finally: self.pool.put(proc) - self.assertEquals(result, 'goodbye') + self.assertEqual(result, 'goodbye') @skip_on_windows def test_write_to_dead(self): @@ -95,7 +95,7 @@ class TestDyingProcessesLeavePool(LimitedTestCase): try: try: result = proc.read() - self.assertEquals(result, 'hello\n') + self.assertEqual(result, 'hello\n') result = proc.read() except processes.DeadProcess: pass diff --git a/tests/queue_test.py b/tests/queue_test.py index dea7192..60527a2 100644 --- a/tests/queue_test.py +++ b/tests/queue_test.py @@ -14,12 +14,12 @@ class TestQueue(LimitedTestCase): def test_send_first(self): q = eventlet.Queue() q.put('hi') - self.assertEquals(q.get(), 'hi') + self.assertEqual(q.get(), 'hi') def test_send_last(self): q = eventlet.Queue() def waiter(q): - self.assertEquals(q.get(), 'hi2') + self.assertEqual(q.get(), 'hi2') gt = eventlet.spawn(eventlet.with_timeout, 0.1, waiter, q) eventlet.sleep(0) @@ -41,12 +41,12 @@ class TestQueue(LimitedTestCase): gt = eventlet.spawn(putter, q) eventlet.sleep(0) - self.assertEquals(results, ['a', 'b']) - self.assertEquals(q.get(), 'a') + self.assertEqual(results, ['a', 'b']) + self.assertEqual(q.get(), 'a') eventlet.sleep(0) - self.assertEquals(results, ['a', 'b', 'c']) - self.assertEquals(q.get(), 'b') - self.assertEquals(q.get(), 'c') + self.assertEqual(results, ['a', 'b', 'c']) + self.assertEqual(q.get(), 'b') + self.assertEqual(q.get(), 'c') gt.wait() def test_zero_max_size(self): @@ -64,8 +64,8 @@ class TestQueue(LimitedTestCase): eventlet.sleep(0) self.assert_(not evt.ready()) gt2 = eventlet.spawn(receiver, q) - self.assertEquals(gt2.wait(),'hi') - self.assertEquals(evt.wait(),'done') + self.assertEqual(gt2.wait(),'hi') + self.assertEqual(evt.wait(),'done') gt.wait() def test_resize_up(self): @@ -90,10 +90,10 @@ class TestQueue(LimitedTestCase): for i in range(5): q.put(i) - self.assertEquals(list(q.queue), list(range(5))) + self.assertEqual(list(q.queue), list(range(5))) q.resize(1) eventlet.sleep(0) - self.assertEquals(list(q.queue), list(range(5))) + self.assertEqual(list(q.queue), list(range(5))) def test_resize_to_Unlimited(self): q = eventlet.Queue(0) @@ -127,21 +127,21 @@ class TestQueue(LimitedTestCase): results = set() for i, gt in enumerate(gts): results.add(gt.wait()) - self.assertEquals(results, set(sendings)) + self.assertEqual(results, set(sendings)) def test_waiters_that_cancel(self): q = eventlet.Queue() gt = eventlet.spawn(do_bail, q) - self.assertEquals(gt.wait(), 'timed out') + self.assertEqual(gt.wait(), 'timed out') q.put('hi') - self.assertEquals(q.get(), 'hi') + self.assertEqual(q.get(), 'hi') def test_getting_before_sending(self): q = eventlet.Queue() gt = eventlet.spawn(q.put, 'sent') - self.assertEquals(q.get(), 'sent') + self.assertEqual(q.get(), 'sent') gt.wait() def test_two_waiters_one_dies(self): @@ -153,8 +153,8 @@ class TestQueue(LimitedTestCase): waiting = eventlet.spawn(waiter, q) eventlet.sleep(0) q.put('hi') - self.assertEquals(dying.wait(), 'timed out') - self.assertEquals(waiting.wait(), 'hi') + self.assertEqual(dying.wait(), 'timed out') + self.assertEqual(waiting.wait(), 'hi') def test_two_bogus_waiters(self): q = eventlet.Queue() @@ -162,20 +162,20 @@ class TestQueue(LimitedTestCase): gt2 = eventlet.spawn(do_bail, q) eventlet.sleep(0) q.put('sent') - self.assertEquals(gt1.wait(), 'timed out') - self.assertEquals(gt2.wait(), 'timed out') - self.assertEquals(q.get(), 'sent') + self.assertEqual(gt1.wait(), 'timed out') + self.assertEqual(gt2.wait(), 'timed out') + self.assertEqual(q.get(), 'sent') def test_waiting(self): q = eventlet.Queue() gt1 = eventlet.spawn(q.get) eventlet.sleep(0) - self.assertEquals(1, q.getting()) + self.assertEqual(1, q.getting()) q.put('hi') eventlet.sleep(0) - self.assertEquals(0, q.getting()) - self.assertEquals('hi', gt1.wait()) - self.assertEquals(0, q.getting()) + self.assertEqual(0, q.getting()) + self.assertEqual('hi', gt1.wait()) + self.assertEqual(0, q.getting()) def test_channel_send(self): channel = eventlet.Queue(0) @@ -222,7 +222,7 @@ class TestQueue(LimitedTestCase): w2 = eventlet.spawn(c.get) w3 = eventlet.spawn(c.get) eventlet.sleep(0) - self.assertEquals(c.getting(), 3) + self.assertEqual(c.getting(), 3) s1 = eventlet.spawn(c.put, 1) s2 = eventlet.spawn(c.put, 2) s3 = eventlet.spawn(c.put, 3) @@ -230,10 +230,10 @@ class TestQueue(LimitedTestCase): s1.wait() s2.wait() s3.wait() - self.assertEquals(c.getting(), 0) + self.assertEqual(c.getting(), 0) # NOTE: we don't guarantee that waiters are served in order results = sorted([w1.wait(), w2.wait(), w3.wait()]) - self.assertEquals(results, [1,2,3]) + self.assertEqual(results, [1,2,3]) def test_channel_sender_timing_out(self): from eventlet import queue diff --git a/tests/ssl_test.py b/tests/ssl_test.py index a50ed17..73b9b43 100644 --- a/tests/ssl_test.py +++ b/tests/ssl_test.py @@ -46,7 +46,7 @@ class SSLTest(LimitedTestCase): client = util.wrap_ssl(eventlet.connect(('127.0.0.1', sock.getsockname()[1]))) client.write(b'line 1\r\nline 2\r\n\r\n') - self.assertEquals(client.read(8192), b'response') + self.assertEqual(client.read(8192), b'response') server_coro.wait() @skip_if_no_ssl @@ -55,7 +55,7 @@ class SSLTest(LimitedTestCase): sock, addr = listener.accept() sock.read(8192) try: - self.assertEquals(b"", sock.read(8192)) + self.assertEqual(b"", sock.read(8192)) except greenio.SSL.ZeroReturnError: pass @@ -90,13 +90,13 @@ class SSLTest(LimitedTestCase): def test_ssl_unwrap(self): def serve(): sock, addr = listener.accept() - self.assertEquals(sock.recv(6), b'before') + self.assertEqual(sock.recv(6), b'before') sock_ssl = util.wrap_ssl(sock, certificate_file, private_key_file, server_side=True) sock_ssl.do_handshake() - self.assertEquals(sock_ssl.read(6), b'during') + self.assertEqual(sock_ssl.read(6), b'during') sock2 = sock_ssl.unwrap() - self.assertEquals(sock2.recv(5), b'after') + self.assertEqual(sock2.recv(5), b'after') sock2.close() listener = eventlet.listen(('127.0.0.1', 0)) @@ -160,8 +160,8 @@ class SSLTest(LimitedTestCase): listener = listen_ssl_socket(('', 0)) eventlet.spawn(serve, listener) client = ssl(eventlet.connect(('localhost', listener.getsockname()[1]))) - self.assertEquals(client.read(1024), b'content') - self.assertEquals(client.read(1024), b'') + self.assertEqual(client.read(1024), b'content') + self.assertEqual(client.read(1024), b'') @skip_if_no_ssl def test_regression_gh_17(self): diff --git a/tests/test__coros_queue.py b/tests/test__coros_queue.py index 3ebf441..9cb8663 100644 --- a/tests/test__coros_queue.py +++ b/tests/test__coros_queue.py @@ -11,7 +11,7 @@ class TestQueue(LimitedTestCase): def test_send_first(self): q = coros.queue() q.send('hi') - self.assertEquals(q.wait(), 'hi') + self.assertEqual(q.wait(), 'hi') @silence_warnings def test_send_exception_first(self): @@ -24,7 +24,7 @@ class TestQueue(LimitedTestCase): q = coros.queue() def waiter(q): timer = eventlet.Timeout(0.1) - self.assertEquals(q.wait(), 'hi2') + self.assertEqual(q.wait(), 'hi2') timer.cancel() spawn(waiter, q) @@ -47,12 +47,12 @@ class TestQueue(LimitedTestCase): spawn(putter, q) sleep(0) - self.assertEquals(results, ['a', 'b']) - self.assertEquals(q.wait(), 'a') + self.assertEqual(results, ['a', 'b']) + self.assertEqual(q.wait(), 'a') sleep(0) - self.assertEquals(results, ['a', 'b', 'c']) - self.assertEquals(q.wait(), 'b') - self.assertEquals(q.wait(), 'c') + self.assertEqual(results, ['a', 'b', 'c']) + self.assertEqual(q.wait(), 'b') + self.assertEqual(q.wait(), 'c') @silence_warnings def test_zero_max_size(self): @@ -72,8 +72,8 @@ class TestQueue(LimitedTestCase): sleep(0) self.assert_(not e1.ready()) spawn(receiver, e2, q) - self.assertEquals(e2.wait(),'hi') - self.assertEquals(e1.wait(),'done') + self.assertEqual(e2.wait(),'hi') + self.assertEqual(e1.wait(),'done') @silence_warnings def test_multiple_waiters(self): @@ -93,7 +93,7 @@ class TestQueue(LimitedTestCase): results = set() for i, gt in enumerate(gts): results.add(gt.wait()) - self.assertEquals(results, set(sendings)) + self.assertEqual(results, set(sendings)) @silence_warnings def test_waiters_that_cancel(self): @@ -110,10 +110,10 @@ class TestQueue(LimitedTestCase): evt = Event() spawn(do_receive, q, evt) - self.assertEquals(evt.wait(), 'timed out') + self.assertEqual(evt.wait(), 'timed out') q.send('hi') - self.assertEquals(q.wait(), 'hi') + self.assertEqual(q.wait(), 'hi') @silence_warnings def test_senders_that_die(self): @@ -123,7 +123,7 @@ class TestQueue(LimitedTestCase): q.send('sent') spawn(do_send, q) - self.assertEquals(q.wait(), 'sent') + self.assertEqual(q.wait(), 'sent') @silence_warnings def test_two_waiters_one_dies(self): @@ -144,8 +144,8 @@ class TestQueue(LimitedTestCase): spawn(waiter, q, waiting_evt) sleep(0) q.send('hi') - self.assertEquals(dying_evt.wait(), 'timed out') - self.assertEquals(waiting_evt.wait(), 'hi') + self.assertEqual(dying_evt.wait(), 'timed out') + self.assertEqual(waiting_evt.wait(), 'hi') @silence_warnings def test_two_bogus_waiters(self): @@ -164,9 +164,9 @@ class TestQueue(LimitedTestCase): spawn(do_receive, q, e2) sleep(0) q.send('sent') - self.assertEquals(e1.wait(), 'timed out') - self.assertEquals(e2.wait(), 'timed out') - self.assertEquals(q.wait(), 'sent') + self.assertEqual(e1.wait(), 'timed out') + self.assertEqual(e2.wait(), 'timed out') + self.assertEqual(q.wait(), 'sent') @silence_warnings def test_waiting(self): @@ -178,12 +178,12 @@ class TestQueue(LimitedTestCase): e1 = Event() spawn(do_wait, q, e1) sleep(0) - self.assertEquals(1, q.waiting()) + self.assertEqual(1, q.waiting()) q.send('hi') sleep(0) - self.assertEquals(0, q.waiting()) - self.assertEquals('hi', e1.wait()) - self.assertEquals(0, q.waiting()) + self.assertEqual(0, q.waiting()) + self.assertEqual('hi', e1.wait()) + self.assertEqual(0, q.waiting()) class TestChannel(LimitedTestCase): @@ -240,19 +240,19 @@ class TestChannel(LimitedTestCase): w2 = eventlet.spawn(c.wait) w3 = eventlet.spawn(c.wait) sleep(0) - self.assertEquals(c.waiting(), 3) + self.assertEqual(c.waiting(), 3) s1 = eventlet.spawn(c.send, 1) s2 = eventlet.spawn(c.send, 2) s3 = eventlet.spawn(c.send, 3) sleep(0) # this gets all the sends into a waiting state - self.assertEquals(c.waiting(), 0) + self.assertEqual(c.waiting(), 0) s1.wait() s2.wait() s3.wait() # NOTE: we don't guarantee that waiters are served in order results = sorted([w1.wait(), w2.wait(), w3.wait()]) - self.assertEquals(results, [1,2,3]) + self.assertEqual(results, [1,2,3]) if __name__=='__main__': main() diff --git a/tests/test__pool.py b/tests/test__pool.py index 94482c0..ab2d969 100644 --- a/tests/test__pool.py +++ b/tests/test__pool.py @@ -68,7 +68,7 @@ class TestCoroutinePool(LimitedTestCase): done = pool.execute(consumer) pool.execute_async(producer) done.wait() - self.assertEquals(['cons1', 'prod', 'cons2'], results) + self.assertEqual(['cons1', 'prod', 'cons2'], results) def test_timer_cancel(self): # this test verifies that local timers are not fired @@ -82,7 +82,7 @@ class TestCoroutinePool(LimitedTestCase): worker = pool.execute(some_work) worker.wait() api.sleep(0) - self.assertEquals(timer_fired, []) + self.assertEqual(timer_fired, []) def test_reentrant(self): pool = self.klass(0,1) @@ -131,7 +131,7 @@ class TestCoroutinePool(LimitedTestCase): e.wait() pool.execute(wait_long_time, evt) pool.execute(wait_long_time, evt) - self.assertEquals(pool.free(), 0) + self.assertEqual(pool.free(), 0) self.assert_pool_has_free(pool, 0) # verify that the pool discards excess items put into it @@ -143,12 +143,12 @@ class TestCoroutinePool(LimitedTestCase): api.sleep(0) api.sleep(0) - self.assertEquals(pool.free(), 1) + self.assertEqual(pool.free(), 1) self.assert_pool_has_free(pool, 1) # resize larger and assert that there are more free items pool.resize(2) - self.assertEquals(pool.free(), 2) + self.assertEqual(pool.free(), 2) self.assert_pool_has_free(pool, 2) def test_stderr_raising(self): @@ -199,7 +199,7 @@ class TestCoroutinePool(LimitedTestCase): api.sleep(0.1) return 'ok' pool.execute(slow) - self.assertEquals(pool.wait(), 'ok') + self.assertEqual(pool.wait(), 'ok') def test_pool_smash(self): # The premise is that a coroutine in a Pool tries to get a token out @@ -220,7 +220,7 @@ class TestCoroutinePool(LimitedTestCase): # the execute makes the token pool expect that coroutine, but then # immediately cuts bait e1 = pool.execute(do_receive, tp) - self.assertEquals(e1.wait(), 'timed out') + self.assertEqual(e1.wait(), 'timed out') # the pool can get some random item back def send_wakeup(tp): @@ -232,10 +232,10 @@ class TestCoroutinePool(LimitedTestCase): def resume(): return 'resumed' e2 = pool.execute(resume) - self.assertEquals(e2.wait(), 'resumed') + self.assertEqual(e2.wait(), 'resumed') # we should be able to get out the thing we put in there, too - self.assertEquals(tp.get(), 'wakeup') + self.assertEqual(tp.get(), 'wakeup') class PoolBasicTests(LimitedTestCase): diff --git a/tests/thread_test.py b/tests/thread_test.py index 98665cf..e54f022 100644 --- a/tests/thread_test.py +++ b/tests/thread_test.py @@ -84,16 +84,16 @@ class Locals(LimitedTestCase): my_local = Caller() my_local.foo = "foo1" - self.assertEquals("foo1", my_local.callme()) + self.assertEqual("foo1", my_local.callme()) def do_something(): my_local.foo = "foo2" - self.assertEquals("foo2", my_local.callme()) + self.assertEqual("foo2", my_local.callme()) eventlet.spawn(do_something).wait() my_local.foo = "foo3" - self.assertEquals("foo3", my_local.callme()) + self.assertEqual("foo3", my_local.callme()) def test_no_leaking(self): refs = weakref.WeakKeyDictionary() diff --git a/tests/tpool_test.py b/tests/tpool_test.py index 5423b54..a699309 100644 --- a/tests/tpool_test.py +++ b/tests/tpool_test.py @@ -14,17 +14,15 @@ # limitations under the License. from __future__ import print_function -import itertools -import random -from sys import stdout -import time -import re import gc -from tests import skipped, skip_with_pyevent, LimitedTestCase, main +import random +import re +import time -from eventlet import tpool, debug -from eventlet.support import six import eventlet +from eventlet import tpool +from eventlet.support import six +from tests import LimitedTestCase, skipped, skip_with_pyevent, main one = 1 @@ -68,8 +66,10 @@ class TestTpool(LimitedTestCase): @skip_with_pyevent def test_wrap_uniterable(self): prox = tpool.Proxy([]) + def index(): prox[0] + def key(): prox['a'] @@ -78,7 +78,7 @@ class TestTpool(LimitedTestCase): @skip_with_pyevent def test_wrap_dict(self): - my_object = {'a':1} + my_object = {'a': 1} prox = tpool.Proxy(my_object) self.assertEqual('a', prox.keys()[0]) self.assertEqual(1, prox['a']) @@ -111,9 +111,9 @@ class TestTpool(LimitedTestCase): def test_wrap_hash(self): prox1 = tpool.Proxy(''+'A') prox2 = tpool.Proxy('A'+'') - self.assert_(prox1=='A') - self.assert_('A'==prox2) - #self.assert_(prox1==prox2) FIXME - could __eq__ unwrap rhs if it is other proxy? + self.assert_(prox1 == 'A') + self.assert_('A' == prox2) + #self.assert_(prox1 == prox2) FIXME - could __eq__ unwrap rhs if it is other proxy? self.assertEqual(hash(prox1), hash(prox2)) proxList = tpool.Proxy([]) self.assertRaises(TypeError, hash, proxList) @@ -130,19 +130,19 @@ class TestTpool(LimitedTestCase): def test_multiple_wraps(self): prox1 = tpool.Proxy(re) prox2 = tpool.Proxy(re) - x1 = prox1.compile('.') + prox1.compile('.') x2 = prox1.compile('.') del x2 - x3 = prox2.compile('.') + prox2.compile('.') @skip_with_pyevent def test_wrap_getitem(self): - prox = tpool.Proxy([0,1,2]) + prox = tpool.Proxy([0, 1, 2]) self.assertEqual(prox[0], 0) @skip_with_pyevent def test_wrap_setitem(self): - prox = tpool.Proxy([0,1,2]) + prox = tpool.Proxy([0, 1, 2]) prox[1] = 2 self.assertEqual(prox[1], 2) @@ -153,11 +153,12 @@ class TestTpool(LimitedTestCase): result = [] for i in prox: result.append(i) - self.assertEquals(list(range(10)), result) + self.assertEqual(list(range(10)), result) @skip_with_pyevent def test_wrap_iterator2(self): self.reset_timeout(5) # might take a while due to imprecise sleeping + def foo(): import time for x in range(2): @@ -165,9 +166,10 @@ class TestTpool(LimitedTestCase): time.sleep(0.001) counter = [0] + def tick(): for i in six.moves.range(20000): - counter[0]+=1 + counter[0] += 1 if counter[0] % 20 == 0: eventlet.sleep(0.0001) else: @@ -185,6 +187,7 @@ class TestTpool(LimitedTestCase): @skip_with_pyevent def test_raising_exceptions(self): prox = tpool.Proxy(re) + def nofunc(): prox.never_name_a_function_like_this() self.assertRaises(AttributeError, nofunc) @@ -197,8 +200,8 @@ class TestTpool(LimitedTestCase): def test_variable_and_keyword_arguments_with_function_calls(self): import optparse parser = tpool.Proxy(optparse.OptionParser()) - z = parser.add_option('-n', action='store', type='string', dest='n') - opts,args = parser.parse_args(["-nfoo"]) + parser.add_option('-n', action='store', type='string', dest='n') + opts, args = parser.parse_args(["-nfoo"]) self.assertEqual(opts.n, 'foo') @skip_with_pyevent @@ -207,11 +210,11 @@ class TestTpool(LimitedTestCase): prox = tpool.Proxy(tpool_test) pile = eventlet.GreenPile(4) - pile.spawn(lambda: self.assertEquals(prox.one, 1)) - pile.spawn(lambda: self.assertEquals(prox.two, 2)) - pile.spawn(lambda: self.assertEquals(prox.three, 3)) + pile.spawn(lambda: self.assertEqual(prox.one, 1)) + pile.spawn(lambda: self.assertEqual(prox.two, 2)) + pile.spawn(lambda: self.assertEqual(prox.three, 3)) results = list(pile) - self.assertEquals(len(results), 3) + self.assertEqual(len(results), 3) @skip_with_pyevent def test_timeout(self): @@ -227,7 +230,7 @@ class TestTpool(LimitedTestCase): @skip_with_pyevent def test_autowrap(self): - x = tpool.Proxy({'a':1, 'b':2}, autowrap=(int,)) + x = tpool.Proxy({'a': 1, 'b': 2}, autowrap=(int,)) self.assert_(isinstance(x.get('a'), tpool.Proxy)) self.assert_(not isinstance(x.items(), tpool.Proxy)) # attributes as well as callables @@ -238,7 +241,7 @@ class TestTpool(LimitedTestCase): @skip_with_pyevent def test_autowrap_names(self): - x = tpool.Proxy({'a':1, 'b':2}, autowrap_names=('get',)) + x = tpool.Proxy({'a': 1, 'b': 2}, autowrap_names=('get',)) self.assert_(isinstance(x.get('a'), tpool.Proxy)) self.assert_(not isinstance(x.items(), tpool.Proxy)) from tests import tpool_test @@ -259,11 +262,11 @@ class TestTpool(LimitedTestCase): def wrapped(arg): return arg x = tpool.Proxy(wrapped) - self.assertEquals(4, x(4)) + self.assertEqual(4, x(4)) # verify that it wraps return values if specified x = tpool.Proxy(wrapped, autowrap_names=('__call__',)) self.assert_(isinstance(x(4), tpool.Proxy)) - self.assertEquals("4", str(x(4))) + self.assertEqual("4", str(x(4))) @skip_with_pyevent def test_callable_iterator(self): @@ -274,7 +277,7 @@ class TestTpool(LimitedTestCase): x = tpool.Proxy(wrapped, autowrap_names=('__call__',)) for r in x(3): - self.assertEquals(3, r) + self.assertEqual(3, r) @skip_with_pyevent def test_eventlet_timeout(self): @@ -285,15 +288,18 @@ class TestTpool(LimitedTestCase): @skip_with_pyevent def test_tpool_set_num_threads(self): tpool.set_num_threads(5) - self.assertEquals(5, tpool._nthreads) + self.assertEqual(5, tpool._nthreads) + class TpoolLongTests(LimitedTestCase): - TEST_TIMEOUT=60 + TEST_TIMEOUT = 60 + @skip_with_pyevent def test_a_buncha_stuff(self): assert_ = self.assert_ + class Dummy(object): - def foo(self,when,token=None): + def foo(self, when, token=None): assert_(token is not None) time.sleep(random.random()/200.0) return token @@ -305,16 +311,16 @@ class TpoolLongTests(LimitedTestCase): eventlet.sleep(random.random()/200.0) now = time.time() token = loopnum * count + n - rv = obj.foo(now,token=token) - self.assertEquals(token, rv) + rv = obj.foo(now, token=token) + self.assertEqual(token, rv) eventlet.sleep(random.random()/200.0) cnt = 10 pile = eventlet.GreenPile(cnt) for i in six.moves.range(cnt): - pile.spawn(sender_loop,i) + pile.spawn(sender_loop, i) results = list(pile) - self.assertEquals(len(results), cnt) + self.assertEqual(len(results), cnt) tpool.killall() @skipped diff --git a/tests/wsgi_test.py b/tests/wsgi_test.py index 53206a8..5bc71b0 100644 --- a/tests/wsgi_test.py +++ b/tests/wsgi_test.py @@ -447,7 +447,7 @@ class TestHttpd(_TestBase): sock = eventlet.wrap_ssl(sock) sock.write('POST /foo HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nContent-length:3\r\n\r\nabc') result = sock.read(8192) - self.assertEquals(result[-3:], 'abc') + self.assertEqual(result[-3:], 'abc') @skip_if_no_ssl def test_013_empty_return(self): @@ -467,7 +467,7 @@ class TestHttpd(_TestBase): sock = eventlet.wrap_ssl(sock) sock.write('GET /foo HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n') result = sock.read(8192) - self.assertEquals(result[-4:], '\r\n\r\n') + self.assertEqual(result[-4:], '\r\n\r\n') def test_014_chunked_post(self): self.site.application = chunked_post @@ -544,7 +544,7 @@ class TestHttpd(_TestBase): break else: header_lines.append(line) - self.assertEquals(1, len( + self.assertEqual(1, len( [l for l in header_lines if l.lower().startswith('content-length')])) @skip_if_no_ssl @@ -748,8 +748,8 @@ class TestHttpd(_TestBase): fd.write('PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 1025\r\nExpect: 100-continue\r\n\r\n') fd.flush() result = read_http(sock) - self.assertEquals(result.status, 'HTTP/1.1 417 Expectation Failed') - self.assertEquals(result.body, 'failure') + self.assertEqual(result.status, 'HTTP/1.1 417 Expectation Failed') + self.assertEqual(result.body, 'failure') fd.write('PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 7\r\nExpect: 100-continue\r\n\r\ntesting') fd.flush() header_lines = [] @@ -768,7 +768,7 @@ class TestHttpd(_TestBase): else: header_lines.append(line) self.assert_(header_lines[0].startswith('HTTP/1.1 200 OK')) - self.assertEquals(fd.read(7), 'testing') + self.assertEqual(fd.read(7), 'testing') fd.close() sock.close() @@ -787,7 +787,7 @@ class TestHttpd(_TestBase): eventlet.connect(('localhost', self.port)) self.fail("Didn't expect to connect") except socket.error as exc: - self.assertEquals(get_errno(exc), errno.ECONNREFUSED) + self.assertEqual(get_errno(exc), errno.ECONNREFUSED) self.assert_('Invalid argument' in self.logfile.getvalue(), self.logfile.getvalue()) @@ -815,7 +815,7 @@ class TestHttpd(_TestBase): result = read_http(sock) self.assertEqual(result.headers_lower['connection'], 'close') self.assertNotEqual(result.headers_lower.get('transfer-encoding'), 'chunked') - self.assertEquals(result.body, "thisischunked") + self.assertEqual(result.body, "thisischunked") def test_minimum_chunk_size_parameter_leaves_httpprotocol_class_member_intact(self): start_size = wsgi.HttpProtocol.minimum_chunk_size @@ -922,11 +922,11 @@ class TestHttpd(_TestBase): posthook2_count = [0] def posthook1(env, value, multiplier=1): - self.assertEquals(env['local.test'], 'test_029_posthooks') + self.assertEqual(env['local.test'], 'test_029_posthooks') posthook1_count[0] += value * multiplier def posthook2(env, value, divisor=1): - self.assertEquals(env['local.test'], 'test_029_posthooks') + self.assertEqual(env['local.test'], 'test_029_posthooks') posthook2_count[0] += value / divisor def one_posthook_app(env, start_response): @@ -944,11 +944,11 @@ class TestHttpd(_TestBase): fp = sock.makefile('rw') fp.write('GET / HTTP/1.1\r\nHost: localhost\r\n\r\n') fp.flush() - self.assertEquals(fp.readline(), 'HTTP/1.1 200 OK\r\n') + self.assertEqual(fp.readline(), 'HTTP/1.1 200 OK\r\n') fp.close() sock.close() - self.assertEquals(posthook1_count[0], 6) - self.assertEquals(posthook2_count[0], 0) + self.assertEqual(posthook1_count[0], 6) + self.assertEqual(posthook2_count[0], 0) def two_posthook_app(env, start_response): env['local.test'] = 'test_029_posthooks' @@ -967,11 +967,11 @@ class TestHttpd(_TestBase): fp = sock.makefile('rw') fp.write('GET / HTTP/1.1\r\nHost: localhost\r\n\r\n') fp.flush() - self.assertEquals(fp.readline(), 'HTTP/1.1 200 OK\r\n') + self.assertEqual(fp.readline(), 'HTTP/1.1 200 OK\r\n') fp.close() sock.close() - self.assertEquals(posthook1_count[0], 26) - self.assertEquals(posthook2_count[0], 25) + self.assertEqual(posthook1_count[0], 26) + self.assertEqual(posthook2_count[0], 25) def test_030_reject_long_header_lines(self): sock = eventlet.connect(('localhost', self.port)) @@ -981,7 +981,7 @@ class TestHttpd(_TestBase): fd.write(request) fd.flush() result = read_http(sock) - self.assertEquals(result.status, 'HTTP/1.0 400 Header Line Too Long') + self.assertEqual(result.status, 'HTTP/1.0 400 Header Line Too Long') fd.close() def test_031_reject_large_headers(self): @@ -992,7 +992,7 @@ class TestHttpd(_TestBase): fd.write(request) fd.flush() result = read_http(sock) - self.assertEquals(result.status, 'HTTP/1.0 400 Headers Too Large') + self.assertEqual(result.status, 'HTTP/1.0 400 Headers Too Large') fd.close() def test_032_wsgi_input_as_iterable(self): @@ -1019,9 +1019,9 @@ class TestHttpd(_TestBase): fd.write(request) fd.flush() result = read_http(sock) - self.assertEquals(result.body, upload_data) + self.assertEqual(result.body, upload_data) fd.close() - self.assertEquals(g[0], 1) + self.assertEqual(g[0], 1) def test_zero_length_chunked_response(self): def zero_chunked_app(env, start_response): @@ -1400,7 +1400,7 @@ class TestChunkedInput(_TestBase): def ping(self, fd): fd.sendall("GET /ping HTTP/1.1\r\n\r\n") - self.assertEquals(read_http(fd).body, "pong") + self.assertEqual(read_http(fd).body, "pong") def test_short_read_with_content_length(self): body = self.body() @@ -1408,7 +1408,7 @@ class TestChunkedInput(_TestBase): fd = self.connect() fd.sendall(req) - self.assertEquals(read_http(fd).body, "this is ch") + self.assertEqual(read_http(fd).body, "this is ch") self.ping(fd) fd.close() @@ -1418,7 +1418,7 @@ class TestChunkedInput(_TestBase): req = "POST /short-read HTTP/1.1\r\ntransfer-encoding: Chunked\r\nContent-Length:0\r\n\r\n" + body fd = self.connect() fd.sendall(req) - self.assertEquals(read_http(fd).body, "this is ch") + self.assertEqual(read_http(fd).body, "this is ch") self.ping(fd) fd.close() @@ -1429,7 +1429,7 @@ class TestChunkedInput(_TestBase): fd = self.connect() fd.sendall(req) - self.assertEquals(read_http(fd).body, "this is ch") + self.assertEqual(read_http(fd).body, "this is ch") self.ping(fd) fd.close() @@ -1440,7 +1440,7 @@ class TestChunkedInput(_TestBase): fd = self.connect() fd.sendall(req) - self.assertEquals(read_http(fd).body, "pong") + self.assertEqual(read_http(fd).body, "pong") self.ping(fd) fd.close() @@ -1451,7 +1451,7 @@ class TestChunkedInput(_TestBase): fd = self.connect() fd.sendall(req) - self.assertEquals(read_http(fd).body, 'this is chunked\nline 2\nline3') + self.assertEqual(read_http(fd).body, 'this is chunked\nline 2\nline3') fd.close() def test_chunked_readline_wsgi_override_minimum_chunk_size(self): @@ -1466,7 +1466,7 @@ class TestChunkedInput(_TestBase): resp_so_far += one_byte if resp_so_far.endswith('\r\n\r\n'): break - self.assertEquals(fd.recv(1), ' ') + self.assertEqual(fd.recv(1), ' ') try: with eventlet.Timeout(.1): fd.recv(1) @@ -1477,7 +1477,7 @@ class TestChunkedInput(_TestBase): self.yield_next_space = True with eventlet.Timeout(.1): - self.assertEquals(fd.recv(1), ' ') + self.assertEqual(fd.recv(1), ' ') def test_chunked_readline_wsgi_not_override_minimum_chunk_size(self): @@ -1492,7 +1492,7 @@ class TestChunkedInput(_TestBase): resp_so_far += one_byte if resp_so_far.endswith('\r\n\r\n'): break - self.assertEquals(fd.recv(1), ' ') + self.assertEqual(fd.recv(1), ' ') except eventlet.Timeout: pass else: diff --git a/tests/zmq_test.py b/tests/zmq_test.py index a31e8dd..283eef8 100644 --- a/tests/zmq_test.py +++ b/tests/zmq_test.py @@ -1,12 +1,9 @@ from __future__ import with_statement -from eventlet import event, spawn, sleep, patcher, semaphore -from eventlet.hubs import get_hub, _threadlocal, use_hub +from eventlet import event, spawn, sleep, semaphore from nose.tools import * -from tests import check_idle_cpu_usage, mock, LimitedTestCase, using_pyevent, skip_unless -from unittest import TestCase +from tests import check_idle_cpu_usage, LimitedTestCase, using_pyevent, skip_unless -from threading import Thread try: from eventlet.green import zmq except ImportError: @@ -197,7 +194,7 @@ class TestUpstreamDownStream(LimitedTestCase): def tx(sock): for i in range(1, 1001): - msg = "sub%s %s" % ([2,1][i % 2], i) + msg = "sub%s %s" % ([2, 1][i % 2], i) sock.send(msg) sleep() sock.send('sub1 LAST') @@ -312,7 +309,6 @@ class TestUpstreamDownStream(LimitedTestCase): for evt in done_evts: self.assertEqual(evt.wait(), 0) - @skip_unless(zmq_supported) def test_send_during_recv_multipart(self): sender, receiver, port = self.create_bound_pair(zmq.XREQ, zmq.XREQ) @@ -349,14 +345,12 @@ class TestUpstreamDownStream(LimitedTestCase): final_i = done_evts[i].wait() self.assertEqual(final_i, 0) - # Need someway to ensure a thread is blocked on send... This isn't working @skip_unless(zmq_supported) def test_recv_during_send(self): sender, receiver, port = self.create_bound_pair(zmq.XREQ, zmq.XREQ) sleep() - num_recvs = 30 done = event.Event() try: @@ -480,12 +474,12 @@ class TestQueueLock(LimitedTestCase): spawn(lock, 3) sleep() - self.assertEquals(results, []) + self.assertEqual(results, []) q.release() s.acquire() s.acquire() s.acquire() - self.assertEquals(results, [1,2,3]) + self.assertEqual(results, [1, 2, 3]) @skip_unless(zmq_supported) def test_count(self): @@ -520,6 +514,7 @@ class TestQueueLock(LimitedTestCase): s = semaphore.Semaphore(0) results = [] + def lock(x): with q: results.append(x) @@ -527,15 +522,15 @@ class TestQueueLock(LimitedTestCase): spawn(lock, 1) sleep() - self.assertEquals(results, []) + self.assertEqual(results, []) q.release() sleep() - self.assertEquals(results, []) + self.assertEqual(results, []) self.assertTrue(q) q.release() s.acquire() - self.assertEquals(results, [1]) + self.assertEqual(results, [1]) class TestBlockedThread(LimitedTestCase):