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 test_on_enquire_link(self):
transport, protocol = yield self.setup_bind()
pdu = EnquireLink(sequence_number=0)
protocol.dataReceived(pdu.get_bin())
[enquire_link_resp] = yield wait_for_pdus(transport, 1)
self.assertCommand(
enquire_link_resp, 'enquire_link_resp', sequence_number=0,
status='ESME_ROK')
def test_on_enquire_link(self):
protocol = yield self.get_protocol()
yield self.fake_smsc.bind()
pdu = EnquireLink(0)
protocol.dataReceived(pdu.get_bin())
enquire_link_resp = yield self.fake_smsc.await_pdu()
self.assertCommand(
enquire_link_resp, 'enquire_link_resp', sequence_number=0,
status='ESME_ROK')
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 enquire_link(self):
"""
Ping the SMSC to see if they're still around.
"""
sequence_number = yield self.sequence_generator.next()
self.send_pdu(EnquireLink(sequence_number))
returnValue(sequence_number)
def enquire_link(self, **kwargs):
if self.state in ['BOUND_TX', 'BOUND_TRX']:
sequence_number = self.get_seq()
pdu = EnquireLink(sequence_number, **dict(self.defaults, **kwargs))
self.get_next_seq()
self.send_pdu(pdu)
return sequence_number
return 0
def enquire_link(self, **kwargs):
if self.state in ['BOUND_TX', 'BOUND_RX', 'BOUND_TRX']:
sequence_number = yield self.get_next_seq()
pdu = EnquireLink(sequence_number,
**dict(self.bind_params, **kwargs))
self.send_pdu(pdu)
returnValue(sequence_number)
returnValue(0)
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_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_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_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_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_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_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_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)
