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)