forked from ObjectProfile/PythonBridge
-
Notifications
You must be signed in to change notification settings - Fork 3
Expand file tree
/
Copy pathtest_http_platform.py
More file actions
136 lines (114 loc) · 4.59 KB
/
test_http_platform.py
File metadata and controls
136 lines (114 loc) · 4.59 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
import unittest
from PythonBridge import bridge_globals, flask_platform
import threading
from http.server import HTTPServer, BaseHTTPRequestHandler
import requests
import json
import time
class NoLogger():
def log(self, msg):
pass
def signal_error(handler):
raise Exception("ERROR!!!!")
class TestHandler(BaseHTTPRequestHandler):
callback = signal_error
def _set_headers(self):
self.send_response(200)
self.send_header("Content-type", "application/json")
self.end_headers()
def do_GET(self):
self._set_headers()
self.wfile.write('<html><body><h1>LALALA</h1></body></html>'.encode("utf8"))
def do_HEAD(self):
self._set_headers()
def do_POST(self):
# Doesn't do anything with posted data
self._set_headers()
self.callback() # Very ugly, callback is not a method, but an external lambda that receives self.
# Though Python treats it like a method.
def read_data(self):
text = self.rfile.read(int(self.headers.get('Content-Length'))).decode("utf-8")
return json.loads(text)
class TestHTTPPlatform(unittest.TestCase):
thread = None
msg_service = None
server_port = 9977
python_port = 9978
server = HTTPServer(('localhost',server_port), TestHandler)
@classmethod
def post(cls,dictionary, port=python_port,route=''):
response = requests.post('http://localhost:'+str(port)+'/'+route, data=json.dumps(dictionary))
return response.json()
@classmethod
def setUpClass(cls):
bridge_globals.logger = NoLogger()
cls.start_server()
cls.start_msg_service()
time.sleep(0.5)
@classmethod
def start_server(cls):
if cls.thread != None:
return
cls.thread = threading.Thread(target=cls._start_server, args=())
cls.thread.daemon = True
cls.thread.start()
@classmethod
def start_msg_service(cls):
if cls.msg_service != None:
return
cls.msg_service = flask_platform.build_service(cls.python_port,cls.server_port,signal_error)
cls.msg_service.start()
@classmethod
def _start_server(cls):
cls.continue_running = True
while cls.continue_running:
cls.server.handle_request()
def write_answer(self, answer, handler):
self.exec_flag = True
return handler.wfile.write(json.dumps(answer).encode("utf8"))
def setUp(self):
TestHandler.callback = signal_error
self.exec_flag = False
def test_write_server(self):
self.assertTrue(self.thread != None)
TestHandler.callback = lambda handler: self.write_answer({'rr': 33}, handler)
self.assertEqual(self.post({}, port=self.server_port), {'rr': 33})
self.assertTrue(self.exec_flag)
def test_read_server(self):
self.assertTrue(self.thread != None)
def assert_handle(handler):
self.assertEqual(handler.read_data(), {'ss': 44})
self.write_answer({}, handler)
TestHandler.callback = assert_handle
self.assertEqual(self.post({'ss': 44}, port=self.server_port), {})
self.assertTrue(self.exec_flag)
def test_send_sync_msg(self):
self.sync_id = None
def assert_handle(handler):
data = handler.read_data()
self.assertEqual(data['val'], 3)
self.assertEqual(data['type'], 'MSG')
self.sync_id = data['__sync']
self.write_answer({'type': 'MSG', 'foo':7, '__sync': self.sync_id}, handler)
TestHandler.callback = assert_handle
ans = self.msg_service.send_sync_message({'type': 'MSG', 'val': 3})
self.assertEqual({'type': 'MSG', 'foo':7, '__sync': self.sync_id}, ans)
self.assertTrue(self.exec_flag)
def test_send_async_msg(self):
def assert_handle(handler):
data = handler.read_data()
self.assertEqual(data['val'], 3)
self.assertEqual(data['type'], 'MSG')
self.write_answer({}, handler)
TestHandler.callback = assert_handle
self.msg_service.send_async_message({'type': 'MSG', 'val': 3})
self.assertTrue(self.exec_flag)
def test_is_alive(self):
self.assertEqual(self.post({'type':'IS_ALIVE'}, route='IS_ALIVE'), {})
def test_enqueue_callback(self):
def assert_enqueue_handle(msg):
self.exec_flag = True
self.assertEqual(msg, {'type':'ENQUEUE', 'data':'FFFFFFF'})
self.msg_service.feed_callback = assert_enqueue_handle
self.post({'type':'ENQUEUE', 'data':'FFFFFFF'}, route='ENQUEUE')
self.exec_flag = True