tests: Remove skipped tests

They serve no purpose being skipped, better get rid of them than be
misled by their presence.

tests/db_pool_test.py

@@ -7,7 +7,7 @@ import os
 import traceback
 from unittest import TestCase, main
 
-from tests import mock, skipped, skip_unless, skip_with_pyevent, get_database_auth
+from tests import mock, skip_unless, skip_with_pyevent, get_database_auth
 from eventlet import event
 from eventlet import db_pool
 from eventlet.support import six
@@ -116,14 +116,6 @@ class DBConnectionPool(DBTester):
         assert self.pool.free() == 1
         self.assertRaises(AttributeError, self.connection.cursor)
 
-    @skipped
-    def test_deletion_does_a_put(self):
-        # doing a put on del causes some issues if __del__ is called in the
-        # main coroutine, so, not doing that for now
-        assert self.pool.free() == 0
-        self.connection = None
-        assert self.pool.free() == 1
-
     def test_put_doesnt_double_wrap(self):
         self.pool.put(self.connection)
         conn = self.pool.get()
@@ -213,45 +205,6 @@ class DBConnectionPool(DBTester):
             conn.commit()
             self.pool.put(conn)
 
-    @skipped
-    def test_two_simultaneous_connections(self):
-        # timing-sensitive test, disabled until we come up with a better
-        # way to do this
-        self.pool = self.create_pool(max_size=2)
-        conn = self.pool.get()
-        self.set_up_dummy_table(conn)
-        self.fill_up_table(conn)
-        curs = conn.cursor()
-        conn2 = self.pool.get()
-        self.set_up_dummy_table(conn2)
-        self.fill_up_table(conn2)
-        curs2 = conn2.cursor()
-        results = []
-        LONG_QUERY = "select * from test_table"
-        SHORT_QUERY = "select * from test_table where row_id <= 20"
-
-        evt = event.Event()
-
-        def long_running_query():
-            self.assert_cursor_works(curs)
-            curs.execute(LONG_QUERY)
-            results.append(1)
-            evt.send()
-        evt2 = event.Event()
-
-        def short_running_query():
-            self.assert_cursor_works(curs2)
-            curs2.execute(SHORT_QUERY)
-            results.append(2)
-            evt2.send()
-
-        eventlet.spawn(long_running_query)
-        eventlet.spawn(short_running_query)
-        evt.wait()
-        evt2.wait()
-        results.sort()
-        self.assertEqual([1, 2], results)
-
     def test_clear(self):
         self.pool = self.create_pool()
         self.pool.put(self.connection)
@@ -318,80 +271,6 @@ class DBConnectionPool(DBTester):
         self.connection.close()
         self.assertEqual(len(self.pool.free_items), 0)
 
-    @skipped
-    def test_max_idle(self):
-        # This test is timing-sensitive.  Rename the function without
-        # the "dont" to run it, but beware that it could fail or take
-        # a while.
-
-        self.pool = self.create_pool(max_size=2, max_idle=0.02)
-        self.connection = self.pool.get()
-        self.connection.close()
-        self.assertEqual(len(self.pool.free_items), 1)
-        eventlet.sleep(0.01)  # not long enough to trigger the idle timeout
-        self.assertEqual(len(self.pool.free_items), 1)
-        self.connection = self.pool.get()
-        self.connection.close()
-        self.assertEqual(len(self.pool.free_items), 1)
-        eventlet.sleep(0.01)  # idle timeout should have fired but done nothing
-        self.assertEqual(len(self.pool.free_items), 1)
-        self.connection = self.pool.get()
-        self.connection.close()
-        self.assertEqual(len(self.pool.free_items), 1)
-        eventlet.sleep(0.03)  # long enough to trigger idle timeout for real
-        self.assertEqual(len(self.pool.free_items), 0)
-
-    @skipped
-    def test_max_idle_many(self):
-        # This test is timing-sensitive.  Rename the function without
-        # the "dont" to run it, but beware that it could fail or take
-        # a while.
-
-        self.pool = self.create_pool(max_size=2, max_idle=0.02)
-        self.connection, conn2 = self.pool.get(), self.pool.get()
-        self.connection.close()
-        eventlet.sleep(0.01)
-        self.assertEqual(len(self.pool.free_items), 1)
-        conn2.close()
-        self.assertEqual(len(self.pool.free_items), 2)
-        eventlet.sleep(0.02)  # trigger cleanup of conn1 but not conn2
-        self.assertEqual(len(self.pool.free_items), 1)
-
-    @skipped
-    def test_max_age(self):
-        # This test is timing-sensitive.  Rename the function without
-        # the "dont" to run it, but beware that it could fail or take
-        # a while.
-
-        self.pool = self.create_pool(max_size=2, max_age=0.05)
-        self.connection = self.pool.get()
-        self.connection.close()
-        self.assertEqual(len(self.pool.free_items), 1)
-        eventlet.sleep(0.01)  # not long enough to trigger the age timeout
-        self.assertEqual(len(self.pool.free_items), 1)
-        self.connection = self.pool.get()
-        self.connection.close()
-        self.assertEqual(len(self.pool.free_items), 1)
-        eventlet.sleep(0.05)  # long enough to trigger age timeout
-        self.assertEqual(len(self.pool.free_items), 0)
-
-    @skipped
-    def test_max_age_many(self):
-        # This test is timing-sensitive.  Rename the function without
-        # the "dont" to run it, but beware that it could fail or take
-        # a while.
-
-        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.assertEqual(len(self.pool.free_items), 1)
-        eventlet.sleep(0)  # not long enough to trigger the age timeout
-        self.assertEqual(len(self.pool.free_items), 1)
-        eventlet.sleep(0.2)  # long enough to trigger age timeout
-        self.assertEqual(len(self.pool.free_items), 0)
-        conn2.close()  # should not be added to the free items
-        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
         # and someone puts an immediately-closed connection back in
