def test_main():
id = "%s:%s" % (os.getpid(), current_thread().getName())
m = Manager()
assert repr(m) == "<Manager/ %s (queued=0) [S]>" % id
app = App()
app.register(m)
s = repr(m)
assert s == "<Manager/ %s (queued=1) [S]>" % id
m.start()
pytest.wait_for(m, "_running", True)
sleep(0.1)
s = repr(m)
assert s == "<Manager/ %s (queued=0) [R]>" % id
m.stop()
pytest.wait_for(m, "_Manager__thread", None)
s = repr(m)
assert s == "<Manager/ %s (queued=0) [S]>" % id
def test_tcp_lookup_failure(Poller, ipv6):
m = Manager() + Poller()
if ipv6:
tcp_client = TCP6Client()
else:
tcp_client = TCPClient()
client = Client() + tcp_client
client.register(m)
m.start()
try:
assert pytest.wait_for(client, "ready")
client.fire(connect("foo", 1234))
assert pytest.wait_for(
client, "error", lambda obj, attr: isinstance(getattr(obj, attr), SocketError))
if pytest.PLATFORM == "win32":
assert client.error.errno == 11004
else:
assert client.error.errno in (EAI_NODATA, EAI_NONAME,)
finally:
m.stop()
def test_basic(Poller, ipv6):
m = Manager() + Poller()
if ipv6:
udp_server = UDP6Server(("::1", 0))
udp_client = UDP6Client(("::1", 0), channel="client")
else:
udp_server = UDPServer(0)
udp_client = UDPClient(0, channel="client")
server = Server() + udp_server
client = Client() + udp_client
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(server, "ready")
assert pytest.wait_for(client, "ready")
wait_host(server)
client.fire(write((server.host, server.port), b"foo"))
assert pytest.wait_for(server, "data", b"foo")
client.fire(close())
assert pytest.wait_for(client, "closed")
server.fire(close())
assert pytest.wait_for(server, "closed")
finally:
m.stop()
def test_close(Poller, ipv6):
m = Manager() + Poller()
server = Server() + UDPServer(0)
server.register(m)
m.start()
try:
assert pytest.wait_for(server, "ready")
wait_host(server)
host, port = server.host, server.port
server.fire(close())
assert pytest.wait_for(server, "disconnected")
server.unregister()
def test(obj, attr):
return attr not in obj.components
assert pytest.wait_for(m, server, value=test)
server = Server() + UDPServer((host, port))
server.register(m)
assert pytest.wait_for(server, "ready", timeout=30.0)
finally:
m.stop()
def test_unix(tmpfile, Poller):
m = Manager() + Poller()
server = Server() + UNIXServer(tmpfile)
client = Client() + UNIXClient()
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(server, "ready")
assert pytest.wait_for(client, "ready")
client.fire(connect(tmpfile))
assert pytest.wait_for(client, "connected")
assert pytest.wait_for(server, "connected")
assert pytest.wait_for(client, "data", b"Ready")
client.fire(write(b"foo"))
assert pytest.wait_for(server, "data", b"foo")
client.fire(close())
assert pytest.wait_for(client, "disconnected")
assert pytest.wait_for(server, "disconnected")
server.fire(close())
assert pytest.wait_for(server, "closed")
finally:
m.stop()
def test_unix(tmpdir, Poller):
m = Manager() + Poller()
sockpath = tmpdir.ensure("test.sock")
filename = str(sockpath)
server = Server() + UNIXServer(filename)
client = Client() + UNIXClient()
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(server, "ready")
assert pytest.wait_for(client, "ready")
client.fire(connect(filename))
assert pytest.wait_for(client, "connected")
assert pytest.wait_for(server, "connected")
assert pytest.wait_for(client, "data", b"Ready")
client.fire(write(b"foo"))
assert pytest.wait_for(server, "data", b"foo")
client.fire(close())
assert pytest.wait_for(client, "disconnected")
assert pytest.wait_for(server, "disconnected")
server.fire(close())
assert pytest.wait_for(server, "closed")
finally:
m.stop()
os.remove(filename)
def test(worker):
x = worker.fire(task(f))
assert pytest.wait_for(x, "result")
assert x.result
assert x.value == 1000000
def test_args(worker):
x = worker.fire(task(add, 1, 2))
assert pytest.wait_for(x, "result")
assert x.result
assert x.value == 3
def test_datetime(app):
now = datetime.now()
d = now + timedelta(seconds=0.1)
timer = Timer(d, test(), "timer")
timer.register(app)
assert pytest.wait_for(app, "flag")
app.reset()
def test_http_1_1_no_host_headers(webapp):
transport = TCPClient()
client = Client()
client += transport
client.start()
host, port, resource, secure = parse_url(webapp.server.http.base)
client.fire(connect(host, port))
assert pytest.wait_for(transport, "connected")
client.fire(write(b"GET / HTTP/1.1\r\n\r\n"))
assert pytest.wait_for(client, "done")
client.stop()
s = client.buffer().decode('utf-8').split('\r\n')[0]
assert s == "HTTP/1.1 400 Bad Request"
def test_tcp_connect_closed_port(Poller, ipv6):
### FIXME: This test is wrong.
### We need to figure out the sequence of events on Windows
### for this scenario. I think if you attempt to connect to
### a shutdown listening socket (tcp server) you should get
### an error event as response.
if pytest.PLATFORM == "win32":
pytest.skip("Broken on Windows")
m = Manager() + Poller()
if ipv6:
tcp_server = TCP6Server(("::1", 0))
tcp_client = TCP6Client()
else:
tcp_server = TCPServer(0)
tcp_client = TCPClient()
server = Server() + tcp_server
client = Client() + tcp_client
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(client, "ready")
assert pytest.wait_for(server, "ready")
wait_host(server)
host, port = server.host, server.port
tcp_server._sock.close()
# 1st connect
client.fire(connect(host, port))
assert pytest.wait_for(client, "connected")
assert isinstance(client.error, SocketError)
client.fire(write(b"foo"))
assert pytest.wait_for(client, "disconnected")
client.disconnected = False
client.fire(write(b"foo"))
assert pytest.wait_for(client, "disconnected", timeout=1.0) is None
finally:
m.stop()
def test(webapp):
transport = TCPClient()
client = Client()
client += transport
client.start()
host, port, resource, secure = parse_url(webapp.server.http.base)
client.fire(connect(host, port))
assert pytest.wait_for(transport, "connected")
client.fire(write(b"GET / HTTP/1.1\r\n"))
client.fire(write(b"Content-Type: text/plain\r\n\r\n"))
assert pytest.wait_for(client, "done")
client.stop()
s = client.buffer().decode('utf-8').split('\r\n')[0]
assert s == "HTTP/1.1 200 OK"
def test_override():
app = App2()
app.start()
x = app.fire(test())
assert pytest.wait_for(x, "result")
v = x.value
assert v == "Foobar"
app.stop()
def test_tcp_bind(Poller, ipv6):
m = Manager() + Poller()
if ipv6:
sock = socket(AF_INET6, SOCK_STREAM)
sock.bind(("::1", 0))
sock.listen(5)
_, bind_port, _, _ = sock.getsockname()
sock.close()
server = Server() + TCP6Server(("::1", 0))
client = Client() + TCP6Client()
else:
sock = socket(AF_INET, SOCK_STREAM)
sock.bind(("", 0))
sock.listen(5)
_, bind_port = sock.getsockname()
sock.close()
server = Server() + TCPServer(0)
client = Client() + TCPClient()
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(client, "ready")
assert pytest.wait_for(server, "ready")
wait_host(server)
client.fire(connect(server.host, server.port))
assert pytest.wait_for(client, "connected")
assert pytest.wait_for(server, "connected")
assert pytest.wait_for(client, "data", b"Ready")
# assert server.client[1] == bind_port
client.fire(write(b"foo"))
assert pytest.wait_for(server, "data", b"foo")
client.fire(close())
assert pytest.wait_for(client, "disconnected")
assert pytest.wait_for(server, "disconnected")
server.fire(close())
assert pytest.wait_for(server, "closed")
finally:
m.stop()
def test_inheritence():
app = App1()
app.start()
x = app.fire(test())
assert pytest.wait_for(x, "result")
v = x.value
assert v == ["Hello World!", "Foobar"]
app.stop()
def test_pipe(Poller):
m = Manager() + Poller()
a, b = Pipe("a", "b")
a.register(m)
b.register(m)
a = Client(channel=a.channel).register(m)
b = Client(channel=b.channel).register(m)
m.start()
try:
assert pytest.wait_for(a, "ready")
assert pytest.wait_for(b, "ready")
a.fire(write(b"foo"))
assert pytest.wait_for(b, "data", b"foo")
b.fire(write(b"foo"))
assert pytest.wait_for(a, "data", b"foo")
a.fire(close())
assert pytest.wait_for(a, "disconnected")
b.fire(close())
assert pytest.wait_for(b, "disconnected")
finally:
m.stop()
def test_tcps_basic(Poller, ipv6):
from circuits import Debugger
m = Manager() + Debugger() + Poller()
if ipv6:
tcp_server = TCP6Server(("::1", 0), secure=True, certfile=CERT_FILE)
tcp_client = TCP6Client()
else:
tcp_server = TCPServer(0, secure=True, certfile=CERT_FILE)
tcp_client = TCPClient()
server = Server() + tcp_server
client = Client() + tcp_client
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(client, "ready")
assert pytest.wait_for(server, "ready")
wait_host(server)
client.fire(connect(server.host, server.port, secure=True))
assert pytest.wait_for(client, "connected")
assert pytest.wait_for(server, "connected")
assert pytest.wait_for(client, "data", b"Ready")
client.fire(write(b"foo"))
assert pytest.wait_for(server, "data", b"foo")
assert pytest.wait_for(client, "data", b"foo")
client.fire(close())
assert pytest.wait_for(client, "disconnected")
assert pytest.wait_for(server, "disconnected")
server.fire(close())
assert pytest.wait_for(server, "closed")
finally:
m.stop()
def test_tcp_basic(Poller, ipv6):
m = Manager() + Poller()
if ipv6:
tcp_server = TCP6Server(("::1", 0))
tcp_client = TCP6Client()
else:
tcp_server = TCPServer(0)
tcp_client = TCPClient()
server = Server() + tcp_server
client = Client() + tcp_client
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(client, "ready")
assert pytest.wait_for(server, "ready")
wait_host(server)
client.fire(connect(server.host, server.port))
assert pytest.wait_for(client, "connected")
assert pytest.wait_for(server, "connected")
assert pytest.wait_for(client, "data", b"Ready")
client.fire(write(b"foo"))
assert pytest.wait_for(server, "data", b"foo")
assert pytest.wait_for(client, "data", b"foo")
client.fire(close())
assert pytest.wait_for(client, "disconnected")
assert pytest.wait_for(server, "disconnected")
server.fire(close())
assert pytest.wait_for(server, "closed")
finally:
m.stop()
def test_tcp_connect_closed_port(Poller, ipv6):
if pytest.PLATFORM == "win32":
pytest.skip("Broken on Windows")
m = Manager() + Poller() + Debugger()
if ipv6:
tcp_server = TCP6Server(("::1", 0))
tcp_client = TCP6Client(connect_timeout=1)
else:
tcp_server = TCPServer(0)
tcp_client = TCPClient(connect_timeout=1)
server = Server() + tcp_server
client = Client() + tcp_client
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(client, "ready")
assert pytest.wait_for(server, "ready")
wait_host(server)
host, port = server.host, server.port
tcp_server._sock.close()
# 1st connect
client.fire(connect(host, port))
waiter = WaitEvent(m, "unreachable", channel='client')
assert waiter.wait()
finally:
server.unregister()
client.unregister()
m.stop()
def test(manager, watcher):
app = App()
process, bridge = app.start(process=True, link=manager)
assert watcher.wait("ready", timeout=30)
x = manager.fire(hello())
assert pytest.wait_for(x, "result")
assert x.value == "Hello from {0:d}".format(app.pid)
app.stop()
app.join()
bridge.unregister()
watcher.wait("unregistered")
def test_persistentTimer(app):
app.timestamps.append(time.time())
timer = Timer(0.2, test(), "timer", persist=True)
timer.register(app)
wait_res = pytest.wait_for(app, "count", 2)
assert app.count >= 2
assert wait_res
delta = app.timestamps[1] - app.timestamps[0]
# Should be 0.1, but varies depending on timer precision and load
assert delta >= 0.08 and delta < 0.5
delta = app.timestamps[2] - app.timestamps[1]
assert delta >= 0.08 and delta < 0.5
app.reset()
timer.unregister()
def test_main():
m = Manager()
loader = Loader(paths=[dirname(__file__)]).register(m)
m.start()
loader.load("app")
x = m.fire(test())
assert pytest.wait_for(x, "result")
s = x.value
assert s == "Hello World!"
m.stop()
def test_timer(app):
timer = Timer(0.1, test(), "timer")
timer.register(app)
assert pytest.wait_for(app, "flag")
app.reset()
def test_timer(app):
timer = Timer(0.1, test(), "timer")
timer.register(app)
assert pytest.wait_for(app, "flag")
app.reset()
def wait_host(server):
def checker(obj, attr):
return all((getattr(obj, a) for a in attr))
assert pytest.wait_for(server, ("host", "port"), checker)
def wait_host(server):
def checker(obj, attr):
return all((getattr(obj, a) for a in attr))
assert pytest.wait_for(server, ("host", "port"), checker)
def test_tcp_reconnect(Poller, ipv6):
# XXX: Apparently this doesn't work on Windows either?
# XXX: UPDATE: Apparently Broken on Windows + Python 3.2
# TODO: Need to look into this. Find out why...
if pytest.PLATFORM == "win32" and pytest.PYVER[:2] >= (3, 2):
pytest.skip("Broken on Windows on Python 3.2")
m = Manager() + Poller()
if ipv6:
tcp_server = TCP6Server(("::1", 0))
tcp_client = TCP6Client()
else:
tcp_server = TCPServer(0)
tcp_client = TCPClient()
server = Server() + tcp_server
client = Client() + tcp_client
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(client, "ready")
assert pytest.wait_for(server, "ready")
wait_host(server)
# 1st connect
client.fire(connect(server.host, server.port))
assert pytest.wait_for(client, "connected")
assert pytest.wait_for(server, "connected")
assert pytest.wait_for(client, "data", b"Ready")
client.fire(write(b"foo"))
assert pytest.wait_for(server, "data", b"foo")
# disconnect
client.fire(close())
assert pytest.wait_for(client, "disconnected")
# 2nd reconnect
client.fire(connect(server.host, server.port))
assert pytest.wait_for(client, "connected")
assert pytest.wait_for(server, "connected")
assert pytest.wait_for(client, "data", b"Ready")
client.fire(write(b"foo"))
assert pytest.wait_for(server, "data", b"foo")
client.fire(close())
assert pytest.wait_for(client, "disconnected")
assert pytest.wait_for(server, "disconnected")
server.fire(close())
assert pytest.wait_for(server, "closed")
finally:
m.stop()
def test_tcp_reconnect(Poller, ipv6):
# XXX: Apparently this doesn't work on Windows either?
# XXX: UPDATE: Apparently Broken on Windows + Python 3.2
# TODO: Need to look into this. Find out why...
if pytest.PLATFORM == "win32" and pytest.PYVER[:2] >= (3, 2):
pytest.skip("Broken on Windows on Python 3.2")
m = Manager() + Poller()
if ipv6:
tcp_server = TCP6Server(("::1", 0))
tcp_client = TCP6Client()
else:
tcp_server = TCPServer(0)
tcp_client = TCPClient()
server = Server() + tcp_server
client = Client() + tcp_client
server.register(m)
client.register(m)
m.start()
try:
assert pytest.wait_for(client, "ready")
assert pytest.wait_for(server, "ready")
wait_host(server)
# 1st connect
client.fire(connect(server.host, server.port))
assert pytest.wait_for(client, "connected")
assert pytest.wait_for(server, "connected")
assert pytest.wait_for(client, "data", b"Ready")
client.fire(write(b"foo"))
assert pytest.wait_for(server, "data", b"foo")
# disconnect
client.fire(close())
assert pytest.wait_for(client, "disconnected")
# 2nd reconnect
client.fire(connect(server.host, server.port))
assert pytest.wait_for(client, "connected")
assert pytest.wait_for(server, "connected")
assert pytest.wait_for(client, "data", b"Ready")
client.fire(write(b"foo"))
assert pytest.wait_for(server, "data", b"foo")
client.fire(close())
assert pytest.wait_for(client, "disconnected")
assert pytest.wait_for(server, "disconnected")
server.fire(close())
assert pytest.wait_for(server, "closed")
finally:
m.stop()
