def test_websocket_enable_disable(self):
server = get_server()
self.assertTrue(hasattr(server.start(), "websocket"))
server.stop()
server.join(5)
server = get_server(websockets_enabled=False)
self.assertFalse(hasattr(server.start(), "websocket"))
server.stop()
server.join(5)
def test_respect_requested_port(self):
server = get_server(port=64003).start()
self.assertEqual(server.port, 64003)
# dies request port taken
# logging.info("the next test should fail to bind to 64003")
try:
server = get_server(port=64003).start(timeout=0.1)
except ExhibitionistError as e:
# self.assertEqual(e.errno, errno.EADDRNOTAVAIL)
pass
else:
self.fail("exception was not raised")
def test_multiple(self):
"""
Torture test of mutliple server,
mutliple object, multile client hitting
servers concurrently,
"""
try:
import grequests
except ImportError:
raise nose.SkipTest("grequests not available")
import grequests
from exhibitionist.objectRegistry import ObjectRegistry
from exhibitionist.decorators import http_handler
import random
registry = ObjectRegistry()
@http_handler(r'/{{objid}}', __registry=registry)
class Handler(ExhibitionistRequestHandler):
def get(self, *args, **kwds):
self.write(str(id(context.object)))
N_SERVERS = 3
N_CONC_CONNS = 20
for i in range(10):
try:
servers = []
for i in range(N_SERVERS):
servers.append(get_server().add_handler(Handler).start())
assert len(servers) == N_SERVERS
urls=[]
objs=[object() for i in range(N_CONC_CONNS)] # use integers
for i in range(N_CONC_CONNS): # 50 connections at once
o = objs[i]
r = random.randint(0, N_SERVERS-1)
assert r < N_SERVERS
s = servers[r]
urls.append(s.get_view_url("Handler", o, __registry=registry))
assert len(urls) == len(objs)
jobs = [grequests.get(url) for url in urls]
results = grequests.map(jobs)
for i,r in enumerate(results):
self.assertTrue(str(id(objs[i])) == r.content)
finally:
for s in servers:
try:
s.stop()
except:
pass
def test_stop_server(self):
import time
from random import random
for i in range(10):
server = get_server().start()
self.assertTrue(server.isAlive())
server.stop()
server.join(1)
self.assertFalse(server.isAlive())
def test_stop_server_releases_port(self):
import time
from random import random
import socket
for i in range(100):
server = get_server(port=4000).start()
self.assertTrue(server.isAlive())
# make sure port is taken
s = socket.socket()
addr, port = server.address, server.port
# print(addr,port)
try:
s.bind((addr, port))
except socket.error as e:
if e.errno != errno.EADDRINUSE:
self.fail("excpected EADDRINUSE, got some other error")
else:
s.close()
self.fail("socket was supposed to be taken")
# stop server and wait
server.stop()
server.join(1)
self.assertFalse(server.isAlive())
error=False
# make sure port is available
try:
s.bind((addr, port))
except (OSError, socket.error) as e:
error = True
if e.errno == errno.EADDRINUSE:
msg = "socket not released after server stop()"
else:
msg = "couldn't bind to available socket, unknown error"
else:
s.close()
if error:
self.fail(msg)
def test_pure_evil_at_bay(self):
# make sure requests to a given port are always handled
# by the server thread that is listening to that port,
# even having identical routes on different servers.
# Tornado 2.4.1 doesn't do that if server threads share the IOLoop
from tornado.web import RequestHandler
import threading
import requests
from exhibitionist.decorators import http_handler
bucket = set()
@http_handler("/a",__test=True)
class H(RequestHandler):
def __init__(self, *args, **kwds):
super(H, self).__init__(*args, **kwds)
self.bucket = bucket
def get(self):
self.bucket.add(threading.current_thread().ident)
servers = []
try:
for i in range(10):
servers.append(get_server().add_handler(H).start())
for i in range(100):
requests.get(servers[0].get_view_url("H"))
self.assertEqual(len(bucket), 1)
finally:
for s in servers:
try:
s.stop()
except:
pass
pjoin = os.path.join
dirname = lambda x: os.path.abspath(os.path.dirname(x))
# tell the server where the templates and static files
# are served from.
# This enables get_template_path() in request handlers
# and {{static_url(filename)}} in templates, if you're using
# the tornado template engine.
STATIC_DIR = pjoin(dirname(__file__), "static")
TEMPLATE_DIR = pjoin(dirname(__file__), "templates")
# Instantiate aserver, register handlers ("views"), and start the server listening
# websockets_enabled=True is the default, You can omit it for brevity
server = get_server(template_path=TEMPLATE_DIR,
static_path=STATIC_DIR,
websockets_enabled=True).add_handler(handlers).start()
obj = ["foo", "bar", "baz", 1, 2, 3] # the object to be viewed
# get the url of the MainViewHandler view defined in handlers
url = server.get_view_url("MainViewHandler", obj)
# UrlDisplay adapts to the environment in which it is run
# in ipnb you'll get inline html, in ipython-qtconsole it provides a hot link
# and in other environments, a text message with the url
#
# Alternatively, IPNB allows you to install a display hook based on object type
# google "ipython formatters for_type"
# or see:
# http://ipython.org/ipython-doc/stable/api/generated/IPython.core.formatters.html
def setUp(self):
self.server = get_server().start()
assert self.server._ensure_up() == 0
self.ws_url = self.server.get_view_url('WebSocketEvents')
self.o = object()
self.objid = self.server.registry.register(self.o)
def test_creation_and_reg_with_server(self):
from exhibitionist import get_server
self.server = get_server(websockets_enabled=True).start()
assert self.server._ensure_up() == 0
self.ws_url = self.server.get_view_url('WebSocketEvents')
def setUp(self):
self.server = get_server()