@@ -421,29 +300,6 @@ class DBConnectionPool(DBTester):
         self.assertEqual(self.pool.waiting(), 0)
         self.pool.put(conn)
 
-    @skipped
-    def test_0_straight_benchmark(self):
-        """ Benchmark; don't run unless you want to wait a while."""
-        import time
-        iterations = 20000
-        c = self.connection.cursor()
-        self.connection.commit()
-
-        def bench(c):
-            for i in six.moves.range(iterations):
-                c.execute('select 1')
-
-        bench(c)  # warm-up
-        results = []
-        for i in range(3):
-            start = time.time()
-            bench(c)
-            end = time.time()
-            results.append(end - start)
-
-        print("\n%u iterations took an average of %f seconds, (%s) in %s\n" % (
-            iterations, sum(results) / len(results), results, type(self)))
-
     def test_raising_create(self):
         # if the create() method raises an exception the pool should
         # not lose any connections

tests/greenio_test.py

@@ -836,110 +836,6 @@ class TestGreenIoLong(tests.LimitedTestCase):
         assert len(results2) > 0
         debug.hub_prevent_multiple_readers()
 
-    @tests.skipped  # by rdw because it fails but it's not clear how to make it pass
-    @tests.skip_with_pyevent
-    def test_multiple_readers2(self):
-        self.test_multiple_readers(clibufsize=True)
-
-
-class TestGreenIoStarvation(tests.LimitedTestCase):
-    # fixme: this doesn't succeed, because of eventlet's predetermined
-    # ordering.  two processes, one with server, one with client eventlets
-    # might be more reliable?
-
-    TEST_TIMEOUT = 300  # the test here might take a while depending on the OS
-
-    @tests.skipped  # by rdw, because it fails but it's not clear how to make it pass
-    @tests.skip_with_pyevent
-    def test_server_starvation(self, sendloops=15):
-        recvsize = 2 * min_buf_size()
-        sendsize = 10000 * recvsize
-
-        results = [[] for i in range(5)]
-
-        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))
-        port = listener.getsockname()[1]
-        listener.listen(50)
-
-        base_time = time.time()
-
-        def server(my_results):
-            sock, addr = listener.accept()
-
-            datasize = 0
-
-            t1 = None
-            t2 = None
-            try:
-                while True:
-                    data = sock.recv(recvsize)
-                    if not t1:
-                        t1 = time.time() - base_time
-                    if not data:
-                        t2 = time.time() - base_time
-                        my_results.append(datasize)
-                        my_results.append((t1, t2))
-                        break
-                    datasize += len(data)
-            finally:
-                sock.close()
-
-        def client():
-            pid = os.fork()
-            if pid:
-                return pid
-
-            client = _orig_sock.socket(socket.AF_INET, socket.SOCK_STREAM)
-            client.connect(('127.0.0.1', port))
-
-            bufsized(client, size=sendsize)
-
-            for i in range(sendloops):
-                client.sendall(b'*' * sendsize)
-            client.close()
-            os._exit(0)
-
-        clients = []
-        servers = []
-        for r in results:
-            servers.append(eventlet.spawn(server, r))
-        for r in results:
-            clients.append(client())
-
-        for s in servers:
-            s.wait()
-        for c in clients:
-            os.waitpid(c, 0)
-
-        listener.close()
-
-        # now test that all of the server receive intervals overlap, and
-        # that there were no errors.
-        for r in results:
-            assert len(r) == 2, "length is %d not 2!: %s\n%s" % (len(r), r, results)
-            assert r[0] == sendsize * sendloops
-            assert len(r[1]) == 2
-            assert r[1][0] is not None
-            assert r[1][1] is not None
-
-        starttimes = sorted(r[1][0] for r in results)
-        endtimes = sorted(r[1][1] for r in results)
-        runlengths = sorted(r[1][1] - r[1][0] for r in results)
-
-        # 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)
-
-        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!"
-
 
 def test_set_nonblocking():
     sock = _orig_sock.socket(socket.AF_INET, socket.SOCK_DGRAM)

