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" }
