def open_handler(err, file): tu.check_context() tu.azzert(err == None) num_chunks = 100; chunk_size = 1000; tot_buff = Buffer.create() self.written = 0 for i in range(0, num_chunks): buff = TestUtils.gen_buffer(chunk_size) tot_buff.append_buffer(buff) def write_handler(err, res): tu.check_context() self.written += 1 if self.written == num_chunks: # all written tot_read = Buffer.create() self.read = 0 for j in range(0, num_chunks): pos = j * chunk_size def read_handler(err, buff): tu.check_context tu.azzert(err == None) self.read += 1 if self.read == num_chunks: # all read tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read)) def close_handler(err, res): tu.check_context() tu.test_complete() file.close(close_handler) file.read(tot_read, pos, pos, chunk_size, read_handler) file.write(buff, i * chunk_size, write_handler)
def client_connect_handler(socket): tu.check_context() sends = 10 size = 100 sent = Buffer.create() received = Buffer.create() @socket.data_handler def data_handler(data): tu.check_context() received.append_buffer(data) if received.length == sends * size: tu.azzert(TestUtils.buffers_equal(sent, received)) tu.test_complete() @socket.drain_handler def drain_handler(stream): tu.check_context() #print "drained\n" @socket.end_handler def end_handler(stream): tu.check_context() #print "end\n" socket.pause() socket.resume() socket.write_queue_full socket.write_queue_max_size = 100000 for i in range(0, sends): data = TestUtils.gen_buffer(size) sent.append_buffer(data) socket.write_buffer(data)
def echo(self, binary): @server.websocket_handler def websocket_handler(ws): tu.check_context() @ws.data_handler def data_handler(buff): tu.check_context() ws.write_buffer(buff) server.listen(8080) if binary: self.buff = TestUtils.gen_buffer(1000) else: self.str_ = TestUtils.random_unicode_string(1000) def connect_handler(ws): tu.check_context() received = Buffer.create() @ws.data_handler def data_handler(buff): tu.check_context() received.append_buffer(buff) if received.length == buff.length: tu.azzert(TestUtils.buffers_equal(buff, received)) tu.test_complete() if binary: ws.write_binary_frame(self.buff) else: ws.write_text_frame(self.str_) client.connect_web_socket("/someurl", connect_handler)
def open_handler(err, file): tu.check_context() tu.azzert(err == None) num_chunks = 100; chunk_size = 1000; tot_buff = Buffer.create() write_stream = file.write_stream for i in range(0, num_chunks): buff = TestUtils.gen_buffer(chunk_size) tot_buff.append_buffer(buff) write_stream.write_buffer(buff) def close_handler(err, file): def open_handler2(err, file): tu.check_context() tu.azzert(err == None) read_stream = file.read_stream tot_read = Buffer.create() def data_handler(data): tot_read.append_buffer(data) read_stream.data_handler(data_handler) def end_handler(stream): tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read)) tu.check_context def close_handler2(err, result): tu.check_context() tu.test_complete() file.close(close_handler2) read_stream.end_handler(end_handler) FileSystem.open(filename, handler=open_handler2) file.close(close_handler)
def open_handler(err, file): tu.check_thread() tu.azzert(err == None) num_chunks = 100; chunk_size = 1000; tot_buff = Buffer.create() self.written = 0 for i in range(0, num_chunks): buff = TestUtils.gen_buffer(chunk_size) tot_buff.append_buffer(buff) def write_handler(err, res): tu.check_thread() self.written += 1 if self.written == num_chunks: # all written tot_read = Buffer.create() self.read = 0 for j in range(0, num_chunks): pos = j * chunk_size def read_handler(err, buff): tu.check_thread tu.azzert(err == None) self.read += 1 if self.read == num_chunks: # all read tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read)) def close_handler(err, res): tu.check_thread() tu.test_complete() file.close(close_handler) file.read_at_pos(tot_read, pos, pos, chunk_size, read_handler) file.write_at_pos(buff, i * chunk_size, write_handler)
def open_handler(err, file): tu.check_thread() tu.azzert(err == None) num_chunks = 100; chunk_size = 1000; tot_buff = Buffer.create() for i in range(0, num_chunks): buff = TestUtils.gen_buffer(chunk_size) tot_buff.append_buffer(buff) file.write(buff) def close_handler(err, file): def open_handler2(err, file): tu.check_thread() tu.azzert(err == None) read_stream = file tot_read = Buffer.create() def data_handler(data): tot_read.append_buffer(data) read_stream.data_handler(data_handler) def end_handler(): tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read)) tu.check_thread def close_handler2(err, result): tu.check_thread() tu.test_complete() file.close(close_handler2) read_stream.end_handler(end_handler) fs.open(filename, handler=open_handler2) file.close(close_handler)
def test_hash(self): hash1 = SharedData.get_hash("map1") tu.azzert(hash1 != None) hash2 = SharedData.get_hash("map1") tu.azzert(hash2 != None) tu.azzert(hash1 == hash2) hash3 = SharedData.get_hash("map3") tu.azzert(hash3 != None) tu.azzert(hash1 != hash3) key = 'wibble' hash1[key] = 'hello' tu.azzert(hash1[key] == 'hello') tu.azzert(hash2[key] == 'hello') tu.azzert(isinstance(hash1[key], unicode)) # Make sure it's not a Java String hash1[key] = 12 tu.azzert(hash1[key] == 12) tu.azzert(hash2[key] == 12) hash1[key] = 1.2344 tu.azzert(hash1[key] == 1.2344) tu.azzert(hash2[key] == 1.2344) hash1[key] = True tu.azzert(hash1[key] == True) tu.azzert(hash2[key] == True) hash1[key] = False tu.azzert(hash1[key] == False) tu.azzert(hash2[key] == False) succeeded = False try: hash1[key] = SomeOtherClass() succeeded = True except: pass # OK tu.azzert(not succeeded, 'Should throw exception') # Make sure it deals with Ruby buffers ok, and copies them buff1 = TestUtils.gen_buffer(100) hash1[key] = buff1 buff2 = hash1[key] tu.azzert(isinstance(buff2, Buffer)) tu.azzert(buff1 != buff2) tu.azzert(TestUtils.buffers_equal(buff1, buff2)) tu.azzert(SharedData.remove_hash("map1")) tu.azzert(not SharedData.remove_hash("map1")) tu.azzert(SharedData.remove_hash("map3")) tu.test_complete()
def listen_handler(err, sock): tu.azzert(err is None) tu.azzert(sock == peer2) buffer = TestUtils.gen_buffer(128) @peer2.data_handler def data_handler(data): tu.check_thread() tu.azzert(TestUtils.buffers_equal(buffer, data.data)) tu.test_complete() def send_handler(err, sock): tu.check_thread() tu.azzert(err is None) tu.azzert(sock == peer1) peer1.send('255.255.255.255', 1234, buffer, send_handler)
def client_connect_handler(err, socket): tu.azzert(err == None) tu.check_thread() tu.azzert(socket.local_address[0] is not None) tu.azzert(socket.local_address[1] > -1) tu.azzert(socket.remote_address[0] is not None) tu.azzert(socket.remote_address[1] > -1) sends = 10 size = 100 sent = Buffer.create() received = Buffer.create() @socket.data_handler def data_handler(data): tu.check_thread() received.append_buffer(data) if received.length == sends * size: tu.azzert(TestUtils.buffers_equal(sent, received)) tu.test_complete() #Just call the methods. Real testing is done in java tests @socket.drain_handler def drain_handler(): tu.check_thread() @socket.end_handler def end_handler(): tu.check_thread() @socket.close_handler def close_handler(): tu.check_thread() socket.pause() socket.resume() socket.write_queue_full socket.write_queue_max_size = 100000 for i in range(0, sends): data = TestUtils.gen_buffer(size) sent.append_buffer(data) socket.write(data)
def peer2_listen_handler(err, serv): tu.check_thread() tu.azzert(err is None) tu.azzert(serv == peer2) buffer = TestUtils.gen_buffer(128) @peer2.data_handler def data_handler(data): tu.check_thread() tu.azzert(TestUtils.buffers_equal(buffer, data.data)) tu.test_complete() def send_handler(err, result): tu.check_thread() tu.azzert(err is None) tu.azzert(result == peer1) peer1.send('127.0.0.1', 1234, buffer, send_handler)
def test_echo(self): @peer1.exception_handler def exception_handler(err): tu.azzert(False) @peer2.exception_handler def exception_handler(err): tu.azzert(False) buffer = TestUtils.gen_buffer(128) def peer2_listen_handler(err, sock): @peer2.data_handler def data_handler(data): tu.check_thread() tu.azzert(TestUtils.buffers_equal(buffer, data.data)) def send_handler(err, sock): tu.check_thread() tu.azzert(err is None) tu.azzert(sock == peer2) peer2.send('127.0.0.1', 1235, data.data, send_handler) def peer1_listen_handler(err, sock): @peer1.data_handler def data_handler(data): tu.check_thread() tu.azzert(TestUtils.buffers_equal(buffer, data.data)) tu.test_complete() def send_handler(err, sock): tu.check_thread() tu.azzert(err is None) tu.azzert(sock == peer1) peer1.send('127.0.0.1', 1234, buffer, send_handler) peer1.listen(1235, '127.0.0.1', peer1_listen_handler) peer2.listen(1234, '127.0.0.1', peer2_listen_handler)
def echo(self, binary): @server.websocket_handler def websocket_handler(ws): tu.check_thread() @ws.data_handler def data_handler(buff): tu.check_thread() ws.write(buff) if binary: self.buff = TestUtils.gen_buffer(1000) else: self.str_ = TestUtils.random_unicode_string(1000) def connect_handler(ws): tu.check_thread() received = Buffer.create() @ws.data_handler def data_handler(buff): tu.check_thread() received.append_buffer(buff) if received.length == buff.length: tu.azzert(TestUtils.buffers_equal(buff, received)) tu.test_complete() if binary: ws.write_binary_frame(self.buff) else: ws.write_text_frame(self.str_) def listen_handler(err, serv): tu.azzert(err == None) tu.azzert(serv == server) client.connect_web_socket("/someurl", connect_handler) server.listen(8080, "0.0.0.0", listen_handler)
def http_method(ssl, method, chunked): logger.info("in http method %s" % method) if ssl: server.ssl = True server.key_store_path = "./src/test/keystores/server-keystore.jks" server.key_store_password = "******" server.trust_store_path = "./src/test/keystores/server-truststore.jks" server.trust_store_password = "******" server.client_auth_required = True path = "/someurl/blah.html" query = "param1=vparam1¶m2=vparam2" uri = "http://localhost:8080" + path + "?" + query @server.request_handler def request_handler(req): tu.check_context() tu.azzert(req.uri == uri) tu.azzert(req.method == method) tu.azzert(req.path == path) tu.azzert(req.query == query) tu.azzert(req.headers["header1"] == "vheader1") tu.azzert(req.headers["header2"] == "vheader2") tu.azzert(req.params["param1"] == "vparam1") tu.azzert(req.params["param2"] == "vparam2") req.response.put_header("rheader1", "vrheader1") req.response.put_header("rheader2", "vrheader2") body = Buffer.create() @req.data_handler def data_handler(data): tu.check_context() body.append_buffer(data) req.response.chunked = chunked @req.end_handler def end_handler(stream): tu.check_context() if method != "HEAD" and method != "CONNECT": if not chunked: req.response.put_header("Content-Length", body.length) req.response.write_buffer(body) if chunked: req.response.put_trailer("trailer1", "vtrailer1") req.response.put_trailer("trailer2", "vtrailer2") req.response.end() server.listen(8080) if ssl: client.ssl = True client.key_store_path = "./src/test/keystores/client-keystore.jks" client.key_store_password = "******" client.trust_store_path = "./src/test/keystores/client-truststore.jks" client.trust_store_password = "******" sent_buff = TestUtils.gen_buffer(1000) def response_handler(resp): tu.check_context() tu.azzert(200 == resp.status_code) tu.azzert("vrheader1" == resp.headers["rheader1"]) tu.azzert("vrheader2" == resp.headers["rheader2"]) body = Buffer.create() @resp.data_handler def data_handler(data): tu.check_context() body.append_buffer(data) @resp.end_handler def end_handler(stream): tu.check_context() if method != "HEAD" and method != "CONNECT": tu.azzert(TestUtils.buffers_equal(sent_buff, body)) if chunked: tu.azzert("vtrailer1" == resp.trailers["trailer1"]) tu.azzert("vtrailer2" == resp.trailers["trailer2"]) tu.test_complete() request = client.request(method, uri, response_handler) request.chunked = chunked request.put_header("header1", "vheader1") request.put_header("header2", "vheader2") if not chunked: request.put_header("Content-Length", sent_buff.length) request.write_buffer(sent_buff) request.end()
def test_set(self): set1 = SharedData.get_set("set1") tu.azzert(set1 != None) set2 = SharedData.get_set("set1") tu.azzert(set2 != None) tu.azzert(set1 == set2) set3 = SharedData.get_set("set3") tu.azzert(set3 != None) tu.azzert(set1 != set3) set1.add("foo") set1.add("bar") set1.add("quux") tu.azzert(3 == len(set1)) tu.azzert("foo" in set1) tu.azzert("bar" in set1) tu.azzert("quux" in set1) tu.azzert(not ("wibble" in set1)) tu.azzert(not set1.empty()) set1.delete("foo") tu.azzert(2 == len(set1)) tu.azzert(2 == set1.size()) tu.azzert(not ("foo" in set1)) tu.azzert("bar" in set1) tu.azzert("quux" in set1) tu.azzert(not set1.empty()) set1.clear() tu.azzert(set1.empty()) set1.add("foo") set1.add("bar") set1.add("quux") set2 = set() @set1.each def each(o): set2.add(o) tu.azzert("foo" in set2) tu.azzert("bar" in set2) tu.azzert("quux" in set2) set1.clear() set1.add(12) @set1.each def each2(elem): tu.azzert(elem == 12) set1.clear() set1.add(1.234) @set1.each def each3(elem): tu.azzert(elem == 1.234) set1.clear() set1.add("foo") @set1.each def each4(elem): tu.azzert(elem == "foo") tu.azzert(isinstance(elem, unicode)) set1.clear() set1.add(True) @set1.each def each5(elem): tu.azzert(elem == True) set1.clear() set1.add(False) @set1.each def each6(elem): tu.azzert(elem == False) buff = TestUtils.gen_buffer(100) set1.clear() set1.add(buff) @set1.each def each7(elem): tu.azzert(TestUtils.buffers_equal(buff, elem)) tu.azzert(buff != elem) tu.azzert(isinstance(elem, Buffer)) set1.clear() succeeded = False try: set1.add(SomeOtherClass()) succeeded = True except: pass # OK tu.azzert(not succeeded, 'Should throw exception') tu.azzert(SharedData.remove_set("set1")) tu.azzert(not SharedData.remove_set("set1")) tu.azzert(SharedData.remove_set("set3")) tu.test_complete()
def http_method(ssl, method, chunked): logger.info("in http method %s" % method) if ssl: server.ssl = True server.key_store_path = './src/test/keystores/server-keystore.jks' server.key_store_password = '******' server.trust_store_path = './src/test/keystores/server-truststore.jks' server.trust_store_password = '******' server.client_auth_required = True path = "/someurl/blah.html" query = "param1=vparam1¶m2=vparam2" uri = "http://localhost:8080" + path + "?" + query @server.request_handler def request_handler(req): tu.check_context() tu.azzert(req.uri == uri) tu.azzert(req.method == method) tu.azzert(req.path == path) tu.azzert(req.query == query) tu.azzert(req.headers['header1'] == 'vheader1') tu.azzert(req.headers['header2'] == 'vheader2') tu.azzert(req.params['param1'] == 'vparam1') tu.azzert(req.params['param2'] == 'vparam2') req.response.put_header('rheader1', 'vrheader1') req.response.put_header('rheader2', 'vrheader2') body = Buffer.create() @req.data_handler def data_handler(data): tu.check_context() body.append_buffer(data) req.response.chunked = chunked @req.end_handler def end_handler(stream): tu.check_context() if not chunked: req.response.put_header('Content-Length', body.length) req.response.write_buffer(body) if chunked: req.response.put_trailer('trailer1', 'vtrailer1') req.response.put_trailer('trailer2', 'vtrailer2') req.response.end() server.listen(8080) if ssl: client.ssl = True client.key_store_path = './src/test/keystores/client-keystore.jks' client.key_store_password = '******' client.trust_store_path = './src/test/keystores/client-truststore.jks' client.trust_store_password = '******' sent_buff = TestUtils.gen_buffer(1000) def response_handler(resp): tu.check_context() tu.azzert(200 == resp.status_code) tu.azzert('vrheader1' == resp.headers['rheader1']) tu.azzert('vrheader2' == resp.headers['rheader2']) body = Buffer.create() @resp.data_handler def data_handler(data): tu.check_context() body.append_buffer(data) @resp.end_handler def end_handler(stream): tu.check_context() tu.azzert(TestUtils.buffers_equal(sent_buff, body)) if chunked: tu.azzert('vtrailer1' == resp.trailers['trailer1']) tu.azzert('vtrailer2' == resp.trailers['trailer2']) tu.test_complete() request = client.request(method, uri, response_handler) request.chunked = chunked request.put_header('header1', 'vheader1') request.put_header('header2', 'vheader2') if not chunked: request.put_header('Content-Length', sent_buff.length) request.write_buffer(sent_buff) request.end()
def create_buffer(self, len): return TestUtils.gen_buffer(len)
def http_method(ssl, method, chunked): logger.info("in http method %s"% method) server.compression_supported = True tu.azzert(server.compression_supported) if ssl: server.ssl = True server.key_store_path = './src/test/keystores/server-keystore.jks' server.key_store_password = '******' server.trust_store_path = './src/test/keystores/server-truststore.jks' server.trust_store_password = '******' server.client_auth_required = True path = "/someurl/blah.html" query = "param1=vparam1¶m2=vparam2" uri = "http://localhost:8080" + path + "?" + query; @server.request_handler def request_handler(req): tu.check_thread() tu.azzert(req.version == 'HTTP_1_1') tu.azzert(req.uri == uri) tu.azzert(req.method == method) tu.azzert(req.path == path) tu.azzert(req.query == query) tu.azzert(req.headers['header1'] == 'vheader1') tu.azzert(req.headers['header2'] == 'vheader2') tu.azzert(req.params['param1'] == 'vparam1') tu.azzert(req.params['param2'] == 'vparam2') headers = req.headers tu.azzert(headers.contains('header1')) tu.azzert(headers.contains('header2')) tu.azzert(headers.contains('header3')) tu.azzert(not headers.is_empty) headers.remove('header3') tu.azzert(not headers.contains('header3')) req.response.put_header('rheader1', 'vrheader1') req.response.put_header('rheader2', 'vrheader2') body = Buffer.create() @req.data_handler def data_handler(data): tu.check_thread() body.append_buffer(data) if method != 'HEAD' and method != 'CONNECT': req.response.chunked = chunked @req.end_handler def end_handler(): tu.check_thread() if method != 'HEAD' and method != 'CONNECT': if not chunked: req.response.put_header('Content-Length', str(body.length)) req.response.write(body) if chunked: req.response.put_trailer('trailer1', 'vtrailer1') req.response.put_trailer('trailer2', 'vtrailer2') req.response.end() client.try_use_compression = False tu.azzert(client.try_use_compression == False) if ssl: client.ssl = True client.key_store_path = './src/test/keystores/client-keystore.jks' client.key_store_password = '******' client.trust_store_path = './src/test/keystores/client-truststore.jks' client.trust_store_password = '******' sent_buff = TestUtils.gen_buffer(1000) def response_handler(resp): tu.check_thread() tu.azzert(200 == resp.status_code) tu.azzert('vrheader1' == resp.headers['rheader1']) tu.azzert('vrheader2' == resp.headers['rheader2']) body = Buffer.create() @resp.data_handler def data_handler(data): tu.check_thread() body.append_buffer(data) @resp.end_handler def end_handler(): tu.check_thread() if method != 'HEAD' and method != 'CONNECT': tu.azzert(TestUtils.buffers_equal(sent_buff, body)) if chunked: tu.azzert('vtrailer1' == resp.trailers['trailer1']) tu.azzert('vtrailer2' == resp.trailers['trailer2']) resp.headers.clear() tu.azzert(resp.headers.is_empty) tu.test_complete() def listen_handler(err, serv): tu.azzert(err == None) tu.azzert(serv == server) request = client.request(method, uri, response_handler) request.chunked = chunked request.put_header('header1', 'vheader1') request.put_header('header2', 'vheader2') if not chunked: request.put_header('Content-Length', str(sent_buff.length)) request.headers.add('header3', 'vheader3_1').add('header3', 'vheader3') size = request.headers.size names = request.headers.names() tu.azzert(size == len(names)) for k in names: tu.azzert(request.headers.get_all(k) is not None) request.write(sent_buff) request.end() server.listen(8080, "0.0.0.0", listen_handler)
def http_method(ssl, method, chunked): logger.info("in http method %s" % method) if ssl: server.ssl = True server.key_store_path = './src/test/keystores/server-keystore.jks' server.key_store_password = '******' server.trust_store_path = './src/test/keystores/server-truststore.jks' server.trust_store_password = '******' server.client_auth_required = True path = "/someurl/blah.html" query = "param1=vparam1¶m2=vparam2" uri = "http://localhost:8080" + path + "?" + query @server.request_handler def request_handler(req): tu.check_thread() tu.azzert(req.version == 'HTTP_1_1') tu.azzert(req.uri == uri) tu.azzert(req.method == method) tu.azzert(req.path == path) tu.azzert(req.query == query) tu.azzert(req.headers['header1'] == 'vheader1') tu.azzert(req.headers['header2'] == 'vheader2') tu.azzert(req.params['param1'] == 'vparam1') tu.azzert(req.params['param2'] == 'vparam2') headers = req.headers tu.azzert(headers.contains('header1')) tu.azzert(headers.contains('header2')) tu.azzert(headers.contains('header3')) tu.azzert(not headers.is_empty) headers.remove('header3') tu.azzert(not headers.contains('header3')) req.response.put_header('rheader1', 'vrheader1') req.response.put_header('rheader2', 'vrheader2') body = Buffer.create() @req.data_handler def data_handler(data): tu.check_thread() body.append_buffer(data) if method != 'HEAD' and method != 'CONNECT': req.response.chunked = chunked @req.end_handler def end_handler(): tu.check_thread() if method != 'HEAD' and method != 'CONNECT': if not chunked: req.response.put_header('Content-Length', str(body.length)) req.response.write(body) if chunked: req.response.put_trailer('trailer1', 'vtrailer1') req.response.put_trailer('trailer2', 'vtrailer2') req.response.end() if ssl: client.ssl = True client.key_store_path = './src/test/keystores/client-keystore.jks' client.key_store_password = '******' client.trust_store_path = './src/test/keystores/client-truststore.jks' client.trust_store_password = '******' sent_buff = TestUtils.gen_buffer(1000) def response_handler(resp): tu.check_thread() tu.azzert(200 == resp.status_code) tu.azzert('vrheader1' == resp.headers['rheader1']) tu.azzert('vrheader2' == resp.headers['rheader2']) body = Buffer.create() @resp.data_handler def data_handler(data): tu.check_thread() body.append_buffer(data) @resp.end_handler def end_handler(): tu.check_thread() if method != 'HEAD' and method != 'CONNECT': tu.azzert(TestUtils.buffers_equal(sent_buff, body)) if chunked: tu.azzert('vtrailer1' == resp.trailers['trailer1']) tu.azzert('vtrailer2' == resp.trailers['trailer2']) resp.headers.clear() tu.azzert(resp.headers.is_empty) tu.test_complete() def listen_handler(err, serv): tu.azzert(err == None) tu.azzert(serv == server) request = client.request(method, uri, response_handler) request.chunked = chunked request.put_header('header1', 'vheader1') request.put_header('header2', 'vheader2') if not chunked: request.put_header('Content-Length', str(sent_buff.length)) request.headers.add('header3', 'vheader3_1').add('header3', 'vheader3') size = request.headers.size names = request.headers.names() tu.azzert(size == len(names)) for k in names: tu.azzert(request.headers.get_all(k) is not None) request.write(sent_buff) request.end() server.listen(8080, "0.0.0.0", listen_handler)
def http_method(ssl, method, chunked): logger.info("in http method %s"% method) if ssl: server.ssl = True server.key_store_path = './src/test/keystores/server-keystore.jks' server.key_store_password = '******' server.trust_store_path = './src/test/keystores/server-truststore.jks' server.trust_store_password = '******' server.client_auth_required = True path = "/someurl/blah.html" query = "param1=vparam1¶m2=vparam2" uri = "http://localhost:8080" + path + "?" + query; @server.request_handler def request_handler(req): tu.check_context() tu.azzert(req.uri == uri) tu.azzert(req.method == method) tu.azzert(req.path == path) tu.azzert(req.query == query) tu.azzert(req.headers['header1'] == 'vheader1') tu.azzert(req.headers['header2'] == 'vheader2') tu.azzert(req.params['param1'] == 'vparam1') tu.azzert(req.params['param2'] == 'vparam2') req.response.put_header('rheader1', 'vrheader1') req.response.put_header('rheader2', 'vrheader2') body = Buffer.create() @req.data_handler def data_handler(data): tu.check_context() body.append_buffer(data) req.response.chunked = chunked @req.end_handler def end_handler(stream): tu.check_context() if not chunked: req.response.put_header('Content-Length', body.length) req.response.write_buffer(body) if chunked: req.response.put_trailer('trailer1', 'vtrailer1') req.response.put_trailer('trailer2', 'vtrailer2') req.response.end() server.listen(8080) if ssl: client.ssl = True client.key_store_path = './src/test/keystores/client-keystore.jks' client.key_store_password = '******' client.trust_store_path = './src/test/keystores/client-truststore.jks' client.trust_store_password = '******' sent_buff = TestUtils.gen_buffer(1000) def response_handler(resp): tu.check_context() tu.azzert(200 == resp.status_code) tu.azzert('vrheader1' == resp.headers['rheader1']) tu.azzert('vrheader2' == resp.headers['rheader2']) body = Buffer.create() @resp.data_handler def data_handler(data): tu.check_context() body.append_buffer(data) @resp.end_handler def end_handler(stream): tu.check_context() tu.azzert(TestUtils.buffers_equal(sent_buff, body)) if chunked: tu.azzert('vtrailer1' == resp.trailers['trailer1']) tu.azzert('vtrailer2' == resp.trailers['trailer2']) tu.test_complete() request = client.request(method, uri, response_handler) request.chunked = chunked request.put_header('header1', 'vheader1') request.put_header('header2', 'vheader2') if not chunked: request.put_header('Content-Length', sent_buff.length) request.write_buffer(sent_buff) request.end()