def test_no_sending_if_throttler(self): with mock.patch("naz.broker.SimpleBroker.dequeue", new=AsyncMock()) as mock_naz_dequeue: sample_size = 8.0 throttle_handler = naz.throttle.SimpleThrottleHandler( sampling_period=5.0, sample_size=sample_size, deny_request_at=0.4 ) cli = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), broker=self.broker, throttle_handler=throttle_handler, logger=naz.log.SimpleLogger("naz.test_no_sending_if_throttler", level="DEBUG"), ) log_id = "12345" short_message = "hello smpp" mock_naz_dequeue.mock.return_value = naz.protocol.SubmitSM( version=1, log_id=log_id, short_message=short_message, smpp_command=naz.SmppCommand.SUBMIT_SM, source_addr="2547000000", destination_addr="254711999999", ) self._run(cli.connect()) cli.current_session_state = naz.SmppSessionState.BOUND_TRX # mock SMSC throttling naz for _ in range(0, int(sample_size) * 2): self._run(cli.throttle_handler.throttled()) self._run(cli.dequeue_messages(TESTING=True)) self.assertFalse(mock_naz_dequeue.mock.called)
def test_custom_encodings(self): """ tests that any of the encodings allowed by SMPP spec[1] can be used. 1. https://github.com/komuw/naz/blob/c47f5030b720f3bac400dd6bd457b4415b0d5b7b/naz/state.py#L328 2. Also see section 5.2.19 of SMPP spec """ for encoding in [ "gsm0338", "ucs2", "ascii", "latin_1", "iso2022jp", "iso8859_5" ]: cli = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), broker=self.broker, logger=naz.log.SimpleLogger( "TestClient", level="DEBUG", handler=naz.log.BreachHandler(capacity=200)), socket_timeout=0.0000001, codec=naz.codec.SimpleCodec(encoding=encoding), ) self._run(cli.connect()) self.assertTrue(hasattr(cli.reader, "read")) self.assertTrue(hasattr(cli.writer, "write"))
def setUp(self): self.loop = asyncio.get_event_loop() self.cli = naz.Client( async_loop=self.loop, SMSC_HOST="127.0.0.1", SMSC_PORT=2775, system_id="smppclient1", password="******", ) self.docker_client = docker.from_env() smppSimulatorName = "nazTestSmppSimulator" running_containers = self.docker_client.containers.list() for container in running_containers: container.stop() self.smpp_simulator = self.docker_client.containers.run( "komuw/smpp_server:v0.2", name=smppSimulatorName, detach=True, auto_remove=True, labels={ "name": "smpp_server", "use": "running_naz_tets" }, ports={ "2775/tcp": 2775, "8884/tcp": 8884 }, stdout=True, stderr=True, )
def test_no_sending_if_throttler(self): with mock.patch("naz.q.SimpleOutboundQueue.dequeue", new=AsyncMock()) as mock_naz_dequeue: sample_size = 8.0 throttle_handler = naz.throttle.SimpleThrottleHandler( sampling_period=5.0, sample_size=sample_size, deny_request_at=0.4 ) cli = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), outboundqueue=self.outboundqueue, throttle_handler=throttle_handler, loglevel="DEBUG", ) log_id = "12345" short_message = "hello smpp" mock_naz_dequeue.mock.return_value = { "version": "1", "log_id": log_id, "short_message": short_message, "smpp_command": naz.SmppCommand.SUBMIT_SM, "source_addr": "2547000000", "destination_addr": "254711999999", } self._run(cli.connect()) cli.current_session_state = naz.SmppSessionState.BOUND_TRX # mock SMSC throttling naz for _ in range(0, int(sample_size) * 2): self._run(cli.throttle_handler.throttled()) self._run(cli.dequeue_messages(TESTING=True)) self.assertFalse(mock_naz_dequeue.mock.called)
def setUp(self): self.outboundqueue = naz.q.SimpleOutboundQueue(maxsize=1000) self.cli = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), outboundqueue=self.outboundqueue, loglevel="DEBUG", # run tests with debug so as to debug what is going on ) self.docker_client = docker.from_env() smppSimulatorName = "nazTestSmppSimulator" running_containers = self.docker_client.containers.list() for container in running_containers: container.stop() self.smpp_server = self.docker_client.containers.run( "komuw/smpp_server:v0.3", name=smppSimulatorName, detach=True, auto_remove=True, labels={"name": "smpp_server", "use": "running_naz_tets"}, ports={"2775/tcp": 2775, "8884/tcp": 8884}, stdout=True, stderr=True, )
def setUp(self): self.broker = naz.broker.SimpleBroker(maxsize=1000) smsc_port = 2775 self.cli = naz.Client( smsc_host="127.0.0.1", smsc_port=smsc_port, system_id="smppclient1", password=os.getenv("password", "password"), broker=self.broker, logger=naz.log.SimpleLogger( "TestClient", level="DEBUG", handler=naz.log.BreachHandler(capacity=200) ), # run tests with debug so as to debug what is going on socket_timeout=0.0000001, ) self.docker_client = docker.from_env() smppSimulatorName = "nazTestSmppSimulator" running_containers = self.docker_client.containers.list() for container in running_containers: container.stop() self.smpp_server = self.docker_client.containers.run( "komuw/smpp_server:v0.3", name=smppSimulatorName, detach=True, auto_remove=True, labels={"name": "smpp_server", "use": "running_naz_tets"}, ports={"{0}/tcp".format(smsc_port): smsc_port, "8884/tcp": 8884}, stdout=True, stderr=True, )
def test_custom_encodings(self): """ tests that any of the encodings allowed by SMPP spec[1] can be used. 1. https://github.com/komuw/naz/blob/c47f5030b720f3bac400dd6bd457b4415b0d5b7b/naz/state.py#L328 2. Also see section 5.2.19 of SMPP spec """ class ExampleCodec(codecs.Codec): # All the methods have to be staticmethods because they are passed to `codecs.CodecInfo` @staticmethod def encode(input, errors="strict"): return codecs.utf_8_encode(input, errors) @staticmethod def decode(input, errors="strict"): return codecs.utf_8_decode(input, errors) for encoding in ["gsm0338", "ucs2", "ascii", "latin_1", "iso2022jp", "iso8859_5"]: naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), broker=self.broker, logger=naz.log.SimpleLogger( "TestClient", level="DEBUG", handler=naz.log.BreachHandler(capacity=10) ), socket_timeout=self.socket_timeout, custom_codecs={ encoding: codecs.CodecInfo( name=encoding, encode=ExampleCodec.encode, decode=ExampleCodec.decode, ), }, )
def mock_create_client(): naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), broker="bad-Type", )
def mock_create_client(): naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), broker=self.broker, codec_class=naz.nazcodec.SimpleNazCodec(encoding=encoding), )
def mock_create_client(): naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), encoding=encoding, outboundqueue=self.outboundqueue, )
def mock_create_client(): naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), log_metadata="bad-Type", outboundqueue=self.outboundqueue, )
def mock_create_client(): naz.Client( async_loop=self.loop, SMSC_HOST="127.0.0.1", SMSC_PORT=2775, system_id="smppclient1", password="******", log_metadata="bad-Type", )
def mock_create_client(): naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), broker=self.broker, custom_codecs={"encoding": {"someKey": "someValue"}}, )
def setUp(self): self.client = naz.Client( smsc_host="smsc_host", smsc_port=6767, system_id="system_id", password=os.environ.get("password", "password"), broker=naz.broker.SimpleBroker(), drain_duration=0.001, ) self.loop = asyncio.get_event_loop() self.logger = naz.log.SimpleLogger("naz.TestCliSigHandling")
def setUp(self): self.broker = naz.broker.SimpleBroker(maxsize=1000) self.socket_timeout = 0.01 self.cli = naz.Client( smsc_host="127.0.0.1", smsc_port=TestClient.smsc_port, system_id="smppclient1", password=os.getenv("password", "password"), broker=self.broker, logger=naz.log.SimpleLogger( "TestClient", level="INFO", handler=naz.log.BreachHandler(capacity=10) ), # run tests with debug so as to debug what is going on socket_timeout=self.socket_timeout, )
def mock_create_client(): naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), broker=self.broker, custom_codecs={ encoding: codecs.CodecInfo( name=encoding, encode=naz.codec.UCS2Codec.encode, decode=naz.codec.UCS2Codec.decode, ), }, )
self.connect() method_frame, _, body = self.channel.basic_get(self.queue_name) if body and method_frame: self.channel.basic_ack(delivery_tag=method_frame.delivery_tag) item = body.decode() return naz.protocol.json_to_Message(item) else: return None loop = asyncio.get_event_loop() broker = RabbitmqExampleBroker() cli = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), broker=broker, enquire_link_interval=17.00, ) loop.run_until_complete( broker.enqueue( naz.protocol.SubmitSM( short_message="Hello World", log_id="myid1234", source_addr="254722111111", destination_addr="254722999999", ))) try: # 1. connect to the SMSC host
import cli import naz import docker from .utils import AsyncMock, MockStreamWriter, MockArgumentParser from examples.example_klasses import ExampleRedisBroker, MySeqGen, MyRateLimiter NAZ_CLIENT = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password="******", broker=ExampleRedisBroker(), sequence_generator=MySeqGen(), logger=naz.log.SimpleLogger( "naz.client", level="INFO", log_metadata={"environment": "production", "release": "canary"} ), enquire_link_interval=30.00, rate_limiter=MyRateLimiter(), ) BAD_NAZ_CLIENT = MySeqGen() class TestCli(TestCase): """ run tests as: python -m unittest discover -v -s . run one testcase as:
import naz from examples.example_klasses import ExampleRedisQueue, MySeqGen, MyRateLimiter # run as: # naz-cli --client examples.example_config.client client = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password="******", outboundqueue=ExampleRedisQueue(), encoding="gsm0338", sequence_generator=MySeqGen(), loglevel="INFO", log_metadata={ "environment": "staging", "release": "canary" }, codec_errors_level="ignore", enquire_link_interval=70.00, rateLimiter=MyRateLimiter(), address_range= "^254", # any msisdns beginning with 254. See Appendix A of SMPP spec doc )
import os import asyncio import naz loop = asyncio.get_event_loop() broker = naz.broker.SimpleBroker(maxsize=1000) cli = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), broker=broker, ) # queue messages to send for i in range(0, 4): print("submit_sm round:", i) loop.run_until_complete( broker.enqueue( naz.protocol.Message( version=1, smpp_command=naz.SmppCommand.SUBMIT_SM, short_message="Hello World-{0}".format(str(i)), log_id="myid1234-{0}".format(str(i)), source_addr="254722111111", destination_addr="254722999999", ))) # altenatively:: # loop.run_until_complete(
import naz from examples.example_klasses import ExampleRedisBroker # , MySeqGen, MyRateLimiter # run as: # naz-cli --client examples.example_config.client client = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password="******", broker=ExampleRedisBroker(), # codec=naz.codec.SimpleCodec(encoding="ucs2"), socket_timeout=4.00, logger=naz.log.SimpleLogger("example_config.client", render_as_json=False), enquire_link_interval=59.00, address_range= "254722111111", # any msisdns beginning with 254. See Appendix A of smpp spec )
def add_argument(self, *args, **kwargs): pass def parse_args(self, args=None, namespace=None): return argparse.Namespace(client=self.naz_config, dry_run=True) NAZ_CLIENT = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password="******", broker=ExampleRedisBroker(), encoding="gsm0338", sequence_generator=MySeqGen(), loglevel="INFO", log_metadata={ "environment": "production", "release": "canary" }, codec_errors_level="ignore", enquire_link_interval=30.00, rateLimiter=MyRateLimiter(), ) BAD_NAZ_CLIENT = MySeqGen() class TestCli(TestCase): """ run tests as:
import os import naz from my_hook import BenchmarksHook from redis_broker import MyRedisBroker from my_logger import BenchmarksLogger # run as: # naz-cli --client benchmarks.app.my_naz_client country_code = "254" my_naz_client = naz.Client( smsc_host=os.environ["SMSC_HOST"], smsc_port=2775, system_id="smppclient1", password=os.environ["SMSC_PASSWORD"], broker=MyRedisBroker(), hook=BenchmarksHook(), logger=BenchmarksLogger(logger_name="naz.benchmarks", level="DEBUG", log_metadata={"project": "naz_benchmarks"}), socket_timeout=15.00, enquire_link_interval=80.00, address_range="^{0}".format( country_code ), # any msisdns beginning with 254. See Appendix A of smpp spec )
import naz from examples.example_klasses import ExampleRedisBroker, MySeqGen, MyRateLimiter # run as: # naz-cli --client examples.example_config.client client = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password="******", broker=ExampleRedisBroker(), sequence_generator=MySeqGen(), logger=naz.log.SimpleLogger( "naz.client", level="INFO", log_metadata={"environment": "staging", "release": "canary"} ), enquire_link_interval=70.00, rateLimiter=MyRateLimiter(), address_range="^254", # any msisdns beginning with 254. See Appendix A of SMPP spec doc )
def mock_create_client(): naz.Client(**client_args)
import os import asyncio import naz loop = asyncio.get_event_loop() outboundqueue = naz.q.SimpleOutboundQueue(maxsize=1000) cli = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password=os.getenv("password", "password"), outboundqueue=outboundqueue, ) # queue messages to send for i in range(0, 4): print("submit_sm round:", i) item_to_enqueue = { "version": "1", "smpp_command": naz.SmppCommand.SUBMIT_SM, "short_message": "Hello World-{0}".format(str(i)), "log_id": "myid12345", "source_addr": "254722111111", "destination_addr": "254722999999", } loop.run_until_complete(outboundqueue.enqueue(item_to_enqueue)) # altenatively:: # loop.run_until_complete( # cli.submit_sm(
import asyncio import naz loop = asyncio.get_event_loop() cli = naz.Client( async_loop=loop, SMSC_HOST="127.0.0.1", SMSC_PORT=2775, system_id="smppclient1", password="******", ) # queue messages to send for i in range(0, 4): print("submit_sm round:", i) loop.run_until_complete( cli.submit_sm( msg="Hello World-{0}".format(str(i)), correlation_id="myid12345", source_addr="254722111111", destination_addr="254722999999", )) # connect to the SMSC host reader, writer = loop.run_until_complete(cli.connect()) # bind to SMSC as a tranceiver loop.run_until_complete(cli.tranceiver_bind()) # read any data from SMSC, send any queued messages to SMSC and continually check the state of the SMSC gathering = asyncio.gather(cli.send_forever(), cli.receive_data(),
import naz import random from examples.example_klasses import ExampleRedisBroker from pythonfuzz.main import PythonFuzz import asyncio # run as: # python3.7 tests/fuzz.py parse_response_pdu client = naz.Client( smsc_host="127.0.0.1", smsc_port=2775, system_id="smppclient1", password="******", broker=ExampleRedisBroker(), enquire_link_interval=70.00, logger=naz.log.SimpleLogger("naz.fuzz", level="INFO", log_metadata={ "environment": "staging", "release": "canary" }), ) FUNCTIONALITIES = [ "msg_to_log", "send_data", "parse_response_pdu", "command_handlers" ] FUNCTIONALITY_TO_FUZZ = None @PythonFuzz def fuzz(buf):