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()