def test_default_state():
fake_request(10.0)
assert pmnc.state.get("") is None
assert pmnc.state.get("", "default") == "default"
pmnc.state.set("", None)
assert pmnc.state.get("") is None
assert pmnc.state.get("", "default") is None
pmnc.state.delete("")
assert pmnc.state.get("", "default") == "default"
# and now for str/bytes support
pmnc.state.set(rus, rus + rus)
assert pmnc.state.get(rus) == rus + rus
pmnc.state.delete(rus)
with expected(InputParameterError):
pmnc.state.set(rus_b, rus)
with expected(InputParameterError):
pmnc.state.get(rus_b)
with expected(InputParameterError):
pmnc.state.delete(rus_b)
pmnc.state.set(rus, rus_b)
assert pmnc.state.get(rus) == rus_b
pmnc.state.delete(rus)
def test_bytes_str():
fake_request(5.0)
xa = pmnc.transaction.create()
xa.state.set(rus, rus + rus)
assert xa.execute() == (None, )
xa = pmnc.transaction.create()
xa.state.get(rus)
assert xa.execute() == (rus + rus, )
xa = pmnc.transaction.create()
xa.state.delete(rus)
assert xa.execute() == (None, )
xa = pmnc.transaction.create()
xa.state.get(rus_b)
with expected(ResourceInputParameterError):
xa.execute()
xa = pmnc.transaction.create()
xa.state.set(rus_b, "value")
with expected(ResourceInputParameterError):
xa.execute()
xa = pmnc.transaction.create()
xa.state.delete(rus_b)
with expected(ResourceInputParameterError):
xa.execute()
def test_default_state():
fake_request(10.0)
assert pmnc.state.get("") is None
assert pmnc.state.get("", "default") == "default"
pmnc.state.set("", None)
assert pmnc.state.get("") is None
assert pmnc.state.get("", "default") is None
pmnc.state.delete("")
assert pmnc.state.get("", "default") == "default"
# and now for str/bytes support
pmnc.state.set(rus, rus + rus)
assert pmnc.state.get(rus) == rus + rus
pmnc.state.delete(rus)
with expected(InputParameterError):
pmnc.state.set(rus_b, rus)
with expected(InputParameterError):
pmnc.state.get(rus_b)
with expected(InputParameterError):
pmnc.state.delete(rus_b)
pmnc.state.set(rus, rus_b)
assert pmnc.state.get(rus) == rus_b
pmnc.state.delete(rus)
def test_bytes_str():
fake_request(5.0)
xa = pmnc.transaction.create()
xa.state.set(rus, rus + rus)
assert xa.execute() == (None,)
xa = pmnc.transaction.create()
xa.state.get(rus)
assert xa.execute() == (rus + rus,)
xa = pmnc.transaction.create()
xa.state.delete(rus)
assert xa.execute() == (None,)
xa = pmnc.transaction.create()
xa.state.get(rus_b)
with expected(ResourceInputParameterError):
xa.execute()
xa = pmnc.transaction.create()
xa.state.set(rus_b, "value")
with expected(ResourceInputParameterError):
xa.execute()
xa = pmnc.transaction.create()
xa.state.delete(rus_b)
with expected(ResourceInputParameterError):
xa.execute()
def test_bind_points():
db_config = pmnc.config_resource_postgresql_2.copy()
assert db_config.pop("protocol") == "postgresql_psycopg"
r = Resource("test", **db_config)
assert r._convert_bind_points("", {}) == ("", {})
assert r._convert_bind_points("{i}", dict(i = 123)) == ("%(i)s", dict(i = 123))
assert r._convert_bind_points("{{i}}{i}{{i}}", dict(i = 123)) == ("{i}%(i)s{i}", dict(i = 123))
assert r._convert_bind_points("{i}{i}", dict(i = 123)) == ("%(i)s%(i)s", dict(i = 123))
assert r._convert_bind_points("{i}{{i}}{i}", dict(i = 123)) == ("%(i)s{i}%(i)s", dict(i = 123))
assert r._convert_bind_points("{i}{{i{i}i}}{i}", dict(i = 123)) == ("%(i)s{i%(i)si}%(i)s", dict(i = 123))
assert r._convert_bind_points("", dict(i = 123, s = "foo")) == ("", dict())
assert r._convert_bind_points("{i}", dict(i = 123, s = "foo")) == ("%(i)s", dict(i = 123))
assert r._convert_bind_points("{s}", dict(i = 123, s = "foo")) == ("%(s)s", dict(s = "foo"))
assert r._convert_bind_points("{i}{s}", dict(i = 123, s = "foo")) == ("%(i)s%(s)s", dict(i = 123, s = "foo"))
assert r._convert_bind_points("{s}{i}", dict(i = 123, s = "foo")) == ("%(s)s%(i)s", dict(i = 123, s = "foo"))
assert r._convert_bind_points("{i}{s}{i}", dict(i = 123, s = "foo")) == ("%(i)s%(s)s%(i)s", dict(i = 123, s = "foo"))
assert r._convert_bind_points("{s}{i}{s}", dict(i = 123, s = "foo")) == ("%(s)s%(i)s%(s)s", dict(i = 123, s = "foo"))
assert r._convert_bind_points("{x} {{}} {y} {{}} {z} " * 10000, dict(x = None, y = 123, z = "foo")) == \
("%(x)s {} %(y)s {} %(z)s " * 10000, dict(x = None, y = 123, z = "foo"))
with expected(KeyError("missing")):
r._convert_bind_points("{missing}", {})
with expected(ValueError("Unknown ")):
r._convert_bind_points("{i:d}", dict(i = 123))
def test_qmarks():
db_config = pmnc.config_resource_postgresql_1.copy()
assert db_config.pop("protocol") == "postgresql_pg8000"
r = Resource("test", **db_config)
assert r._convert_to_qmarks("", {}) == ("", ())
assert r._convert_to_qmarks("{i}", dict(i = 123)) == ("?", (123,))
assert r._convert_to_qmarks("{{i}}{i}{{i}}", dict(i = 123)) == ("{i}?{i}", (123,))
assert r._convert_to_qmarks("{i}{i}", dict(i = 123)) == ("??", (123, 123))
assert r._convert_to_qmarks("{i}{{i}}{i}", dict(i = 123)) == ("?{i}?", (123, 123))
assert r._convert_to_qmarks("{i}{{i{i}i}}{i}", dict(i = 123)) == ("?{i?i}?", (123, 123, 123))
assert r._convert_to_qmarks("", dict(i = 123, s = "foo")) == ("", ())
assert r._convert_to_qmarks("{i}", dict(i = 123, s = "foo")) == ("?", (123,))
assert r._convert_to_qmarks("{s}", dict(i = 123, s = "foo")) == ("?", ("foo",))
assert r._convert_to_qmarks("{i}{s}", dict(i = 123, s = "foo")) == ("??", (123, "foo"))
assert r._convert_to_qmarks("{s}{i}", dict(i = 123, s = "foo")) == ("??", ("foo", 123))
assert r._convert_to_qmarks("{i}{s}{i}", dict(i = 123, s = "foo")) == ("???", (123, "foo", 123))
assert r._convert_to_qmarks("{s}{i}{s}", dict(i = 123, s = "foo")) == ("???", ("foo", 123, "foo"))
assert r._convert_to_qmarks("|{s}|{i}|{c}|", dict(i = 123, s = "foo", c = b"")) == ("|?|?|?|", ("foo", 123, b""))
assert r._convert_to_qmarks("{x} ? {y} ? {z} " * 10000, dict(x = None, y = 123, z = "foo")) == \
("? ? ? ? ? " * 10000, (None, 123, "foo") * 10000)
with expected(KeyError("missing")):
r._convert_to_qmarks("{missing}", {})
with expected(ValueError("Unknown ")):
r._convert_to_qmarks("{i:d}", dict(i = 123))
def test_fragmentation():
assert Resource._frag_message(b"") == [ b"" ]
# --- 7 bit encoding ---
# left padding to septet
assert Resource._frag_message(b"\x11", 7, 140, 0) == [ b"\x11" ]
assert Resource._frag_message(b"\xff", 7, 140, 1) == [ b"\x03\xfc" ]
assert Resource._frag_message(b"\x5a\x5a", 7, 140, 2) == [ b"\x02\xd2\xd0" ]
assert Resource._frag_message(b"\x01\x02\x04", 7, 140, 3) == [ b"\x00\x10\x20\x40" ]
assert Resource._frag_message(b"\xfe", 7, 140, 4) == [ b"\x1f\xc0" ]
assert Resource._frag_message(b"\xff\xff\xff", 7, 140, 5) == [ b"\x3f\xff\xff\xc0" ]
assert Resource._frag_message(b"\x01\x80", 7, 140, 6) == [ b"\x00\xc0\x00" ]
assert Resource._frag_message(b"\x11", 7, 140, 7) == [ b"\x11" ]
# fragmentation
assert Resource._frag_message(b"\x01\x02\x03\x04\x05\x06\x07", 7, 7) == \
[ b"\x01\x02\x03\x04\x05\x06\x07" ]
assert Resource._frag_message(b"\x01\x02\x03\x04\x05\x06\x07\x08", 7, 7) == \
[ b"\x01\x02\x03\x04\x05\x06\x07", b"\x08" ]
with expected(Exception("fragment size 8 is too small")):
Resource._frag_message(b"\xff", 7, 8, 1)
assert Resource._frag_message(b"\xff\xff\xff\xff\xff\xff\xff", 7, 9, 1) == \
[ b"\x03\xff\xff\xff\xff\xff\xff\xfc" ]
assert Resource._frag_message(b"\xff\xff\xff\xff\xff\xff\xff\xff", 7, 9, 1) == \
[ b"\x03\xff\xff\xff\xff\xff\xff\xfc", b"\x03\xfc" ]
# --- 8 bit encoding ---
assert Resource._frag_message(b"\x01\x02", 8, 2) == \
[ b"\x01\x02" ]
assert Resource._frag_message(b"\x01\x02", 8, 2, 1) == \
[ b"\x01", b"\x02" ]
# --- 16 bit encoding ---
assert Resource._frag_message(b"\x12\x34", 16) == [ b"\x12\x34" ]
with expected(Exception("fragment size 1 is too small")):
Resource._frag_message(b"\x12\x34", 16, 1)
with expected(Exception("fragment size 2 is too small")):
Resource._frag_message(b"\x12\x34", 16, 2, 1)
assert Resource._frag_message(b"\x01\x02\x03\x04", 16, 3) == \
[ b"\x01\x02", b"\x03\x04" ]
def test_event():
with expected(InputParameterError("event() has got an incompatible value for key: 123")):
pmnc.performance.event(123)
with expected(InputParameterError("event() has got an incompatible value for key: $$$")):
pmnc.performance.event("$$$")
with expected(InputParameterError("event() has got an incompatible value for key: foo")):
pmnc.performance.event("foo")
pmnc.performance.event("interface.foo.request_rate")
def test_event():
with expected(InputParameterError("event() has got an incompatible value for key: 123")):
pmnc.performance.event(123)
with expected(InputParameterError("event() has got an incompatible value for key: $$$")):
pmnc.performance.event("$$$")
with expected(InputParameterError("event() has got an incompatible value for key: foo")):
pmnc.performance.event("foo")
pmnc.performance.event("interface.foo.request_rate")
def test_WorkSource_end_work():
ws = _WorkSource(2.0)
with expected(AssertionError):
ws.end_work()
ws.add_work()
with expected(AssertionError):
ws.end_work()
assert ws.begin_work()
ws.end_work()
with expected(AssertionError):
ws.end_work()
def test_WorkSource_end_work():
ws = _WorkSource(2.0)
with expected(AssertionError):
ws.end_work()
ws.add_work()
with expected(AssertionError):
ws.end_work()
assert ws.begin_work()
ws.end_work()
with expected(AssertionError):
ws.end_work()
def test_sample():
with expected(InputParameterError("sample() has got an incompatible value for key: 123")):
pmnc.performance.sample(123, 1000)
with expected(InputParameterError("sample() has got an incompatible value for key: $$$")):
pmnc.performance.sample("$$$", 1000)
with expected(InputParameterError("sample() has got an incompatible value for key: bar")):
pmnc.performance.sample("bar", 1000)
with expected(InputParameterError("sample() has got an incompatible value for value: value")):
pmnc.performance.sample("resource.bar.processing_time", "value")
pmnc.performance.sample("resource.bar.processing_time", 1000)
def test_sample():
with expected(InputParameterError("sample() has got an incompatible value for key: 123")):
pmnc.performance.sample(123, 1000)
with expected(InputParameterError("sample() has got an incompatible value for key: $$$")):
pmnc.performance.sample("$$$", 1000)
with expected(InputParameterError("sample() has got an incompatible value for key: bar")):
pmnc.performance.sample("bar", 1000)
with expected(InputParameterError("sample() has got an incompatible value for value: value")):
pmnc.performance.sample("resource.bar.processing_time", "value")
pmnc.performance.sample("resource.bar.processing_time", 1000)
def test_transaction_isolation():
fake_request(10.0)
tn = "table_{0:s}".format(random_string(8))
xa = pmnc.transaction.create()
xa.oracle_1.execute("CREATE TABLE {0:s} (ID NUMBER(8) NOT NULL PRIMARY KEY)".format(tn))
xa.execute()
xa = pmnc.transaction.create()
xa.oracle_1.execute("INSERT INTO {0:s} (ID) VALUES ({{id}})".format(tn),
"SELECT ID FROM {0:s}".format(tn), id = 1)
xa.oracle_1.execute("INSERT INTO {0:s} (ID) VALUES ({{id}})".format(tn),
"SELECT ID FROM {0:s}".format(tn), id = 2)
assert xa.execute() == (([], [{ "ID": 1 }]), ([], [{ "ID": 2 }]))
fake_request(5.0)
xa = pmnc.transaction.create()
xa.oracle_1.execute("INSERT INTO {0:s} (ID) VALUES ({{id}})".format(tn), id = 3) # causes a deadlock
xa.oracle_1.execute("INSERT INTO {0:s} (ID) VALUES ({{id}})".format(tn), id = 3)
with expected(Exception("request deadline")):
xa.execute()
fake_request(10.0)
xa = pmnc.transaction.create()
xa.oracle_1.execute("SELECT id FROM {0:s} ORDER BY id".format(tn),
"DROP TABLE {0:s}".format(tn))
assert xa.execute()[0] == ([{ "ID": 1 }, { "ID": 2 }], [])
def test_module_state():
fake_request(10.0)
module_state_dir = _module_state_dir("foo")
module_state = ModuleState(module_state_dir)
try:
# note that the first access to a queue or a database creates it,
# therefore options such as re_len are required, but subsequent
# accesses just open it and the options can be omitted
assert not os_path.exists(os_path.join(module_state_dir, "state.queue"))
queue = module_state.get_queue_db("state", re_len=100)
assert os_path.exists(os_path.join(module_state_dir, "state.queue"))
stat = queue.stat()
assert "buckets" not in stat
queue.append("foo")
assert module_state.get_queue_db("state") is queue
assert module_state.get_queue_db("state2") is not queue
assert not os_path.exists(os_path.join(module_state_dir, "state.btree"))
btree = module_state.get_btree_db("state")
assert os_path.exists(os_path.join(module_state_dir, "state.btree"))
stat = btree.stat()
assert "buckets" not in stat
with expected(bsddb.DBInvalidArgError):
btree.append("foo")
assert module_state.get_btree_db("state") is btree
assert module_state.get_btree_db("state2") is not btree
finally:
module_state.close()
def test_execute_timeout():
fake_request(1.0)
with expected(Exception("request deadline waiting for response")):
pmnc.__getattr__(__name__).execute_reverse("bad_cage", "module",
"method", (), {})
def test_create():
p = PDUParameter(name="foo",
type=SMPPInteger1,
check=lambda v: v.value % 2 == 0)
with expected(
InputParameterError(
"__init__() has got an incompatible value for value: b'bar'"
)):
p.create(b"bar")
assert p.create(0x00) == SMPPInteger1(0)
with expected(Exception("SMPPInteger1(0x01) does not pass the check")):
p.create(0x01)
def test_command():
fake_request(10.0)
with expected(ResourceError, "no such cmd.*"):
pmnc.transaction.mongodb_1.command("no-such-cmd")
# implicit { command: 1 }
pmnc.transaction.mongodb_1.command("ping")
# explicit { command: value }
rs = pmnc.transaction.mongodb_1.command("isMaster", isMaster=1.0)
assert rs.documents[0]["ismaster"] in (True, False)
# with extra params
rs = pmnc.transaction.mongodb_1.command("collStats", {"scale": 1024},
collStats="test")
assert rs.documents[0]["count"] == 100
rs = pmnc.transaction.mongodb_1.command("distinct", {
"key": "k",
"query": {}
},
distinct="test")
vs = rs.documents[0]["values"]
vs.sort()
assert vs == list(range(100))
def test_wait_response():
pdu = EnquireLinkPDU.create()
with expected(Exception("timeout waiting for response to EnquireLinkPDU")):
_wait_response(pdu, 1.0)
resp = pdu.create_response()
pdu.set_response(resp)
before = time()
assert _wait_response(pdu, 0.1) is resp
after = time()
assert after - before < 0.01
resp = pdu.create_nack(error_codes.ESME_RUNKNOWNERR)
pdu.set_response(resp)
with expected(SMPPResponseError("SMPP error ESME_RUNKNOWNERR (Unknown Error)")):
_wait_response(pdu, 0.1)
def test_drop():
fake_request(10.0)
pmnc.transaction.mongodb_1.test.drop()
with expected(ResourceError, ".*not found.*"):
pmnc.transaction.mongodb_1.command("collStats", {},
collStats="test")
def test_request_processing():
fake_request(1.0)
with pmnc.performance.request_processing():
pass
with expected(ZeroDivisionError):
with pmnc.performance.request_processing():
1 / 0
def test_request_processing():
fake_request(1.0)
with pmnc.performance.request_processing():
pass
with expected(ZeroDivisionError):
with pmnc.performance.request_processing():
1 / 0
def test_read():
p = PDUParameter(name="foo",
type=SMPPInteger1,
check=lambda v: v.value % 2 == 0)
assert p.read(BytesIO(
SMPPInteger1(0x00).serialize())) == SMPPInteger1(0x00)
assert p.read(BytesIO(SMPPInteger1(0x00).serialize()),
1) == SMPPInteger1(0x00)
with expected(
InputParameterError(
"read() has got an incompatible value for length: 2")):
p.read(BytesIO(SMPPInteger1(0x00).serialize()), 2)
with expected(Exception("SMPPInteger1(0x01) does not pass the check")):
p.read(BytesIO(SMPPInteger1(0x01).serialize()))
p = PDUParameter(name="foo", type=SMPPInteger1)
assert p.read(BytesIO(
SMPPInteger1(0x01).serialize())) == SMPPInteger1(0x01)
def test_post():
with expected(Exception("the request is no longer pending for response")):
pmnc.__getattr__(__name__).post("RQ-ABC", "RESULT")
rs_queue = InterlockedQueue()
_rs_queues["RQ-ABC"] = rs_queue
pmnc.__getattr__(__name__).post("RQ-ABC", "RESULT")
assert rs_queue.pop() == "RESULT"
def test_close_cursor():
fake_request(10.0)
rs = pmnc.transaction.mongodb_1.test.find(docs_to_return=2)
assert len(rs.documents) == 2 and rs.cursor_id != 0
pmnc.transaction.mongodb_1.kill_cursors([rs.cursor_id])
with expected(ResourceError, "cursor not found"):
pmnc.transaction.mongodb_1.test.get_more(rs.cursor_id)
def test_post():
with expected(
Exception("the request is no longer pending for response")):
pmnc.__getattr__(__name__).post("RQ-ABC", "RESULT")
rs_queue = InterlockedQueue()
_rs_queues["RQ-ABC"] = rs_queue
pmnc.__getattr__(__name__).post("RQ-ABC", "RESULT")
assert rs_queue.pop() == "RESULT"
def test_convert_to_named():
db_config = pmnc.config_resource_oracle_1.copy()
assert db_config.pop("protocol") == "oracle_cx"
r = Resource("test", **db_config)
assert r._convert_to_named("", {}) == ("", {})
assert r._convert_to_named("", { "foo": 1 }) == ("", {})
assert r._convert_to_named("{foo}", { "foo": 1 }) == (":foo", { "foo": 1 })
with expected(KeyError("foo")):
r._convert_to_named("{foo}", {})
assert r._convert_to_named("{{{foo}}}", { "foo": 1, "bar": 2 }) == ("{:foo}", { "foo": 1 })
assert r._convert_to_named("{foo}{foo}", { "foo": 1 }) == (":foo:foo", { "foo": 1 })
assert r._convert_to_named("{foo}:foo:{{foo}}:foo{foo}", { "foo": 1 }) == (":foo:foo:{foo}:foo:foo", { "foo": 1 })
with expected(KeyError("foo{{foo}}")):
r._convert_to_named("{{{foo{{foo}}}}}", { "foo": 1 })
assert r._convert_to_named("{{{foo}{{{foo}}}}}", { "foo": 1, "bar": None }) == ("{:foo{:foo}}", { "foo": 1 })
assert r._convert_to_named("SELECT {foo} FROM {bar}", { "foo": 1, "bar": 2, "biz": "baz" }) == \
("SELECT :foo FROM :bar", { "foo": 1, "bar": 2 })
def test_resource_read():
fn = random_filename()
fake_request(3.0)
pmnc.transaction.file_1.write(fn, b"foobar")
assert pmnc.transaction.file_1.read(fn) == b"foobar"
assert os_path.isfile(target_filename(fn))
assert pmnc.transaction.file_1.read(fn, remove = True, frag_size = 4) == b"foobar"
assert not os_path.isfile(target_filename(fn))
with expected(ResourceError, "^.*never_existed.*$"):
pmnc.transaction.file_1.read("never_existed")
pmnc.transaction.file_1.write(fn, b"\x00" * 33554432)
fake_request(0.1)
with expected(Exception, "^request deadline.*$"):
pmnc.transaction.file_1.read(fn, frag_size = 1)
def test_timedelta():
td = timedelta(minutes = 10)
assert test_value("interval", td) == ([{'value': td}], [], [], [{'value': td}], [])
td = timedelta(microseconds = 1)
assert test_value("interval", td) == ([{'value': td}], [], [], [{'value': td}], [])
td = timedelta(days = 3650, hours = 23, minutes = 59, seconds = 59, microseconds = 999999)
assert test_value("interval", td) == ([{'value': td}], [], [], [{'value': td}], [])
with expected(ResourceError, "month intervals cannot be converted"):
pmnc.transaction.postgresql_1.execute("SELECT '1 month'::interval AS td")
def test_timing():
with expected(InputParameterError("timing() has got an incompatible value for key: 123")):
with pmnc.performance.timing(123):
pass
with expected(InputParameterError("timing() has got an incompatible value for key: $$$")):
with pmnc.performance.timing("$$$"):
pass
with expected(InputParameterError("timing() has got an incompatible value for key: biz")):
with pmnc.performance.timing("biz"):
pass
with pmnc.performance.timing("interface.biz.processing_time") as t:
assert t.elapsed_ms < 100
sleep(1.0)
assert t.elapsed_ms > 900
with expected(Exception("foo")):
with pmnc.performance.timing("interface.biz.processing_time"):
raise Exception("foo")
def test_timing():
with expected(InputParameterError("timing() has got an incompatible value for key: 123")):
with pmnc.performance.timing(123):
pass
with expected(InputParameterError("timing() has got an incompatible value for key: $$$")):
with pmnc.performance.timing("$$$"):
pass
with expected(InputParameterError("timing() has got an incompatible value for key: biz")):
with pmnc.performance.timing("biz"):
pass
with pmnc.performance.timing("interface.biz.processing_time") as t:
assert t.elapsed_ms < 100
sleep(1.0)
assert t.elapsed_ms > 900
with expected(Exception("foo")):
with pmnc.performance.timing("interface.biz.processing_time"):
raise Exception("foo")
def test_queue_many_items():
fake_request(60.0)
q = pmnc.state.get_queue("queue_many_items", re_len=64)
counter = InterlockedCounter()
def _push_n(txn, n):
for i in range(n):
c = counter.next()
_push(txn, q, "test-{0:d}".format(c), pickle)
def push_n(n):
pmnc.state.implicit_transaction(_push_n, n)
# push as much as we can per single transaction
for i in range(8):
push_n(1024)
push_n(2048)
push_n(4096)
push_n(8100)
# until we hit the limit of max_objects (8192) for one transaction
with expected(MemoryError):
push_n(8192)
Timeout(4.0).wait() # wait for checkpoint
# now pop everything off the queue
def _pop_n(txn, n):
for i in range(n):
assert _pop(txn, q, None, unpickle) is not None
def pop_n(n):
pmnc.state.implicit_transaction(_pop_n, n)
assert peek(q) == "test-0"
for i in range(8):
pop_n(8100)
pop_n(4096)
pop_n(2048)
pop_n(1024)
# the attempt to push 8192 records should have left no trace
assert peek(q) is None
def test_queue_many_items():
fake_request(60.0)
q = pmnc.state.get_queue("queue_many_items", re_len=64)
counter = InterlockedCounter()
def _push_n(txn, n):
for i in range(n):
c = counter.next()
_push(txn, q, "test-{0:d}".format(c), pickle)
def push_n(n):
pmnc.state.implicit_transaction(_push_n, n)
# push as much as we can per single transaction
for i in range(8):
push_n(1024)
push_n(2048)
push_n(4096)
push_n(8100)
# until we hit the limit of max_objects (8192) for one transaction
with expected(MemoryError):
push_n(8192)
Timeout(4.0).wait() # wait for checkpoint
# now pop everything off the queue
def _pop_n(txn, n):
for i in range(n):
assert _pop(txn, q, None, unpickle) is not None
def pop_n(n):
pmnc.state.implicit_transaction(_pop_n, n)
assert peek(q) == "test-0"
for i in range(8):
pop_n(8100)
pop_n(4096)
pop_n(2048)
pop_n(1024)
# the attempt to push 8192 records should have left no trace
assert peek(q) is None
def test_deadlock():
fake_request(10.0)
tn = random_name()
pmnc.transaction.mysql_1.execute(
"CREATE TABLE {0:s} (i INT, PRIMARY KEY (i))".format(tn),
"INSERT INTO {0:s} (i) VALUES ({{i}})".format(tn), i = 0)
xa = pmnc.transaction.create()
xa.mysql_1.execute("SELECT * FROM {0:s} WHERE i = {{zero}} FOR UPDATE".format(tn), zero = 0)
xa.mysql_1.execute("SELECT * FROM {0:s} WHERE i = {{zero}} FOR UPDATE".format(tn), zero = 0)
with expected(TransactionExecutionError, "request deadline waiting for intermediate result.*"):
xa.execute()
def test_resource_kill():
fake_request(2.0)
ping = Resource("sleep/1",
executable="sleep",
arguments=(),
environment={})
ping.connect()
try:
ping.set_pool_info("sleep", 1)
with expected(WorkUnitTimedOut):
ping.execute(4)
finally:
ping.disconnect()
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_qmarks():
db_config = pmnc.config_resource_sqlserver_1.copy()
assert db_config.pop("protocol") == "sqlserver_adodb"
r = Resource("test", **db_config)
assert r._convert_to_qmarks("", {}) == ("", ())
assert r._convert_to_qmarks("{i}", dict(i = 123)) == ("?", (123,))
assert r._convert_to_qmarks("{i}", dict(i = None)) == ("NULL", ())
assert r._convert_to_qmarks("{{i}}{i}{{i}}", dict(i = 123)) == ("{i}?{i}", (123,))
assert r._convert_to_qmarks("{i}{i}", dict(i = 123)) == ("??", (123, 123))
assert r._convert_to_qmarks("{i}{i}", dict(i = None)) == ("NULLNULL", ())
assert r._convert_to_qmarks("{i}{{i}}{i}", dict(i = 123)) == ("?{i}?", (123, 123))
assert r._convert_to_qmarks("{i}{{i{i}i}}{i}", dict(i = 123)) == ("?{i?i}?", (123, 123, 123))
assert r._convert_to_qmarks("{i}{{i{i}i}}{i}", dict(i = None)) == ("NULL{iNULLi}NULL", ())
assert r._convert_to_qmarks("", dict(i = 123, s = "foo")) == ("", ())
assert r._convert_to_qmarks("{i}", dict(i = 123, s = "foo")) == ("?", (123,))
assert r._convert_to_qmarks("{s}", dict(i = 123, s = "foo")) == ("?", ("foo",))
assert r._convert_to_qmarks("{i}{s}", dict(i = 123, s = "foo")) == ("??", (123, "foo"))
assert r._convert_to_qmarks("{s}{i}", dict(i = 123, s = "foo")) == ("??", ("foo", 123))
assert r._convert_to_qmarks("{i}{s}{i}", dict(i = 123, s = "foo")) == ("???", (123, "foo", 123))
assert r._convert_to_qmarks("{s}{i}{s}", dict(i = 123, s = "foo")) == ("???", ("foo", 123, "foo"))
assert r._convert_to_qmarks("|{i}|{s}|{c}|", dict(i = 123, s = "foo", c = b"")) == ("|?|?|?|", (123, "foo", b""))
assert r._convert_to_qmarks("|{i}|{s}|{c}|", dict(i = None, s = "foo", c = b"")) == ("|NULL|?|?|", ("foo", b""))
assert r._convert_to_qmarks("|{i}|{s}|{c}|", dict(i = 123, s = None, c = b"")) == ("|?|NULL|?|", (123, b""))
assert r._convert_to_qmarks("|{i}|{s}|{c}|", dict(i = 123, s = "foo", c = None)) == ("|?|?|NULL|", (123, "foo"))
assert r._convert_to_qmarks("? {x} ? {y} ? {z} ? " * 10000, dict(x = None, y = 123, z = "foo")) == \
("? NULL ? ? ? ? ? " * 10000, (123, "foo") * 10000)
with expected(KeyError("missing")):
r._convert_to_qmarks("{missing}", {})
with expected(ValueError("Unknown ")):
r._convert_to_qmarks("{i:d}", dict(i = 123))
def self_test():
from expected import expected
from pmnc.request import fake_request
from pmnc.resource_pool import ResourceError
fake_request(10.0)
assert pmnc.transaction.void.success("foo", biz = "baz") == \
(("foo", ), { "biz": "baz" })
with expected(ResourceError, "failure"):
pmnc.transaction.void.failure()
assert pmnc.transaction.void.execute(lambda *args, **kwargs: (args, kwargs), "foo", biz = "baz") == \
(("foo", ), { "biz": "baz" })
def test_resource_void():
fake_request(1.0)
na = Resource("na/1",
executable="never#existed",
arguments=(),
environment={})
na.connect()
try:
assert na.expired
na.set_pool_info("na", 1)
with expected(Exception):
na.execute()
finally:
na.disconnect()
def test_large_queue_items():
fake_request(10.0)
q = pmnc.state.get_queue("large_items", re_len=1024, re_pad=0x5a)
for i in (16, 64, 256, 1024):
value = b"*" * i
push(q, value, lambda x: x)
with expected(bsddb.DBInvalidArgError):
push(q, b"*" * 1025, lambda x: x)
for i in (16, 64, 256, 1024):
value = b"*" * i + b"\x5a" * (1024 - i)
assert pop(q, None, lambda x: x) == value
assert pop(q, None, lambda x: x) is None
def test_large_queue_items():
fake_request(10.0)
q = pmnc.state.get_queue("large_items", re_len=1024, re_pad=0x5A)
for i in (16, 64, 256, 1024):
value = b"*" * i
push(q, value, lambda x: x)
with expected(bsddb.DBInvalidArgError):
push(q, b"*" * 1025, lambda x: x)
for i in (16, 64, 256, 1024):
value = b"*" * i + b"\x5a" * (1024 - i)
assert pop(q, None, lambda x: x) == value
assert pop(q, None, lambda x: x) is None
###################################
cages_directory = mkdtemp()
shared_directory = os_path.join(cages_directory, ".shared")
mkdir(shared_directory)
cage_directory = os_path.join(cages_directory, "test")
mkdir(cage_directory)
###################################
ml = ModuleLocator(cage_directory)
with expected(InputParameterError):
ModuleLocator(cage_directory + "notthere")
###################################
with expected(InputParameterError):
ml.locate("foo.txt")
with expected(InputParameterError):
ml.locate("foo..py")
assert ml.locate("foo.py") is None
dfn = os_path.join(shared_directory, "foo.py")
df = open(dfn, "w").close()
assert ml.locate("foo.py") == dfn
def test_execute_timeout():
fake_request(1.0)
with expected(Exception("request deadline waiting for response")):
pmnc.__getattr__(__name__).execute_reverse("bad_cage", "module", "method", (), {})
print("ok")
###################################
print("module reload timeout: ", end = "")
fake_request(0.1)
sleep(0.5)
write_module(os_path.join("..", ".shared", "reload_timeout.py"),
"__all__ = ['foo']\n"
"def foo():\n"
" return 1\n"
"# EOF")
with expected(ModuleReloadTimedOutError("request deadline waiting for exclusive access to module reload_timeout")):
pmnc.reload_timeout.foo()
fake_request(3.0)
assert pmnc.reload_timeout.foo() == 1
print("ok")
###################################
print("__all__ declaration: ", end = "")
fake_request(30.0)
write_module(os_path.join("..", ".shared", "all_test.py"),
from expected import expected
from typecheck import by_regex, InputParameterError
from threading import Thread
###################################
r = Request()
assert not r.expired
assert not r.expires_in(86400.0)
assert r.elapsed >= 0.0
assert r.interface is None
assert r.protocol is None
assert r.parameters == {}
assert r.unique_id.startswith("RQ-20")
assert r._description is None
with expected(Exception("infinite request never expires")):
r.expired_for
assert not r.self_test
###################################
r = Request(timeout = 0.5, interface = "test", protocol = "tcp",
parameters = { "foo": "bar", "self-test": "some_module" },
description = "some request")
assert not r.expired
assert r.expires_in(1.0)
assert r.elapsed >= 0.0
assert r.interface == "test"
assert r.protocol == "tcp"
assert r.parameters == { "foo": "bar", "self-test": "some_module" }
from pmnc.request import fake_request, InfiniteRequest
###################################
def wu_skip(): pass
def wu_loopback(*args, **kwargs):
return args, kwargs
###################################
print("work unit timeouts: ", end = "")
wu = WorkUnit(fake_request(0.1), wu_skip, (), {})
before = time()
with expected(WorkUnitTimedOut):
wu.wait()
after = time()
assert after - before >= 0.1
wu = WorkUnit(fake_request(0.1), wu_skip, (), {}); wu()
before = time()
wu.wait()
after = time()
assert after - before < 0.01
print("ok")
###################################
print("earliest deadline first ordering: ", end = "")
def th_proc():
fake_request(10.0)
with expected(ZeroDivisionError):
pmnc.state.implicit_transaction(txn1)
print("self-testing module interlocked_factory.py:")
###################################
from expected import expected
###################################
class Foo:
pass
ilf = InterlockedFactory(Foo)
assert ilf.count == 0
with expected(AssertionError):
ilf.wait(1.0)
f, n = ilf.create()
assert isinstance(f, Foo)
assert n == ilf.count == 1
with expected(AssertionError):
ilf.wait(1.0)
with expected(TypeError):
ilf.create("will throw")
assert ilf.count == 1
ilf.stop()
with expected(AssertionError):
def _get_guard_fails(func):
with expected(GuardExpressionException("guarded function foo() requires a \"_when\" "
"argument with guard expression text as its default value")):
_get_guard(func)
assert _get_guard(foo) == 123
def foo(a, *, _when): pass
_get_guard_fails(foo)
def foo(a, *, _when = "123"): pass
assert _get_guard(foo) == 123
def foo(_when, *, a): pass
_get_guard_fails(foo)
def foo(_when = "123", *, a): pass
assert _get_guard(foo) == 123
def foo(_when = ""): pass
with expected(GuardExpressionException("invalid guard expression for foo(): "
"unexpected EOF while parsing (foo, line 0)")):
_get_guard(foo)
def foo(_when = "@\n"): pass
with expected(GuardExpressionException("invalid guard expression for foo(): "
"invalid syntax (foo, line 1)")):
_get_guard(foo)
########
print("ok")
############################################################################
print("simple match args: ", end = "")
sleep(1.25)
assert t.remain > 0.5
assert not t.expired
sleep(1.25)
assert t.remain == 0.0
assert t.expired
t = Timeout(2.0)
sleep(1.25)
assert not t.expired
t.reset()
assert t.remain > 1.9
sleep(1.25)
assert not t.expired
with expected(InputParameterError("__init__() has got an incompatible value for timeout: 1")):
Timeout(1)
before = time()
t = Timeout(1.0)
while not t.expired:
pass
after = time()
assert after - before >= 1.0
###################################
t = Timeout(0.5)
sleep(1.0)
assert t.expired
t.reset()
threading.current_thread().name = "MainThread"
lck = SharedLock("TestLock", None, True)
assert lck._dump() == "TestLock(ex(-)sh(-))", lck._dump()
assert lck.acquire()
assert lck._dump() == "TestLock(ex(MainThread:1)sh(-))", lck._dump()
lck.release()
assert lck._dump() == "TestLock(ex(-)sh(-))", lck._dump()
assert lck.acquire_shared()
assert lck._dump() == "TestLock(ex(-)sh(MainThread:1))", lck._dump()
lck.release_shared()
assert lck._dump() == "TestLock(ex(-)sh(-))", lck._dump()
with expected(AssertionError("thread MainThread has not acquired the lock")):
lck.release()
with expected(AssertionError("thread MainThread has not acquired the lock")):
lck.release_shared()
# check that a lock can be acquired in no time
assert lck.acquire(0.0)
lck.release()
assert lck.acquire_shared(0.0)
lck.release_shared()
print("ok")
