180 lines
7.3 KiB
Python
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()
|