def get_data_generator(self):
""" Returns a data generator. """
if not self.data_generator:
from database.data_creator import DataGenerator
self.data_generator = DataGenerator()
self.init_application()
self.data_generator.initialise(self.application)
return self.data_generator
class Worker(object):
""" The Worker makes requests to the web application. It can
run the web application itself which is needed for performance testing
or use an actual running instance.' """
def __init__(self, **kw):
self.host = kw.get("host", "127.0.0.1")
self.port = kw.get("port", "8000")
self.application_name = kw.get("application")
self.username = kw.get("username")
self.password = kw.get("password")
self.profile = kw.get("profile", False)
self.process = kw.get("process", False)
self.quiet = kw.get("quiet", False)
self.verbose = kw.get("verbose", False)
self.testfile = kw.get("testfile", False)
self.test_output = []
self.fake_server = kw.get("fake_server", False)
self._test_function = None
self._setup_function = None
self.application = None
self.data_generator = None
if self.fake_server:
# use internal fake webserver
import web
from fake_webob import FakeSession
self.init_application()
self.server = web.WebApplication(self.application)
self.server.fake_requests()
# fake environ
self.environ = {}
self.environ["PATH_INFO"] = "/ajax"
self.environ["params"] = {}
self.environ["beaker.session"] = FakeSession()
else:
# use real webserver
# cookie handler
cookie_proc = urllib2.HTTPCookieProcessor()
self.opener = urllib2.build_opener(cookie_proc)
self.url = "http://%s:%s/ajax" % (self.host, self.port)
# log in if we have user details
if self.username and self.password:
self.login(self.username, self.password)
def init_application(self):
""" Initialise the application if needed. """
if self.application:
return
if self.application_name:
import application
self.application = application.Application(self.application_name)
else:
raise Exception("No Application Name")
def get_data_generator(self):
""" Returns a data generator. """
if not self.data_generator:
from database.data_creator import DataGenerator
self.data_generator = DataGenerator()
self.init_application()
self.data_generator.initialise(self.application)
return self.data_generator
def start_response(*junk):
""" Null function for fake webserver """
pass
def request(self, data):
""" Make a request to the application. """
if self.verbose:
print "== Sent Data", "=" * 47
pprint.pprint(data)
print "-" * 60
if self.fake_server:
self.environ["params"]["body"] = data
return self.server(self.environ, self.start_response)
else:
return self.opener.open(self.url, "body=%s" % data).read()
def get_form_data(self, form_name):
""" Get the data for the named form. """
form_data = self.decode.get("form").get(form_name)
if form_data:
return form_data.get("data")
else:
return {}
def decode_response_part(self, data):
""" Decode a part response and store form and node data. """
if self.verbose:
print "== Returned Data", "=" * 43
pprint.pprint(data)
print "-" * 60
# data = data['data']
action = data.get("action")
if action == "function":
info = "function: %s" % data["function"]
elif action == "form" or action == "dialog":
info = "form: %s" % data.get("title")
self.decode["form"] = {}
for form_name in data.get("data"):
form_data = data.get("data").get(form_name).get("data")
if "__array" in form_data:
array_data = form_data.get("__array")
if array_data:
form_data = array_data
else:
if not self.quiet:
print "No array data sent"
form_data = {}
version = data.get("data").get(form_name).get("form").get("version")
self.decode["form"][form_name] = dict(version=version, data=form_data)
self.decode["node_data"] = data.get("node_data")
elif action == "general_error":
info = "general_error:\n%s" % data.get("data")
else:
info = action
if not self.quiet:
print info
def decode_response(self, response):
""" Decode the response - data is stored in self.decode. """
self.decode = {}
data = json.loads(response)
for row in data:
self.decode_response_part(row)
def request_node(self, node_name, command="", **kw):
""" Make a node request to the web application. """
req = dict(node=node_name, command=command)
req.update(kw)
if self.testfile:
self.test_output.append(req)
data = json.dumps(req, separators=(",", ":"))
start = time.time()
response = self.request(data)
duration = "%sms" % int((time.time() - start) * 1000)
if not self.quiet:
print node_name, command, duration
print "(%s bytes)" % len(response)
if self.process:
self.decode_response(response)
def login(self, username, password):
""" log in to the system """
data = dict(login_name=username, password=password)
form_data = [dict(form="login_form", data=data)]
self.request_node("user.User", "login", form_data=form_data)
def logout(self):
""" log in to the system """
self.request_node("user.User", "logout")
def setup_function(self, function):
""" Set the test function. """
self._setup_function = function
def test_function(self, function, count=10):
""" Set the test function. """
self._test_function = function
self.count = count
def run(self):
""" Run the test function. """
if not self._test_function:
print "No test function supplied"
return
cumlative_time = 0.0
for i in xrange(self.count):
start = time.time()
self._test_function(self, self.test_environ)
duration = time.time() - start
cumlative_time += duration
print "--- run %s --- %sms" % (i, int(duration * 1000))
print "total time %ss" % cumlative_time
print "average %sms" % int(cumlative_time / self.count * 1000)
def start(self):
""" Start the test. """
self.test_environ = {}
if self._setup_function:
self._setup_function(self, self.test_environ)
if self.profile:
import cProfile
cProfile.run("a.run()", "ajax.profile")
else:
self.run()
if self.testfile:
f = open(self.testfile, "w+")
f.write(json.dumps(self.test_output))
f.close()
