def test_start_stop(): def process_request(request, response): pass with active_interface("smpp", **interface_config(process_request = process_request)): sleep(10.0)
def test_interface_ordering(): file_names = [ "{0:08d}.msg".format(i) for i in range(100) ] shuffle(file_names) for file_name in file_names: write_file(file_name, b"data") loopback_queue = InterlockedQueue() def process_request(request, response): sleep(0.1) loopback_queue.push(request) with active_interface("file_1", **interface_config(process_request = process_request, filename_regex = write_prefix + "[0-9a-f]{8}\\.msg")): for i in range(100): file_name = loopback_queue.pop(3.0)["file_name"] assert os_path.basename(file_name).endswith("{0:08d}.msg".format(i)) if i % 10 == 9: write_file("{0:08d}.msg".format(i // 10), b"data") for i in range(10): file_name = loopback_queue.pop(3.0)["file_name"] assert os_path.basename(file_name).endswith("{0:08d}.msg".format(i)) assert loopback_queue.pop(3.0) is None
def test_send_fragmented(): def process_request(request, response): pass with active_interface("smpp_1", **interface_config(process_request = process_request)): sleep(3.0) # to allow connection to spin up fake_request(30.0) pmnc.transaction.smpp_1.submit_sm( dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = "BEGIN" + "o" * 170 + "END") # with automatic encoding 80 backslashes become 160 gsm7 bytes pmnc.transaction.smpp_1.submit_sm( dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = "BEGIN" + "\\" * 80 + "END") # with automatic encoding 132 international chars becomes 264 unicode bytes pmnc.transaction.smpp_1.submit_sm( dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = russian * 2)
def test_failure(): def process_revrpc_request(module, method, args, kwargs): 1 / 0 with active_interface( "revrpc", **interface_config( process_revrpc_request=process_revrpc_request)): fake_request(3.0) request_dict = pmnc.request.to_dict() request = dict(source_cage="source_cage", target_cage=__cage__, module="module", method="method", args=(), kwargs={}, request=request_dict) poll_queue.push(request) request_id, response = post_queue.pop(3.0) assert request_id == pmnc.request.unique_id error = response.pop("exception") assert not response assert error.startswith("ZeroDivisionError(")
def test_process_timeout(): loopback_queue = InterlockedQueue() delay = Event(); delay.set() def process_request(request, response): if delay.is_set(): sleep(pmnc.request.remain + 1.0) loopback_queue.push(request) with active_interface("jms_1", **interface_config(process_request = process_request, request_timeout = 3.0)): fake_request(10.0) xa = pmnc.transaction.create() xa.jms_1.send("<xml/>") message_id = xa.execute()[0] assert loopback_queue.pop(3.0) is None delay.clear() request = loopback_queue.pop(10.0) assert request["message_id"] == message_id assert request["message_text"] == "<xml/>"
def test_failure(): def process_revrpc_request(module, method, args, kwargs): 1 / 0 with active_interface("revrpc", **interface_config(process_revrpc_request = process_revrpc_request)): fake_request(3.0) request_dict = pmnc.request.to_dict() request = dict(source_cage = "source_cage", target_cage = __cage__, module = "module", method = "method", args = (), kwargs = {}, request = request_dict) poll_queue.push(request) request_id, response = post_queue.pop(3.0) assert request_id == pmnc.request.unique_id error = response.pop("exception") assert not response assert error.startswith("ZeroDivisionError(")
def test_send_many(): loopback_queue = InterlockedQueue() def process_request(request, response): loopback_queue.push(int(request["message_text"])) with active_interface("jms_1", **interface_config(process_request = process_request)): for i in range(200): fake_request(30.0) xa = pmnc.transaction.create() xa.jms_1.send(str(i*5)) xa.jms_1.send(str(i*5+1)) xa.jms_1.send(str(i*5+2)) xa.jms_1.send(str(i*5+3)) xa.jms_1.send(str(i*5+4)) xa.execute() received = [] message_number = loopback_queue.pop(10.0) while message_number is not None: received.append(message_number) message_number = loopback_queue.pop(10.0) assert len(received) == 1000 received_sorted = [] for i in range(200): # every 5 should have been sent atomically received_sorted.extend(list(sorted(received[i*5:(i+1)*5]))) assert received_sorted == list(range(1000))
def test_process_failure(): loopback_queue = InterlockedQueue() fail = Event(); fail.set() def process_request(request, response): if fail.is_set(): sleep(1.0) raise Exception("processing failure") else: loopback_queue.push(request) with active_interface("jms_1", **interface_config(process_request = process_request)): fake_request(10.0) xa = pmnc.transaction.create() xa.jms_1.send("<xml/>") message_id = xa.execute()[0] assert loopback_queue.pop(3.0) is None fail.clear() request = loopback_queue.pop(10.0) assert request["message_id"] == message_id assert request["message_text"] == "<xml/>" headers = request["headers"] assert not headers.get("JMSCorrelationID")
def test_interface_marshaling(): def process_xmlrpc_request(request, response): if request["method"] == "raise": raise Exception(request["args"][0]) response["result"] = [request["method"], request["args"]] with active_interface( "xmlrpc_1", **interface_config( process_xmlrpc_request=process_xmlrpc_request)) as ifc: assert post_string(ifc, "MethodName", "foo", "utf-8") == ["MethodName", ["foo"]] assert post_string(ifc, rus, rus, "cp866") == [rus, [rus]] try: post_string(ifc, "raise", "foo", "iso-8859-5") except Fault as e: assert e.faultCode == 500 and e.faultString.startswith( "Exception(\"foo\")") else: assert False try: post_string(ifc, "raise", rus, "utf-8") except Fault as e: assert e.faultCode == 500 and e.faultString.startswith( "Exception(\"" + rus + "\")") else: assert False
def test_timeout(): def process_revrpc_request(module, method, args, kwargs): sleep(4.0) return "ok" with active_interface( "revrpc", **interface_config( process_revrpc_request=process_revrpc_request)): fake_request(3.0) request_dict = pmnc.request.to_dict() request = dict(source_cage="source_cage", target_cage=__cage__, module="module", method="method", args=(), kwargs={}, request=request_dict) poll_queue.push(request) assert pmnc.request.pop(post_queue) is None request_id, response = post_queue.pop(2.0) assert response == {"result": "ok"}
def test_interface_start_stop(): def process_request(request, response): pass with active_interface("file_1", **interface_config(process_request = process_request, filename_regex = write_prefix + "[0-9a-f]{8}\\.msg")): sleep(3.0)
def test_interface_start_stop(): def process_xmlrpc_request(request, response): pass with active_interface( "xmlrpc_1", **interface_config( process_xmlrpc_request=process_xmlrpc_request)): pass
def drain_queue(): loopback_queue = InterlockedQueue() def process_request(request, response): loopback_queue.push(request) with active_interface("jms_1", **interface_config(process_request = process_request)): while loopback_queue.pop(10.0) is not None: pass
def test_interface_failure(): loopback_queue = InterlockedQueue() def process_request(request, response): not_defined with active_interface( "schedule_1", **interface_config(process_request=process_request)): assert loopback_queue.pop(4.0) is None
def test_processing(): def process_request(request, response): req = request["pdu"] if isinstance(req, QuerySmPDU): resp = req.create_response(message_id = req.message_id.value, final_date = b"", message_state = 0x03, error_code = 0x00) else: raise Exception("not supported") response["pdu"] = resp with active_interface("smpp_1", **interface_config(process_request = process_request, ping_interval = 600.0)) as ifc: sleep(3.0) # to allow connection to spin up ifc._connection._writer.stop() # to prevent writer from interfering fake_request(10.0) ########################### req = EnquireLinkPDU.create() ifc._in_q.push(req) resp = ifc._out_q.pop(3.0) assert isinstance(resp, EnquireLinkRespPDU) assert resp.sequence_number == req.sequence_number ########################### req = QuerySmPDU.create(message_id = b"RECEIPT", source_addr_ton = 0x00, source_addr_npi = 0x01, source_addr = b"SENDER") ifc._in_q.push(req) resp = ifc._out_q.pop(3.0) assert isinstance(resp, QuerySmRespPDU) assert resp.sequence_number == req.sequence_number assert resp.message_id == req.message_id assert resp.final_date.value == b"" assert resp.message_state.value == 0x03 assert resp.error_code.value == 0x00 ########################### req = UnbindPDU.create() ifc._in_q.push(req) resp = ifc._out_q.pop(3.0) assert isinstance(resp, GenericNackPDU) assert resp.sequence_number == req.sequence_number assert resp.command_status.value == error_codes.ESME_RSYSERR
def test_too_large(): fake_request(10.0) q = InterlockedQueue() def process_request(request, response): q.push(request["packet"]) with active_interface("udp", **interface_config(process_request = process_request)) as ifc: pmnc.transaction.udp_1.send(b"x" * 60000) assert q.pop(3.0) is None
def test_timeout(): fake_request(10.0) q = InterlockedQueue() def process_request(request, response): sleep(5.0) with active_interface("udp", **interface_config(process_request = process_request)) as ifc: msg = b"foo" pmnc.transaction.udp_1.send(msg) assert q.pop(3.0) is None
def test_success(): fake_request(10.0) q = InterlockedQueue() def process_request(request, response): q.push(request["packet"]) with active_interface("udp", **interface_config(process_request = process_request)) as ifc: msg = b"foo" pmnc.transaction.udp_1.send(msg) assert q.pop(3.0) == msg
def test_interface_failure(): loopback_queue = InterlockedQueue() def process_request(request, response): not_defined with active_interface("file_1", **interface_config(process_request = process_request, filename_regex = write_prefix + "[0-9a-f]{8}\\.msg")): assert loopback_queue.pop(3.0) is None file_name = write_file(random_filename() + ".msg", b"data") assert os_path.isfile(file_name) assert loopback_queue.pop(3.0) is None assert os_path.isfile(file_name) remove(file_name)
def test_interface_remove(): loopback_queue = InterlockedQueue() def process_request(request, response): remove(request["file_name"]) loopback_queue.push(request) with active_interface("file_1", **interface_config(process_request = process_request, filename_regex = write_prefix + "[0-9a-f]{8}\\.msg")): file_name = write_file(random_filename() + ".msg", b"data") assert loopback_queue.pop(3.0) == dict(file_name = file_name) assert loopback_queue.pop(3.0) is None assert not os_path.exists(file_name)
def test_interface_success(): loopback_queue = InterlockedQueue() def process_request(request, response): sleep(0.1) loopback_queue.push("ok") with active_interface( "schedule_1", **interface_config(process_request=process_request)): assert loopback_queue.pop(4.0) == "ok" assert loopback_queue.pop(1.0) is None assert loopback_queue.pop(3.0) == "ok" assert loopback_queue.pop(1.0) is None assert loopback_queue.pop(3.0) == "ok"
def test_interface_no_wait(): loopback_queue = InterlockedQueue() def process_request(request, response): sleep(5.0) loopback_queue.push(request["invocation_time"]) with active_interface( "schedule_1", **interface_config(process_request=process_request)): dt1 = loopback_queue.pop(9.0) dt2 = loopback_queue.pop(6.0) dt3 = loopback_queue.pop(6.0) assert (dt3 - dt2).seconds == (dt2 - dt1).seconds == 3
def test_success(): def process_revrpc_request(module, method, args, kwargs): return module, method, args, kwargs, pmnc.request.to_dict() with active_interface( "revrpc", **interface_config( process_revrpc_request=process_revrpc_request)): fake_request(3.0) pmnc.request.describe("my request") pmnc.request.parameters["foo"] = "bar" request_dict = pmnc.request.to_dict() request = dict(source_cage="source_cage", target_cage=__cage__, module="module", method="method", args=(1, "2"), kwargs={"biz": "baz"}, request=request_dict) poll_queue.push(request) request_id, response = post_queue.pop(3.0) assert request_id == pmnc.request.unique_id module, method, args, kwargs, request = response.pop("result") assert not response assert module == "module" and method == "method" and args == ( 1, "2") and kwargs == { "biz": "baz" } deadline = request.pop("deadline") assert abs(deadline - (time() + pmnc.request.remain)) < 0.01 assert request == dict \ ( protocol = pmnc.request.protocol, description = "my request", parameters = dict(auth_tokens = { "source_cage": "source_cage" }, foo = "bar"), interface = pmnc.request.interface, unique_id = pmnc.request.unique_id, log_levels = [], )
def test_send_many(): def process_request(request, response): pass with active_interface("smpp_1", **interface_config(process_request = process_request)): sleep(3.0) # to allow connection to spin up fake_request(30.0) xa = pmnc.transaction.create() xa.smpp_1.submit_sm(dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = "test1") xa.smpp_1.submit_sm(dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = "test2") xa.smpp_1.submit_sm(dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = "test3") xa.execute() sleep(10.0)
def test_resource(): def process_xmlrpc_request(request, response): if request["method"] == "ShouldBe.Failing": raise Exception(request["args"][0]) else: response["result"] = request, pmnc.request.parameters[ "auth_tokens"] with active_interface( "xmlrpc_1", **interface_config( process_xmlrpc_request=process_xmlrpc_request)): fake_request(10.0) for i in range(16): s = "*" * 2**i n = "n" + str(i) result = pmnc.transaction.xmlrpc_1.Module.Method( i, s, [s], { s: i, n: None }) assert result == [{ "method": "Module.Method", "args": [i, s, [s], { s: i, n: None }] }, { "username": "******", "peer_ip": "127.0.0.1", "password": "******", "encrypted": False }] try: pmnc.transaction.xmlrpc_1.ShouldBe.Failing("some error") except ResourceError as e: assert e.code == 500 and e.description.startswith( "Exception(\"some error\")") assert not e.recoverable and not e.terminal
def test_interface_broken_requests(): def process_xmlrpc_request(request, response): pass with active_interface( "xmlrpc_1", **interface_config( process_xmlrpc_request=process_xmlrpc_request)) as ifc: s = sendall(ifc, b"POST / HTTP/1.0\nContent-Type: text/plain\n\n") resp = recvall(s) assert resp.startswith(b"HTTP/1.1 415 Unsupported Media Type\r\n") s = sendall( ifc, b"POST / HTTP/1.0\nContent-Type: text/xml\nContent-Length: 3\n\nfoo" ) resp = recvall(s) assert resp.startswith(b"HTTP/1.1 500 Internal Server Error\r\n") assert b"invalid XMLRPC request" in resp
def test_process_one(): loopback_queue = InterlockedQueue() def process_request(request, response): loopback_queue.push(request) with active_interface("jms_1", **interface_config(process_request = process_request)): fake_request(10.0) xa = pmnc.transaction.create() xa.jms_1.send(russian, JMSCorrelationID = russian, FOOBAR = "123") message_id = xa.execute()[0] request = loopback_queue.pop(10.0) assert request["message_id"] == message_id assert request["message_text"] == russian headers = request["headers"] assert headers["JMSCorrelationID"] == russian and headers["FOOBAR"] == "123"
def test_success(): def process_revrpc_request(module, method, args, kwargs): return module, method, args, kwargs, pmnc.request.to_dict() with active_interface("revrpc", **interface_config(process_revrpc_request = process_revrpc_request)): fake_request(3.0) pmnc.request.describe("my request") pmnc.request.parameters["foo"] = "bar" request_dict = pmnc.request.to_dict() request = dict(source_cage = "source_cage", target_cage = __cage__, module = "module", method = "method", args = (1, "2"), kwargs = { "biz": "baz" }, request = request_dict) poll_queue.push(request) request_id, response = post_queue.pop(3.0) assert request_id == pmnc.request.unique_id module, method, args, kwargs, request = response.pop("result") assert not response assert module == "module" and method == "method" and args == (1, "2") and kwargs == { "biz": "baz" } deadline = request.pop("deadline") assert abs(deadline - (time() + pmnc.request.remain)) < 0.01 assert request == dict \ ( protocol = pmnc.request.protocol, description = "my request", parameters = dict(auth_tokens = { "source_cage": "source_cage" }, foo = "bar"), interface = pmnc.request.interface, unique_id = pmnc.request.unique_id, )
def test_deletion_failure(): loopback_queue = InterlockedQueue() def process_request(request, response): loopback_queue.push(request) with active_interface("file_1", **interface_config(process_request = process_request, filename_regex = write_prefix + "[0-9a-f]{8}\\.msg")) as ifc: ifc._remove_file_ = ifc._remove_file ifc._remove_file = lambda file_name: 1 / 0 file_name = write_file(random_filename() + ".msg", b"data") assert loopback_queue.pop(3.0) == dict(file_name = file_name) assert loopback_queue.pop(3.0) is None assert os_path.isfile(file_name) assert ifc._processed_files == { file_name } ifc._remove_file = ifc._remove_file_ assert loopback_queue.pop(3.0) is None assert not os_path.exists(file_name) assert ifc._processed_files == set()
def test_send_one(): def process_request(request, response): pass with active_interface("smpp_1", **interface_config(process_request = process_request)): sleep(3.0) # to allow connection to spin up fake_request(30.0) with expected(ResourceError, "^data_coding is not specified, provide short_message of type str$"): pmnc.transaction.smpp_1.submit_sm( dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = b"test") with expected(ResourceError, "^data_coding is specified, provide short_message of type bytes$"): pmnc.transaction.smpp_1.submit_sm( dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = "test", data_coding = 0x00) pmnc.transaction.smpp_1.submit_sm( dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = b"test1", data_coding = 0x00) pmnc.transaction.smpp_1.submit_sm( dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = "test2") # encoded to GSM7 pmnc.transaction.smpp_1.submit_sm( dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = "@$\\") # encoded to GSM7 pmnc.transaction.smpp_1.submit_sm( dest_addr_ton = DEST_TON, dest_addr_npi = DEST_NPI, destination_addr = DEST_ADDR, short_message = russian) # encoded to UCS2
def test_timeout(): def process_revrpc_request(module, method, args, kwargs): sleep(4.0) return "ok" with active_interface("revrpc", **interface_config(process_revrpc_request = process_revrpc_request)): fake_request(3.0) request_dict = pmnc.request.to_dict() request = dict(source_cage = "source_cage", target_cage = __cage__, module = "module", method = "method", args = (), kwargs = {}, request = request_dict) poll_queue.push(request) assert pmnc.request.pop(post_queue) is None request_id, response = post_queue.pop(2.0) assert response == { "result": "ok" }