def test_submit_sm_resp_explicit(self):
"""
FakeSMSC can respond to a SubmitSM PDU that is explicitly passed in.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
# No params.
submit_sm_resp_d = fake_smsc.submit_sm_resp(SubmitSM(123).obj)
self.assertNoResult(submit_sm_resp_d)
client.handle_pdu_d.callback(None)
self.successResultOf(submit_sm_resp_d)
resp = SubmitSMResp(123, message_id="id123", command_status="ESME_ROK")
self.assertEqual(client.pdus_handled, [resp.obj])
client.pdus_handled[:] = []
# Explicit message_id.
submit_sm_resp_d = fake_smsc.submit_sm_resp(SubmitSM(124).obj,
message_id="foo")
yield client.write(SubmitSM(124).get_bin())
self.assertNoResult(submit_sm_resp_d)
client.handle_pdu_d.callback(None)
self.successResultOf(submit_sm_resp_d)
resp = SubmitSMResp(124, message_id="foo", command_status="ESME_ROK")
self.assertEqual(client.pdus_handled, [resp.obj])
def test_waiting_pdu_count(self):
"""
FakeSMSC knows how many received PDUs are waiting.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
# Nothing received yet.
self.assertEqual(fake_smsc.waiting_pdu_count(), 0)
# Some PDUs received.
yield client.write(EnquireLink(1).get_bin())
self.assertEqual(fake_smsc.waiting_pdu_count(), 1)
yield client.write(EnquireLink(2).get_bin())
self.assertEqual(fake_smsc.waiting_pdu_count(), 2)
# Some PDUs returned.
self.successResultOf(fake_smsc.await_pdu())
self.assertEqual(fake_smsc.waiting_pdu_count(), 1)
self.successResultOf(fake_smsc.await_pdu())
self.assertEqual(fake_smsc.waiting_pdu_count(), 0)
# Wait for a PDU that arrives later.
pdu_d = fake_smsc.await_pdu()
self.assertNoResult(pdu_d)
self.assertEqual(fake_smsc.waiting_pdu_count(), 0)
yield client.write(EnquireLink(3).get_bin())
self.assertEqual(fake_smsc.waiting_pdu_count(), 0)
self.successResultOf(pdu_d)
def setUp(self):
self.clock = Clock()
self.fake_smsc = FakeSMSC()
self.tx_helper = self.add_helper(
TransportHelper(SmppTransceiverTransport))
self.default_config = {
'transport_name':
self.tx_helper.transport_name,
'twisted_endpoint':
self.fake_smsc.endpoint,
'deliver_short_message_processor':
('vumi.transports.smpp.processors.sixdee.'
'DeliverShortMessageProcessor'),
'submit_short_message_processor':
('vumi.transports.smpp.processors.sixdee.'
'SubmitShortMessageProcessor'),
'system_id':
'foo',
'password':
'******',
'deliver_short_message_processor_config': {
'data_coding_overrides': {
0: 'utf-8',
}
},
'submit_short_message_processor_config': {
'submit_sm_encoding': 'utf-16be',
'submit_sm_data_coding': 8,
'send_multipart_udh': True,
}
}
def test_test_submit_sm_resp_wrong_pdu(self):
"""
FakeSMSC will raise an exception if asked to bind with a non-bind PDU.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
submit_sm_resp_d = fake_smsc.submit_sm_resp()
yield client.write(EnquireLink(0).get_bin())
self.failureResultOf(submit_sm_resp_d, ValueError)
def test_respond_to_enquire_link_wrong_pdu(self):
"""
FakeSMSC will raise an exception if asked to respond to an enquire_link
that isn't an enquire_link.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
rtel_d = fake_smsc.respond_to_enquire_link()
yield client.write(DeliverSM(0).get_bin())
self.failureResultOf(rtel_d, ValueError)
def setUp(self):
self.clock = Clock()
self.persistence_helper = self.add_helper(PersistenceHelper())
self.redis = yield self.persistence_helper.get_redis_manager()
self.fake_smsc = FakeSMSC(auto_accept=False)
self.default_config = {
'transport_name': 'sphex_transport',
'twisted_endpoint': self.fake_smsc.endpoint,
'system_id': 'system_id',
'password': '******',
}
def test_respond_to_enquire_link_explicit(self):
"""
FakeSMSC can respond to an enquire_link PDU explicitly passed in.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
rtel_d = fake_smsc.respond_to_enquire_link(EnquireLink(2).obj)
yield wait0()
# enquire_link response received.
self.successResultOf(rtel_d)
self.assertEqual(client.received, EnquireLinkResp(2).get_bin())
def test_auto_unbind(self):
"""
FakeSMSC will automatically respond to an unbind request by default.
The unbind PDU remains in the queue.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
self.assertEqual(fake_smsc.waiting_pdu_count(), 0)
yield client.write(Unbind(7).get_bin())
self.assertEqual(client.received, UnbindResp(7).get_bin())
self.assertEqual(fake_smsc.waiting_pdu_count(), 1)
def test_await_pdus_arrived(self):
"""
The caller can wait for multiple PDU that have already arrived.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
yield client.write(EnquireLink(1).get_bin())
yield client.write(EnquireLink(2).get_bin())
self.assertEqual(self.successResultOf(fake_smsc.await_pdus(2)), [
unpack_pdu(EnquireLink(1).get_bin()),
unpack_pdu(EnquireLink(2).get_bin())
])
def test_respond_to_enquire_link(self):
"""
FakeSMSC can respond to an enquire_link.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
rtel_d = fake_smsc.respond_to_enquire_link()
yield client.write(EnquireLink(2).get_bin())
# enquire_link response received.
self.assertNoResult(rtel_d)
self.assertEqual(client.received, EnquireLinkResp(2).get_bin())
yield wait0()
self.successResultOf(rtel_d)
def test_send_bytes(self):
"""
Bytes can be sent to the client.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
send_d = fake_smsc.send_bytes(b"abc")
# Bytes sent, not yet received.
self.assertNoResult(send_d)
self.assertEqual(client.received, b"")
yield send_d
# Bytes received.
self.assertEqual(client.received, b"abc")
def test_bind_mode_RX(self):
"""
FakeSMSC can accept receiver bind requests.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
bind_d = fake_smsc.bind()
yield client.write(BindReceiver(0).get_bin())
yield client.write(EnquireLink(1).get_bin())
self.assertEqual(
client.received, b"".join(
[BindReceiverResp(0).get_bin(),
EnquireLinkResp(1).get_bin()]))
yield wait0()
self.successResultOf(bind_d)
def test_await_connected(self):
"""
The caller can wait for a client to connect.
"""
fake_smsc = FakeSMSC(auto_accept=True)
await_connected_d = fake_smsc.await_connected()
self.assertNoResult(await_connected_d)
self.assertEqual(self.client_factory.proto, None)
self.assertEqual(fake_smsc._client_protocol, None)
self.connect(fake_smsc)
# The client has connected.
self.successResultOf(await_connected_d)
client = self.client_factory.proto
self.assertNotEqual(client, None)
self.assertEqual(fake_smsc._client_protocol, client)
self.assertEqual(client.connected, True)
def test_await_disconnect(self):
"""
FakeSMSC can wait for the connection to close.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
disconnect_d = fake_smsc.await_disconnect()
yield wait0()
self.assertNoResult(disconnect_d)
client.transport.loseConnection()
# Disconnect triggered, but not completed.
self.assertNoResult(disconnect_d)
yield wait0()
# Disconnect completed.
self.successResultOf(disconnect_d)
def test_send_pdu(self):
"""
A PDU can be sent to the client over the wire.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
self.assertEqual(client.pdus_handled, [])
pdu = DeliverSM(0)
send_d = fake_smsc.send_pdu(pdu)
# PDU sent, not yet received.
self.assertNoResult(send_d)
self.assertNotEqual(client.received, pdu.get_bin())
yield send_d
# PDU received.
self.assertEqual(client.received, pdu.get_bin())
self.assertEqual(client.pdus_handled, [])
def test_await_pdu(self):
"""
The caller can wait for a PDU to arrive.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
pdu_d = fake_smsc.await_pdu()
# No PDU yet.
self.assertNoResult(pdu_d)
client.write(EnquireLink(1).get_bin()) # No yield.
# PDU sent, not yet received.
self.assertNoResult(pdu_d)
yield wait0()
# PDU received.
self.assertEqual(self.successResultOf(pdu_d),
unpack_pdu(EnquireLink(1).get_bin()))
def test_await_connecting(self):
"""
The caller can wait for a client connection attempt.
"""
fake_smsc = FakeSMSC(auto_accept=False)
await_connecting_d = fake_smsc.await_connecting()
self.assertNoResult(await_connecting_d)
self.assertEqual(self.client_factory.proto, None)
self.assertEqual(fake_smsc._client_protocol, None)
connect_d = self.connect(fake_smsc)
# The client connection has started ...
self.successResultOf(await_connecting_d)
client = self.client_factory.proto
self.assertNotEqual(client, None)
self.assertEqual(fake_smsc._client_protocol, client)
# ... but has not yet been accepted.
self.assertNoResult(connect_d)
self.assertEqual(client.connected, False)
def test_has_pending_connection(self):
"""
FakeSMSC knows if there's a pending connection.
"""
fake_smsc = FakeSMSC(auto_accept=False)
self.assertEqual(fake_smsc.has_pending_connection(), False)
# Pending connection we reject.
connect_d = self.connect(fake_smsc)
self.assertEqual(fake_smsc.has_pending_connection(), True)
fake_smsc.reject_connection()
self.assertEqual(fake_smsc.has_pending_connection(), False)
self.failureResultOf(connect_d)
# Pending connection we accept.
connected_d = self.connect(fake_smsc)
self.assertEqual(fake_smsc.has_pending_connection(), True)
fake_smsc.accept_connection()
self.assertEqual(fake_smsc.has_pending_connection(), False)
self.successResultOf(connected_d)
def test_handle_pdu(self):
"""
A PDU can be sent to the client for direct processing.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
self.assertEqual(client.pdus_handled, [])
pdu = DeliverSM(0)
handle_d = fake_smsc.handle_pdu(pdu)
# PDU sent, not yet processed.
self.assertNoResult(handle_d)
self.assertEqual(client.pdus_handled, [])
client.handle_pdu_d.callback(None)
# PDU processed.
self.successResultOf(handle_d)
self.assertEqual(client.received, b"")
self.assertEqual(client.pdus_handled, [pdu.obj])
def test_await_pdus(self):
"""
The caller can wait for multiple PDUs to arrive.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
pdus_d = fake_smsc.await_pdus(2)
# No PDUs yet.
self.assertNoResult(pdus_d)
yield client.write(EnquireLink(1).get_bin())
# One PDU received, no result.
self.assertNoResult(pdus_d)
yield client.write(EnquireLink(2).get_bin())
# Both PDUs received.
self.assertEqual(self.successResultOf(pdus_d), [
unpack_pdu(EnquireLink(1).get_bin()),
unpack_pdu(EnquireLink(2).get_bin())
])
def test_reject_connection(self):
"""
With auto-accept disabled, a connection may be rejected.
"""
fake_smsc = FakeSMSC(auto_accept=False)
await_connecting_d = fake_smsc.await_connecting()
await_connected_d = fake_smsc.await_connected()
self.assertNoResult(await_connecting_d)
self.assertNoResult(await_connected_d)
connect_d = self.connect(fake_smsc)
# The client connection is pending.
self.successResultOf(await_connecting_d)
self.assertNoResult(await_connected_d)
self.assertNoResult(connect_d)
client = self.client_factory.proto
self.assertEqual(client.connected, False)
fake_smsc.reject_connection()
# The client is not connected.
self.failureResultOf(connect_d, ConnectionRefusedError)
self.assertNoResult(await_connected_d)
self.assertEqual(client.connected, False)
def test_bind_explicit(self):
"""
FakeSMSC can bind using a PDU explicitly passed in.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
bind_d = fake_smsc.bind(BindTransceiver(0).obj)
yield wait0()
# Bind response received.
self.assertNoResult(bind_d)
self.assertEqual(client.received, BindTransceiverResp(0).get_bin())
client.received = b""
yield client.write(EnquireLink(1).get_bin())
# enquire_link response received.
self.assertNoResult(bind_d)
self.assertEqual(client.received, EnquireLinkResp(1).get_bin())
yield wait0()
# Bind complete.
self.successResultOf(bind_d)
def test_send_mo(self):
"""
FakeSMSC can send a DeliverSM PDU.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
yield fake_smsc.send_mo(5, "hello")
# First MO received.
self.assertEqual(
client.received,
DeliverSM(5, short_message="hello", data_coding=1).get_bin())
client.received = b""
yield fake_smsc.send_mo(6, "hello again", 8, destination_addr="123")
# Second MO received.
self.assertEqual(
client.received,
DeliverSM(6,
short_message="hello again",
data_coding=8,
destination_addr="123").get_bin())
def test_bind(self):
"""
FakeSMSC can accept a bind request and respond to the first
enquire_link.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(client.received, b"")
bind_d = fake_smsc.bind()
yield client.write(BindTransceiver(0).get_bin())
# Bind response received.
self.assertNoResult(bind_d)
self.assertEqual(client.received, BindTransceiverResp(0).get_bin())
client.received = b""
yield client.write(EnquireLink(1).get_bin())
# enquire_link response received.
self.assertNoResult(bind_d)
self.assertEqual(client.received, EnquireLinkResp(1).get_bin())
yield wait0()
# Bind complete.
self.successResultOf(bind_d)
def test_disconnect(self):
"""
FakeSMSC can disconnect from the client.
"""
fake_smsc = FakeSMSC()
client = self.successResultOf(self.connect(fake_smsc))
self.assertEqual(fake_smsc.connected, True)
self.assertEqual(client.connected, True)
disconnect_d = fake_smsc.disconnect()
# Disconnect triggered, but not completed.
self.assertNoResult(disconnect_d)
self.assertEqual(client.connected, True)
self.assertEqual(fake_smsc.connected, True)
yield wait0()
# Disconnect completed.
self.successResultOf(disconnect_d)
self.assertEqual(client.connected, False)
self.assertEqual(fake_smsc.connected, False)
self.assertEqual(fake_smsc.protocol, None)
self.assertEqual(fake_smsc._client_protocol, None)
self.assertNoResult(fake_smsc._listen_d)
self.assertNoResult(fake_smsc._connected_d)
def test_accept_connection(self):
"""
With auto-accept disabled, a connection must be manually accepted.
"""
fake_smsc = FakeSMSC(auto_accept=False)
await_connecting_d = fake_smsc.await_connecting()
await_connected_d = fake_smsc.await_connected()
self.assertNoResult(await_connecting_d)
self.assertNoResult(await_connected_d)
connect_d = self.connect(fake_smsc)
# The client connection is pending.
self.successResultOf(await_connecting_d)
self.assertNoResult(await_connected_d)
self.assertNoResult(connect_d)
client = self.client_factory.proto
self.assertEqual(client.connected, False)
accept_d = fake_smsc.accept_connection()
# The client is connected.
self.successResultOf(await_connected_d)
self.successResultOf(accept_d)
self.assertEqual(client.connected, True)
self.assertEqual(self.successResultOf(connect_d), client)
def setUp(self):
self.clock = Clock()
self.persistence_helper = self.add_helper(PersistenceHelper())
self.redis = yield self.persistence_helper.get_redis_manager()
self.fake_smsc = FakeSMSC(auto_accept=False)
def setUp(self):
self.fake_smsc = FakeSMSC()
self.tx_helper = self.add_helper(
TransportHelper(SmppTransceiverTransport))
self.clock = Clock()
def test_reject_connection_no_pending(self):
"""
There must be a pending connection to reject.
"""
fake_smsc = FakeSMSC(auto_accept=False)
self.assertRaises(Exception, fake_smsc.reject_connection)
