def test_tymee():
"""
Test Tymee class
"""
tymee = tyming.Tymee()
assert tymee.tymth == None
with pytest.raises(TypeError):
tymee.tyme # NoneType object not callable
tymist = tyming.Tymist(tock=1.0)
tymee = tyming.Tymee(tymth=tymist.tymen())
assert tymee.tyme == tymist.tyme == 0.0
tymist.tick()
assert tymee.tyme == tymist.tyme == 1.0
tymist = tyming.Tymist(tock=0.5)
tymee.tymth = tymist.tymen()
assert tymee.tyme == tymist.tyme == 0.0
tymist.tick()
assert tymee.tyme == tymist.tyme == 0.5
tymist = tyming.Tymist(tock=0.25)
tymee.wind(tymth=tymist.tymen())
assert tymee.tyme == tymist.tyme == 0.0
tymist.tick()
assert tymee.tyme == tymist.tyme == 0.25
tymist.tick()
assert tymee.tyme == tymist.tyme == 0.5
tymist.tock = 1.0
tymist.tick()
assert tymee.tyme == tymist.tyme == 1.5
"""End Test"""
def test_trydoer_break():
"""
Test TryDoer testing class with break to normal exit
"""
tymist = tyming.Tymist(tock=0.125)
doer = TryDoer(tymth=tymist.tymen(), tock=0.25)
assert doer.tock == 0.25
assert doer.states == []
assert tymist.tyme == 0.0
do = doer(tymth=doer.tymth, tock=doer.tock)
assert inspect.isgenerator(do)
result = do.send(None)
assert result == 0.25
assert doer.states == [State(tyme=0.0, context='enter', feed='Default', count=0)]
result = do.send("Hello")
assert result == 0.25
assert doer.states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1)]
tymist.tick()
result = do.send("Hi")
assert result == 0.25
assert doer.states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2)]
tymist.tick()
result = do.send("Blue")
assert result == 0.25
assert doer.states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='recur', feed='Blue', count=3)]
tymist.tick()
try:
result = do.send("Red")
except StopIteration as ex:
assert ex.value == True # clean return
assert doer.states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='recur', feed='Blue', count=3),
State(tyme=0.375, context='recur', feed='Red', count=4),
State(tyme=0.375, context='exit', feed=None, count=5)]
# send after break
tymist.tick()
try:
result = do.send("Red")
except StopIteration as ex:
assert ex.value == None # after break no StopIteration value
assert doer.states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='recur', feed='Blue', count=3),
State(tyme=0.375, context='recur', feed='Red', count=4),
State(tyme=0.375, context='exit', feed=None, count=5)]
"""End Test """
def test_doify():
"""
Test wrapper function doify()
"""
def genfun(tymth, tock=0.0, **opts):
tyme = yield(tock)
assert inspect.isgeneratorfunction(genfun)
gf0 = doing.doify(genfun, name='gf0', tock=0.25)
gf1 = doing.doify(genfun, name='gf1', tock=0.125)
assert inspect.isgeneratorfunction(gf0)
assert inspect.isgeneratorfunction(gf1)
assert id(gf0) != id(gf1)
assert gf0.__name__ == 'gf0'
assert gf1.__name__ == 'gf1'
assert gf0.tock == 0.25
assert gf1.tock == 0.125
assert gf0.done == None
assert gf1.done == None
assert gf0.opts == dict()
assert gf1.opts == dict()
tymist = tyming.Tymist()
g0 = gf0(tymth=tymist.tymen(), tock=gf0.tock, **gf0.opts)
assert inspect.isgenerator(g0)
g1 = gf0(tymth=tymist.tymen(), tock=gf1.tock, **gf1.opts)
assert inspect.isgenerator(g1)
assert id(g0) != id(g1)
"""End Test"""
def test_trydo_break():
"""
Test trydo testing function example with break to normal exit
"""
assert inspect.isgeneratorfunction(tryDo)
assert hasattr(tryDo, "tock")
assert hasattr(tryDo, "opts")
tymist = tyming.Tymist(tock=0.125)
assert tymist.tyme == 0.0
states = []
do = tryDo(tymth=tymist.tymen(), states=states, tock=0.25)
assert inspect.isgenerator(do)
result = do.send(None)
assert result == 0
assert states == [State(tyme=0.0, context='enter', feed='Default', count=0)]
result = do.send("Hello")
assert result == 1
assert states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1)]
tymist.tick()
result = do.send("Hi")
assert result == 2
assert states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2)]
tymist.tick()
result = do.send("Blue")
assert result == 3
assert states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='recur', feed='Blue', count=3)]
tymist.tick()
try:
result = do.send("Red")
except StopIteration as ex:
assert ex.value == True # clean return
assert states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='recur', feed='Blue', count=3),
State(tyme=0.375, context='recur', feed='Red', count=4),
State(tyme=0.375, context='exit', feed='Red', count=5)]
# send after break
tymist.tick()
try:
result = do.send("Red")
except StopIteration as ex:
assert ex.value == None # no value after already finished
assert states == [State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='recur', feed='Blue', count=3),
State(tyme=0.375, context='recur', feed='Red', count=4),
State(tyme=0.375, context='exit', feed='Red', count=5)]
"""End Test """
def run():
"""
Use hio http server
"""
tymist = tyming.Tymist(tyme=0.0)
app = falcon.App() # falcon.API instances are callable WSGI apps
WEB_DIR_PATH = os.path.dirname(
os.path.abspath(sys.modules.get(__name__).__file__))
STATIC_DIR_PATH = os.path.join(WEB_DIR_PATH, 'static')
sink = serving.StaticSink(staticDirPath=STATIC_DIR_PATH)
app.add_sink(sink, prefix=sink.DefaultStaticSinkBasePath)
try:
server = http.Server(name='test',
port=8080,
tymeout=0.5,
app=app,
tymth=tymist.tymen())
server.reopen()
while True:
try:
server.service()
time.sleep(0.0625)
tymist.tick(tock=0.0625)
except KeyboardInterrupt: # use CNTL-C to shutdown from shell
break
finally:
server.close()
def test_trydoer_throw():
"""
Test TryDoer testing class with throw to force exit
"""
tymist = tyming.Tymist(tock=0.125)
doer = TryDoer(tymth=tymist.tymen(), tock=0.25)
assert doer.tock == 0.25
assert doer.states == []
assert tymist.tyme == 0.0
do = doer(tymth=doer.tymth, tock=doer.tock)
assert inspect.isgenerator(do)
result = do.send(None)
assert result == 0.25
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0)
]
result = do.send("Hello")
assert result == 0.25
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1)
]
tymist.tick()
result = do.send("Hi")
assert result == 0.25
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2)
]
tymist.tick()
try:
result = do.throw(ValueError, "Bad")
except ValueError as ex:
assert ex.args[0] == "Bad" # exception alue is thrown value
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='abort', feed='Bad', count=3),
State(tyme=0.25, context='exit', feed=None, count=4)
]
# send after throw
tymist.tick()
try:
result = do.send("what?")
except StopIteration as ex:
assert ex.value == None # after throw no StopIteration value
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='abort', feed='Bad', count=3),
State(tyme=0.25, context='exit', feed=None, count=4)
]
def test_trydoer_close():
"""
Test TryDoer testing class with close to force exit
"""
tymist = tyming.Tymist(tock=0.125)
doer = TryDoer(tymth=tymist.tymen(), tock=0.25)
assert doer.tock == 0.25
assert doer.states == []
assert tymist.tyme == 0.0
do = doer(tymth=doer.tymth, tock=doer.tock)
assert inspect.isgenerator(do)
result = do.send(None)
assert result == 0.25
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0)
]
result = do.send("Hello")
assert result == 0.25
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1)
]
tymist.tick()
result = do.send("Hi")
assert result == 0.25
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2)
]
tymist.tick()
result = do.close()
assert result == None # not clean return no return from close
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='close', feed=None, count=3),
State(tyme=0.25, context='exit', feed=None, count=4)
]
# send after close
tymist.tick()
try:
result = do.send("what?")
except StopIteration as ex:
assert ex.value == None # after close no StopIteration value
assert doer.states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='close', feed=None, count=3),
State(tyme=0.25, context='exit', feed=None, count=4)
]
"""End Test """
def test_trydo_throw():
"""
Test trydo testing function example with throw to force exit
"""
tymist = tyming.Tymist(tock=0.125)
assert tymist.tyme == 0.0
states = []
do = tryDo(tymth=tymist.tymen(), states=states, tock=0.25)
assert inspect.isgenerator(do)
result = do.send(None)
assert result == 0
assert states == [
State(tyme=0.0, context='enter', feed='Default', count=0)
]
result = do.send("Hello")
assert result == 1
assert states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1)
]
tymist.tick()
result = do.send("Hi")
assert result == 2
assert states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2)
]
tymist.tick()
try:
result = do.throw(ValueError, "Bad")
except ValueError as ex:
assert ex.args[0] == "Bad"
assert states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='abort', feed='Hi', count=3),
State(tyme=0.25, context='exit', feed='Hi', count=4)
]
tymist.tick()
try:
result = do.send("what?")
except StopIteration as ex:
assert ex.value == None # not clean return
assert states == [
State(tyme=0.0, context='enter', feed='Default', count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.125, context='recur', feed='Hi', count=2),
State(tyme=0.25, context='abort', feed='Hi', count=3),
State(tyme=0.25, context='exit', feed='Hi', count=4)
]
def test_tymist():
"""
Test Tymist class
"""
tymist = tyming.Tymist()
assert tymist.tyme == 0.0
assert tymist.tock == 0.03125
tymist.tock = 1.0
tymist.tick()
assert tymist.tyme == 1.0
tymist.tick(tock=0.75)
assert tymist.tyme == 1.75
tymist.tock = 0.5
tymist.tick()
assert tymist.tyme == 2.25
tymist = tyming.Tymist(tyme=2.0, tock=0.25)
assert tymist.tyme == 2.0
assert tymist.tock == 0.25
tymist.tick()
assert tymist.tyme == 2.25
tymist.tick(tock=0.75)
assert tymist.tyme == 3.0
tymist.tock = 0.5
tymist.tick()
assert tymist.tyme == 3.5
tymth = tymist.tymen()
assert inspect.isfunction(tymth)
tymth.__name__ == 'tymth'
assert tymth() == tymist.tyme
tymist.tick()
assert tymth() == tymist.tyme
g = tymth
assert inspect.isfunction(tymth)
g.__name__ == "g"
assert g() == tymist.tyme
tymist.tick()
assert g() == tymist.tyme
"""End Test """
def test_doize():
"""
Test decorator @doize
"""
@doing.doize(tock=0.25)
def genfun(tymth, tock=0.0, **opts):
tyme = yield(tock)
assert inspect.isgeneratorfunction(genfun)
assert genfun.tock == 0.25
assert genfun.done == None
assert genfun.opts == dict()
tymist = tyming.Tymist()
gen = genfun(tymth=tymist.tymen(), tock=genfun.tock, **genfun.opts)
assert inspect.isgenerator(gen)
"""End Test"""
def test_tcp_service_wired():
"""
Test Classes tcp service methods
"""
# wire log everything to same file filed not buffered
tymist = tyming.Tymist()
with wiring.openWL(samed=True, filed=True) as wl, \
openServer(tymth=tymist.tymen(), ha=("", 6101), wl=wl) as server, \
openClient(tymth=tymist.tymen(), ha=("127.0.0.1", 6101), wl=wl) as beta:
assert isinstance(wl, wiring.WireLog)
assert wl.rxed is True
assert wl.txed is True
assert wl.samed is True
assert wl.filed is True
assert wl.name == "test"
assert wl.temp == True
assert wl.rxl is wl.txl
assert wl.dirPath
assert wl.opened
assert server.opened == True
assert server.ha == ('0.0.0.0', 6101)
assert server.eha == ('127.0.0.1', 6101)
assert server.wl == wl
assert beta.opened == True
assert beta.accepted == False
assert beta.connected == False
assert beta.cutoff == False
assert beta.wl == wl
# connect beta to server
while not (beta.connected and beta.ca in server.ixes):
beta.serviceConnect()
server.serviceConnects()
time.sleep(0.05)
assert beta.accepted == True
assert beta.connected == True
assert beta.cutoff == False
assert beta.ca == beta.cs.getsockname()
assert beta.ha == beta.cs.getpeername() == server.eha
ixBeta = server.ixes[beta.ca]
assert ixBeta.cs.getsockname() == beta.cs.getpeername()
assert ixBeta.cs.getpeername() == beta.cs.getsockname()
assert ixBeta.ca == beta.ca
assert ixBeta.ha == beta.ha
msgOut1 = b"Beta sends to Server first"
beta.tx(msgOut1)
while not ixBeta.rxbs and beta.txbs:
beta.serviceSends()
time.sleep(0.05)
server.serviceReceivesAllIx()
time.sleep(0.05)
msgIn = bytes(ixBeta.rxbs)
assert msgIn == msgOut1
offset = len(ixBeta.rxbs) # offset into .rxbs of first message
# send multiple additional messages
msgOut2 = b"Beta sends to Server second"
beta.tx(msgOut2)
msgOut3 = b"Beta sends to Server third"
beta.tx(msgOut3)
while len(ixBeta.rxbs) < len(msgOut1) + len(msgOut2) + len(msgOut3):
beta.serviceSends()
server.serviceReceivesAllIx()
time.sleep(0.05)
msgIn = bytes(ixBeta.rxbs)
assert msgIn == msgOut1 + msgOut2 + msgOut3
ixBeta.clearRxbs() # clear out the receive buffer
# send from server to beta
msgOut = b"Server sends to Beta"
ixBeta.tx(msgOut)
while len(beta.rxbs) < len(msgOut):
server.serviceSendsAllIx()
beta.serviceReceives()
time.sleep(0.05)
msgIn = bytes(beta.rxbs)
beta.clearRxbs()
assert msgIn == msgOut
readrx = wl.readRx()
readtx = wl.readTx()
assert readrx == readtx
assert len(readrx) == 357
assert beta.opened == False
assert server.opened == False
assert wl.rxl.closed
assert wl.txl.closed
assert not wl.opened
assert not os.path.exists(wl.dirPath)
# wire log everything to same buffer not filed
tymist = tyming.Tymist()
with wiring.openWL(samed=True) as wl, \
openServer(tymth=tymist.tymen(), ha=("", 6101), wl=wl) as server, \
openClient(tymth=tymist.tymen(), ha=("127.0.0.1", 6101), wl=wl) as beta:
assert isinstance(wl, wiring.WireLog)
assert wl.rxed is True
assert wl.txed is True
assert wl.samed is True
assert wl.filed is False
assert wl.name == "test"
assert wl.temp == True
assert wl.rxl is wl.txl
assert wl.dirPath is None # filed == False
assert wl.opened
assert server.opened == True
assert server.ha == ('0.0.0.0', 6101)
assert server.eha == ('127.0.0.1', 6101)
assert server.wl == wl
assert beta.opened == True
assert beta.accepted == False
assert beta.connected == False
assert beta.cutoff == False
assert beta.wl == wl
# connect beta to server
while not (beta.connected and beta.ca in server.ixes):
beta.serviceConnect()
server.serviceConnects()
time.sleep(0.05)
assert beta.accepted == True
assert beta.connected == True
assert beta.cutoff == False
assert beta.ca == beta.cs.getsockname()
assert beta.ha == beta.cs.getpeername() == server.eha
ixBeta = server.ixes[beta.ca]
assert ixBeta.cs.getsockname() == beta.cs.getpeername()
assert ixBeta.cs.getpeername() == beta.cs.getsockname()
assert ixBeta.ca == beta.ca
assert ixBeta.ha == beta.ha
msgOut1 = b"Beta sends to Server first"
beta.tx(msgOut1)
while not ixBeta.rxbs and beta.txbs:
beta.serviceSends()
time.sleep(0.05)
server.serviceReceivesAllIx()
time.sleep(0.05)
msgIn = bytes(ixBeta.rxbs)
assert msgIn == msgOut1
offset = len(ixBeta.rxbs) # offset into .rxbs of first message
# send multiple additional messages
msgOut2 = b"Beta sends to Server second"
beta.tx(msgOut2)
msgOut3 = b"Beta sends to Server third"
beta.tx(msgOut3)
while len(ixBeta.rxbs) < len(msgOut1) + len(msgOut2) + len(msgOut3):
beta.serviceSends()
server.serviceReceivesAllIx()
time.sleep(0.05)
msgIn = bytes(ixBeta.rxbs)
assert msgIn == msgOut1 + msgOut2 + msgOut3
ixBeta.clearRxbs() # clear out the receive buffer
# send from server to beta
msgOut = b"Server sends to Beta"
ixBeta.tx(msgOut)
while len(beta.rxbs) < len(msgOut):
server.serviceSendsAllIx()
beta.serviceReceives()
time.sleep(0.05)
msgIn = bytes(beta.rxbs)
beta.clearRxbs()
assert msgIn == msgOut
readrx = wl.readRx()
readtx = wl.readTx()
assert readrx == readtx
assert len(readrx) == 357
assert beta.opened == False
assert server.opened == False
assert wl.rxl.closed
assert wl.txl.closed
assert not wl.opened
"""Done Test"""
def test_wsgi_server_tls():
"""
Test Valet WSGI service with secure TLS request response
"""
tymist = tyming.Tymist(tyme=0.0)
def wsgiApp(environ, start_response):
start_response('200 OK', [('Content-type', 'text/plain'),
('Content-length', '12')])
return [b"Hello World!"]
serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
#serverKeypath = '/etc/pki/tls/certs/server_key.pem' # local server private key
#serverCertpath = '/etc/pki/tls/certs/server_cert.pem' # local server public cert
#clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
serverKeypath = certdirpath + '/server_key.pem' # local server private key
serverCertpath = certdirpath + '/server_cert.pem' # local server public cert
clientCafilepath = certdirpath + '/client.pem' # remote client public cert
with http.openServer(port = 6101, bufsize=131072, app=wsgiApp, \
scheme='https', keypath=serverKeypath, \
certpath=serverCertpath, cafilepath=clientCafilepath, \
tymth=tymist.tymen()) as alpha:
assert alpha.servant.ha == ('0.0.0.0', 6101)
assert alpha.servant.eha == ('127.0.0.1', 6101)
#clientKeypath = '/etc/pki/tls/certs/client_key.pem' # local client private key
#clientCertpath = '/etc/pki/tls/certs/client_cert.pem' # local client public cert
#serverCafilepath = '/etc/pki/tls/certs/server.pem' # remote server public cert
clientKeypath = certdirpath + '/client_key.pem' # local client private key
clientCertpath = certdirpath + '/client_cert.pem' # local client public cert
serverCafilepath = certdirpath + '/server.pem' # remote server public cert
path = "https://{0}:{1}/".format('localhost', alpha.servant.eha[1])
with http.openClient(bufsize=131072, path=path, scheme='https', \
certedhost=serverCertCommonName, keypath=clientKeypath, \
certpath=clientCertpath, cafilepath=serverCafilepath, \
tymth=tymist.tymen(), reconnectable=True,) as beta:
assert not beta.connector.accepted
assert not beta.connector.connected
assert not beta.connector.cutoff
request = dict([
('method', u'GET'),
('path', u'/echo?name=fame'),
('qargs', dict()),
('fragment', u''),
('headers',
dict([('Accept', 'application/json'),
('Content-Length', 0)])),
])
beta.requests.append(request)
while (beta.requests or beta.connector.txbs or not beta.responses
or not alpha.idle()):
alpha.service()
time.sleep(0.05)
beta.service()
time.sleep(0.05)
assert beta.connector.accepted
assert beta.connector.connected
assert not beta.connector.cutoff
assert len(alpha.servant.ixes) == 1
assert len(alpha.reqs) == 1
assert len(alpha.reps) == 1
requestant = list(alpha.reqs.values())[0]
assert requestant.method == request['method']
assert requestant.url == request['path']
assert requestant.headers == help.Hict([
('Host', 'localhost:6101'), ('Accept-Encoding', 'identity'),
('Accept', 'application/json'), ('Content-Length', '0')
])
assert len(beta.responses) == 1
response = beta.responses.popleft()
assert response['body'] == (b'Hello World!')
assert response['status'] == 200
responder = list(alpha.reps.values())[0]
responder.status.startswith(str(response['status']))
assert responder.headers == response['headers']
def test_connection_non_persistent():
"""
Test WSGI service request response non persistent connection in request
"""
try:
import bottle
except ImportError as ex:
logger.error("Bottle not available.\n")
return
tymist = tyming.Tymist(tyme=0.0)
app = bottle.default_app() # create bottle app
@app.get('/echo')
@app.get('/echo/<action>')
@app.post('/echo')
@app.post('/echo/<action>')
def echoGet(action=None):
"""
Echo back request data
"""
query = dict(bottle.request.query.items())
body = bottle.request.json
raw = bottle.request.body.read()
form = dict(bottle.request.forms)
data = dict(verb=bottle.request.method,
url=bottle.request.url,
action=action,
query=query,
form=form,
content=body)
return data
with http.openServer(port = 6101, bufsize=131072, app=app, \
tymth=tymist.tymen()) as alpha:
assert alpha.servant.ha == ('0.0.0.0', 6101)
assert alpha.servant.eha == ('127.0.0.1', 6101)
path = "http://{0}:{1}/".format('localhost', alpha.servant.eha[1])
with http.openClient(bufsize=131072, path=path, reconnectable=True, \
tymth=tymist.tymen(),) as beta:
assert not beta.connector.accepted
assert not beta.connector.connected
assert not beta.connector.cutoff
request = dict([
('method', u'GET'),
('path', u'/echo?name=fame'),
('qargs', dict()),
('fragment', u''),
('headers',
dict([('Accept', 'application/json'),
('Connection', 'close')])),
])
beta.requests.append(request)
while (beta.requests or beta.connector.txbs or not beta.responses
or not alpha.idle()):
alpha.service()
time.sleep(0.05)
beta.service()
time.sleep(0.05)
tymist.tick(tock=0.1)
assert beta.connector.accepted
assert beta.connector.connected
assert not beta.connector.cutoff
assert len(alpha.servant.ixes) == 1
assert len(alpha.reqs) == 1
assert len(alpha.reps) == 1
requestant = list(alpha.reqs.values())[0]
assert requestant.method == request['method']
assert requestant.url == request['path']
assert requestant.headers == help.Hict([
('Host', 'localhost:6101'), ('Accept-Encoding', 'identity'),
('Accept', 'application/json'), ('Connection', 'close')
])
assert len(beta.responses) == 1
response = beta.responses.popleft()
assert response['status'] == 200
assert response['reason'] == 'OK'
assert response['body'] == (
b'{"verb": "GET", "url": "http://localhost:6101/echo?name=fame", "'
b'action": null, "query": {"name": "fame"}, "form": {}, "content":'
b' null}')
assert response['data'] == {
'action': None,
'content': None,
'form': {},
'query': {
'name': 'fame'
},
'url': 'http://localhost:6101/echo?name=fame',
'verb': 'GET'
}
responder = list(alpha.reps.values())[0]
assert responder.status.startswith(str(response['status']))
assert responder.headers == response['headers']
def test_tcp_tls_verify_server():
"""
Test TCP TLS client server connection with verify certs for server not client
"""
certDirPath = localTestCertDirPath()
assert os.path.exists(certDirPath)
serverKeyPath = os.path.join(certDirPath,
'server_key.pem') # local server private key
serverCertPath = os.path.join(
certDirPath, 'server_cert.pem') # local server public cert
clientCaPath = os.path.join(certDirPath,
'client.pem') # remote client public cert
clientKeyPath = os.path.join(certDirPath,
'client_key.pem') # local client private key
clientCertPath = os.path.join(
certDirPath, 'client_cert.pem') # local client public cert
serverCaPath = os.path.join(certDirPath,
'server.pem') # remote server public cert
assert os.path.exists(serverKeyPath)
assert os.path.exists(serverCertPath)
assert os.path.exists(clientCaPath)
assert os.path.exists(clientKeyPath)
assert os.path.exists(clientCertPath)
assert os.path.exists(serverCaPath)
serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
tymist = tyming.Tymist()
with tcp.openServer(cls=tcp.ServerTls,
tymth=tymist.tymen(),
ha=("", 6101),
bs=16192,
keypath=serverKeyPath,
certpath=serverCertPath,
cafilepath=clientCaPath,
certify=ssl.CERT_NONE ,) as server, \
tcp.openClient(cls=tcp.ClientTls,
tymth=tymist.tymen(),
ha=("127.0.0.1", 6101),
bs=16192,
certedhost=serverCertCommonName,
keypath=clientKeyPath,
certpath=clientCertPath,
cafilepath=serverCaPath,
certify=ssl.CERT_REQUIRED,
hostify=True,) as beta:
assert server.opened == True
assert server.eha == ('127.0.0.1', 6101)
assert server.ha == ('0.0.0.0', 6101)
assert beta.opened == True
assert beta.accepted == False
assert beta.connected == False
assert beta.cutoff == False
# Connect beta to server
while not (beta.connected and len(server.ixes) >= 1):
beta.serviceConnect()
server.serviceConnects()
time.sleep(0.01)
assert beta.accepted == True
assert beta.connected == True
assert beta.cutoff == False
assert beta.ca == beta.cs.getsockname()
assert beta.ha == beta.cs.getpeername()
ixBeta = server.ixes[beta.ca]
assert ixBeta.cs.getsockname() == beta.cs.getpeername()
assert ixBeta.cs.getpeername() == beta.cs.getsockname()
assert ixBeta.ca == beta.ca
assert ixBeta.ha == beta.ha
msgOut = b"Beta sends to Server\n"
beta.tx(msgOut)
while not (not beta.txbs and ixBeta.rxbs):
beta.serviceSends()
server.serviceReceivesAllIx()
time.sleep(0.01)
time.sleep(0.05)
server.serviceReceivesAllIx()
msgIn = bytes(ixBeta.rxbs)
assert msgIn == msgOut
ixBeta.clearRxbs()
msgOut = b'Server sends to Beta\n'
ixBeta.tx(msgOut)
while not (not ixBeta.txbs and beta.rxbs):
server.serviceSendsAllIx()
beta.serviceReceives()
time.sleep(0.01)
msgIn = bytes(beta.rxbs)
assert msgIn == msgOut
beta.clearRxbs()
assert beta.opened == False
assert server.opened == False
"""Done Test"""
def test_doify():
"""
Test wrapper function doify()
"""
def genfun(tymth, tock=0.0, **opts):
tyme = yield (tock)
assert inspect.isgeneratorfunction(genfun)
gf0 = doing.doify(genfun, name='gf0', tock=0.25)
gf1 = doing.doify(genfun, name='gf1', tock=0.125)
assert inspect.isgeneratorfunction(gf0)
assert inspect.isgeneratorfunction(gf1)
assert id(gf0) != id(gf1)
assert gf0.__name__ == 'gf0'
assert gf1.__name__ == 'gf1'
assert gf0.tock == 0.25
assert gf1.tock == 0.125
assert gf0.done == None
assert gf1.done == None
assert gf0.opts == dict()
assert gf1.opts == dict()
tymist = tyming.Tymist()
g0 = gf0(tymth=tymist.tymen(), tock=gf0.tock, **gf0.opts)
assert inspect.isgenerator(g0)
g1 = gf0(tymth=tymist.tymen(), tock=gf1.tock, **gf1.opts)
assert inspect.isgenerator(g1)
assert id(g0) != id(g1)
class A:
def __init__(self, name="hi"):
self.name = name
def gf(self):
yield self.name
a = A()
tock = 0.5
opts = dict(cold=True)
a.dgf = doing.doify(a.gf, name="dgf", tock=tock, **opts)
assert inspect.isgeneratorfunction(a.dgf)
gen = a.dgf()
assert next(gen) == "hi" == a.name
assert inspect.isgeneratorfunction(a.dgf)
assert inspect.isgenerator(gen)
assert a.dgf.__func__.done is None
a.dgf.__func__.done = True
assert a.dgf.done == True
assert a.dgf.opts == opts
b = A()
assert not hasattr(b, "dgf")
b.dgf = doing.doify(b.gf, name="dgf", tock=tock, **opts)
assert inspect.isgeneratorfunction(b.dgf)
gen = b.dgf()
assert next(gen) == "hi" == b.name
assert inspect.isgeneratorfunction(b.dgf)
assert inspect.isgenerator(gen)
assert b.dgf.__func__.done is None
b.dgf.__func__.done = False
assert b.dgf.done == False
assert a.dgf.done == True
assert b.dgf.opts == opts
assert a.dgf is not b.dgf
"""End Test"""
def test_doer():
"""
Test Doer base class
"""
tock = 1.0
doer = doing.Doer()
assert isinstance(doer, doing.Doer)
assert callable(doing.Doer)
assert callable(doer)
assert inspect.isgeneratorfunction(doer.do)
# callable instance when called returns generator
assert not inspect.isgeneratorfunction(
doer) # not directly generator function
assert doer.tock == 0.0
assert doer.tymth == None
tymist = tyming.Tymist()
doer = doing.Doer(tymth=tymist.tymen(), tock=tock)
assert doer.tock == tock == 1.0
doer.tock = 0.0
assert doer.tock == 0.0
# create generator use send and explicit close
args = {}
dog = doer(tymth=doer.tymth, tock=doer.tock, **args)
assert inspect.isgenerator(dog)
result = dog.send(None)
assert result == doer.tock == 0.0
result = dog.send("Hello")
assert result == doer.tock == 0.0
result = dog.send("Hi")
assert result == doer.tock == 0.0
result = dog.close()
assert result == None # no yielded value on close
with pytest.raises(StopIteration): # send after close
try:
result = dog.send("what?")
except StopIteration as ex:
assert ex.value == None
raise
# use next instead of send
dog = doer(tymth=doer.tymth, tock=doer.tock)
assert inspect.isgenerator(dog)
result = next(dog)
assert result == doer.tock == 0.0
result = next(dog)
assert result == doer.tock == 0.0
result = next(dog)
assert result == doer.tock == 0.0
result = dog.close()
assert result == None
with pytest.raises(StopIteration): # send after close
try:
result = dog.send("what?")
except StopIteration as ex:
assert ex.value == None
raise
# use different tock
dog = doer(tymth=doer.tymth, tock=tock)
assert inspect.isgenerator(dog)
result = next(dog)
assert result == tock == 1.0
result = next(dog)
assert result == tock == 1.0
result = next(dog)
assert result == tock == 1.0
result = dog.close()
assert result == None
with pytest.raises(StopIteration):
result = dog.send("what?")
doer.tock = 0.0
dog = doer(tymth=doer.tymth, tock=tock)
assert inspect.isgenerator(dog)
result = next(dog)
assert result == tock == 1.0
result = next(dog)
assert result == 1.0
result = next(dog)
assert result == 1.0
result = dog.close()
assert result == None
with pytest.raises(StopIteration): # send after close
try:
result = dog.send("what?")
except StopIteration as ex:
assert ex.value == None
raise
# Test default pass through of extra __init__ kwa to .opts
assert callable(doing.Doer)
opts = dict(extra=True, more=1, evenmore="hi")
doer = doing.Doer(extra=True, more=1, evenmore="hi")
assert callable(doer)
assert not inspect.isgeneratorfunction(doer)
assert doer.tock == 0.0
assert doer.tymth is None
assert doer.opts == opts
dog = doer(tymth=doer.tymth, tock=doer.tock, **doer.opts)
assert inspect.isgenerator(dog)
tymist = tyming.Tymist()
tock = 1.0
doer = doing.Doer(tymth=tymist.tymen(), tock=tock, **opts)
assert callable(doer)
assert not inspect.isgeneratorfunction(doer)
assert doer.tymth is not None
assert doer.tyme == tymist.tyme == 0.0
assert doer.tock == tock == 1.0
assert doer.opts == opts
tymist.tick()
assert doer.tyme == tymist.tyme == tymist.tock == 0.03125
dog = doer(tymth=doer.tymth, tock=doer.tock, **doer.opts)
assert inspect.isgenerator(dog)
"""End Test """
return body.encode("utf-8")
def on_get(self, req, rep):
"""
Handles GET request that makes request to another backend endpoint
"""
# status and headers are injected via ._status and ._headers of
# backendGenerator
# alternativly could just get response from backend generator and
# examine here to assign to rep
rep.stream = self.backendGenerator(req=req, rep=rep)
# must do it here to inject into Falcon endpoint resource instances
tymist = tyming.Tymist(tyme=0.0)
exapp = falcon.App() # falcon.App instances are callable WSGI apps
WEB_DIR_PATH = os.path.dirname(
os.path.abspath(
sys.modules.get(__name__).__file__))
STATIC_DIR_PATH = os.path.join(WEB_DIR_PATH, 'static')
# /Users/Load/Data/Code/public/hio/tests/core/http/falcon
sink = serving.StaticSink(staticDirPath=STATIC_DIR_PATH)
exapp.add_sink(sink, prefix=sink.DefaultStaticSinkBasePath)
example = ExampleEnd() # Resources are represented by long-lived class instances
exapp.add_route('/example', example) # example handles all requests to '/example' URL path
def test_tymer():
"""
Test Tymer class
"""
tymer = tyming.Tymer() # uses start=0.0 if not .tymth
tymist = tyming.Tymist()
tymer.wind(tymth=tymist.tymen())
assert tymer.tyme == tymist.tyme
tymist = tyming.Tymist()
assert tymist.tock == 0.03125
tymer = tyming.Tymer(tymth=tymist.tymen())
assert tymer.tyme == 0.0
assert tymer.duration == 0.0
assert tymer.elapsed == 0.0
assert tymer.remaining == 0.0
assert tymer.expired == True
tymist.tock = 0.25
assert tymist.tock == 0.25
tymer.start(duration=1.0)
assert tymer.duration == 1.0
assert tymer.elapsed == 0.0
assert tymer.remaining == 1.0
assert tymer.expired == False
tymist.tick()
assert tymer.tyme == tymist.tyme == 0.25
assert tymer.elapsed == 0.25
assert tymer.remaining == 0.75
assert tymer.expired == False
tymist.tick()
tymist.tick()
assert tymer.tyme == 0.75
assert tymer.elapsed == 0.75
assert tymer.remaining == 0.25
assert tymer.expired == False
tymist.tick()
assert tymer.tyme == 1.0
assert tymer.elapsed == 1.0
assert tymer.remaining == 0.0
assert tymer.expired == True
tymist.tick()
assert tymer.tyme == 1.25
assert tymer.elapsed == 1.25
assert tymer.remaining == -0.25
assert tymer.expired == True
tymer.restart()
assert tymer.duration == 1.0
assert tymer.elapsed == 0.25
assert tymer.remaining == 0.75
assert tymer.expired == False
tymist.tyme = 2.0
assert tymer.elapsed == 1.0
assert tymer.remaining == 0.0
assert tymer.expired == True
tymer.restart(duration=0.25)
assert tymer.duration == 0.25
assert tymer.elapsed == 0.0
assert tymer.remaining == 0.25
assert tymer.expired == False
tymist.tick()
assert tymer.elapsed == 0.25
assert tymer.remaining == 0.0
assert tymer.expired == True
tymist = tyming.Tymist(tock=1.0)
tymer = tyming.Tymer(tymth=tymist.tymen(), duration=1.0, start=0.25)
assert tymer.tyme == 0.0
assert tymer.duration == 1.0
assert tymer.elapsed == -0.25
assert tymer.remaining == 1.25
assert tymer.expired == False
tymist.tick()
assert tymer.tyme == 1.0
assert tymer.elapsed == 0.75
assert tymer.remaining == 0.25
assert tymer.expired == False
tymist.tick()
assert tymer.tyme == 2.0
assert tymer.elapsed == 1.75
assert tymer.remaining == -0.75
assert tymer.expired == True
tymist = tyming.Tymist(tyme=5.0, tock=0.125)
tymer.wind(tymist.tymen())
assert tymer.tyme == tymist.tyme == 5.0
assert tymer.expired == False
assert tymer._start == tymer.tyme == 5.0
assert tymer._stop == tymer.tyme + tymer.duration == 6.0
tymist.tick()
assert tymer.tyme == tymer._start + tymist.tock == 5.125
"""End Test """
def test_get_static_sink():
"""
Test GET to static files
"""
# must do it here to inject into Falcon endpoint resource instances
tymist = tyming.Tymist(tyme=0.0)
#myapp = falcon.App() # falcon.App instances are callable WSGI apps
#ending.loadEnds(myapp, tymth=tymist.tymen())
client = testing.TestClient(app=exapp)
index = ('<html>\n'
' <head>\n'
' <title>Demo</title>\n'
' <!--\n'
' <link rel="stylesheet" type="text/css" '
'href="semantic/dist/semantic.min.css">\n'
' <script src="node_modules/jquery/dist/jquery.min.js"></script>\n'
' <script src="semantic/dist/semantic.min.js"></script>\n'
' -->\n'
' </head>\n'
' <body>\n'
' <!--\n'
' <script src="bin/app.js"></script>\n'
' <button class="ui button">Follow</button>\n'
' -->\n'
' <p>Hello World.</p>\n'
' </body>\n'
'</html>\n')
# get default at / which is index.html
rep = client.simulate_get('/')
assert rep.status == falcon.HTTP_OK
assert rep.headers['content-type'] == 'text/html; charset=UTF-8'
assert len(rep.text) > 0
assert rep.text == index
# get default at /static which is index.html
rep = client.simulate_get('/static')
assert rep.status == falcon.HTTP_OK
assert rep.headers['content-type'] == 'text/html; charset=UTF-8'
assert len(rep.text) > 0
assert rep.text == index
# get default at /static/ e.g. trailing / which is index.html
rep = client.simulate_get('/static/')
assert rep.status == falcon.HTTP_OK
assert rep.headers['content-type'] == 'text/html; charset=UTF-8'
assert len(rep.text) > 0
assert rep.text == index
# get index.html
rep = client.simulate_get('/index.html')
assert rep.status == falcon.HTTP_OK
assert rep.headers['content-type'] == 'text/html; charset=UTF-8'
assert len(rep.text) > 0
assert rep.text == index
# get /static/index.html
rep = client.simulate_get('/static/index.html')
assert rep.status == falcon.HTTP_OK
assert rep.headers['content-type'] == 'text/html; charset=UTF-8'
assert len(rep.text) > 0
assert rep.text == index
# attempt missing file
rep = client.simulate_get('/static/missing.txt')
assert rep.status == falcon.HTTP_NOT_FOUND
assert rep.headers['content-type'] == 'application/json'
assert rep.json['title'] == 'Missing Resource'
# get robots.txt
rep = client.simulate_get('/static/robots.txt')
assert rep.status == falcon.HTTP_OK
assert rep.headers['content-type'] == 'text/plain; charset=UTF-8'
assert rep.text == '# robotstxt.org\n\nUser-agent: *\n'
# get trial.js
rep = client.simulate_get('/static/index.js')
assert rep.status == falcon.HTTP_OK
assert rep.headers['content-type'] == 'application/javascript; charset=UTF-8'
assert len(rep.text) > 0
assert rep.text == '// vanilla index.js\n\nm.render(document.body, "Hello world")\n'
def test_tcp_service():
"""
Test Classes tcp service methods
"""
tymist = tyming.Tymist()
with tcp.openServer(tymth=tymist.tymen(), ha=("", 6101)) as server, \
tcp.openClient(tymth=tymist.tymen(), ha=("127.0.0.1", 6101)) as beta:
assert server.opened == True
assert server.ha == ('0.0.0.0', 6101)
assert server.eha == ('127.0.0.1', 6101)
assert beta.opened == True
assert beta.accepted == False
assert beta.connected == False
assert beta.cutoff == False
# connect beta to server
while not (beta.connected and beta.ca in server.ixes):
beta.serviceConnect()
server.serviceConnects()
time.sleep(0.05)
assert beta.accepted == True
assert beta.connected == True
assert beta.cutoff == False
assert beta.ca == beta.cs.getsockname()
assert beta.ha == beta.cs.getpeername() == server.eha
ixBeta = server.ixes[beta.ca]
assert ixBeta.cs.getsockname() == beta.cs.getpeername()
assert ixBeta.cs.getpeername() == beta.cs.getsockname()
assert ixBeta.ca == beta.ca
assert ixBeta.ha == beta.ha
msgOut1 = b"Beta sends to Server first"
beta.tx(msgOut1)
while not ixBeta.rxbs and beta.txbs:
beta.serviceSends()
time.sleep(0.05)
server.serviceReceivesAllIx()
time.sleep(0.05)
msgIn = bytes(ixBeta.rxbs)
assert msgIn == msgOut1
offset = len(ixBeta.rxbs) # offset into .rxbs of first message
# send multiple additional messages
msgOut2 = b"Beta sends to Server second"
beta.tx(msgOut2)
msgOut3 = b"Beta sends to Server third"
beta.tx(msgOut3)
while len(ixBeta.rxbs) < len(msgOut1) + len(msgOut2) + len(msgOut3):
beta.serviceSends()
server.serviceReceivesAllIx()
time.sleep(0.05)
msgIn = bytes(ixBeta.rxbs)
assert msgIn == msgOut1 + msgOut2 + msgOut3
ixBeta.clearRxbs() # clear out the receive buffer
# build message too big to fit in buffer
size = beta.actualBufSizes()[0]
msgOutBig = bytearray()
count = 0
while (len(msgOutBig) <= size * 4):
msgOutBig.extend(b"%032x_" % (count))
count += 1
assert len(msgOutBig) >= size * 4
beta.tx(msgOutBig)
while len(ixBeta.rxbs) < len(msgOutBig):
beta.serviceSends()
time.sleep(0.05)
server.serviceReceivesAllIx()
time.sleep(0.05)
msgIn = bytes(ixBeta.rxbs)
ixBeta.clearRxbs()
assert msgIn == msgOutBig
# send from server to beta
msgOut = b"Server sends to Beta"
ixBeta.tx(msgOut)
while len(beta.rxbs) < len(msgOut):
server.serviceSendsAllIx()
beta.serviceReceives()
time.sleep(0.05)
msgIn = bytes(beta.rxbs)
beta.clearRxbs()
assert msgIn == msgOut
# send big from server to beta
ixBeta.tx(msgOutBig)
while len(beta.rxbs) < len(msgOutBig):
server.serviceSendsAllIx()
time.sleep(0.05)
beta.serviceReceives()
time.sleep(0.05)
msgIn = bytes(beta.rxbs)
beta.clearRxbs()
assert msgIn == msgOutBig
assert beta.opened == False
assert server.opened == False
"""Done Test"""
def test_doer():
"""
Test Doer base class
"""
tock = 1.0
doer = doing.Doer()
assert doer.tock == 0.0
assert doer.tymth == None
tymist = tyming.Tymist()
doer = doing.Doer(tymth=tymist.tymen(), tock=tock)
assert doer.tock == tock == 1.0
doer.tock = 0.0
assert doer.tock == 0.0
# create generator use send and explicit close
args = {}
dog = doer(tymth=doer.tymth, tock=doer.tock, **args)
assert inspect.isgenerator(dog)
result = dog.send(None)
assert result == doer.tock == 0.0
result = dog.send("Hello")
assert result == doer.tock == 0.0
result = dog.send("Hi")
assert result == doer.tock == 0.0
result = dog.close()
assert result == None # no yielded value on close
with pytest.raises(StopIteration): # send after close
try:
result = dog.send("what?")
except StopIteration as ex:
assert ex.value == None
raise
# use next instead of send
dog = doer(tymth=doer.tymth, tock=doer.tock)
assert inspect.isgenerator(dog)
result = next(dog)
assert result == doer.tock == 0.0
result = next(dog)
assert result == doer.tock == 0.0
result = next(dog)
assert result == doer.tock == 0.0
result = dog.close()
assert result == None
with pytest.raises(StopIteration): # send after close
try:
result = dog.send("what?")
except StopIteration as ex:
assert ex.value == None
raise
# use different tock
dog = doer(tymth=doer.tymth, tock=tock)
assert inspect.isgenerator(dog)
result = next(dog)
assert result == tock == 1.0
result = next(dog)
assert result == tock == 1.0
result = next(dog)
assert result == tock == 1.0
result = dog.close()
assert result == None
with pytest.raises(StopIteration):
result = dog.send("what?")
doer.tock = 0.0
dog = doer(tymth=doer.tymth, tock=tock)
assert inspect.isgenerator(dog)
result = next(dog)
assert result == tock == 1.0
result = next(dog)
assert result == 1.0
result = next(dog)
assert result == 1.0
result = dog.close()
assert result == None
with pytest.raises(StopIteration): # send after close
try:
result = dog.send("what?")
except StopIteration as ex:
assert ex.value == None
raise
"""End Test """
def test_bare_server_echo():
"""
Test BaserServer service request response of echo non blocking
"""
tymist = tyming.Tymist(tyme=0.0)
with http.openServer(cls=http.BareServer, port = 6101, bufsize=131072, \
tymth=tymist.tymen()) as alpha:
assert alpha.servant.ha == ('0.0.0.0', 6101)
assert alpha.servant.eha == ('127.0.0.1', 6101)
path = "http://{0}:{1}/".format('localhost', alpha.servant.eha[1])
with http.openClient(bufsize=131072, path=path, tymth=tymist.tymen(), \
reconnectable=True,) as beta:
assert not beta.connector.accepted
assert not beta.connector.connected
assert not beta.connector.cutoff
request = dict([
('method', u'GET'),
('path', u'/echo?name=fame'),
('qargs', dict()),
('fragment', u''),
('headers',
dict([('Accept', 'application/json'),
('Content-Length', 0)])),
])
beta.requests.append(request)
while (beta.requests or beta.connector.txbs or not beta.responses
or not alpha.servant.ixes or not alpha.idle()):
alpha.service()
time.sleep(0.05)
beta.service()
time.sleep(0.05)
assert beta.connector.accepted
assert beta.connector.connected
assert not beta.connector.cutoff
assert len(alpha.servant.ixes) == 1
assert len(alpha.stewards) == 1
requestant = list(alpha.stewards.values())[0].requestant
assert requestant.method == request['method']
assert requestant.url == request['path']
assert requestant.headers == help.Hict([
('Host', 'localhost:6101'), ('Accept-Encoding', 'identity'),
('Accept', 'application/json'), ('Content-Length', '0')
])
assert len(beta.responses) == 1
response = beta.responses.popleft()
assert response['data'] == {
'version':
'HTTP/1.1',
'method':
'GET',
'path':
'/echo',
'qargs': {
'name': 'fame'
},
'fragment':
'',
'headers': [['Host', 'localhost:6101'],
['Accept-Encoding', 'identity'],
['Accept', 'application/json'],
['Content-Length', '0']],
'body':
'',
'data':
None
}
responder = list(alpha.stewards.values())[0].responder
assert responder.status == response['status']
assert responder.headers == response['headers']
def test_tcp_basic():
"""
Test the tcp connection between client and server
client send from and receive to port is ephemeral
server receive to and send from port is well known
Server listens on ist well know receive to and send from port
So incoming to server.
Source address is client host and client ephemeral port
Destination address is server host and server well known port
Each accept socket on server is a different duple of client source, server dest
all the dest are the same but each source is differenct so can route
based on the source.
Server routes incoming packets to accept socket port. The routing uses
the clients send from ephemeral port to do the routing to the
correct accept socket. All the accept sockets have the same local
port but a different remote IP host .
The servers accept socket port is the well known port so still receives to
and sends from its well know port.
The server sends to and receives from the clients ephemeral port number.
"""
tymist = tyming.Tymist()
client = tcp.Client(tymth=tymist.tymen())
assert client.tymeout == 0.0
assert isinstance(client.tymer, tyming.Tymer)
assert client.tymer.duration == client.tymeout
assert client.ha == ('127.0.0.1', 56000)
assert (client.host, client.port) == client.ha
assert client.hostname == client.host
assert client.cs == None
assert client.ca == (None, None)
assert client.accepted == False
assert client.cutoff == False
assert client.reconnectable == False
assert client.opened == False
assert client.bs == 8096
assert isinstance(client.txbs, bytearray)
assert isinstance(client.rxbs, bytearray)
assert client.wl == None
tymist = tyming.Tymist()
with tcp.openClient(tymth=tymist.tymen(), tymeout=0.5) as client:
assert client.tymeout == 0.5
assert client.ha == ('127.0.0.1', 56000)
assert client.opened == True
assert client.accepted == False
assert client.cutoff == False
assert client.reconnectable == False
assert client.opened == False
assert client.accepted == False
assert client.cutoff == False
server = tcp.Server()
assert server.tymeout == 1.0
assert server.ha == ('', 56000)
assert server.eha == ('127.0.0.1', 56000)
assert server.opened == False
assert server.bs == 8096
assert isinstance(server.axes, deque)
assert isinstance(server.ixes, dict)
assert server.wl == None
with tcp.openServer(tymth=tymist.tymen(), tymeout=1.5) as server:
assert server.ha == ('0.0.0.0', 56000)
assert server.eha == ('127.0.0.1', 56000)
assert server.opened == True
assert server.opened == False
tymist = tyming.Tymist()
with tcp.openServer(tymth=tymist.tymen(), ha=("", 6101)) as server, \
tcp.openClient(tymth=tymist.tymen(), ha=("127.0.0.1", 6101)) as beta, \
tcp.openClient(tymth=tymist.tymen(), ha=("127.0.0.1", 6101)) as gamma:
assert server.opened == True
assert beta.opened == True
assert gamma.opened == True
assert server.ha == ('0.0.0.0', 6101) # listen interface
assert server.eha == ('127.0.0.1', 6101
) # normalized listen/accept external interface
assert beta.ha == (
'127.0.0.1', 6101
) # server listen/accept maybe sha (server host address)
assert beta.accepted == False
assert beta.connected == False
assert beta.cutoff == False
assert gamma.accepted == False
assert gamma.connected == False
assert gamma.cutoff == False
# connect beta to server
while not (beta.connected and beta.ca in server.ixes):
beta.serviceConnect()
server.serviceConnects()
time.sleep(0.05)
assert beta.accepted == True
assert beta.connected == True
assert beta.cutoff == False
assert beta.ca == beta.cs.getsockname() # local connection address
assert beta.ha == beta.cs.getpeername() # remote connection address
assert server.eha == beta.ha # server external, beta external for server
ixBeta = server.ixes[beta.ca]
assert ixBeta.cs.getsockname() == beta.cs.getpeername(
) # ixBeta local beta remote
assert ixBeta.cs.getpeername() == beta.cs.getsockname(
) # ixBeta remote beta local
assert ixBeta.ca == beta.ca == ixBeta.cs.getpeername()
assert ixBeta.ha == beta.ha == ixBeta.cs.getsockname()
msgOut = b"Beta sends to Server"
count = beta.send(msgOut)
assert count == len(msgOut)
time.sleep(0.05)
msgIn = ixBeta.receive()
assert msgOut == msgIn
# receive without sending
msgIn = ixBeta.receive()
assert msgIn is None
# send multiple
msgOut1 = b"First Message"
count = beta.send(msgOut1)
assert count == len(msgOut1)
msgOut2 = b"Second Message"
count = beta.send(msgOut2)
assert count == len(msgOut2)
time.sleep(0.05)
msgIn = ixBeta.receive()
assert msgIn == msgOut1 + msgOut2
# send from server to beta
msgOut = b"Server sends to Beta"
count = ixBeta.send(msgOut)
assert count == len(msgOut)
time.sleep(0.05)
msgIn = beta.receive()
assert msgOut == msgIn
# receive without sending
msgIn = beta.receive()
assert msgIn is None
# build message too big to fit in buffer
size = beta.actualBufSizes()[0]
msgOut = bytearray()
count = 0
while (len(msgOut) <= size * 4):
msgOut.extend(b"%032x_" % (count)) # need to fix this
count += 1
assert len(msgOut) >= size * 4
msgIn = bytearray()
txbs = bytearray(msgOut) # make copy
size = 0
while len(msgIn) < len(msgOut):
#if size < len(msgOut):
#size += beta.send(msgOut[size:])
count = beta.send(txbs)
del txbs[:count]
size += count
time.sleep(0.05)
msgIn.extend(ixBeta.receive())
assert size == len(msgOut)
assert msgOut == msgIn
# gamma to server
while not (gamma.connected and gamma.ca in server.ixes):
gamma.serviceConnect()
server.serviceConnects()
time.sleep(0.05)
assert gamma.accepted == True
assert gamma.connected == True
assert gamma.cutoff == False
assert gamma.ca == gamma.cs.getsockname()
assert gamma.ha == gamma.cs.getpeername()
assert server.eha, gamma.ha
ixGamma = server.ixes[gamma.ca]
assert ixGamma.cs.getsockname() == gamma.cs.getpeername()
assert ixGamma.cs.getpeername() == gamma.cs.getsockname()
assert ixGamma.ca == gamma.ca
assert ixGamma.ha == gamma.ha
msgOut = b"Gamma sends to Server"
count = gamma.send(msgOut)
assert count == len(msgOut)
time.sleep(0.05)
msgIn = ixGamma.receive()
assert msgOut == msgIn
# receive without sending
msgIn = ixGamma.receive()
assert msgIn is None
# send from server to gamma
msgOut = b"Server sends to Gamma"
count = ixGamma.send(msgOut)
assert count == len(msgOut)
time.sleep(0.05)
msgIn = gamma.receive()
assert msgOut == msgIn
# recieve without sending
msgIn = gamma.receive()
assert msgIn is None
# close beta and then attempt to send
beta.close()
msgOut = b"Beta send on closed socket"
with pytest.raises(AttributeError):
count = beta.send(msgOut)
# attempt to receive on closed socket
with pytest.raises(AttributeError):
msgIn = beta.receive()
# read on server after closed beta
msgIn = ixBeta.receive()
assert msgIn == b''
# send on server after closed beta
msgOut = b"Servers sends to Beta after close"
count = ixBeta.send(msgOut)
assert count == len(msgOut) #apparently works
# close ixBeta manually
ixBeta.close()
del server.ixes[ixBeta.ca]
time.sleep(0.05)
#after close no socket .cs so can't receive
with pytest.raises(AttributeError):
msgIn = ixBeta.receive()
assert ixBeta.cutoff == True
# send on gamma to servver first then shutdown gamma sends
msgOut = b"Gamma sends to server"
count = gamma.send(msgOut)
assert count == len(msgOut)
gamma.shutdownSend()
time.sleep(0.05)
msgIn = ixGamma.receive()
assert msgOut == msgIn # send before shutdown worked
msgIn = ixGamma.receive()
assert msgIn == b'' # gamma shutdown detected, not None
assert ixGamma.cutoff == True
# send from server to gamma first then shutdown server send
msgOut = b"Server sends to Gamma"
count = ixGamma.send(msgOut)
assert count == len(msgOut)
ixGamma.shutdown() # shutdown server connection to gamma
time.sleep(0.05)
msgIn = gamma.receive()
assert msgOut == msgIn
msgIn = gamma.receive()
if 'linux' in sys.platform:
assert msgIn == b'' # server shutdown detected not None
assert gamma.cutoff == True
else:
assert msgIn == None # server shutdown not detected
assert gamma.cutoff == False
time.sleep(0.05)
msgIn = gamma.receive()
if 'linux' in sys.platform:
assert msgIn == b'' # server shutdown detected not None
assert gamma.cutoff == True
else:
assert msgIn == None # server shutdown not detected
assert gamma.cutoff == False
ixGamma.close() # close server connection to gamma
del server.ixes[ixGamma.ca]
time.sleep(0.05)
msgIn = gamma.receive()
assert msgIn == b'' # server close is detected
assert gamma.cutoff == True
# reopen beta
assert beta.reopen() == True
assert beta.accepted == False
assert beta.connected == False
assert beta.cutoff == False
# reconnect beta to server
while not (beta.connected and beta.ca in server.ixes):
beta.serviceConnect()
server.serviceConnects()
time.sleep(0.05)
assert beta.accepted == True
assert beta.connected == True
assert beta.cutoff == False
assert beta.ca == beta.cs.getsockname()
assert beta.ha == beta.cs.getpeername()
assert server.eha == beta.ha
ixBeta = server.ixes[beta.ca]
assert ixBeta.cs.getsockname() == beta.cs.getpeername()
assert ixBeta.cs.getpeername() == beta.cs.getsockname()
assert ixBeta.ca == beta.ca
assert ixBeta.ha == beta.ha
msgOut = b"Beta sends to server"
count = beta.send(msgOut)
assert count == len(msgOut)
time.sleep(0.05)
msgIn = ixBeta.receive()
assert msgOut == msgIn
# send from server to beta
msgOut = b"Server sends to Beta"
count = ixBeta.send(msgOut)
assert count == len(msgOut)
time.sleep(0.05)
msgIn = beta.receive()
assert msgOut == msgIn
# send from server to beta then shutdown sever and attempt to send again
msgOut1 = b"Server sends to Beta"
count = ixBeta.send(msgOut)
assert count == len(msgOut1)
ixBeta.shutdownSend()
msgOut2 = b"Server send again after server shutdowns socket"
with pytest.raises(OSError) as ex:
count = ixBeta.send(msgOut)
assert ex.typename == 'BrokenPipeError'
time.sleep(0.05)
msgIn = beta.receive()
assert msgOut1 == msgIn
msgIn = beta.receive()
assert msgIn == b'' # beta detects shutdown socket
assert beta.cutoff == True
# send from beta to server then shutdown beta
msgOut = b"Beta sends to server"
count = beta.send(msgOut)
assert count == len(msgOut)
beta.shutdown()
time.sleep(0.05)
msgIn = ixBeta.receive()
assert msgOut == msgIn
time.sleep(0.05)
msgIn = ixBeta.receive()
if 'linux' in sys.platform:
assert ixBeta.cutoff == True
assert msgIn == b'' # server does detect shutdown
else:
assert ixBeta.cutoff == False
assert msgIn == None # server does not detect shutdown
beta.close()
time.sleep(0.05)
msgIn = ixBeta.receive()
assert msgIn == b'' # server detects closed socket
ixBeta.close()
del server.ixes[ixBeta.ca]
# reopen gamma
assert gamma.reopen() == True
assert gamma.accepted == False
assert gamma.connected == False
assert gamma.cutoff == False
# reconnect gamma to server
while not (gamma.connected and gamma.ca in server.ixes):
gamma.serviceConnect()
server.serviceConnects()
time.sleep(0.05)
assert gamma.accepted == True
assert gamma.connected == True
assert gamma.cutoff == False
assert gamma.ca == gamma.cs.getsockname()
assert gamma.ha == gamma.cs.getpeername()
assert server.eha == gamma.ha
ixGamma = server.ixes[gamma.ca]
assert ixGamma.cs.getsockname() == gamma.cs.getpeername()
assert ixGamma.cs.getpeername() == gamma.cs.getsockname()
assert ixGamma.ca == gamma.ca
assert ixGamma.ha == gamma.ha
msgOut = b"Gamma sends to server"
count = gamma.send(msgOut)
assert count == len(msgOut)
time.sleep(0.05)
msgIn = ixGamma.receive()
assert msgOut == msgIn
# close both sides and reopen Gamma
gamma.close()
time.sleep(0.05)
msgIn = ixGamma.receive()
assert ixGamma.cutoff == True # closed on other end
assert msgIn == b'' # server detects close
ixGamma.close()
del server.ixes[ixGamma.ca]
# reopen gamma
assert gamma.reopen() == True
assert gamma.accepted == False
assert gamma.connected == False
assert gamma.cutoff == False
# reconnect gamma to server
while not (gamma.connected and gamma.ca in server.ixes):
gamma.serviceConnect()
server.serviceConnects()
time.sleep(0.05)
assert gamma.accepted == True
assert gamma.connected == True
assert gamma.cutoff == False
assert gamma.ca == gamma.cs.getsockname()
assert gamma.ha == gamma.cs.getpeername()
assert server.eha == gamma.ha
ixGamma = server.ixes[gamma.ca]
assert ixGamma.cs.getsockname() == gamma.cs.getpeername()
assert ixGamma.cs.getpeername() == gamma.cs.getsockname()
assert ixGamma.ca == gamma.ca
assert ixGamma.ha == gamma.ha
# send from server to gamma
msgOut = b"Server sends to Gamma"
count = ixGamma.send(msgOut)
assert count == len(msgOut)
time.sleep(0.05)
msgIn = gamma.receive()
assert msgOut == msgIn
ixGamma.close()
del server.ixes[ixGamma.ca]
time.sleep(0.05)
msgIn = gamma.receive()
assert msgIn == b'' # gamma detects close
assert gamma.cutoff == True
assert beta.opened == False
assert gamma.opened == False
assert server.opened == False
"""Done Test"""
def test_redoer():
"""
Test ReDoer base class
"""
tock = 1.0
redoer = doing.ReDoer()
assert redoer.tock == 0.0
tymist = tyming.Tymist()
redoer = doing.ReDoer(tymth=tymist.tymen(), tock=tock)
assert redoer.tock == tock == 1.0
redoer.tock = 0.0
assert redoer.tock == 0.0
# create generator use send and run until normal exit. emulates Doist.ready
args = {}
dog = redoer(tymth=redoer.tymth, tock=redoer.tock, **args)
assert inspect.isgenerator(dog)
result = dog.send(None)
assert result == redoer.tock == 0.0
tymist.tick()
result = dog.send(tymist.tyme)
assert result == redoer.tock == 0.0
tymist.tick()
result = dog.send(tymist.tyme)
assert result == redoer.tock == 0.0
tymist.tick()
with pytest.raises(StopIteration):
try:
result = dog.send(tymist.tyme)
except StopIteration as ex:
assert ex.value == True
raise
tymist.tick()
with pytest.raises(StopIteration): # send after break
try:
result = dog.send(tymist.tyme)
except StopIteration as ex:
assert ex.value == None
raise
# create generator use send and then explicit close. emulates Doist.ready
args = {}
dog = redoer(tymth=redoer.tymth, tock=redoer.tock, **args)
assert inspect.isgenerator(dog)
result = dog.send(None)
assert result == redoer.tock == 0.0
tymist.tick()
result = dog.send(tymist.tyme)
assert result == redoer.tock == 0.0
result = dog.close()
assert result == None # no yielded value on close
tymist.tick()
with pytest.raises(StopIteration): # send after close
try:
result = dog.send(tymist.tyme)
except StopIteration as ex:
assert ex.value == None
raise
# use next instead of send
args = {}
dog = redoer(tymth=redoer.tymth, tock=redoer.tock, **args)
assert inspect.isgenerator(dog)
result = next(dog)
assert result == redoer.tock == 0.0
result = next(dog)
assert result == redoer.tock == 0.0
result = dog.close()
assert result == None # no yielded value on close
tymist.tick()
with pytest.raises(StopIteration): # send after close
try:
result = dog.send(tymist.tyme)
except StopIteration as ex:
assert ex.value == None
raise
"""End Test """
def test_client_auto_reconnect():
"""
Test client auto reconnect when .reconnectable
"""
tymist = tyming.Tymist(tock=0.05)
with tcp.openServer(tymth=tymist.tymen(), ha=("", 6101)) as server, \
tcp.openClient(tymth=tymist.tymen(), tymeout=0.2, reconnectable=True,
ha=("127.0.0.1", 6101)) as beta:
# close server
server.close()
assert server.opened == False
assert beta.opened == True
assert beta.accepted == False
assert beta.connected == False
assert beta.cutoff == False
assert beta.reconnectable == True
# attempt to connect beta to serve while server down (closed)
while tymist.tyme <= 0.25:
beta.serviceConnect()
tymist.tick()
time.sleep(0.05)
assert beta.accepted == False
assert beta.connected == False
assert server.reopen() == True
assert server.ha == ('0.0.0.0', 6101)
assert server.eha == ('127.0.0.1', 6101)
assert beta.ha == server.eha
# attempt to connect beta to server while server up (opened)
while not (beta.connected and beta.ca in server.ixes):
beta.serviceConnect()
server.serviceConnects()
tymist.tick() # advances clients reconnect retry tymer
time.sleep(0.05)
assert beta.accepted == True
assert beta.connected == True
assert beta.cutoff == False
assert beta.ca == beta.cs.getsockname()
assert beta.ha == beta.cs.getpeername()
assert server.eha == beta.ha
ixBeta = server.ixes[beta.ca]
assert ixBeta.cs.getsockname() == beta.cs.getpeername()
assert ixBeta.cs.getpeername() == beta.cs.getsockname()
assert ixBeta.ca == beta.ca
assert ixBeta.ha == beta.ha
msgOut = b"Beta sends to Server on reconnect"
beta.tx(msgOut)
while not ixBeta.rxbs and beta.txbs:
beta.serviceSends()
time.sleep(0.05)
server.serviceReceivesAllIx()
time.sleep(0.05)
msgIn = bytes(ixBeta.rxbs)
assert msgIn == msgOut
index = len(ixBeta.rxbs)
assert beta.opened == False
assert server.opened == False
"""Done Test"""
def test_dodoer():
"""
Test DoDoer class
"""
tock = 1.0
dodoer = doing.DoDoer()
assert dodoer.tock == 0.0
tymist = tyming.Tymist()
dodoer = doing.DoDoer(tymth=tymist.tymen(), tock=tock)
assert dodoer.tock == tock == 1.0
dodoer.tock = 0.0
assert dodoer.tock == 0.0
# create generator use send and run until normal exit. emulates Doist.ready
args = {}
dog = dodoer(tymth=dodoer.tymth, tock=dodoer.tock, **args)
assert inspect.isgenerator(dog)
assert dodoer.doers == []
result = dog.send(None)
assert result == dodoer.tock == 0.0
assert dodoer.doers == []
tymist.tick() # empty doers does list so ends right away
with pytest.raises(StopIteration):
try:
result = dog.send(tymist.tyme)
except StopIteration as ex:
assert ex.value == True
raise
tymist.tick()
with pytest.raises(StopIteration): # send after break
try:
result = dog.send(tymist.tyme)
except StopIteration as ex:
assert ex.value == None
raise
# create some doers
doer0 = doing.Doer()
doer1 = doing.Doer()
doer2 = doing.Doer()
doers = [doer0, doer1, doer2]
# create generator use send and then explicit close. emulates Doist.ready
args = {}
dog = dodoer(tymth=dodoer.tymth, tock=dodoer.tock, doers=doers, **args)
assert inspect.isgenerator(dog)
assert dodoer.doers == []
result = dog.send(None)
assert result == dodoer.tock == 0.0
assert dodoer.doers == doers
tymist.tick()
result = dog.send(tymist.tyme)
assert result == dodoer.tock == 0.0
tymist.tick()
result = dog.send(tymist.tyme)
assert result == dodoer.tock == 0.0
result = dog.close()
assert result == None # no yielded value on close
tymist.tick()
with pytest.raises(StopIteration): # send after close
try:
result = dog.send(tymist.tyme)
except StopIteration as ex:
assert ex.value == None
raise
"""End Test """
def test_server_with_bottle_tls():
"""
Test WSGI service secure TLS request response
"""
try:
import bottle
except ImportError as ex:
logger.error("Bottle not available.\n")
return
tymist = tyming.Tymist(tyme=0.0)
app = bottle.default_app() # create bottle app
@app.get('/echo')
@app.get('/echo/<action>')
@app.post('/echo')
@app.post('/echo/<action>')
def echoGet(action=None):
"""
Echo back request data
"""
query = dict(bottle.request.query.items())
body = bottle.request.json
raw = bottle.request.body.read()
form = dict(bottle.request.forms)
data = dict(verb=bottle.request.method,
url=bottle.request.url,
action=action,
query=query,
form=form,
content=body)
return data
serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
#serverKeypath = '/etc/pki/tls/certs/server_key.pem' # local server private key
#serverCertpath = '/etc/pki/tls/certs/server_cert.pem' # local server public cert
#clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
serverKeypath = certdirpath + '/server_key.pem' # local server private key
serverCertpath = certdirpath + '/server_cert.pem' # local server public cert
clientCafilepath = certdirpath + '/client.pem' # remote client public cert
with http.openServer(port = 6101, bufsize=131072, scheme='https', \
keypath=serverKeypath, certpath=serverCertpath, \
cafilepath=clientCafilepath, app=app, tymth=tymist.tymen()) as alpha:
assert alpha.servant.ha == ('0.0.0.0', 6101)
assert alpha.servant.eha == ('127.0.0.1', 6101)
#clientKeypath = '/etc/pki/tls/certs/client_key.pem' # local client private key
#clientCertpath = '/etc/pki/tls/certs/client_cert.pem' # local client public cert
#serverCafilepath = '/etc/pki/tls/certs/server.pem' # remote server public cert
clientKeypath = certdirpath + '/client_key.pem' # local client private key
clientCertpath = certdirpath + '/client_cert.pem' # local client public cert
serverCafilepath = certdirpath + '/server.pem' # remote server public cert
path = "https://{0}:{1}/".format('localhost', alpha.servant.eha[1])
with http.openClient(bufsize=131072, path=path, scheme='https', \
certedhost=serverCertCommonName, keypath=clientKeypath, \
certpath=clientCertpath, cafilepath=serverCafilepath, \
reconnectable=True, tymth=tymist.tymen(),) as beta:
assert not beta.connector.accepted
assert not beta.connector.connected
assert not beta.connector.cutoff
request = dict([
('method', u'GET'),
('path', u'/echo?name=fame'),
('qargs', dict()),
('fragment', u''),
('headers',
dict([('Accept', 'application/json'),
('Content-Length', 0)])),
])
beta.requests.append(request)
while (beta.requests or beta.connector.txbs or not beta.responses
or not alpha.idle()):
alpha.service()
time.sleep(0.05)
beta.service()
time.sleep(0.05)
tymist.tick(tock=0.1)
assert beta.connector.accepted
assert beta.connector.connected
assert not beta.connector.cutoff
assert len(alpha.servant.ixes) == 1
assert len(alpha.reqs) == 1
assert len(alpha.reps), 1
requestant = list(alpha.reqs.values())[0]
assert requestant.method == request['method']
assert requestant.url, request['path']
assert requestant.headers == help.Hict([
('Host', 'localhost:6101'), ('Accept-Encoding', 'identity'),
('Accept', 'application/json'), ('Content-Length', '0')
])
assert len(beta.responses) == 1
response = beta.responses.popleft()
assert response['status'] == 200
assert response['reason'] == 'OK'
assert response['body'] == (
b'{"verb": "GET", '
b'"url": "https://localhost:6101/echo?name=fame", '
b'"action": null, '
b'"query": {"name": "fame"}, '
b'"form": {}, '
b'"content": null}')
assert response['data'] == {
'action': None,
'content': None,
'form': {},
'query': {
'name': 'fame'
},
'url': 'https://localhost:6101/echo?name=fame',
'verb': 'GET'
}
responder = list(alpha.reps.values())[0]
assert responder.status.startswith(str(response['status']))
assert responder.headers == response['headers']
def test_exDo():
"""
Test exDo generator function non-class based
"""
doizeExDo = doing.doizeExDo
assert inspect.isgeneratorfunction(doizeExDo)
assert hasattr(doizeExDo, "tock")
assert hasattr(doizeExDo, "opts")
assert "states" in doizeExDo.opts
assert doizeExDo.opts["states"] == None
doizeExDo.opts["states"] = []
tymist = tyming.Tymist()
dog = doizeExDo(tymth=tymist.tymen(), tock=doizeExDo.tock, **doizeExDo.opts)
assert inspect.isgenerator(dog)
tock = dog.send(None)
assert tock == 0.0
tock = dog.send("Hello")
assert tock == 0.0
tock = dog.send("Hi")
assert tock == 0.0
tock = dog.close()
assert tock == None
with pytest.raises(StopIteration):
tock = dog.send("what?")
assert doizeExDo.opts["states"] == [State(tyme=0.0, context='enter', feed=0.0, count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.0, context='recur', feed='Hi', count=2),
State(tyme=0.0, context='close', feed=None, count=3),
State(tyme=0.0, context='exit', feed=None, count=4)]
doizeExDo.opts["states"] = []
dog = doizeExDo(tymth=tymist.tymen(), tock=1.0, **doizeExDo.opts)
assert inspect.isgenerator(dog)
tock = dog.send(None)
assert tock == 1.0
tock = dog.send("Hello")
assert tock == 1.0
tock = dog.send("Hi")
assert tock == 1.0
tock = dog.close()
assert tock == None
with pytest.raises(StopIteration):
tock = dog.send("what?")
assert doizeExDo.opts["states"] == [State(tyme=0.0, context='enter', feed=0.0, count=0),
State(tyme=0.0, context='recur', feed='Hello', count=1),
State(tyme=0.0, context='recur', feed='Hi', count=2),
State(tyme=0.0, context='close', feed=None, count=3),
State(tyme=0.0, context='exit', feed=None, count=4)]
doizeExDo.opts["states"] = []
dog = doizeExDo(tymth=tymist.tymen(), tock=1.0, **doizeExDo.opts)
assert inspect.isgenerator(dog)
tock = next(dog)
assert tock == 1.0
tock = next(dog)
assert tock == 1.0
tock = next(dog)
assert tock == 1.0
tock = dog.close()
assert tock == None
with pytest.raises(StopIteration):
tock = dog.send("what?")
assert doizeExDo.opts["states"] == [State(tyme=0.0, context='enter', feed=0.0, count=0),
State(tyme=0.0, context='recur', feed=None, count=1),
State(tyme=0.0, context='recur', feed=None, count=2),
State(tyme=0.0, context='close', feed=None, count=3),
State(tyme=0.0, context='exit', feed=None, count=4)]
"""End Test """
def test_sse_stream_tls():
"""
Test WSGI service request response stream sse with tls
"""
try:
import bottle
except ImportError as ex:
logger.error("Bottle not available.\n")
return
tymist = tyming.Tymist(tyme=0.0)
app = bottle.default_app() # create bottle app
@app.get('/stream')
def streamGet():
"""
Create test server sent event stream that sends count events
"""
tymer = tyming.Tymer(tymth=tymist.tymen(), duration=2.0)
bottle.response.set_header('Content-Type', 'text/event-stream') #text
bottle.response.set_header('Cache-Control', 'no-cache')
# HTTP 1.1 servers detect text/event-stream and use Transfer-Encoding: chunked
# Set client-side auto-reconnect timeout to 1000 ms.
yield 'retry: 1000\n\n'
i = 0
yield 'id: {0}\n'.format(i)
i += 1
yield 'data: START\n\n'
n = 1
while not tymer.expired:
yield 'id: {0}\n'.format(i)
i += 1
yield 'data: {0}\n\n'.format(n)
n += 1
yield "data: END\n\n"
serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
#serverKeypath = '/etc/pki/tls/certs/server_key.pem' # local server private key
#serverCertpath = '/etc/pki/tls/certs/server_cert.pem' # local server public cert
#clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
serverKeypath = certdirpath + '/server_key.pem' # local server private key
serverCertpath = certdirpath + '/server_cert.pem' # local server public cert
clientCafilepath = certdirpath + '/client.pem' # remote client public cert
with http.openServer(port = 6101, bufsize=131072, scheme='https', \
keypath=serverKeypath, certpath=serverCertpath, \
cafilepath=clientCafilepath, app=app, tymth=tymist.tymen()) as alpha:
assert alpha.servant.ha == ('0.0.0.0', 6101)
assert alpha.servant.eha == ('127.0.0.1', 6101)
#clientKeypath = '/etc/pki/tls/certs/client_key.pem' # local client private key
#clientCertpath = '/etc/pki/tls/certs/client_cert.pem' # local client public cert
#serverCafilepath = '/etc/pki/tls/certs/server.pem' # remote server public cert
clientKeypath = certdirpath + '/client_key.pem' # local client private key
clientCertpath = certdirpath + '/client_cert.pem' # local client public cert
serverCafilepath = certdirpath + '/server.pem' # remote server public cert
path = "https://{0}:{1}/".format('localhost', alpha.servant.eha[1])
with http.openClient(bufsize=131072, path=path, scheme='https', \
certedhost=serverCertCommonName, keypath=clientKeypath, \
certpath=clientCertpath, cafilepath=serverCafilepath, \
reconnectable=True, tymth=tymist.tymen(),) as beta:
assert not beta.connector.accepted
assert not beta.connector.connected
assert not beta.connector.cutoff
request = dict([
('method', u'GET'),
('path', u'/stream'),
('qargs', dict()),
('fragment', u''),
('headers',
dict([('Accept', 'application/json'),
('Content-Length', 0)])),
('body', None),
])
beta.requests.append(request)
tymer = tyming.Tymer(tymth=tymist.tymen(), duration=1.0)
while (not tymer.expired):
alpha.service()
time.sleep(0.05)
beta.service()
time.sleep(0.05)
tymist.tick(tock=0.1)
assert beta.connector.accepted
assert beta.connector.connected
assert not beta.connector.cutoff
assert len(alpha.servant.ixes) == 1
assert len(alpha.reqs) == 1
assert len(alpha.reps) == 1
requestant = list(alpha.reqs.values())[0]
assert requestant.method == request['method']
assert requestant.url == request['path']
assert requestant.headers == help.Hict([
('Host', 'localhost:6101'), ('Accept-Encoding', 'identity'),
('Accept', 'application/json'), ('Content-Length', '0')
])
# timed out while body streaming still open so no completed responses
# in .responses. But headers fully received
assert beta.waited
assert not beta.respondent.ended
assert len(beta.responses) == 0
assert 'Content-Type' in beta.respondent.headers
assert beta.respondent.headers[
'Content-Type'] == 'text/event-stream'
assert 'Transfer-Encoding' in beta.respondent.headers
assert beta.respondent.headers['Transfer-Encoding'] == 'chunked'
assert len(beta.events) == 3
assert beta.respondent.retry == 1000
assert int(beta.respondent.leid) >= 2
event = beta.events.popleft()
assert event == {'id': '0', 'name': '', 'data': 'START'}
event = beta.events.popleft()
assert event == {'id': '1', 'name': '', 'data': '1'}
event = beta.events.popleft()
assert event == {'id': '2', 'name': '', 'data': '2'}
assert not beta.events
#keep going until ended
tymer.restart(duration=1.5)
while (not tymer.expired):
alpha.service()
time.sleep(0.05)
beta.service()
time.sleep(0.05)
tymist.tick(tock=0.1)
assert len(beta.events) == 8
assert beta.respondent.leid == '9'
assert beta.events[-2] == {'id': '9', 'name': '', 'data': '9'}
assert beta.events[-1] == {'id': '9', 'name': '', 'data': 'END'}
beta.events.clear()
def test_wsgi_server():
"""
Test WSGI Server service request response
"""
tymist = tyming.Tymist(tyme=0.0)
def wsgiApp(environ, start_response):
start_response('200 OK', [('Content-type', 'text/plain'),
('Content-length', '12')])
return [b"Hello World!"]
with http.openServer(port = 6101, bufsize=131072, app=wsgiApp, \
tymth=tymist.tymen()) as alpha: # passthrough
assert alpha.servant.ha == ('0.0.0.0', 6101)
assert alpha.servant.eha == ('127.0.0.1', 6101)
path = "http://{0}:{1}/".format('localhost', alpha.servant.eha[1])
with http.openClient(bufsize=131072, path=path, reconnectable=True, \
tymth=tymist.tymen()) as beta:
assert not beta.connector.accepted
assert not beta.connector.connected
assert not beta.connector.cutoff
request = dict([
('method', u'GET'),
('path', u'/echo?name=fame'),
('qargs', dict()),
('fragment', u''),
('headers',
dict([('Accept', 'application/json'),
('Content-Length', 0)])),
])
beta.requests.append(request)
while (beta.requests or beta.connector.txbs or not beta.responses
or not alpha.idle()):
alpha.service()
time.sleep(0.05)
beta.service()
time.sleep(0.05)
assert beta.connector.accepted
assert beta.connector.connected
assert not beta.connector.cutoff
assert len(alpha.servant.ixes) == 1
assert len(alpha.reqs) == 1
assert len(alpha.reps) == 1
requestant = list(alpha.reqs.values())[0]
assert requestant.method == request['method']
assert requestant.url == request['path']
assert requestant.headers == help.Hict([
('Host', 'localhost:6101'), ('Accept-Encoding', 'identity'),
('Accept', 'application/json'), ('Content-Length', '0')
])
assert len(beta.responses) == 1
response = beta.responses.popleft()
assert response['body'] == (b'Hello World!')
assert response['status'] == 200
responder = list(alpha.reps.values())[0]
assert responder.status.startswith(str(response['status']))
assert responder.headers == response['headers']