tests/thread_test.py

@@ -8,7 +8,7 @@ from eventlet import greenthread
 from eventlet.green import thread
 from eventlet.support import six
 
-from tests import LimitedTestCase, skipped
+from tests import LimitedTestCase
 
 
 class Locals(LimitedTestCase):
@@ -24,29 +24,6 @@ class Locals(LimitedTestCase):
         self.results = []
         super(Locals, self).tearDown()
 
-    @skipped  # cause it relies on internal details of corolocal that are no longer true
-    def test_simple(self):
-        tls = thread._local()
-        g_ids = []
-        evt = event.Event()
-
-        def setter(tls, v):
-            g_id = id(greenthread.getcurrent())
-            g_ids.append(g_id)
-            tls.value = v
-            evt.wait()
-
-        thread.start_new_thread(setter, args=(tls, 1))
-        thread.start_new_thread(setter, args=(tls, 2))
-        eventlet.sleep()
-        objs = object.__getattribute__(tls, "__objs")
-        assert sorted(g_ids) == sorted(objs.keys())
-        assert objs[g_ids[0]]['value'] == 1
-        assert objs[g_ids[1]]['value'] == 2
-        assert getattr(tls, 'value', None) is None
-        evt.send("done")
-        eventlet.sleep()
-
     def test_assignment(self):
         my_local = corolocal.local()
         my_local.a = 1

tests/tpool_test.py

@@ -22,7 +22,7 @@ import time
 import eventlet
 from eventlet import tpool, debug, event
 from eventlet.support import six
-from tests import LimitedTestCase, skipped, skip_with_pyevent, main
+from tests import LimitedTestCase, skip_with_pyevent, main
 
 
 one = 1
@@ -339,28 +339,6 @@ class TpoolLongTests(LimitedTestCase):
         self.assertEqual(len(results), cnt)
         tpool.killall()
 
-    @skipped
-    def test_benchmark(self):
-        """ Benchmark computing the amount of overhead tpool adds to function calls."""
-        iterations = 10000
-        import timeit
-        imports = """
-from tests.tpool_test import noop
-from eventlet.tpool import execute
-        """
-        t = timeit.Timer("noop()", imports)
-        results = t.repeat(repeat=3, number=iterations)
-        best_normal = min(results)
-
-        t = timeit.Timer("execute(noop)", imports)
-        results = t.repeat(repeat=3, number=iterations)
-        best_tpool = min(results)
-
-        tpool_overhead = (best_tpool - best_normal) / iterations
-        print("%s iterations\nTpool overhead is %s seconds per call.  Normal: %s; Tpool: %s" % (
-            iterations, tpool_overhead, best_normal, best_tpool))
-        tpool.killall()
-
     @skip_with_pyevent
     def test_leakage_from_tracebacks(self):
         tpool.execute(noop)  # get it started

tests/wsgi_test.py

@@ -335,14 +335,6 @@ class TestHttpd(_TestBase):
         self.assertRaises(ConnectionClosed, read_http, sock)
         fd.close()
 
-    @tests.skipped
-    def test_005_run_apachebench(self):
-        url = 'http://localhost:12346/'
-        # ab is apachebench
-        subprocess.call(
-            [tests.find_command('ab'), '-c', '64', '-n', '1024', '-k', url],
-            stdout=subprocess.PIPE)
-
     def test_006_reject_long_urls(self):
         sock = eventlet.connect(
             ('localhost', self.port))