Files
mi8-platina-linux/tests/test_camera_control.py
T
shenlei 4f3fe1f94b
Offline project checks / check (push) Canceled after 0s
Fix candidate build metadata and runtime safeguards
Repair kernel patch formatting and refresh kernel/camera package revisions and checksums. Integrate battery guard into generated images, correct charging controls and emergency shutdown handling, and reject invalid camera authentication configuration.

Extend recipe validation and regression coverage, and update build and installation documentation. Kernel, camera and image compilation remain pending on the build server.
2026-11-09 10:49:22 +09:00

378 lines
17 KiB
Python

"""Capture lifetime, privacy defaults and HTTP/MQTT control regressions."""
import importlib.util
import json
import os
from pathlib import Path
import queue
from types import SimpleNamespace
import tempfile
import threading
import unittest
from unittest.mock import Mock, patch
from urllib.error import HTTPError
from urllib.request import Request, urlopen
from http.server import ThreadingHTTPServer
ROOT = Path(__file__).resolve().parents[1]
def module(name):
spec = importlib.util.spec_from_file_location(name, ROOT / 'project/camera/libcamera-headless' / (name + '.py'))
value = importlib.util.module_from_spec(spec)
spec.loader.exec_module(value)
return value
serve = module('serve')
mqtt = module('camera_mqtt')
class AuthenticationConfigTests(unittest.TestCase):
def test_optional_and_explicitly_disabled_authentication(self):
with tempfile.TemporaryDirectory() as temp:
path = Path(temp) / 'auth.json'
self.assertIsNone(serve.load_auth(path))
path.write_text(json.dumps({'enabled': False}))
self.assertIsNone(serve.load_auth(path))
path.write_text(json.dumps({'username': 'operator', 'password': 'test-password'}))
self.assertEqual(serve.load_auth(path), {'username': 'operator', 'password': 'test-password'})
def test_invalid_authentication_never_falls_back_to_anonymous(self):
with tempfile.TemporaryDirectory() as temp:
path = Path(temp) / 'auth.json'
for content in ('{broken', '[]', '{}', '{"enabled": "false"}',
'{"username": "operator"}', '{"username": "", "password": "value"}',
'{"username": 123, "password": "value"}'):
with self.subTest(content=content):
path.write_text(content)
with self.assertRaises(ValueError):
serve.load_auth(path)
path.unlink()
path.symlink_to('missing-credentials')
with self.assertRaises(ValueError):
serve.load_auth(path)
def test_unreadable_authentication_aborts_without_exposing_credentials(self):
path = Mock()
path.read_text.side_effect = PermissionError('sensitive contents')
with self.assertRaisesRegex(ValueError, 'cannot be read') as error:
serve.load_auth(path)
self.assertNotIn('sensitive', str(error.exception))
class ControlTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
root = Path(self.tmp.name)
self.args = SimpleNamespace(config=root / 'settings.json', frame=root / 'run/frame.jpg',
capture='unused', cpu=False)
self.camera = serve.Camera(self.args)
self.audio = serve.Audio()
self.stop = threading.Event()
self.server = ThreadingHTTPServer(('127.0.0.1', 0), serve.make_handler(self.camera, self.stop, self.audio))
self.server.daemon_threads = True
self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
self.thread.start()
self.base = 'http://127.0.0.1:' + str(self.server.server_port)
def tearDown(self):
self.stop.set()
self.server.shutdown()
self.server.server_close()
self.thread.join()
self.camera.stop()
self.audio.close()
self.tmp.cleanup()
def get(self, path):
with urlopen(self.base + path, timeout=3) as response:
return json.load(response)
def post(self, path, payload, origin=None):
headers = {'Content-Type': 'application/json'}
if origin:
headers['Origin'] = origin
request = Request(self.base + path, data=json.dumps(payload).encode(), headers=headers)
with urlopen(request, timeout=3) as response:
return json.load(response)
def test_boot_off_and_reading_image_never_enables_capture(self):
self.assertEqual(self.get('/status')['state'], 'off')
for endpoint in ('/snapshot.jpg', '/stream.mjpg'):
with self.assertRaises(HTTPError) as error:
self.get(endpoint)
self.assertEqual(error.exception.code, 503)
def test_authentication_enforced_when_configured(self):
auth = {'username': 'testuser', 'password': 'secretpassword'}
stop = threading.Event()
server = ThreadingHTTPServer(('127.0.0.1', 0), serve.make_handler(self.camera, stop, self.audio, auth=auth))
server.daemon_threads = True
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
base = 'http://127.0.0.1:' + str(server.server_port)
try:
with self.assertRaises(HTTPError) as err:
urlopen(base + '/status', timeout=3)
self.assertEqual(err.exception.code, 401)
self.assertIn('Basic', err.exception.headers.get('WWW-Authenticate', ''))
import base64
token = base64.b64encode(b'testuser:secretpassword').decode()
req = Request(base + '/status', headers={'Authorization': 'Basic ' + token})
with urlopen(req, timeout=3) as resp:
self.assertEqual(resp.status, 200)
data = json.load(resp)
self.assertEqual(data['state'], 'off')
finally:
stop.set()
server.shutdown()
server.server_close()
thread.join()
self.assertIsNone(self.camera.capture)
def test_settings_off_persist_but_capture_does_not(self):
self.post('/settings', {'focus': 430, 'quality': 10, 'scale': 1.5})
self.post('/save', {})
after = serve.Camera(self.args)
self.assertFalse(after.status()['enabled'])
self.assertEqual(after.settings['focus'], 430)
self.assertEqual(after.settings['quality'], 10)
self.assertEqual(after.settings['scale'], 1.5)
self.assertEqual(self.args.config.stat().st_mode & 0o777, 0o600)
self.assertIsNone(self.camera.focus_fd)
def test_audio_requires_explicit_same_origin_ticket(self):
with patch.object(serve.subprocess, 'Popen') as popen:
with self.assertRaises(HTTPError) as error:
self.get('/audio.pcm')
self.assertEqual(error.exception.code, 409)
with self.assertRaises(HTTPError) as error:
self.post('/audio', {}, 'http://other.example')
self.assertEqual(error.exception.code, 403)
self.assertEqual(self.post('/audio', {})['rate'], 48000)
self.assertIsNone(self.audio.capture)
popen.assert_not_called()
def test_invalid_partial_settings_are_atomic(self):
before = self.get('/settings')
with self.assertRaises(HTTPError):
self.post('/settings', {'quality': 9, 'focus': 999})
self.assertEqual(self.get('/settings'), before)
with self.assertRaises(HTTPError):
self.post('/settings', {'scale': True})
def test_legacy_settings_migrate_without_writing_or_starting_capture(self):
legacy = {key: value for key, value in serve.DEFAULTS.items()
if key not in serve.EXPOSURE_DEFAULTS and key != 'zoom'}
legacy.update(focus=308, quality=40, automatic=False, scale=1.5)
original = json.dumps(legacy).encode()
self.args.config.write_bytes(original)
after = serve.Camera(self.args)
self.assertEqual(after.settings, dict(legacy, **serve.EXPOSURE_DEFAULTS, zoom=1.0))
self.assertFalse(after.status()['enabled'])
self.assertEqual(self.args.config.read_bytes(), original)
# A partially missing new schema is corruption, not a legacy config.
self.args.config.write_text(json.dumps(dict(legacy, exposure_auto=False)))
with self.assertRaises(ValueError):
serve.Camera(self.args)
def test_exposure_api_save_restore_and_control_wire_format(self):
desired = dict(exposure_auto=False, exposure_us=25000, analogue_gain=2.5)
self.post('/settings', desired)
self.post('/save', {})
self.post('/settings', {'exposure_auto': True, 'exposure_us': 5000})
restored = self.post('/restore', {})
for key, value in desired.items():
self.assertEqual(restored[key], value)
self.camera.controls(restored)
fields = Path(str(self.args.frame) + '.controls').read_text().split()
self.assertEqual(fields[-4:], ['0', '25000', '2.5', '1.0'])
self.assertEqual(serve.Camera(self.args).settings, restored)
self.assertFalse(self.camera.status()['enabled'])
def test_exposure_validation_preserves_settings_on_rejection(self):
before = self.get('/settings')
for payload in ({'exposure_auto': 1}, {'exposure_us': 10000.5},
{'exposure_us': True}, {'exposure_us': 99}, {'exposure_us': 100001},
{'analogue_gain': 0}, {'analogue_gain': 8.01}, {'analogue_gain': float('nan')}):
with self.subTest(payload=payload):
with self.assertRaises(HTTPError):
self.post('/settings', payload)
self.assertEqual(self.get('/settings'), before)
def test_mqtt_exposure_changes_are_acknowledged_saved_and_do_not_start_camera(self):
bridge = mqtt.Bridge.__new__(mqtt.Bridge)
bridge.camera = self.camera
bridge.command('exposure_us', '100000')
bridge.command('analogue_gain', '8')
bridge.command('exposure_auto', 'OFF')
self.assertEqual(self.camera.settings['exposure_us'], 100000)
self.assertEqual(self.camera.settings['analogue_gain'], 8)
self.assertFalse(self.camera.settings['exposure_auto'])
self.assertEqual(serve.Camera(self.args).settings, self.camera.settings)
for key, value in [('exposure_auto', 'true'), ('exposure_us', '100.1'), ('analogue_gain', 'inf')]:
with self.assertRaises(ValueError):
bridge.command(key, value)
self.assertFalse(self.camera.status()['enabled'])
def test_discovery_separates_requested_controls_and_actual_telemetry(self):
entries = mqtt.discovery(dict(topic='platina/camera', device_id='platina', web_url='http://platina:8082/'))
entities = {topic.split('/')[-2]: payload for topic, payload in entries}
self.assertEqual(entities['exposure_us']['max'], 100000)
self.assertEqual(entities['analogue_gain']['min'], 1)
self.assertIn('settings.exposure_auto', entities['exposure_auto']['value_template'])
for key in ('exposure_us_actual', 'analogue_gain_actual'):
self.assertNotIn('command_topic', entities[key])
self.assertNotIn('availability_topic', entities[key])
self.assertEqual(entities[key]['availability_mode'], 'all')
self.assertIn("state == 'on'", entities[key]['availability'][1]['value_template'])
def test_zoom_migrates_exposure_schema_without_changing_manual_exposure(self):
legacy = {key: value for key, value in serve.DEFAULTS.items() if key != 'zoom'}
legacy.update(exposure_auto=False, exposure_us=25000, analogue_gain=2.5, focus=308)
self.args.config.write_text(json.dumps(legacy))
before = self.args.config.read_bytes()
after = serve.Camera(self.args)
self.assertEqual(after.settings, dict(legacy, zoom=1.0))
self.assertEqual(self.args.config.read_bytes(), before)
self.assertFalse(after.status()['enabled'])
def test_zoom_live_save_restore_and_mqtt_share_one_setting(self):
self.post('/settings', {'zoom': 2.5})
self.post('/save', {})
bridge = mqtt.Bridge.__new__(mqtt.Bridge)
bridge.camera = self.camera
bridge.command('zoom', '4')
self.assertEqual(self.get('/status')['settings']['zoom'], 4)
self.assertEqual(serve.Camera(self.args).settings['zoom'], 4)
self.post('/settings', {'zoom': 1})
self.assertEqual(self.post('/restore', {})['zoom'], 4)
self.camera.controls(self.camera.settings)
self.assertEqual(Path(str(self.args.frame) + '.controls').read_text().split()[-1], '4.0')
self.assertFalse(self.get('/status')['enabled'])
def test_zoom_validation_is_atomic(self):
before = self.get('/settings')
for value in [0.99, 10.01, True, '2', None, float('nan'), float('inf')]:
with self.subTest(value=value):
with self.assertRaises(HTTPError):
self.post('/settings', {'zoom': value, 'focus': 999})
self.assertEqual(self.get('/settings'), before)
entries = mqtt.discovery(dict(topic='platina/camera', device_id='platina', web_url='http://platina:8082/'))
zoom = next(payload for topic, payload in entries if topic.endswith('/zoom/config'))
self.assertEqual((zoom['min'], zoom['max'], zoom['step']), (1, 10, .1))
self.assertIn('settings.zoom', zoom['value_template'])
def test_extended_zoom_and_fixed_target_fps(self):
self.post('/settings', {'zoom': 10, 'fps': 10})
self.assertEqual(self.get('/settings')['zoom'], 10)
self.assertEqual(self.get('/settings')['fps'], 30)
self.post('/save', {})
self.assertEqual(serve.Camera(self.args).settings['fps'], 30)
bridge = mqtt.Bridge.__new__(mqtt.Bridge)
bridge.camera = self.camera
bridge.command('fps', '15')
self.assertEqual(self.camera.settings['fps'], 30)
def test_cross_origin_rejected(self):
with self.assertRaises(HTTPError) as error:
self.post('/camera', {'enabled': True}, 'http://other.example')
self.assertEqual(error.exception.code, 403)
self.assertFalse(self.get('/status')['enabled'])
def test_stop_releases_lens_and_removes_last_frame(self):
frame = self.args.frame
frame.write_bytes(b'old private image')
lens = frame.with_name('lens')
lens.write_bytes(b'')
fd = os.open(lens, os.O_RDONLY)
child = Mock()
child.poll.return_value = None
self.camera.capture = child
self.camera.focus_fd = fd
self.post('/camera', {'enabled': False})
child.terminate.assert_called_once()
child.wait.assert_called_once_with(timeout=8)
self.assertFalse(frame.exists())
with self.assertRaises(OSError):
os.fstat(fd)
self.assertEqual(self.get('/status')['state'], 'off')
def test_capture_failure_keeps_controls_available(self):
child = Mock()
child.poll.return_value = 1
self.camera.capture = child
self.camera.tick()
self.assertEqual(self.get('/status')['state'], 'error')
self.post('/settings', {'focus': 320})
self.assertEqual(self.get('/settings')['focus'], 320)
self.post('/camera', {'enabled': False})
self.assertEqual(self.get('/status')['state'], 'off')
def test_retained_mqtt_on_is_ignored(self):
bridge = mqtt.Bridge.__new__(mqtt.Bridge)
bridge.commands = queue.Queue()
message = SimpleNamespace(topic='platina/camera/set/enabled', payload=b'ON', retain=True)
bridge.on_message(None, None, message)
self.assertTrue(bridge.commands.empty())
message.retain = False
bridge.on_message(None, None, message)
self.assertEqual(bridge.commands.get_nowait(), ('enabled', 'ON'))
class AudioTests(unittest.TestCase):
def test_ticket_never_opens_microphone_and_expires(self):
audio = serve.Audio()
with patch.object(serve.subprocess, 'Popen') as popen:
ticket = audio.ticket()
self.assertIsNone(audio.capture)
audio.tokens[ticket['token']] = 0
with self.assertRaises(ValueError):
audio.open(ticket['token'])
with self.assertRaises(ValueError):
audio.open('not-authorized')
popen.assert_not_called()
def test_capture_exclusive_single_use_and_restores_mixer(self):
audio = serve.Audio()
audio.command = Mock()
process = Mock()
process.poll.return_value = None
token = audio.ticket()['token']
with patch.object(serve.Path, 'read_text', return_value='Xiaomi Mi 8 Lite'), \
patch.object(serve.subprocess, 'Popen', return_value=process):
session = audio.open(token)
with self.assertRaises(ValueError):
audio.ticket()
with self.assertRaises(ValueError):
audio.open(token)
audio.release(session)
self.assertIsNone(audio.capture)
process.terminate.assert_called_once()
self.assertTrue(audio.released.is_set())
self.assertEqual(audio.command.call_args.args[0][3:], ['restore', '0'])
self.assertFalse(Path(session[1].name).exists())
def test_failed_route_restores_original_mixer(self):
audio = serve.Audio()
audio.command = Mock(side_effect=[None, OSError('route failed'), None])
with patch.object(serve.Path, 'read_text', return_value='Xiaomi Mi 8 Lite'):
with self.assertRaises(OSError):
audio.open(audio.ticket()['token'])
self.assertEqual(audio.command.call_args.args[0][3:], ['restore', '0'])
self.assertIsNone(audio.capture)
def test_shutdown_revokes_unused_tickets(self):
audio = serve.Audio()
ticket = audio.ticket()
audio.close()
with self.assertRaises(ValueError):
audio.open(ticket['token'])
with self.assertRaises(ValueError):
audio.ticket()
if __name__ == '__main__':
unittest.main()