def vertx_stop(): tu.unregister_all() if peer1 is not None: def close_handler(): if peer2 is not None: def close_handler(): tu.app_stopped() peer2.close(close_handler) else: tu.app_stopped() peer1.close(close_handler) elif peer2 is not None: def close_handler(): tu.app_stopped() peer2.close(close_handler) else: tu.app_stopped() tu.register_all(DatagramTest()) tu.app_ready()
# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import vertx from test_utils import TestUtils tu = TestUtils() execfile("src/test/python_scripts/core/scriptloading/script1.py") class ScriptingLoadingTest(object): def test_scriptloading(self): tu.azzert(Foo.func1(tu) == "foo") tu.test_complete() def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(ScriptingLoadingTest()) tu.app_ready()
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from test_utils import TestUtils tu = TestUtils() test_global = None class IsolationTest(object): def test_isolation(self): global test_global # Make sure global variables aren't visible between applications tu.azzert(test_global == None) test_global = 123 tu.test_complete() def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(IsolationTest()) tu.app_ready()
def test_copy(self): str = "iajdoiqwjdiqwdioqwdjiqwd" buff1 = Buffer.create(str) buff2 = buff1.copy() tu.azzert(buff1.length == buff2.length) for i in range(0, buff1.length): tu.azzert(buff1.get_byte(i) == buff2.get_byte(i)) tu.test_complete() def test_create(self): buff1 = Buffer.create() tu.azzert(0 == buff1.length) buff2 = Buffer.create(100) tu.azzert(0 == buff1.length) str = "oqkdioqjwdijqwed" buff3 = Buffer.create_from_str(str) tu.azzert(str == buff3.to_string()) tu.test_complete() def create_buffer(self, len): return TestUtils.gen_buffer(len) def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(BufferTest()) tu.app_ready()
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 vertx_stop(): tu.check_context() tu.unregister_all() client.close() def close_handler(): tu.app_stopped() server.close(close_handler) tu.register_all(HttpTest()) tu.app_ready()
# you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from test_utils import TestUtils from foo_class import FooClass tu = TestUtils() class ScriptingLoadingTest(object): def test_scriptloading(self): tu.azzert(FooClass().foo() == "foo") tu.test_complete() def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(ScriptingLoadingTest()) tu.app_ready()
client.ssl = True client.key_store_path = "foo.jks" client.key_store_password = "******" client.trust_store_path = "bar.jks" client.trust_store_password = "******" client.trust_all = True client.send_buffer_size = 123123 client.receive_buffer_size = 218123 client.tcp_keep_alive = True client.reuse_address = True client.so_linger = True client.traffic_class = 123 client.close() tu.test_complete() def vertx_stop(): tu.unregister_all() client.close() def close_handler(): tu.app_stopped() server.close(close_handler) tu.register_all(NetTest()) tu.app_ready()
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() class SomeOtherClass: pass def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(SharedDataTest()) tu.app_ready()
tu.test_complete() def test_copy(self): str = "iajdoiqwjdiqwdioqwdjiqwd" buff1 = Buffer.create(str) buff2 = buff1.copy() tu.azzert(buff1.length == buff2.length) for i in range(0,buff1.length): tu.azzert(buff1.get_byte(i) == buff2.get_byte(i)) tu.test_complete() def test_create(self): buff1 = Buffer.create() tu.azzert(0 == buff1.length) buff2 = Buffer.create(100) tu.azzert(0 == buff1.length) str = "oqkdioqjwdijqwed" buff3 = Buffer.create_from_str(str) tu.azzert(str == buff3.to_string()) tu.test_complete() def create_buffer(self, len): return TestUtils.gen_buffer(len) def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(BufferTest()) tu.app_ready()
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) fs.open(filename, handler=open_handler) def vertx_stop(): tu.check_thread() fs.delete_recursive_sync(FILEDIR) tu.unregister_all() tu.app_stopped() tu.register_all(FileSystemTest()) setup(tu.app_ready)
req.response.end() def listen_handler(err, serv): tu.azzert(err == None) tu.azzert(serv == server) if regex: getattr(rm, method + '_re')(pattern, handler) else: getattr(rm, method)(pattern, handler) def response_handler(resp): tu.azzert(200 == resp.status_code) tu.test_complete() getattr(client, m)(uri, response_handler).end() server.listen(8080, '0.0.0.0', listen_handler) def vertx_stop(): tu.unregister_all() client.close() def close_handler(err, ok): tu.app_stopped() server.close(close_handler) tu.register_all(RouteMatcherTest()) tu.app_ready()
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from test_utils import TestUtils import vertx tu = TestUtils() class ContextTest(object): def test_run_on_context(self): def handler(): tu.check_thread() tu.test_complete() vertx.run_on_context(handler) def test_get_context(self): def handler(): tu.check_thread() tu.test_complete() ctx = vertx.current_context() ctx.run_on_context(handler) def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(ContextTest()) tu.app_ready()
class ParseToolsTest(object): def test_delimited(self): str = "" iters = 100 for i in range(0, iters): str += "line %s"% i if i != iters - 1: str += "\n" self.lines = [] def each_line(line): self.lines.append(line) parser = RecordParser.new_delimited("\n", each_line) parser.input(Buffer.create_from_str(str)) count = 0 for line in self.lines: tu.azzert("line %i"% count == line.to_string()) count += 1 tu.test_complete() def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(ParseToolsTest()) tu.app_ready()
class TimerTest(object): def test_one_off(self): def handler(timer_id): tu.check_thread() tu.test_complete() vertx.set_timer(10, handler) def test_periodic(self): fires = 10 self.count = 0 def handler(timer_id): tu.check_thread() self.count += 1 if self.count == fires: vertx.cancel_timer(timer_id) # End test in another timer in case the first timer fires again - we want to catch that def complete(timer_id): tu.test_complete() vertx.set_timer(100, complete) elif self.count > fires: tu.azzert(False, 'Fired too many times') vertx.set_periodic(10, handler) def vertx_stop(): tu.check_thread() tu.unregister_all() tu.app_stopped() tu.register_all(TimerTest()) tu.app_ready()
handler_id = None class DeployTest(object): def test_deploy(self): global handler_id def handler(message): if message.body == "started": tu.test_complete() handler_id = EventBus.register_handler("test-handler", False, handler) conf = {'foo' : 'bar'} vertx.deploy_verticle("core/deploy/child.py", conf) def test_undeploy(self): global handler_id def handler(message): if message.body == "stopped": tu.test_complete() handler_id = EventBus.register_handler("test-handler", False, handler) conf = {'foo' : 'bar'} def deploy_handler(id): vertx.undeploy_verticle(id) vertx.deploy_verticle("core/deploy/child.py", conf, handler=deploy_handler) def vertx_stop(): EventBus.unregister_handler(handler_id) tu.unregister_all() tu.app_stopped() tu.register_all(DeployTest()) tu.app_ready()
ws.close() def connect_handler(ws): tu.check_thread() @ws.close_handler def close_handler(): tu.test_complete() 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 vertx_stop(): tu.check_thread() tu.unregister_all() client.close() def close_handler(err, ok): tu.app_stopped() server.close(close_handler) tu.register_all(WebsocketTest()) tu.app_ready()
tu.azzert(peer1.multicast_time_to_live != 2) peer1.multicast_time_to_live = 2 tu.azzert(peer1.multicast_time_to_live == 2) tu.test_complete() def vertx_stop(): tu.unregister_all() if peer1 is not None: def close_handler(): if peer2 is not None: def close_handler(): tu.app_stopped() peer2.close(close_handler) else: tu.app_stopped() peer1.close(close_handler) elif peer2 is not None: def close_handler(): tu.app_stopped() peer2.close(close_handler) else: tu.app_stopped() tu.register_all(DatagramTest()) tu.app_ready()
def reply_handler1(reply): tu.azzert("reply-of-reply" == reply.body) reply.reply("reply-of-reply-of-reply") msg.reply("reply", reply_handler1) id = EventBus.register_handler(address, handler=handler) def reply_handler2(reply): tu.azzert("reply" == reply.body) def reply_handler3(reply2): tu.azzert("reply-of-reply-of-reply" == reply2.body) EventBus.unregister_handler(id) tu.test_complete() reply.reply("reply-of-reply", reply_handler3) EventBus.send(address, "message", reply_handler2) def vertx_stop(): tu.check_context() tu.unregister_all() tu.app_stopped() tu.register_all(EventBusTest()) tu.app_ready()
client = vertx.create_net_client() client.ssl=True client.key_store_path="foo.jks" client.key_store_password="******" client.trust_store_path="bar.jks" client.trust_store_password="******" client.trust_all=True client.send_buffer_size=123123 client.receive_buffer_size=218123 client.tcp_keep_alive=True client.reuse_address=True client.so_linger = True client.traffic_class=123 client.close() tu.test_complete() def vertx_stop(): tu.unregister_all() client.close() def close_handler(): tu.app_stopped() server.close(close_handler) tu.register_all(NetTest()) tu.app_ready()
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() class SomeOtherClass: pass def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(SharedDataTest()) tu.app_ready()
def closed_handler(): tu.test_complete() ws.write_text_frame("foo") client.connect_web_socket("/someurl",connect_handler) def test_close_from_connect(self): @server.websocket_handler def websocket_handler(ws): tu.check_context() ws.close() server.listen(8080) def connect_handler(ws): tu.check_context() @ws.closed_handler def closed_handler(): tu.test_complete() client.connect_web_socket("/someurl", connect_handler) def vertx_stop(): tu.check_context() tu.unregister_all() client.close() @server.close def close(): tu.app_stopped() tu.register_all(WebsocketTest()) tu.app_ready()
str = "" iters = 100 for i in range(0, iters): str += "line %s" % i if i != iters - 1: str += "\n" self.lines = [] def each_line(line): self.lines.append(line) parser = RecordParser.new_delimited("\n", each_line) parser.input(Buffer.create_from_str(str)) count = 0 for line in self.lines: tu.azzert("line %i" % count == line.to_string()) count += 1 tu.test_complete() def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(ParseToolsTest()) tu.app_ready()
@bridge.unregister_handler def handler(socket, address): tu.azzert(isinstance(socket, SockJSSocket)) tu.azzert(address == 'some-address') tu.test_complete() bridge.hook.handleUnregister(None, 'some-address') def test_authorise_hook(self): server = vertx.create_sockjs_server(vertx.create_http_server()) bridge = server.bridge({'prefix': '/eventbus'}, [], []) @bridge.authorise_handler def handler(message, session_id, handler): tu.azzert(message['foo'] == 'bar') tu.azzert(session_id == 'some-id') handler(True) def done_handler(error, result): tu.azzert(error is None) tu.azzert(result) tu.test_complete() bridge.hook.handleAuthorise({'foo': 'bar'}, 'some-id', AsyncHandler(done_handler)) def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(SockJSTest()) tu.app_ready()
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) fs.open(filename, handler=open_handler) def vertx_stop(): tu.check_thread() fs.delete_recursive_sync(FILEDIR) tu.unregister_all() tu.app_stopped() tu.register_all(FileSystemTest()) setup(tu.app_ready)
EventBus.send(address, msg, reply_handler) def test_reply_of_reply_of_reply(self): address = "some-address" def handler(msg): tu.azzert("message" == msg.body) def reply_handler1(reply): tu.azzert("reply-of-reply" == reply.body) reply.reply("reply-of-reply-of-reply") msg.reply("reply", reply_handler1) id = EventBus.register_handler(address, handler=handler) def reply_handler2(reply): tu.azzert("reply" == reply.body) def reply_handler3(reply2): tu.azzert("reply-of-reply-of-reply" == reply2.body) EventBus.unregister_handler(id) tu.test_complete() reply.reply("reply-of-reply", reply_handler3) EventBus.send(address, "message", reply_handler2) def vertx_stop(): tu.check_thread() tu.unregister_all() tu.app_stopped() tu.register_all(EventBusTest()) tu.app_ready()
# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from test_utils import TestUtils tu = TestUtils() test_global = None class IsolationTest(object): def test_isolation(self): global test_global # Make sure global variables aren't visible between applications tu.azzert(test_global == None) test_global = 123 tu.test_complete() def vertx_stop(): tu.unregister_all() tu.app_stopped() tu.register_all(IsolationTest()) tu.app_ready()
def test_periodic(self): fires = 10 self.count = 0 def handler(timer_id): tu.check_thread() self.count += 1 if self.count == fires: vertx.cancel_timer(timer_id) # End test in another timer in case the first timer fires again - we want to catch that def complete(timer_id): tu.test_complete() vertx.set_timer(100, complete) elif self.count > fires: tu.azzert(False, 'Fired too many times') vertx.set_periodic(10, handler) def vertx_stop(): tu.check_thread() tu.unregister_all() tu.app_stopped() tu.register_all(TimerTest()) tu.app_ready()
def handler(err, result): tu.check_thread() tu.azzert(err is None) tu.azzert(ptr == result) tu.test_complete() client = self.prepare_dns(org.vertx.testtools.TestDnsServer.testReverseLookup(ptr)) client.reverse_lookup('10.0.0.1', handler) def test_reverse_lookup_ipv6(self): ptr = 'ptr.vertx.io' def handler(err, result): tu.check_thread() tu.azzert(err is None) tu.azzert(ptr == result) tu.test_complete() client = self.prepare_dns(org.vertx.testtools.TestDnsServer.testReverseLookup(ptr)) client.reverse_lookup('::1', handler) def vertx_stop(): if server is not None: server.stop() tu.check_thread() tu.unregister_all() tu.app_stopped() tu.register_all(DnsClientTest()) tu.app_ready()
tu.azzert(len(req.params) == len(params)) for k,v in params.iteritems(): tu.azzert(v == req.params[k]) req.response.end() if regex: #print "calling rm.%s_re with pattern %s"%(method, pattern) getattr(rm, method + '_re')(pattern, handler) else: #print "calling rm.%s with pattern %s"%(method, pattern) getattr(rm, method)(pattern, handler) if method == 'all': method = 'get' def response_handler(resp): tu.azzert(200 == resp.status_code) tu.test_complete() getattr(client, method)(uri, response_handler).end() def vertx_stop(): tu.unregister_all() client.close() @server.close def close(): tu.app_stopped() tu.register_all(RouteMatcherTest()) tu.app_ready()
@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 vertx_stop(): tu.check_context() tu.unregister_all() client.close() def close_handler(): tu.app_stopped() server.close(close_handler) tu.register_all(HttpTest()) tu.app_ready()
handler_id = None def test_deploy(self): global handler_id def handler(message): if message.body == "started": tu.test_complete() handler_id = EventBus.register_handler("test-handler", False, handler) conf = {'foo' : 'bar'} vertx.deploy_verticle("core/deploy/child.py", conf) def test_undeploy(self): global handler_id def handler(message): if message.body == "stopped": tu.test_complete() handler_id = EventBus.register_handler("test-handler", False, handler) conf = {'foo' : 'bar'} def deploy_handler(id): vertx.undeploy_verticle(id) vertx.deploy_verticle("core/deploy/child.py", conf, handler=deploy_handler) def vertx_stop(): EventBus.unregister_handler(handler_id) tu.unregister_all() tu.app_stopped() tu.register_all(DeployTest()) tu.app_ready()
tu.test_complete() client = self.prepare_dns( org.vertx.testtools.TestDnsServer.testReverseLookup(ptr)) client.reverse_lookup('10.0.0.1', handler) def test_reverse_lookup_ipv6(self): ptr = 'ptr.vertx.io' def handler(err, result): tu.check_thread() tu.azzert(err is None) tu.azzert(ptr == result) tu.test_complete() client = self.prepare_dns( org.vertx.testtools.TestDnsServer.testReverseLookup(ptr)) client.reverse_lookup('::1', handler) def vertx_stop(): if server is not None: server.stop() tu.check_thread() tu.unregister_all() tu.app_stopped() tu.register_all(DnsClientTest()) tu.app_ready()