Files

180 lines
7.3 KiB
Python

import functools
import http.client
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import importlib.util
import json
import os
from pathlib import Path
import socket
import subprocess
import sys
import tempfile
import threading
import time
import unittest
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
from gateway import make_server
from build_bundle import adapt_runtime
import runtime_platform
class Upstream(BaseHTTPRequestHandler):
def log_message(self, *_):
pass
def do_GET(self):
if self.path == '/api/events':
self.send_response(200)
self.send_header('Content-Type', 'text/event-stream')
self.end_headers()
self.wfile.write(b'data: first\n\n')
self.wfile.flush()
time.sleep(.8)
self.wfile.write(b'data: second\n\n')
self.wfile.flush()
else:
body = json.dumps({'cookie': self.headers.get('Cookie'), 'host': self.headers.get('Host')}).encode()
self.send_response(401)
self.send_header('Set-Cookie', 'one=1; HttpOnly')
self.send_header('Set-Cookie', 'two=2; SameSite=Strict')
self.send_header('Content-Length', str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_POST(self):
body = self.rfile.read(int(self.headers['Content-Length']))
self.send_response(201)
self.send_header('Content-Length', str(len(body)))
self.send_header('X-CSRF-Echo', self.headers.get('X-XSRF-TOKEN', ''))
self.end_headers()
self.wfile.write(body)
class GatewayTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.temp = tempfile.TemporaryDirectory()
root = Path(cls.temp.name)
(root / 'index.html').write_text('QUALITY APP', encoding='utf-8')
(root / 'assets').mkdir()
(root / 'assets/file.js').write_text('const x=1;')
cls.backend = ThreadingHTTPServer(('127.0.0.1', 0), Upstream)
cls.frontend = make_server(root, '127.0.0.1', 0, cls.backend.server_port)
for server in (cls.backend, cls.frontend):
threading.Thread(target=server.serve_forever, daemon=True).start()
@classmethod
def tearDownClass(cls):
for server in (cls.frontend, cls.backend):
server.shutdown()
server.server_close()
cls.temp.cleanup()
def connection(self):
return http.client.HTTPConnection('127.0.0.1', self.frontend.server_port, timeout=3)
def test_static_and_spa(self):
for url, body in [('/', b'QUALITY APP'), ('/?page=home', b'QUALITY APP'), ('/analysis', b'QUALITY APP'), ('/assets/file.js', b'const x=1;')]:
connection = self.connection()
connection.request('GET', url)
response = connection.getresponse()
self.assertEqual(response.status, 200)
self.assertEqual(response.read(), body)
connection.close()
def test_no_directory_listing_or_private_files(self):
for url in ('/assets/', '/.runtime/deployment.json', '/../.runtime/deployment.json', '/missing.js'):
connection = self.connection()
connection.request('GET', url)
response = connection.getresponse()
self.assertEqual(response.status, 404)
response.read()
connection.close()
def test_auth_cookies_and_host_are_preserved(self):
connection = self.connection()
connection.request('GET', '/api/auth/me', headers={'Cookie': 'SESSION=abc', 'Host': '192.168.1.22:5280'})
response = connection.getresponse()
self.assertEqual(response.status, 401)
self.assertEqual(len(response.headers.get_all('Set-Cookie')), 2)
self.assertEqual(json.loads(response.read()), {'cookie': 'SESSION=abc', 'host': '192.168.1.22:5280'})
connection.close()
def test_upload_and_csrf(self):
connection = self.connection()
data = os.urandom(2 * 1024 * 1024 + 19)
connection.request('POST', '/api/sources/upload', data, {'X-XSRF-TOKEN': 'csrf-value'})
response = connection.getresponse()
self.assertEqual(response.status, 201)
self.assertEqual(response.getheader('X-CSRF-Echo'), 'csrf-value')
self.assertEqual(response.read(), data)
connection.close()
def test_sse_is_streamed_before_upstream_finishes(self):
connection = self.connection()
started = time.monotonic()
connection.request('GET', '/api/events')
response = connection.getresponse()
self.assertEqual(response.readline(), b'data: first\n')
self.assertLess(time.monotonic() - started, .65)
self.assertIn(b'data: second', response.read())
connection.close()
class PortabilityTest(unittest.TestCase):
def test_port_probe_rejects_live_listener_and_allows_restart(self):
import control
with socket.socket() as listener:
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(('127.0.0.1', 0))
port = listener.getsockname()[1]
listener.listen()
with self.assertRaises(RuntimeError):
control.free_port(port)
accepted, _ = listener.accept()
accepted.close()
control.free_port(port)
def test_process_identity_requires_start_time_executable_and_arguments(self):
import psutil
import control
process = psutil.Process()
info = control.record(process, process.cmdline())
self.assertTrue(control.matches(info))
self.assertFalse(control.matches({**info, 'created': info['created'] - 10}))
self.assertFalse(control.matches({**info, 'executable': '/unrelated/program'}))
self.assertFalse(control.matches({**info, 'args': ['unrelated-command']}))
def test_posix_permissions_are_not_relaxed(self):
if os.name != 'nt':
self.assertFalse(runtime_platform.private_bits(0o100600))
self.assertTrue(runtime_platform.private_bits(0o100640))
def test_lock_excludes_another_process(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / 'lock'
fd = os.open(path, os.O_CREAT | os.O_RDWR, 0o600)
runtime_platform.fcntl.flock(fd, runtime_platform.fcntl.LOCK_EX | runtime_platform.fcntl.LOCK_NB)
code = ('import sys,os;sys.path.insert(0,sys.argv[1]);import runtime_platform as h;'
'fd=os.open(sys.argv[2],os.O_RDWR);h.fcntl.flock(fd,h.fcntl.LOCK_EX|h.fcntl.LOCK_NB)')
result = subprocess.run([sys.executable, '-c', code, str(HERE), str(path)], capture_output=True)
self.assertNotEqual(result.returncode, 0)
os.close(fd)
def test_source_adapter_preserves_mac_source(self):
path = HERE.parents[1] / 'scripts/nao_quality_runtime.py'
source = path.read_text()
adapted = adapt_runtime(source)
self.assertIn('import fcntl', source)
self.assertIn('from runtime_platform import fcntl', adapted)
self.assertIn('_host.private_bits(directory_info.st_mode)', adapted)
self.assertIn('_host.killpg', adapted)
compile(adapted, str(path), 'exec')
self.assertEqual(path.read_text(), source)
if __name__ == '__main__':
unittest.main()