def testBlock(self):
scheduler = Scheduler()
scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher())
scheduler.queue.addSubQueue(1, TestConsumerEvent.createMatcher(), 'consumer', 5, 5)
rA = RoutineContainer(scheduler)
output = bytearray()
async def mainA():
rA.subroutine(mainB(), daemon = True)
for _ in range(0,10):
await rA.wait_for_send(TestConsumerEvent(rA.mainroutine))
output.extend(b'A')
async def mainB():
await rA.do_events()
matcher = TestConsumerEvent.createMatcher(producer=rA.mainroutine)
while True:
ev = await matcher
ev.canignore = True
output.extend(b'B')
async def mainC():
await rA.do_events()
output.extend(b'C')
rA.main = mainA
rA.start()
rA.subroutine(mainC())
scheduler.main()
self.assertEqual(output, b'AAAAACBABABABABABBBBB')
def testLoopConsumer(self):
scheduler = Scheduler()
scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher())
scheduler.queue.addSubQueue(1, TestConsumerEvent.createMatcher(), 'consumer', 5, 5)
rA = RoutineContainer(scheduler)
output = bytearray()
def mainA():
rA.subroutine(mainB(), True, 'mainB', True)
matcher = TestConsumerEvent.createMatcher(rA.mainB)
for i in range(0,10):
for ms in rA.waitForSend(TestConsumerEvent(rA.mainroutine)):
yield ms
output.extend(b'A')
yield (matcher,)
def mainB():
matcher = TestConsumerEvent.createMatcher(producer=rA.mainroutine)
while True:
yield (matcher,)
rA.event.canignore = True
output.extend(b'B')
for ms in rA.waitForSend(TestConsumerEvent(rA.mainB, canignore = True)):
yield ms
rA.main = mainA
rA.start()
scheduler.main()
self.assertEqual(output, b'ABABABABABABABABABAB')
def testServerClientSsl(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, 'testcerts/client.key', 'testcerts/client.crt', 'testcerts/root.crt')
s1 = TcpServer('lssl://localhost:199', self.protocolServer, self.scheduler, 'testcerts/server.key', 'testcerts/server.crt', 'testcerts/root.crt')
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
stopped = False
while True:
yield (m,)
if r.event.connection is c1:
ret.extend(b'B')
else:
ret.extend(b'A')
if not stopped:
for m in s1.shutdown():
yield m
stopped = True
r.main = mainA
r.start()
s1.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testCAVerify3(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, None, None, 'testcerts/root.crt')
c2 = Client('pssl://localhost:199', self.protocolServer, self.scheduler, 'testcerts/server.key','testcerts/server.crt','testcerts/root.crt')
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
while True:
yield (m,)
if r.event.connection is c2:
ret.extend(b'A')
else:
ret.extend(b'B')
self.notconnected = False
def notConnected(connection):
if connection is c1:
self.notconnected = True
if False:
yield
self.protocolClient.notconnected = notConnected
r.main = mainA
r.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
c2.start()
self.scheduler.main()
self.assertTrue(self.notconnected)
self.assertEqual(ret, b'')
def testServerClientSsl(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, 'testcerts/client.key', 'testcerts/client.crt', 'testcerts/root.crt')
s1 = TcpServer('lssl://localhost:199', self.protocolServer, self.scheduler, 'testcerts/server.key', 'testcerts/server.crt', 'testcerts/root.crt')
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
stopped = False
while True:
yield (m,)
if r.event.connection is c1:
ret.extend(b'B')
else:
ret.extend(b'A')
if not stopped:
for m in s1.shutdown():
yield m
stopped = True
r.main = mainA
r.start()
s1.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testSelfConnectionUnixDgram(self):
if not hasattr(socket, 'AF_UNIX'):
print('Skip UNIX socket test because not supported')
return
try:
os.remove('/var/run/unixsocktestudp1.sock')
except:
pass
try:
os.remove('/var/run/unixsocktestudp2.sock')
except:
pass
c1 = Client('dunix:/var/run/unixsocktestudp2.sock', self.protocolClient, self.scheduler, bindaddress = ((socket.AF_UNIX, '/var/run/unixsocktestudp1.sock'),))
c2 = Client('pdunix:/var/run/unixsocktestudp2.sock', self.protocolServer, self.scheduler)
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
while True:
yield (m,)
if r.event.connection is c2:
ret.extend(b'A')
else:
ret.extend(b'B')
r.main = mainA
r.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
c2.start()
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testCAVerify3(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, None, None, 'testcerts/root.crt')
c2 = Client('pssl://localhost:199', self.protocolServer, self.scheduler, 'testcerts/server.key','testcerts/server.crt','testcerts/root.crt')
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
while True:
yield (m,)
if r.event.connection is c2:
ret.extend(b'A')
else:
ret.extend(b'B')
self.notconnected = False
def notConnected(connection):
if connection is c1:
self.notconnected = True
if False:
yield
self.protocolClient.notconnected = notConnected
r.main = mainA
r.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
c2.start()
self.scheduler.main()
self.assertTrue(self.notconnected)
self.assertEqual(ret, b'')
def testBlock(self):
scheduler = Scheduler()
scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher())
scheduler.queue.addSubQueue(1, TestConsumerEvent.createMatcher(), 'consumer', 5, 5)
rA = RoutineContainer(scheduler)
output = bytearray()
def mainA():
rA.subroutine(mainB(), daemon = True)
for i in range(0,10):
for ms in rA.waitForSend(TestConsumerEvent(rA.mainroutine)):
yield ms
output.extend(b'A')
def mainB():
for m in rA.doEvents():
yield m
matcher = TestConsumerEvent.createMatcher(producer=rA.mainroutine)
while True:
yield (matcher,)
rA.event.canignore = True
output.extend(b'B')
def mainC():
for m in rA.doEvents():
yield m
output.extend(b'C')
rA.main = mainA
rA.start()
rA.subroutine(mainC())
scheduler.main()
self.assertEqual(output, b'AAAAACBABABABABABBBBB')
def testBlock(self):
scheduler = Scheduler()
scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher())
scheduler.queue.addSubQueue(1, TestConsumerEvent.createMatcher(),
'consumer', 5, 5)
rA = RoutineContainer(scheduler)
output = bytearray()
def mainA():
rA.subroutine(mainB(), daemon=True)
for i in range(0, 10):
for ms in rA.waitForSend(TestConsumerEvent(rA.mainroutine)):
yield ms
output.extend(b'A')
def mainB():
for m in rA.doEvents():
yield m
matcher = TestConsumerEvent.createMatcher(producer=rA.mainroutine)
while True:
yield (matcher, )
rA.event.canignore = True
output.extend(b'B')
def mainC():
for m in rA.doEvents():
yield m
output.extend(b'C')
rA.main = mainA
rA.start()
rA.subroutine(mainC())
scheduler.main()
self.assertEqual(output, b'AAAAACBABABABABABBBBB')
def testLoopConsumer(self):
scheduler = Scheduler()
scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher())
scheduler.queue.addSubQueue(1, TestConsumerEvent.createMatcher(),
'consumer', 5, 5)
rA = RoutineContainer(scheduler)
output = bytearray()
def mainA():
rA.subroutine(mainB(), True, 'mainB', True)
matcher = TestConsumerEvent.createMatcher(rA.mainB)
for i in range(0, 10):
for ms in rA.waitForSend(TestConsumerEvent(rA.mainroutine)):
yield ms
output.extend(b'A')
yield (matcher, )
def mainB():
matcher = TestConsumerEvent.createMatcher(producer=rA.mainroutine)
while True:
yield (matcher, )
rA.event.canignore = True
output.extend(b'B')
for ms in rA.waitForSend(
TestConsumerEvent(rA.mainB, canignore=True)):
yield ms
rA.main = mainA
rA.start()
scheduler.main()
self.assertEqual(output, b'ABABABABABABABABABAB')
def testSelfConnectionUdp(self):
c1 = Client('udp://localhost:199', self.protocolClient, self.scheduler)
c2 = Client('pudp://localhost:199', self.protocolServer,
self.scheduler)
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
while True:
yield (m, )
if r.event.connection is c2:
ret.extend(b'A')
else:
ret.extend(b'B')
r.main = mainA
r.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
c2.start()
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testSelfConnectionUnixDgram(self):
if not hasattr(socket, 'AF_UNIX'):
print('Skip UNIX socket test because not supported')
return
try:
os.remove('/var/run/unixsocktestudp1.sock')
except Exception:
pass
try:
os.remove('/var/run/unixsocktestudp2.sock')
except Exception:
pass
c1 = Client('dunix:/var/run/unixsocktestudp2.sock', self.protocolClient, self.scheduler, bindaddress = ((socket.AF_UNIX, '/var/run/unixsocktestudp1.sock'),))
c2 = Client('pdunix:/var/run/unixsocktestudp2.sock', self.protocolServer, self.scheduler)
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
while True:
yield (m,)
if r.event.connection is c2:
ret.extend(b'A')
else:
ret.extend(b'B')
r.main = mainA
r.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
c2.start()
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testMultipleClients(self):
c1 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
c2 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
s1 = TcpServer('ltcp://localhost:199', self.protocolServer,
self.scheduler)
r = RoutineContainer(self.scheduler, True)
counter = {c1: 0, c2: 0}
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
c1c = False
c2c = False
shutdown = False
while True:
yield (m, )
counter[r.event.connection] = counter.get(
r.event.connection, 0) + 1
if r.event.connection is c1:
ret.extend(b'A')
c1c = True
elif r.event.connection is c2:
ret.extend(b'B')
c2c = True
if c1c and c2c and not shutdown:
for m in s1.shutdown():
yield m
shutdown = True
r.main = mainA
r.start()
s1.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
r.subroutine(waitAndStart(c2))
self.scheduler.main()
print(ret)
self.assertEqual(counter[c1], 10)
self.assertEqual(counter[c2], 10)
def testMultipleClients(self):
c1 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
c2 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
s1 = TcpServer('ltcp://localhost:199', self.protocolServer, self.scheduler)
r = RoutineContainer(self.scheduler, True)
counter = {c1:0, c2:0}
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
c1c = False
c2c = False
shutdown = False
while True:
yield (m,)
counter[r.event.connection] = counter.get(r.event.connection, 0) + 1
if r.event.connection is c1:
ret.extend(b'A')
c1c = True
elif r.event.connection is c2:
ret.extend(b'B')
c2c = True
if c1c and c2c and not shutdown:
for m in s1.shutdown():
yield m
shutdown = True
r.main = mainA
r.start()
s1.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
r.subroutine(waitAndStart(c2))
self.scheduler.main()
print(ret)
self.assertEqual(counter[c1], 10)
self.assertEqual(counter[c2], 10)
def testSelfConnectionUdp(self):
c1 = Client('udp://localhost:199', self.protocolClient, self.scheduler)
c2 = Client('pudp://localhost:199', self.protocolServer, self.scheduler)
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
while True:
yield (m,)
if r.event.connection is c2:
ret.extend(b'A')
else:
ret.extend(b'B')
r.main = mainA
r.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
c2.start()
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testWaitForAll(self):
scheduler = Scheduler()
rA = RoutineContainer(scheduler)
async def sender(num):
await rA.wait_for_send(TestEvent(num))
result = []
async def test():
try:
for i in range(10):
rA.subroutine(sender(i), False)
matchers = [TestEvent.createMatcher(i) for i in range(10)]
_, eventdict = await rA.wait_for_all(*matchers)
for m in matchers:
self.assertIn(m, eventdict)
self.assertTrue(m.isMatch(eventdict[m]))
except Exception as e:
result.append(e)
raise
else:
result.append(False)
rA.main = test
rA.start()
scheduler.main()
self.assertIs(result[0], False)
def testModuleLoad(self):
logging.basicConfig()
manager['server.startup'] = ('tests.gensrc.testmodule1.TestModule1',
'tests.gensrc.testmodule2.TestModule2')
s = Server()
import tests.gensrc
basedir = tests.gensrc.__path__[0]
with open(os.path.join(basedir, 'testmodule1.py'), 'wb') as f:
f.write(module1)
with open(os.path.join(basedir, 'testmodule2.py'), 'wb') as f:
f.write(module2)
# Run unittest discover may already load the module, reload it
import tests.gensrc.testmodule1
import tests.gensrc.testmodule2
removeCache(tests.gensrc.testmodule1)
removeCache(tests.gensrc.testmodule2)
reload(tests.gensrc.testmodule1)
reload(tests.gensrc.testmodule2)
# Sometimes the timestamp is not working, make sure python re-compile the source file
r = RoutineContainer(s.scheduler)
apiResults = []
def testproc():
yield (ModuleLoadStateChanged.createMatcher(), )
for m in callAPI(r, "testmodule1", "method1", {}):
yield m
apiResults.append(r.retvalue)
for m in callAPI(r, "testmodule1", "method2", {'a': 1, 'b': 2}):
yield m
apiResults.append(r.retvalue)
try:
for m in callAPI(r, "testmodule1", "method4", {}):
yield m
apiResults.append(None)
except ValueError as exc:
apiResults.append(exc.args[0])
from .gensrc.testmodule2 import ModuleTestEvent2
matcher = ModuleTestEvent2.createMatcher()
self.event = False
def proc2():
for m in callAPI(r, "testmodule1", "method3", {
'a': 1,
'b': 2
}):
yield m
def callback(event, matcher):
self.event = event
if False:
yield
for m in r.withCallback(proc2(), callback, matcher):
yield m
if not self.event:
for m in r.waitWithTimeout(0.1, matcher):
yield m
if not r.timeout:
self.event = r.event
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
for m in callAPI(r, "testmodule1", "discover", {}):
yield m
apiResults.append(r.retvalue)
with open(os.path.join(basedir, 'testmodule1.py'), 'wb') as f:
f.write(module1v2)
for m in s.moduleloader.delegate(
s.moduleloader.reloadModules(
['tests.gensrc.testmodule1.TestModule1'])):
yield m
for m in callAPI(r, "testmodule1", "method1", {}):
yield m
apiResults.append(r.retvalue)
matcher = ModuleTestEvent2.createMatcher()
self.event = False
def proc2_2():
for m in callAPI(r, "testmodule1", "method3", {
'a': 1,
'b': 2
}):
yield m
def callback_2(event, matcher):
self.event = event
if False:
yield
for m in r.withCallback(proc2_2(), callback_2, matcher):
yield m
if not self.event:
for m in r.waitWithTimeout(0.1, matcher):
yield m
if not r.timeout:
self.event = r.event
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
with open(os.path.join(basedir, 'testmodule2.py'), 'wb') as f:
f.write(module2v2)
for m in s.moduleloader.delegate(
s.moduleloader.reloadModules(
['tests.gensrc.testmodule2.TestModule2'])):
yield m
matcher = ModuleTestEvent2.createMatcher()
self.event = False
def proc2_3():
for m in callAPI(r, "testmodule1", "method3", {
'a': 1,
'b': 2
}):
yield m
def callback_3(event, matcher):
self.event = event
if False:
yield
for m in r.withCallback(proc2_3(), callback_3, matcher):
yield m
if not self.event:
for m in r.waitWithTimeout(0.1, matcher):
yield m
if not r.timeout:
self.event = r.event
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
with open(os.path.join(basedir, 'testmodule1.py'), 'wb') as f:
f.write(module1v3)
with open(os.path.join(basedir, 'testmodule2.py'), 'wb') as f:
f.write(module2v3)
for m in s.moduleloader.delegate(
s.moduleloader.reloadModules([
'tests.gensrc.testmodule1.TestModule1',
'tests.gensrc.testmodule2.TestModule2'
])):
yield m
for m in callAPI(r, "testmodule1", "method1", {}):
yield m
apiResults.append(r.retvalue)
matcher = ModuleTestEvent2.createMatcher()
self.event = False
def proc2_4():
for m in callAPI(r, "testmodule1", "method3", {
'a': 1,
'b': 2
}):
yield m
def callback_4(event, matcher):
self.event = event
if False:
yield
for m in r.withCallback(proc2_4(), callback_4, matcher):
yield m
if not self.event:
for m in r.waitWithTimeout(0.1, matcher):
yield m
if not r.timeout:
self.event = r.event
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
try:
for m in r.executeWithTimeout(
1.0, callAPI(r, "testmodule1", "notexists", {})):
yield m
except ValueError:
apiResults.append(True)
except Exception:
apiResults.append(False)
else:
apiResults.append(False)
for m in s.moduleloader.delegate(
s.moduleloader.unloadByPath(
"tests.gensrc.testmodule1.TestModule1")):
yield m
r.main = testproc
r.start()
s.serve()
print(repr(apiResults))
self.assertEqual(apiResults, [
'version1', 3, 'test', (3, 'version1'), {
'method1':
'Run method1',
'method2':
'Run method2',
'method3':
'Run method3',
'method4':
'Run method4',
'discover':
'Discover API definitions. Set details=true to show details'
}, 'version2', (3, 'version1'), (3, 'version2'), 'version3',
(3, 'version3'), True
])
def testModuleLoad(self):
logging.basicConfig()
manager['server.startup'] = ('tests.gensrc.testmodule1.TestModule1', 'tests.gensrc.testmodule2.TestModule2')
s = Server()
import tests.gensrc
basedir = tests.gensrc.__path__[0]
with open(os.path.join(basedir, 'testmodule1.py'), 'wb') as f:
f.write(module1)
with open(os.path.join(basedir, 'testmodule2.py'), 'wb') as f:
f.write(module2)
# Run unittest discover may already load the module, reload it
import tests.gensrc.testmodule1
import tests.gensrc.testmodule2
removeCache(tests.gensrc.testmodule1)
removeCache(tests.gensrc.testmodule2)
reload(tests.gensrc.testmodule1)
reload(tests.gensrc.testmodule2)
# Sometimes the timestamp is not working, make sure python re-compile the source file
r = RoutineContainer(s.scheduler)
apiResults = []
def testproc():
yield (ModuleLoadStateChanged.createMatcher(),)
for m in callAPI(r, "testmodule1", "method1", {}):
yield m
apiResults.append(r.retvalue)
for m in callAPI(r, "testmodule1", "method2", {'a' : 1, 'b' : 2}):
yield m
apiResults.append(r.retvalue)
try:
for m in callAPI(r, "testmodule1", "method4", {}):
yield m
apiResults.append(None)
except ValueError as exc:
apiResults.append(exc.args[0])
from .gensrc.testmodule2 import ModuleTestEvent2
matcher = ModuleTestEvent2.createMatcher()
self.event = False
def proc2():
for m in callAPI(r, "testmodule1", "method3", {'a' : 1, 'b' : 2}):
yield m
def callback(event, matcher):
self.event = event
if False:
yield
for m in r.withCallback(proc2(), callback, matcher):
yield m
if not self.event:
for m in r.waitWithTimeout(0.1, matcher):
yield m
if not r.timeout:
self.event = r.event
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
for m in callAPI(r, "testmodule1", "discover", {}):
yield m
apiResults.append(r.retvalue)
with open(os.path.join(basedir, 'testmodule1.py'), 'wb') as f:
f.write(module1v2)
for m in s.moduleloader.delegate(s.moduleloader.reloadModules(['tests.gensrc.testmodule1.TestModule1'])):
yield m
for m in callAPI(r, "testmodule1", "method1", {}):
yield m
apiResults.append(r.retvalue)
matcher = ModuleTestEvent2.createMatcher()
self.event = False
def proc2_2():
for m in callAPI(r, "testmodule1", "method3", {'a' : 1, 'b' : 2}):
yield m
def callback_2(event, matcher):
self.event = event
if False:
yield
for m in r.withCallback(proc2_2(), callback_2, matcher):
yield m
if not self.event:
for m in r.waitWithTimeout(0.1, matcher):
yield m
if not r.timeout:
self.event = r.event
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
with open(os.path.join(basedir, 'testmodule2.py'), 'wb') as f:
f.write(module2v2)
for m in s.moduleloader.delegate(s.moduleloader.reloadModules(['tests.gensrc.testmodule2.TestModule2'])):
yield m
matcher = ModuleTestEvent2.createMatcher()
self.event = False
def proc2_3():
for m in callAPI(r, "testmodule1", "method3", {'a' : 1, 'b' : 2}):
yield m
def callback_3(event, matcher):
self.event = event
if False:
yield
for m in r.withCallback(proc2_3(), callback_3, matcher):
yield m
if not self.event:
for m in r.waitWithTimeout(0.1, matcher):
yield m
if not r.timeout:
self.event = r.event
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
with open(os.path.join(basedir, 'testmodule1.py'), 'wb') as f:
f.write(module1v3)
with open(os.path.join(basedir, 'testmodule2.py'), 'wb') as f:
f.write(module2v3)
for m in s.moduleloader.delegate(s.moduleloader.reloadModules(['tests.gensrc.testmodule1.TestModule1','tests.gensrc.testmodule2.TestModule2'])):
yield m
for m in callAPI(r, "testmodule1", "method1", {}):
yield m
apiResults.append(r.retvalue)
matcher = ModuleTestEvent2.createMatcher()
self.event = False
def proc2_4():
for m in callAPI(r, "testmodule1", "method3", {'a' : 1, 'b' : 2}):
yield m
def callback_4(event, matcher):
self.event = event
if False:
yield
for m in r.withCallback(proc2_4(), callback_4, matcher):
yield m
if not self.event:
for m in r.waitWithTimeout(0.1, matcher):
yield m
if not r.timeout:
self.event = r.event
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
try:
for m in r.executeWithTimeout(1.0, callAPI(r, "testmodule1", "notexists", {})):
yield m
except ValueError:
apiResults.append(True)
except:
apiResults.append(False)
else:
apiResults.append(False)
for m in s.moduleloader.delegate(s.moduleloader.unloadByPath("tests.gensrc.testmodule1.TestModule1")):
yield m
r.main = testproc
r.start()
s.serve()
print(repr(apiResults))
self.assertEqual(apiResults, ['version1', 3, 'test', (3, 'version1'),
{'method1':'Run method1', 'method2':'Run method2', 'method3':'Run method3', 'method4': 'Run method4', 'discover':'Discover API definitions. Set details=true to show details'},
'version2', (3, 'version1'), (3, 'version2'), 'version3', (3, 'version3'), True])
def testModuleLoad(self):
logging.basicConfig()
manager['server.startup'] = ('tests.gensrc.testmodule1.TestModule1',
'tests.gensrc.testmodule2.TestModule2')
s = Server()
import tests.gensrc
basedir = tests.gensrc.__path__[0]
with open(os.path.join(basedir, 'testmodule1.py'), 'wb') as f:
f.write(module1)
with open(os.path.join(basedir, 'testmodule2.py'), 'wb') as f:
f.write(module2)
# Run unittest discover may already load the module, reload it
import tests.gensrc.testmodule1
import tests.gensrc.testmodule2
remove_cache(tests.gensrc.testmodule1)
remove_cache(tests.gensrc.testmodule2)
reload(tests.gensrc.testmodule1)
reload(tests.gensrc.testmodule2)
# Sometimes the timestamp is not working, make sure python re-compile the source file
r = RoutineContainer(s.scheduler)
apiResults = []
async def testproc():
await ModuleLoadStateChanged.createMatcher()
apiResults.append(await call_api(r, "testmodule1", "method1", {}))
apiResults.append(await call_api(r, "testmodule1", "method2", {
'a': 1,
'b': 2
}))
try:
await call_api(r, "testmodule1", "method4", {})
apiResults.append(None)
except ValueError as exc:
apiResults.append(exc.args[0])
from .gensrc.testmodule2 import ModuleTestEvent2
matcher = ModuleTestEvent2.createMatcher()
self.event = False
async def proc2():
return await call_api(r, "testmodule1", "method3", {
'a': 1,
'b': 2
})
def callback(event, matcher):
self.event = event
await r.with_callback(proc2(), callback, matcher)
if not self.event:
timeout, ev, m = await r.wait_with_timeout(0.1, matcher)
if not timeout:
self.event = ev
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
apiResults.append(await call_api(r, "testmodule1", "discover", {}))
with open(os.path.join(basedir, 'testmodule1.py'), 'wb') as f:
f.write(module1v2)
await s.moduleloader.reload_modules(
['tests.gensrc.testmodule1.TestModule1'])
apiResults.append(await call_api(r, "testmodule1", "method1", {}))
matcher = ModuleTestEvent2.createMatcher()
self.event = False
async def proc2_2():
return await call_api(r, "testmodule1", "method3", {
'a': 1,
'b': 2
})
def callback_2(event, matcher):
self.event = event
await r.with_callback(proc2_2(), callback_2, matcher)
if not self.event:
timeout, ev, m = await r.wait_with_timeout(0.1, matcher)
if not timeout:
self.event = ev
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
with open(os.path.join(basedir, 'testmodule2.py'), 'wb') as f:
f.write(module2v2)
await s.moduleloader.reload_modules(
['tests.gensrc.testmodule2.TestModule2'])
matcher = ModuleTestEvent2.createMatcher()
self.event = False
async def proc2_3():
return await call_api(r, "testmodule1", "method3", {
'a': 1,
'b': 2
})
def callback_3(event, matcher):
self.event = event
await r.with_callback(proc2_3(), callback_3, matcher)
if not self.event:
timeout, ev, m = await r.wait_with_timeout(0.1, matcher)
if not timeout:
self.event = ev
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
with open(os.path.join(basedir, 'testmodule1.py'), 'wb') as f:
f.write(module1v3)
with open(os.path.join(basedir, 'testmodule2.py'), 'wb') as f:
f.write(module2v3)
await s.moduleloader.reload_modules([
'tests.gensrc.testmodule1.TestModule1',
'tests.gensrc.testmodule2.TestModule2'
])
apiResults.append(await call_api(r, "testmodule1", "method1", {}))
matcher = ModuleTestEvent2.createMatcher()
self.event = False
async def proc2_4():
return await call_api(r, "testmodule1", "method3", {
'a': 1,
'b': 2
})
def callback_4(event, matcher):
self.event = event
await r.with_callback(proc2_4(), callback_4, matcher)
if not self.event:
timeout, ev, m = await r.wait_with_timeout(0.1, matcher)
if not timeout:
self.event = ev
if self.event:
apiResults.append((self.event.result, self.event.version))
else:
apiResults.append(False)
try:
await r.execute_with_timeout(
1.0, call_api(r, "testmodule1", "notexists", {}))
except APIRejectedException:
apiResults.append(True)
except Exception:
apiResults.append(False)
else:
apiResults.append(False)
await s.moduleloader.unload_by_path(
"tests.gensrc.testmodule1.TestModule1")
r.main = testproc
r.start()
s.serve()
print(repr(apiResults))
self.assertEqual(apiResults, [
'version1', 3, 'test', (3, 'version1'), {
'method1':
'Run method1',
'method2':
'Run method2',
'method3':
'Run method3',
'method4':
'Run method4',
'discover':
'Discover API definitions. Set details=true to show details'
}, 'version2', (3, 'version1'), (3, 'version2'), 'version3',
(3, 'version3'), True
])
