440 lines
19 KiB
Python
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()
|