tests: Remove skipped tests
They serve no purpose being skipped, better get rid of them than be misled by their presence.
This commit is contained in:
Jakub Stasiak
parent
e0d923488c
commit
05cfa71341
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
Loading…
Reference in New Issue