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)