Files
homegate/tests/test_setup.py
DizelBadCoder b305cc1ba8
All checks were successful
Test and publish Homegate / publish (push) Successful in 12m49s
Test and publish Homegate / checks (push) Successful in 29s
Support passwordless Pi-hole authentication and UI settings
2026-10-14 18:12:10 +03:00

200 lines
10 KiB
Python

"""First-run UI, stored connections, live controller reload and process supervision."""
import copy
import json
import os
from pathlib import Path
import subprocess
import sys
import tempfile
import unittest
from unittest.mock import patch
import homegate as h
import homegate_ui as ui
import standalone
from test_ssh_and_zones import MemorySocket
class SetupTests(unittest.TestCase):
def setUp(self):
temp = tempfile.TemporaryDirectory()
self.addCleanup(temp.cleanup)
self.root = Path(temp.name)
self.config = self.root / 'config/services.yaml'
self.config.parent.mkdir()
self.connections = self.config.with_name('connections.json')
self.control = self.root / 'control'
self.panel = ui.Panel(self.config, self.control, '', auth_required=False, connections_file=self.connections)
self.cookie = ''
self.csrf = ''
self.settings = {'config': {'proxy_ip': '192.168.0.11', 'allowed_networks': ['192.168.0.0/24'],
'domain_zones': ['home', 'home.arpa'], 'dns_mode': 'pihole6', 'interval_seconds': 60,
'services': [], 'ssh_hosts': []}, 'connections': {'npm_url': 'http://192.168.0.11:81',
'npm_identity': 'admin@example.com', 'npm_password': 'test-npm-secret',
'pihole_url': 'http://192.168.0.2', 'pihole_password': 'test-pihole-secret'}, 'revision': ''}
def request(self, path='/api/state', body=None, peer='192.168.0.20', headers=None):
method = 'GET' if body is None else 'POST'
payload = b'' if body is None else json.dumps(body).encode()
heads = {'Host': '192.168.0.10:8098', 'Cookie': self.cookie}
if body is not None:
heads.update({'Origin': 'http://192.168.0.10:8098', 'Content-Type': 'application/json',
'Content-Length': str(len(payload)), 'X-Homegate-CSRF': self.csrf})
heads.update(headers or {})
raw = f'{method} {path} HTTP/1.1\r\n' + ''.join(f'{k}: {v}\r\n' for k, v in heads.items()) + '\r\n'
sock = MemorySocket(raw.encode() + payload)
ui.handler_for(self.panel)(sock, (peer, 5000), None)
head, data = sock.output.split(b'\r\n\r\n', 1)
response_headers = dict(line.decode().split(': ', 1) for line in head.split(b'\r\n')[1:])
if 'application/json' in response_headers.get('Content-Type', ''):
data = json.loads(data)
return int(head.split()[1]), data, response_headers
def connect(self):
code, body, headers = self.request('/api/session')
self.assertEqual(code, 200)
self.assertTrue(body['authenticated'])
self.cookie = headers['Set-Cookie'].split(';')[0]
self.csrf = body['csrf']
def install(self):
self.connect()
code, state, _ = self.request('/api/settings', self.settings)
self.assertEqual(code, 200, state)
self.assertFalse(state['setup_required'])
return state
def test_blank_volume_opens_setup_without_password_or_env(self):
self.connect()
code, state, _ = self.request()
self.assertEqual(code, 200)
self.assertTrue(state['setup_required'])
self.assertFalse(state['auth_required'])
self.assertEqual(state['config']['services'], [])
self.assertEqual(self.request('/healthz')[0], 200)
self.assertEqual(self.request('/settings.js')[0], 200)
self.assertFalse(self.config.exists())
def test_setup_persists_and_keeps_secrets_out_of_state_and_exports(self):
state = self.install()
stored = h.read_json(self.connections)
self.assertEqual(stored['npm_password'], 'test-npm-secret')
self.assertEqual(self.connections.stat().st_mode & 0o777, 0o600)
self.assertTrue(state['connections']['npm_password_set'])
self.assertNotIn('test-npm-secret', json.dumps(state))
self.assertNotIn(b'test-npm-secret', self.request('/downloads/services.yaml')[1])
self.assertTrue((self.control / 'sync-request.json').exists())
restarted = ui.Panel(self.config, self.control, '', auth_required=False, connections_file=self.connections)
self.assertFalse(restarted.status()['setup_required'])
self.assertEqual(restarted.status()['connections']['npm_url'], stored['npm_url'])
def test_save_again_preserves_blank_passwords_and_changes_api_url(self):
state = self.install()
settings = copy.deepcopy(self.settings)
settings['revision'] = state['revision']
settings['connections']['npm_url'] = 'http://192.168.0.12:81'
settings['connections']['npm_password'] = ''
code, _, _ = self.request('/api/settings', settings)
self.assertEqual(code, 200)
stored = h.read_json(self.connections)
self.assertEqual(stored['npm_password'], 'test-npm-secret')
self.assertEqual(stored['npm_url'], 'http://192.168.0.12:81')
def test_invalid_settings_and_stale_revision_do_not_change_credentials(self):
state = self.install()
before = self.connections.read_bytes()
for field, value in [('npm_url', 'http://192.168.0.12/api'), ('api_ca_pem', 'not a certificate')]:
settings = copy.deepcopy(self.settings)
settings['revision'] = state['revision']
settings['connections'][field] = value
self.assertEqual(self.request('/api/settings', settings)[0], 400)
self.assertEqual(self.connections.read_bytes(), before)
self.assertEqual(self.request('/api/settings', self.settings)[0], 409)
self.assertEqual(self.connections.read_bytes(), before)
def test_passwordless_pihole_can_be_enabled_and_password_restored(self):
state = self.install()
settings = copy.deepcopy(self.settings)
settings['revision'] = state['revision']
settings['connections']['pihole_password'] = ''
code, state, _ = self.request('/api/settings', settings)
self.assertEqual(code, 200)
self.assertTrue(state['connections']['pihole_password_set'])
settings['revision'] = state['revision']
settings['connections']['clear_pihole_password'] = True
code, state, _ = self.request('/api/settings', settings)
self.assertEqual(code, 200)
self.assertFalse(state['connections']['pihole_password_set'])
stored = h.read_json(self.connections)
self.assertEqual(stored['pihole_password'], '')
self.assertEqual(stored['npm_password'], 'test-npm-secret')
self.assertNotIn('clear_pihole_password', stored)
with patch.dict(os.environ, {'HOMEGATE_CONNECTIONS': str(self.connections)}, clear=True), patch.object(h, 'NPM'), patch.object(h, 'PiHole') as dns, patch.object(h, 'reconcile'):
h.cycle(settings['config'], self.root, None, {})
dns.return_value.login.assert_called_once_with('')
settings['revision'] = state['revision']
settings['connections'].update(clear_pihole_password=False, pihole_password='new-password')
code, state, _ = self.request('/api/settings', settings)
self.assertEqual(code, 200)
self.assertTrue(state['connections']['pihole_password_set'])
self.assertEqual(h.read_json(self.connections)['pihole_password'], 'new-password')
def test_first_setup_accepts_passwordless_pihole(self):
self.settings['connections'].update(pihole_password='', clear_pihole_password=True)
state = self.install()
self.assertFalse(state['connections']['pihole_password_set'])
self.assertEqual(h.read_json(self.connections)['pihole_password'], '')
def test_invalid_password_clear_flag_does_not_change_credentials(self):
state = self.install()
self.settings['revision'] = state['revision']
self.settings['connections']['clear_pihole_password'] = 'true'
before = self.connections.read_bytes()
self.assertEqual(self.request('/api/settings', self.settings)[0], 400)
self.assertEqual(self.connections.read_bytes(), before)
def test_acl_host_and_same_origin_work_without_fixed_origin(self):
self.connect()
self.assertEqual(self.request(peer='8.8.8.8')[0], 403)
for headers in ({'Host': 'attacker.example'}, {'Origin': 'http://attacker.example'}, {'X-Homegate-CSRF': ''}):
self.assertEqual(self.request('/api/settings', self.settings, headers=headers)[0], 403)
self.install()
self.assertEqual(self.request(peer='192.168.1.20')[0], 403)
self.assertEqual(self.request(headers={'Host': 'homegate.home'})[0], 200)
def test_controller_reloads_connections_on_each_cycle(self):
self.install()
with patch.dict(os.environ, {'HOMEGATE_CONNECTIONS': str(self.connections)}, clear=True), patch.object(h, 'NPM') as npm, patch.object(h, 'PiHole') as dns, patch.object(h, 'reconcile'):
h.cycle(self.settings['config'], self.root, None, {})
npm.assert_called_with('http://192.168.0.11:81', 'NPM', True)
npm.return_value.login.assert_called_with('admin@example.com', 'test-npm-secret')
dns.return_value.login.assert_called_with('test-pihole-secret')
settings = h.read_json(self.connections)
settings.update(npm_url='http://192.168.0.12:81', npm_password='changed')
h.save_json(self.connections, settings)
h.cycle(self.settings['config'], self.root, None, {})
npm.assert_called_with('http://192.168.0.12:81', 'NPM', True)
npm.return_value.login.assert_called_with('admin@example.com', 'changed')
class StandaloneTests(unittest.TestCase):
def test_no_user_environment_required(self):
env = standalone.runtime_environment({})
self.assertEqual(env['UI_AUTH_MODE'], 'none')
self.assertEqual(env['HOMEGATE_MANAGED_UI'], '1')
self.assertNotIn('HOMEGATE_LAN_IP', env)
self.assertNotIn('NPM_PASSWORD', env)
def test_child_failure_stops_remaining_processes(self):
processes = []
popen = subprocess.Popen
def start(*args, **kwargs):
process = popen(*args, **kwargs)
processes.append(process)
return process
with patch.object(standalone.subprocess, 'Popen', side_effect=start):
result = standalone.supervise([[sys.executable, '-c', 'raise SystemExit(3)'],
[sys.executable, '-c', 'import time; time.sleep(60)']], {})
self.assertEqual(result, 1)
self.assertTrue(all(process.poll() is not None for process in processes))