SelfRising/calibration/test_server.py

143 lines
6.5 KiB
Python

import base64
from http.client import HTTPConnection
from http.server import ThreadingHTTPServer
import json
from pathlib import Path
import tempfile
import threading
import unittest
from unittest.mock import Mock, patch
import uuid
from calibration.server import App, handler_for, maintain_connection
class ConnectionTests(unittest.TestCase):
def test_initial_connection_failure_retries_preparation_without_starting_motion(self):
bridge = Mock(prepared=False)
def prepare():
if bridge.prepare.call_count == 1:
raise ConnectionError('USB not present yet')
bridge.prepared = True
bridge.prepare.side_effect = prepare
with patch('calibration.server.time.sleep', side_effect=[None, StopIteration]), \
self.assertRaises(StopIteration):
maintain_connection(bridge)
self.assertTrue(bridge.prepared)
self.assertEqual(bridge.prepare.call_count, 2)
self.assertEqual(bridge.refresh.call_count, 2)
bridge.start.assert_not_called()
class FakeBridge:
def __init__(self):
self.jobs = []
self.starts = 0
def status(self):
return {'device': {'connected': False}, 'job': self.jobs[-1] if self.jobs else None}
def export(self):
return {'jobs': self.jobs}
def start(self, p):
self.starts += 1
job = dict(p, id=p['request_id'], status='running')
self.jobs.append(job)
return job
def stop(self):
return None
def refresh(self):
return self.status()
class HTTPTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.bridge = FakeBridge()
self.app = App(self.bridge, Path(self.tmp.name))
self.http = ThreadingHTTPServer(('127.0.0.1', 0), handler_for(self.app, 0))
self.port = self.http.server_port
self.http.RequestHandlerClass = handler_for(self.app, self.port)
self.thread = threading.Thread(target=self.http.serve_forever, daemon=True)
self.thread.start()
def tearDown(self):
self.http.shutdown()
self.http.server_close()
self.thread.join()
self.tmp.cleanup()
def request(self, method, path, data=None, headers=None):
client = HTTPConnection('127.0.0.1', self.port, timeout=2)
h = {'Content-Type': 'application/json', 'X-Cal-Token': self.app.token}
h.update(headers or {})
client.request(method, path, None if data is None else json.dumps(data), h)
res = client.getresponse()
result = res.status, res.read()
client.close()
return result
def test_get_never_moves_and_old_simulation_is_retained(self):
for path in ('/', '/api/calibration/state', '/api/calibration/export', '/api/calibration/report', '/result.json'):
self.assertEqual(self.request('GET', path)[0], 200)
self.assertEqual(self.bridge.starts, 0)
export = json.loads(self.request('GET', '/api/calibration/export')[1])
self.assertNotIn('csrf_token', export)
self.assertFalse(export['parameters_applied'])
self.assertIn('camera', export['history'])
def test_origin_host_and_token_rejection(self):
for headers in ({'Origin': 'https://evil.invalid'}, {'Host': 'evil.invalid'},
{'X-Cal-Token': 'stale'}, {'Sec-Fetch-Site': 'cross-site'}):
self.assertEqual(self.request('POST', '/api/calibration/start', {}, headers)[0], 403)
self.assertEqual(self.bridge.starts, 0)
def test_path_traversal_and_unlisted_evidence(self):
for path in ('/../CALIBRATION_WEB_HANDOFF_20261109.md', '/%2e%2e/%2e%2e/server.py',
'/calibration/evidence/../../server.py', '/calibration/frames/../artifacts.json'):
self.assertEqual(self.request('GET', path)[0], 404)
def test_frame_freshness_binding_and_after_order(self):
image = 'data:image/jpeg;base64,' + base64.b64encode(b'\xff\xd8\xfftest\xff\xd9').decode()
ident = str(uuid.uuid4())
self.assertEqual(self.request('POST', '/api/calibration/frame',
dict(image=image, role='after', job_id=ident))[0], 400)
frame = json.loads(self.request('POST', '/api/calibration/frame', dict(image=image, role='before'))[1])
p = dict(type='servo', pin=32, request_id=ident, before_frame_id=frame['id'])
with patch('calibration.server.time.time', return_value=frame['captured_at'] + 16):
self.assertEqual(self.request('POST', '/api/calibration/start', p)[0], 400)
self.assertEqual(self.bridge.starts, 0)
self.assertEqual(self.request('POST', '/api/calibration/start', p)[0], 200)
self.assertEqual(self.request('POST', '/api/calibration/start', p)[0], 400)
self.assertEqual(self.bridge.starts, 1)
after = dict(image=image, role='after', job_id=ident)
self.assertEqual(self.request('POST', '/api/calibration/frame', after)[0], 400)
phase = dict(image=image, role='phase', job_id=ident, phase='initial_command')
self.assertEqual(self.request('POST', '/api/calibration/frame', phase)[0], 400)
self.bridge.jobs[0].update(phase='initial_command', events=[{'event': 'phase',
'phase': 'initial_command', 'received_at': 0}])
self.assertEqual(self.request('POST', '/api/calibration/frame', phase)[0], 200)
self.bridge.jobs[0]['phase'] = 'increment'
self.assertEqual(self.request('POST', '/api/calibration/frame', phase)[0], 400)
self.bridge.jobs[0]['status'] = 'completed'
self.assertEqual(self.request('POST', '/api/calibration/frame', after)[0], 200)
self.assertEqual(self.request('POST', '/api/calibration/observation',
dict(job_id=ident, physical_result='moved', angles={
'after': {'angle_deg': 5, 'frame_id': frame['id']}}))[0], 400)
self.assertEqual(self.request('POST', '/api/calibration/observation',
dict(job_id=ident, physical_result='uncertain', angles={
'before': None, 'after': None}))[0], 200)
self.assertEqual(self.request('POST', '/api/calibration/observation',
dict(job_id=ident, physical_result='moved', angles={
'before': {'angle_deg': 5, 'frame_id': frame['id'],
'points': [{'x': 'bad', 'y': 0}, {'x': 2, 'y': 4}]}}))[0], 400)
if __name__ == '__main__':
unittest.main()