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):
