Files
mi8-platina-linux/tests/test_cellular_setup.py
2026-11-18 01:39:26 +09:00

440 lines
19 KiB
Python

"""Verify Platina cellular data setup, APN detection, and NetworkManager commands."""
import importlib.util
from pathlib import Path
import subprocess
import unittest
ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location('cellular_setup', ROOT / 'scripts/phone-cellular-setup.py')
cellular = importlib.util.module_from_spec(spec)
spec.loader.exec_module(cellular)
SAMPLE_MMCLI_OUTPUT = """
--------------------------------
General | path: /org/freedesktop/ModemManager1/Modem/0
| device id: d060cbb6f1837ac6
--------------------------------
Hardware | manufacturer: QUALCOMM INCORPORATED
| model: SDM660
| equipment id: 867530901234567
--------------------------------
Status | state: connected
| power state: on
| access tech: lte
| signal quality: 84% (recent)
--------------------------------
3GPP | imei: 867530901234567
| operator id: 46000
| operator name: CMCC
| registration: home
--------------------------------
Bearer | paths: /org/freedesktop/ModemManager1/Bearer/0
"""
class CellularSetupTests(unittest.TestCase):
def test_apn_detection_known_carriers(self):
# China Mobile
self.assertEqual(cellular.detect_apn_for_operator('46000'), 'cmnet')
self.assertEqual(cellular.detect_apn_for_operator('46002'), 'cmnet')
self.assertEqual(cellular.detect_apn_for_operator('46007'), 'cmnet')
# China Unicom
self.assertEqual(cellular.detect_apn_for_operator('46001'), '3gnet')
self.assertEqual(cellular.detect_apn_for_operator('46006'), '3gnet')
# China Telecom
self.assertEqual(cellular.detect_apn_for_operator('46003'), 'ctnet')
self.assertEqual(cellular.detect_apn_for_operator('46011'), 'ctnet')
# US carriers
self.assertEqual(cellular.detect_apn_for_operator('310260'), 'fast.t-mobile.com')
self.assertEqual(cellular.detect_apn_for_operator('310410'), 'nxtgenphone')
# Fallback
self.assertEqual(cellular.detect_apn_for_operator('99999', fallback='custom.apn'), 'custom.apn')
self.assertEqual(cellular.detect_apn_for_operator(None, fallback='internet'), 'internet')
def test_parse_mmcli_modem_info(self):
info = cellular.parse_mmcli_modem_info(SAMPLE_MMCLI_OUTPUT)
self.assertEqual(info['modem_path'], '/org/freedesktop/ModemManager1/Modem/0')
self.assertEqual(info['state'], 'connected')
self.assertEqual(info['operator_name'], 'CMCC')
self.assertEqual(info['operator_code'], '46000')
self.assertEqual(info['signal_percent'], 84)
self.assertEqual(info['access_tech'], 'lte')
self.assertEqual(info['equipment_id'], '867530901234567')
self.assertEqual(info['bearer_path'], '/org/freedesktop/ModemManager1/Bearer/0')
def test_build_nmcli_setup_commands_new(self):
cmds = cellular.build_nmcli_setup_commands(
con_name='platina-cellular',
apn='cmnet',
ifname='*',
existing_connections=['platina-usb', 'WLAN-Home']
)
self.assertEqual(len(cmds), 1)
self.assertIn('add', cmds[0])
self.assertIn('cmnet', cmds[0])
self.assertIn('platina-cellular', cmds[0])
# Ensure autoconnect is disabled to prevent NetworkManager dialing without IPA
self.assertIn('connection.autoconnect', cmds[0])
idx = cmds[0].index('connection.autoconnect')
self.assertEqual(cmds[0][idx + 1], 'no')
self.assertIn('ipv4.route-metric', cmds[0])
m_idx = cmds[0].index('ipv4.route-metric')
self.assertEqual(cmds[0][m_idx + 1], '700')
def test_build_nmcli_setup_commands_existing(self):
cmds = cellular.build_nmcli_setup_commands(
con_name='platina-cellular',
apn='3gnet',
ifname='rmnet_data0',
existing_connections=['platina-cellular', 'platina-usb']
)
self.assertEqual(len(cmds), 1)
self.assertIn('modify', cmds[0])
self.assertIn('3gnet', cmds[0])
self.assertIn('platina-cellular', cmds[0])
self.assertIn('connection.autoconnect', cmds[0])
idx = cmds[0].index('connection.autoconnect')
self.assertEqual(cmds[0][idx + 1], 'no')
self.assertIn('ipv4.route-metric', cmds[0])
m_idx = cmds[0].index('ipv4.route-metric')
self.assertEqual(cmds[0][m_idx + 1], '700')
def test_configure_cellular_invokes_executor(self):
recorded_calls = []
def mock_executor(cmd, **kwargs):
recorded_calls.append(cmd)
# If asking for connection list
if 'connection' in cmd and 'show' in cmd:
return subprocess.CompletedProcess(cmd, 0, stdout='platina-usb\n', stderr='')
return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='')
res = cellular.configure_cellular(apn='ctnet', ifname='*', executor=mock_executor)
self.assertEqual(res['apn'], 'ctnet')
self.assertEqual(res['connection'], 'platina-cellular')
# Ensure nmcli add command was executed
add_calls = [c for c in recorded_calls if 'add' in c]
self.assertEqual(len(add_calls), 1)
self.assertIn('ctnet', add_calls[0])
def test_toggle_cellular(self):
recorded_calls = []
def mock_executor(cmd, **kwargs):
recorded_calls.append(cmd)
return subprocess.CompletedProcess(cmd, 0)
cellular.toggle_cellular(activate=True, executor=mock_executor, datapath_checker=lambda: True)
self.assertEqual(recorded_calls[-1], ['nmcli', 'connection', 'up', 'platina-cellular'])
cellular.toggle_cellular(activate=False, executor=mock_executor, datapath_checker=lambda: True)
self.assertEqual(recorded_calls[-1], ['nmcli', 'connection', 'down', 'platina-cellular'])
# Without datapath, activating must raise RuntimeError
with self.assertRaises(RuntimeError):
cellular.toggle_cellular(activate=True, executor=mock_executor, datapath_checker=lambda: False)
def test_is_cellular_active(self):
def mock_active(cmd, **kwargs):
return subprocess.CompletedProcess(cmd, 0, stdout='platina-usb\nplatina-cellular\n', stderr='')
def mock_inactive(cmd, **kwargs):
return subprocess.CompletedProcess(cmd, 0, stdout='platina-usb\n', stderr='')
def mock_error(cmd, **kwargs):
raise subprocess.CalledProcessError(1, cmd)
self.assertTrue(cellular.is_cellular_active(executor=mock_active))
self.assertFalse(cellular.is_cellular_active(executor=mock_inactive))
self.assertFalse(cellular.is_cellular_active(executor=mock_error))
def test_enable_modem(self):
recorded_calls = []
def mock_executor(cmd, **kwargs):
recorded_calls.append(cmd)
return subprocess.CompletedProcess(cmd, 0)
res = cellular.enable_modem(modem_index=0, executor=mock_executor)
self.assertTrue(res)
self.assertEqual(recorded_calls[-1], ['mmcli', '-m', '0', '-e'])
def test_run_auto_connect(self):
recorded_calls = []
logs = []
active_state = [False]
def mock_executor(cmd, **kwargs):
recorded_calls.append(cmd)
cmd_str = ' '.join(cmd)
if 'mmcli -L' in cmd_str:
return subprocess.CompletedProcess(cmd, 0,
stdout='/org/freedesktop/ModemManager1/Modem/0 [QUALCOMM] SDM660\n', stderr='')
if 'mmcli -m 0' in cmd_str:
return subprocess.CompletedProcess(cmd, 0, stdout=SAMPLE_MMCLI_OUTPUT, stderr='')
if 'connection show --active' in cmd_str:
out = 'platina-cellular\n' if active_state[0] else 'platina-usb\n'
return subprocess.CompletedProcess(cmd, 0, stdout=out, stderr='')
if 'connection show' in cmd_str:
return subprocess.CompletedProcess(cmd, 0, stdout='platina-usb\n', stderr='')
if 'connection up' in cmd_str:
active_state[0] = True
return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='')
return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='')
# Run with max_attempts=1, daemon=False, with hardware datapath present
res = cellular.run_auto_connect(
daemon=False,
poll_interval=1,
max_attempts=2,
executor=mock_executor,
sleeper=lambda s: None,
logger=logs.append,
datapath_checker=lambda: True,
)
self.assertTrue(res)
self.assertTrue(active_state[0])
self.assertTrue(any('Detected carrier' in log for log in logs))
self.assertTrue(any('Connection platina-cellular activated' in log for log in logs))
def test_has_cellular_datapath(self):
import tempfile
with tempfile.TemporaryDirectory() as tmpdir:
base = Path(tmpdir)
# Case 1: Empty sysfs -> False
self.assertFalse(cellular.has_cellular_datapath(tmpdir))
# Case 2: Driver dir exists with only control files -> False
driver_dir = base / 'bus/platform/drivers/ipa'
driver_dir.mkdir(parents=True)
for f in ('bind', 'unbind', 'uevent', 'module'):
(driver_dir / f).touch()
self.assertFalse(cellular.has_cellular_datapath(tmpdir))
# A bound driver alone does not establish a data transport.
(driver_dir / '1e40000.ipa').mkdir()
self.assertFalse(cellular.has_cellular_datapath(tmpdir))
(driver_dir / '1e40000.ipa').rmdir()
# A named rmnet interface without backing is not enough either.
net_dir = base / 'class/net'
net_dir.mkdir(parents=True)
(net_dir / 'lo').mkdir()
(net_dir / 'usb0').mkdir()
self.assertFalse(cellular.has_cellular_datapath(tmpdir))
(net_dir / 'rmnet0').mkdir()
self.assertFalse(cellular.has_cellular_datapath(tmpdir))
def test_datapath_rejects_legacy_ipa_and_its_rmnet_child(self):
import tempfile
with tempfile.TemporaryDirectory() as tmpdir:
base = Path(tmpdir)
device = base / 'devices/14780000.ipa'
(device / 'of_node').mkdir(parents=True)
(device / 'of_node/compatible').write_bytes(b'qcom,sdm660-ipa\0qcom,ipa-v2.6\0')
driver = base / 'bus/platform/drivers/ipa'
driver.mkdir(parents=True)
(device / 'driver').symlink_to(driver, target_is_directory=True)
net = base / 'class/net'
(net / 'rmnet_ipa0').mkdir(parents=True)
(net / 'rmnet_ipa0/device').symlink_to(device, target_is_directory=True)
(net / 'rmnet_data0').mkdir()
(net / 'rmnet_data0/lower_rmnet_ipa0').symlink_to(net / 'rmnet_ipa0', target_is_directory=True)
status = cellular.cellular_datapath_status(tmpdir)
self.assertFalse(status['ready'])
self.assertTrue(any('BAM TX/RX' in row['reason'] for row in status['interfaces']))
# A future implemented v2 backend can opt in explicitly.
(device / 'modem').mkdir()
(device / 'modem/datapath_ready').write_text('1\n')
self.assertTrue(cellular.has_cellular_datapath(tmpdir))
def test_datapath_accepts_bound_modern_ipa(self):
import tempfile
with tempfile.TemporaryDirectory() as tmpdir:
base = Path(tmpdir)
iface = base / 'class/net/rmnet_ipa0'
(iface / 'device/driver').mkdir(parents=True)
(iface / 'device/ipa_version').write_text('3.1\n')
self.assertTrue(cellular.has_cellular_datapath(tmpdir))
def test_cyclic_rmnet_lowers_are_not_a_datapath(self):
import tempfile
with tempfile.TemporaryDirectory() as tmpdir:
iface = Path(tmpdir) / 'class/net/rmnet0'
iface.mkdir(parents=True)
(iface / 'lower_rmnet0').symlink_to(iface, target_is_directory=True)
self.assertFalse(cellular.has_cellular_datapath(tmpdir))
def test_run_auto_connect_no_datapath_skips_dialing(self):
recorded_calls = []
logs = []
def mock_executor(cmd, **kwargs):
recorded_calls.append(cmd)
return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='')
res = cellular.run_auto_connect(
daemon=False,
poll_interval=1,
max_attempts=2,
executor=mock_executor,
sleeper=lambda s: None,
logger=logs.append,
datapath_checker=lambda: False,
)
self.assertFalse(res)
self.assertEqual(recorded_calls, [])
self.assertTrue(any('dialing skipped' in log for log in logs))
def test_check_battery_gate(self):
import tempfile
with tempfile.TemporaryDirectory() as tmpdir:
base = Path(tmpdir)
bat_dir = base / 'class/power_supply/qcom-battery'
bat_dir.mkdir(parents=True)
# Case 1: Healthy battery (50%, 3.9V) -> Passes
(bat_dir / 'capacity').write_text('50\n')
(bat_dir / 'voltage_now').write_text('3900000\n')
ok, msg = cellular.check_battery_gate(min_capacity=15, min_voltage_uv=3700000, sys_path=tmpdir)
self.assertTrue(ok)
self.assertIn('passed', msg.lower())
# Case 2: Low capacity (10%) -> Fails
(bat_dir / 'capacity').write_text('10\n')
ok, msg = cellular.check_battery_gate(min_capacity=15, min_voltage_uv=3700000, sys_path=tmpdir)
self.assertFalse(ok)
self.assertIn('capacity 10%', msg)
# Case 3: Low voltage (3.5V) -> Fails
(bat_dir / 'capacity').write_text('25\n')
(bat_dir / 'voltage_now').write_text('3500000\n')
ok, msg = cellular.check_battery_gate(min_capacity=15, min_voltage_uv=3700000, sys_path=tmpdir)
self.assertFalse(ok)
self.assertIn('voltage', msg)
def test_configure_radio_bands(self):
recorded_cmds = []
def mock_executor(cmd, **kwargs):
recorded_cmds.append(cmd)
return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='')
results = cellular.configure_radio_bands(rat='lte', bands='1,3', executor=mock_executor)
self.assertTrue(all(ok for _, ok, _ in results))
# Check qmicli call
qmi_call = next(c for c in recorded_cmds if 'qmicli' in c)
self.assertTrue(any('mode-pref=lte' in arg and 'lte-band-preference=1,3' in arg for arg in qmi_call))
# Check mmcli call
mm_call = next(c for c in recorded_cmds if 'mmcli' in c)
self.assertIn('--set-allowed-modes=4g', mm_call)
self.assertIn('--set-preferred-mode=4g', mm_call)
def test_run_auto_connect_enforces_battery_gate(self):
logs = []
recorded_cmds = []
def mock_executor(cmd, **kwargs):
recorded_cmds.append(cmd)
return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='')
res = cellular.run_auto_connect(
daemon=False,
poll_interval=1,
max_attempts=1,
executor=mock_executor,
sleeper=lambda s: None,
logger=logs.append,
datapath_checker=lambda: True,
battery_checker=lambda: (False, "Battery gate failed: capacity 10% < 15%"),
)
self.assertFalse(res)
self.assertTrue(any('Battery gate failed' in log for log in logs))
# Verify modem was kept/set to low-power
self.assertTrue(any('--dms-set-operating-mode=low-power' in ' '.join(c) for c in recorded_cmds))
def test_load_modem_modules(self):
recorded = []
def mock_executor(cmd, **kwargs):
recorded.append(cmd)
return subprocess.CompletedProcess(args=cmd, returncode=0, stdout='loaded', stderr='')
results = cellular.load_modem_modules(executor=mock_executor)
self.assertEqual(len(results), 2)
self.assertTrue(all(ok for _, ok, _ in results))
self.assertEqual(recorded[0], ['modprobe', '--ignore-install', 'qcom_q6v5_mss'])
self.assertEqual(recorded[1], ['modprobe', '--ignore-install', 'ipa'])
def test_daemon_waits_for_datapath_and_plmn_registration(self):
checks = [False, True, True]
mm_outputs = [
"General | path: /org/freedesktop/ModemManager1/Modem/0\nStatus | state: searching\n",
SAMPLE_MMCLI_OUTPUT.replace('46000', '46001').replace('CMCC', 'CHN-UNICOM'),
]
mm_idx = [0]
recorded = []
active_state = [False]
logs = []
def mock_datapath():
return checks.pop(0) if checks else True
def mock_executor(cmd, **kwargs):
recorded.append(cmd)
cmd_str = ' '.join(cmd)
if 'mmcli -L' in cmd_str:
return subprocess.CompletedProcess(cmd, 0,
stdout='/org/freedesktop/ModemManager1/Modem/0 [QUALCOMM] SDM660\n', stderr='')
if 'mmcli -m 0' in cmd_str:
out = mm_outputs[min(mm_idx[0], len(mm_outputs) - 1)]
mm_idx[0] += 1
return subprocess.CompletedProcess(cmd, 0, stdout=out, stderr='')
if 'connection show --active' in cmd_str:
out = 'platina-cellular\n' if active_state[0] else 'platina-usb\n'
return subprocess.CompletedProcess(cmd, 0, stdout=out, stderr='')
if 'connection show' in cmd_str:
return subprocess.CompletedProcess(cmd, 0, stdout='platina-usb\n', stderr='')
if 'connection up' in cmd_str:
active_state[0] = True
return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='')
return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='')
res = cellular.run_auto_connect(
daemon=True,
poll_interval=1,
max_attempts=3,
executor=mock_executor,
sleeper=lambda s: None,
logger=logs.append,
datapath_checker=mock_datapath,
)
self.assertFalse(res) # exits cleanly on max_attempts=3 in daemon loop
self.assertTrue(active_state[0])
add_calls = [c for c in recorded if 'add' in c]
self.assertEqual(len(add_calls), 1)
self.assertIn('3gnet', add_calls[0])
self.assertNotIn('cmnet', add_calls[0])
self.assertIn('700', add_calls[0])
self.assertTrue(any('dialing skipped' in log for log in logs))
self.assertTrue(any('waiting for registration' in log for log in logs))
def test_usb_profile_metric_yields_to_cellular_and_wifi(self):
usb_profile = (ROOT / 'ports/candidate/device-xiaomi-platina/platina-usb.nmconnection').read_text()
metric = None
for line in usb_profile.splitlines():
if line.strip().startswith('route-metric='):
metric = int(line.split('=', 1)[1].strip())
break
self.assertIsNotNone(metric)
self.assertEqual(metric, 2000)
self.assertGreater(metric, 700)
if __name__ == '__main__':
unittest.main()