602 lines
25 KiB
Python
602 lines
25 KiB
Python
"""gui_core_pkg.wifi_adb_scan 单元测试。
|
||
|
||
覆盖:
|
||
- parse_subnet_spec:CIDR / 范围 / 单 IP / 逗号 / 空 / 非法
|
||
- get_local_subnet:mock socket 拿到出口 IP 的情况
|
||
- probe_adb_port:开 / 关 / 超时
|
||
- verify_adb_target:connected / unauthorized / failed
|
||
- discover_adb_devices:subnet 推导 → 端口扫描 → adb connect 验证
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import socket
|
||
from types import SimpleNamespace
|
||
from unittest.mock import MagicMock, patch
|
||
|
||
import pytest
|
||
|
||
from gui.gui_core_pkg import wifi_adb_scan as scan
|
||
|
||
|
||
def _proc(stdout: str = "", stderr: str = "", returncode: int = 0):
|
||
return SimpleNamespace(stdout=stdout, stderr=stderr, returncode=returncode)
|
||
|
||
|
||
# ============================================================
|
||
# parse_subnet_spec
|
||
# ============================================================
|
||
|
||
class TestParseSubnetSpec:
|
||
def test_cidr_24(self):
|
||
ips = scan.parse_subnet_spec("192.168.5.0/24")
|
||
# /24 hosts 是 .1 ~ .254(去掉网络/广播)
|
||
assert len(ips) == 254
|
||
assert ips[0] == "192.168.5.1"
|
||
assert ips[-1] == "192.168.5.254"
|
||
|
||
def test_range(self):
|
||
ips = scan.parse_subnet_spec("192.168.5.10-13")
|
||
assert ips == ["192.168.5.10", "192.168.5.11", "192.168.5.12", "192.168.5.13"]
|
||
|
||
def test_single_ip(self):
|
||
assert scan.parse_subnet_spec("10.0.0.42") == ["10.0.0.42"]
|
||
|
||
def test_comma_dedupes(self):
|
||
ips = scan.parse_subnet_spec("10.0.0.5,10.0.0.5,10.0.0.6")
|
||
assert ips == ["10.0.0.5", "10.0.0.6"]
|
||
|
||
def test_empty(self):
|
||
assert scan.parse_subnet_spec("") == []
|
||
assert scan.parse_subnet_spec(None) == [] # type: ignore[arg-type]
|
||
|
||
def test_invalid(self):
|
||
assert scan.parse_subnet_spec("not an ip") == []
|
||
assert scan.parse_subnet_spec("999.999.999.999") == []
|
||
|
||
def test_range_invalid_order(self):
|
||
# 50-10 是反向范围,按规则不接受
|
||
assert scan.parse_subnet_spec("192.168.5.50-10") == []
|
||
|
||
|
||
# ============================================================
|
||
# get_local_subnet
|
||
# ============================================================
|
||
|
||
class TestGetLocalSubnet:
|
||
def test_outbound_ip_to_subnet(self):
|
||
with patch.object(scan, "_get_outbound_ip", return_value="192.168.5.19"), \
|
||
patch.object(scan, "_get_first_private_ipv4", return_value=None):
|
||
assert scan.get_local_subnet() == "192.168.5.0/24"
|
||
|
||
def test_falls_back_to_first_private(self):
|
||
with patch.object(scan, "_get_outbound_ip", return_value=None), \
|
||
patch.object(scan, "_get_first_private_ipv4", return_value="10.0.0.42"):
|
||
assert scan.get_local_subnet() == "10.0.0.0/24"
|
||
|
||
def test_no_ip_returns_none(self):
|
||
with patch.object(scan, "_get_outbound_ip", return_value=None), \
|
||
patch.object(scan, "_get_first_private_ipv4", return_value=None):
|
||
assert scan.get_local_subnet() is None
|
||
|
||
|
||
class TestGetLocalSubnets:
|
||
def test_dedup_and_outbound_first(self):
|
||
with patch.object(scan, "_list_private_ipv4s", return_value=["192.168.10.108", "10.0.0.23", "192.168.10.20"]):
|
||
subnets = scan.get_local_subnets()
|
||
assert subnets == ["192.168.10.0/24", "10.0.0.0/24"]
|
||
|
||
|
||
# ============================================================
|
||
# probe_adb_port
|
||
# ============================================================
|
||
|
||
class TestProbeAdbPort:
|
||
def test_port_open(self):
|
||
fake_sock = MagicMock()
|
||
fake_sock.connect = MagicMock(return_value=None)
|
||
with patch("socket.socket", return_value=fake_sock):
|
||
assert scan.probe_adb_port("192.168.5.2") is True
|
||
|
||
def test_port_closed(self):
|
||
fake_sock = MagicMock()
|
||
fake_sock.connect = MagicMock(side_effect=ConnectionRefusedError())
|
||
with patch("socket.socket", return_value=fake_sock):
|
||
assert scan.probe_adb_port("192.168.5.99") is False
|
||
|
||
def test_timeout(self):
|
||
fake_sock = MagicMock()
|
||
fake_sock.connect = MagicMock(side_effect=socket.timeout())
|
||
with patch("socket.socket", return_value=fake_sock):
|
||
assert scan.probe_adb_port("192.168.5.99", timeout=0.01) is False
|
||
|
||
|
||
# ============================================================
|
||
# scan_open_ports
|
||
# ============================================================
|
||
|
||
class TestScanOpenPorts:
|
||
def test_returns_only_open(self):
|
||
ips = ["192.168.5.2", "192.168.5.3", "192.168.5.4"]
|
||
# 只有 .2 和 .4 开 5555
|
||
with patch.object(
|
||
scan,
|
||
"probe_adb_port",
|
||
side_effect=lambda ip, port=5555, timeout=0.3: ip in {"192.168.5.2", "192.168.5.4"},
|
||
):
|
||
opens = scan.scan_open_ports(ips, max_workers=4)
|
||
# 现在返回 (ip, port) 元组列表
|
||
assert opens == [("192.168.5.2", 5555), ("192.168.5.4", 5555)]
|
||
|
||
def test_progress_callback(self):
|
||
progress = []
|
||
with patch.object(scan, "probe_adb_port", return_value=False):
|
||
scan.scan_open_ports(
|
||
["10.0.0.1", "10.0.0.2", "10.0.0.3"],
|
||
max_workers=2,
|
||
on_progress=lambda d, t: progress.append((d, t)),
|
||
)
|
||
# 进度应该 1/3, 2/3, 3/3 各一次(顺序不保证)
|
||
assert len(progress) == 3
|
||
assert all(t == 3 for d, t in progress)
|
||
|
||
def test_empty_ips(self):
|
||
assert scan.scan_open_ports([]) == []
|
||
|
||
def test_multiple_ports_per_ip(self):
|
||
"""同一个 IP 多个端口都开 → 都应被列出。"""
|
||
ips = ["192.168.5.2"]
|
||
# 5555 和 37001 都开,5556 关
|
||
def fake_probe(ip, port, timeout=0.3):
|
||
return port in (5555, 37001)
|
||
|
||
with patch.object(scan, "probe_adb_port", side_effect=fake_probe):
|
||
opens = scan.scan_open_ports(
|
||
ips, ports=[5555, 5556, 37001], max_workers=4
|
||
)
|
||
assert opens == [("192.168.5.2", 5555), ("192.168.5.2", 37001)]
|
||
|
||
def test_ports_overrides_legacy_port_arg(self):
|
||
"""同时传 port 和 ports 时 ports 优先。"""
|
||
with patch.object(scan, "probe_adb_port", return_value=True):
|
||
opens = scan.scan_open_ports(
|
||
["10.0.0.1"], port=5555, ports=[12345], max_workers=2
|
||
)
|
||
assert opens == [("10.0.0.1", 12345)]
|
||
|
||
def test_sort_by_ip_then_port(self):
|
||
"""结果按 (IP 数值序, port 升序) 排序。"""
|
||
with patch.object(scan, "probe_adb_port", return_value=True):
|
||
opens = scan.scan_open_ports(
|
||
["10.0.0.10", "10.0.0.2"],
|
||
ports=[5556, 5555],
|
||
max_workers=4,
|
||
)
|
||
assert opens == [
|
||
("10.0.0.2", 5555),
|
||
("10.0.0.2", 5556),
|
||
("10.0.0.10", 5555),
|
||
("10.0.0.10", 5556),
|
||
]
|
||
|
||
|
||
# ============================================================
|
||
# parse_port_spec
|
||
# ============================================================
|
||
|
||
class TestParsePortSpec:
|
||
def test_int(self):
|
||
assert scan.parse_port_spec(5555) == [5555]
|
||
|
||
def test_str_single(self):
|
||
assert scan.parse_port_spec("5555") == [5555]
|
||
|
||
def test_comma(self):
|
||
assert scan.parse_port_spec("5555,5556,5557") == [5555, 5556, 5557]
|
||
|
||
def test_range(self):
|
||
assert scan.parse_port_spec("37000-37003") == [37000, 37001, 37002, 37003]
|
||
|
||
def test_mixed(self):
|
||
assert scan.parse_port_spec("5555,37000-37002,40000") == [
|
||
5555, 37000, 37001, 37002, 40000
|
||
]
|
||
|
||
def test_dedup_preserves_order(self):
|
||
assert scan.parse_port_spec([5555, 5556, 5555, 5557]) == [5555, 5556, 5557]
|
||
|
||
def test_none_returns_default(self):
|
||
assert scan.parse_port_spec(None) == [scan.DEFAULT_ADB_PORT]
|
||
|
||
def test_empty_returns_default(self):
|
||
assert scan.parse_port_spec("") == [scan.DEFAULT_ADB_PORT]
|
||
assert scan.parse_port_spec(" ") == [scan.DEFAULT_ADB_PORT]
|
||
assert scan.parse_port_spec([]) == [scan.DEFAULT_ADB_PORT]
|
||
|
||
def test_out_of_range_int(self):
|
||
# 超过 65535 / <=0 都退化为默认
|
||
assert scan.parse_port_spec(0) == [scan.DEFAULT_ADB_PORT]
|
||
assert scan.parse_port_spec(70000) == [scan.DEFAULT_ADB_PORT]
|
||
|
||
def test_invalid_strings(self):
|
||
assert scan.parse_port_spec("abc") == [scan.DEFAULT_ADB_PORT]
|
||
# 单个非法 + 一个有效
|
||
assert scan.parse_port_spec("abc,5555") == [5555]
|
||
|
||
def test_inverted_range_skipped(self):
|
||
# lo > hi 跳过
|
||
result = scan.parse_port_spec("5555,40000-30000")
|
||
assert result == [5555]
|
||
|
||
def test_huge_range_skipped(self):
|
||
# > 1024 个端口的单个范围不展开
|
||
result = scan.parse_port_spec("5555,1-2000")
|
||
assert result == [5555]
|
||
|
||
def test_android_wireless_debug_range_allowed(self):
|
||
result = scan.parse_port_spec("37000-65535")
|
||
assert result[0] == 37000
|
||
assert result[-1] == 65535
|
||
assert len(result) == 28536
|
||
|
||
|
||
# ============================================================
|
||
# verify_adb_target
|
||
# ============================================================
|
||
|
||
class TestVerifyAdbTarget:
|
||
def test_connected(self):
|
||
with patch("subprocess.run", return_value=_proc("connected to 192.168.5.2:5555", "", 0)):
|
||
state, msg = scan.verify_adb_target("/adb", "192.168.5.2:5555")
|
||
assert state == "connected"
|
||
|
||
def test_already_connected(self):
|
||
with patch("subprocess.run", return_value=_proc("already connected to 192.168.5.2:5555", "", 0)):
|
||
state, _ = scan.verify_adb_target("/adb", "192.168.5.2:5555")
|
||
assert state == "connected"
|
||
|
||
def test_unauthorized(self):
|
||
with patch("subprocess.run", return_value=_proc("failed to authenticate to 192.168.5.2:5555", "", 0)):
|
||
state, _ = scan.verify_adb_target("/adb", "192.168.5.2:5555")
|
||
assert state == "unauthorized"
|
||
|
||
def test_failed(self):
|
||
with patch("subprocess.run", return_value=_proc("cannot connect: refused", "", 1)):
|
||
state, _ = scan.verify_adb_target("/adb", "192.168.5.99:5555")
|
||
assert state == "failed"
|
||
|
||
def test_timeout_but_devices_shows_connected(self):
|
||
with patch.object(scan, "_run_adb", side_effect=[
|
||
(-1, "timeout"),
|
||
(0, "List of devices attached\n192.168.5.2:5555 device product:x model:y\n"),
|
||
]):
|
||
state, msg = scan.verify_adb_target("/adb", "192.168.5.2:5555")
|
||
assert state == "connected"
|
||
assert "192.168.5.2:5555 device" in msg
|
||
|
||
def test_timeout_but_devices_shows_unauthorized(self):
|
||
with patch.object(scan, "_run_adb", side_effect=[
|
||
(-1, "timeout"),
|
||
(0, "List of devices attached\n192.168.5.2:5555 unauthorized\n"),
|
||
]):
|
||
state, msg = scan.verify_adb_target("/adb", "192.168.5.2:5555")
|
||
assert state == "unauthorized"
|
||
assert "unauthorized" in msg
|
||
|
||
|
||
class TestDiscoverMdnsTargets:
|
||
def test_parse_ipv4_targets(self):
|
||
sample = """
|
||
List of discovered mdns services
|
||
adb-1234 _adb-tls-connect._tcp. 192.168.10.66:40075
|
||
adb-5678 _adb._tcp. 10.0.0.9:5555
|
||
garbage line
|
||
"""
|
||
with patch.object(scan, "_run_adb", return_value=(0, sample)):
|
||
targets = scan.discover_mdns_targets("/adb")
|
||
assert targets == [("10.0.0.9", 5555), ("192.168.10.66", 40075)]
|
||
|
||
def test_ignores_pairing_port_and_keeps_connect_port(self):
|
||
sample = """
|
||
List of discovered mdns services
|
||
adb-1234 _adb-tls-pairing._tcp. 192.168.10.66:35223
|
||
adb-1234 _adb-tls-connect._tcp. 192.168.10.66:45321
|
||
"""
|
||
with patch.object(scan, "_run_adb", return_value=(0, sample)):
|
||
targets = scan.discover_mdns_targets("/adb")
|
||
assert targets == [("192.168.10.66", 45321)]
|
||
|
||
def test_empty_on_error(self):
|
||
with patch.object(scan, "_run_adb", return_value=(1, "failed")):
|
||
assert scan.discover_mdns_targets("/adb") == []
|
||
|
||
|
||
class TestRunAdbEnv:
|
||
def test_sets_openscreen_mdns_by_default(self):
|
||
called = {}
|
||
|
||
def fake_run(*args, **kwargs):
|
||
called["env"] = kwargs.get("env", {})
|
||
return _proc("", "", 0)
|
||
|
||
with patch("subprocess.run", side_effect=fake_run):
|
||
scan._run_adb("/adb", ["mdns", "services"])
|
||
|
||
env = called.get("env", {})
|
||
assert env.get("ADB_MDNS_OPENSCREEN") == "1"
|
||
|
||
|
||
# ============================================================
|
||
# discover_adb_devices —— 主入口集成测试
|
||
# ============================================================
|
||
|
||
class TestDiscoverAdbDevices:
|
||
def test_full_flow_one_connected(self):
|
||
"""子网推导 → 1 个 IP 开 5555 → connect connected → 取 model。"""
|
||
with patch.object(scan, "get_local_subnet", return_value="192.168.5.0/24"), \
|
||
patch("gui.gui_core_pkg.config.get_last_wifi_target", return_value={}), \
|
||
patch.object(
|
||
scan,
|
||
"scan_open_ports",
|
||
return_value=[("192.168.5.2", 5555)],
|
||
), \
|
||
patch.object(
|
||
scan,
|
||
"verify_adb_target",
|
||
return_value=("connected", "already connected to 192.168.5.2:5555"),
|
||
), \
|
||
patch.object(scan, "query_device_model", return_value="PEPM00"):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
assert len(devs) == 1
|
||
assert devs[0].ip == "192.168.5.2"
|
||
assert devs[0].port == 5555
|
||
assert devs[0].adb_state == "connected"
|
||
assert devs[0].model == "PEPM00"
|
||
assert devs[0].target == "192.168.5.2:5555"
|
||
|
||
def test_unauthorized_still_listed(self):
|
||
with patch.object(scan, "get_local_subnet", return_value="192.168.5.0/24"), \
|
||
patch("gui.gui_core_pkg.config.get_last_wifi_target", return_value={}), \
|
||
patch.object(scan, "scan_open_ports", return_value=[("192.168.5.2", 5555)]), \
|
||
patch.object(
|
||
scan,
|
||
"verify_adb_target",
|
||
return_value=("unauthorized", "failed to authenticate"),
|
||
), \
|
||
patch.object(scan, "query_device_model", return_value=""):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
assert len(devs) == 1
|
||
assert devs[0].adb_state == "unauthorized"
|
||
# unauthorized 不应再去 query model
|
||
assert devs[0].model == ""
|
||
|
||
def test_no_subnet_returns_empty(self):
|
||
with patch.object(scan, "get_local_subnets", return_value=[]), \
|
||
patch.object(scan, "get_local_subnet", return_value=None):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
assert devs == []
|
||
|
||
def test_explicit_subnet_overrides_auto(self):
|
||
captured = {}
|
||
|
||
def fake_scan_ports(ips, **kwargs):
|
||
captured["ips"] = list(ips)
|
||
return []
|
||
|
||
with patch.object(scan, "scan_open_ports", side_effect=fake_scan_ports):
|
||
scan.discover_adb_devices("/adb", subnet_spec="10.0.0.5-7")
|
||
|
||
assert captured["ips"] == ["10.0.0.5", "10.0.0.6", "10.0.0.7"]
|
||
|
||
def test_no_open_ports_returns_empty(self):
|
||
with patch.object(scan, "get_local_subnet", return_value="192.168.5.0/24"), \
|
||
patch.object(scan, "scan_open_ports", return_value=[]):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
assert devs == []
|
||
|
||
def test_multi_port_passes_through(self):
|
||
"""传入 ports=[5555,37001] 时 scan_open_ports 也收到这个列表。"""
|
||
captured = {}
|
||
|
||
def fake_scan_ports(ips, **kwargs):
|
||
captured["ports"] = kwargs.get("ports")
|
||
return []
|
||
|
||
with patch.object(scan, "scan_open_ports", side_effect=fake_scan_ports):
|
||
scan.discover_adb_devices(
|
||
"/adb", subnet_spec="10.0.0.5", ports=[5555, 37001]
|
||
)
|
||
|
||
assert captured["ports"] == [5555, 37001]
|
||
|
||
def test_auto_multi_subnet_fallback_scans_all(self):
|
||
calls = []
|
||
|
||
def fake_scan_ports(ips, **kwargs):
|
||
calls.append(list(ips))
|
||
# 第一网段无设备,第二网段有一个
|
||
if "192.168.10.2" in ips:
|
||
return []
|
||
return [("10.0.0.9", 5555)]
|
||
|
||
with patch.object(scan, "get_local_subnets", return_value=["192.168.10.0/30", "10.0.0.8/30"]), \
|
||
patch.object(scan, "discover_mdns_targets", return_value=[]), \
|
||
patch.object(scan, "_list_arp_ipv4_candidates", return_value=[]), \
|
||
patch.object(scan, "scan_open_ports", side_effect=fake_scan_ports), \
|
||
patch.object(scan, "verify_adb_target", return_value=("connected", "ok")), \
|
||
patch.object(scan, "query_device_model", return_value="PEPM00"):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
|
||
assert len(calls) == 3
|
||
assert calls[0] == ["192.168.10.1", "192.168.10.2", "10.0.0.9", "10.0.0.10"]
|
||
assert len(devs) == 1
|
||
assert devs[0].target == "10.0.0.9:5555"
|
||
|
||
def test_merges_mdns_targets_before_port_scan(self):
|
||
with patch.object(scan, "discover_mdns_targets", return_value=[("192.168.10.66", 40075)]), \
|
||
patch.object(scan, "get_local_subnets", return_value=["192.168.10.0/30"]), \
|
||
patch.object(scan, "scan_open_ports", return_value=[]), \
|
||
patch.object(scan, "verify_adb_target", side_effect=lambda adb, t: ("connected", f"ok:{t}")), \
|
||
patch.object(scan, "query_device_model", return_value="PEPM00"):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
assert len(devs) == 1
|
||
assert devs[0].target == "192.168.10.66:40075"
|
||
|
||
def test_connected_wifi_devices_are_scan_fallback(self):
|
||
with patch.object(scan, "discover_mdns_targets", return_value=[]), \
|
||
patch.object(scan, "discover_connected_wifi_targets", return_value=[("192.168.10.105", 46107)]), \
|
||
patch.object(scan, "get_local_subnets", return_value=["192.168.10.0/30"]), \
|
||
patch.object(scan, "scan_open_ports", return_value=[]), \
|
||
patch.object(scan, "verify_adb_target", return_value=("connected", "already connected")), \
|
||
patch.object(scan, "query_device_model", return_value="PEPM00"):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
|
||
assert len(devs) == 1
|
||
assert devs[0].target == "192.168.10.105:46107"
|
||
|
||
def test_returns_devs_with_correct_ports(self):
|
||
"""两个 (ip, port) 分别返回各自端口的 DiscoveredDevice。"""
|
||
with patch.object(
|
||
scan,
|
||
"scan_open_ports",
|
||
return_value=[("192.168.5.2", 5555), ("192.168.5.2", 37001)],
|
||
), patch.object(
|
||
scan, "verify_adb_target",
|
||
side_effect=lambda adb, target: ("connected", f"connected to {target}"),
|
||
), patch.object(scan, "query_device_model", return_value="PEPM00"):
|
||
devs = scan.discover_adb_devices(
|
||
"/adb", subnet_spec="192.168.5.0/24", ports=[5555, 37001]
|
||
)
|
||
assert len(devs) == 2
|
||
assert devs[0].port == 5555
|
||
assert devs[1].port == 37001
|
||
assert devs[0].target == "192.168.5.2:5555"
|
||
assert devs[1].target == "192.168.5.2:37001"
|
||
|
||
def test_fast_path_includes_last_target_but_still_scans_other_wifi_devices(self):
|
||
calls = []
|
||
|
||
def fake_scan_ports(ips, **kwargs):
|
||
calls.append((list(ips), list(kwargs.get("ports") or [])))
|
||
return [("192.168.10.104", 5555)]
|
||
|
||
with patch.object(scan, "get_local_subnets", return_value=["192.168.10.0/24"]), \
|
||
patch("gui.gui_core_pkg.config.get_last_wifi_target", return_value={"target": "192.168.10.103:37697", "model": "Xiaomi 14"}), \
|
||
patch.object(scan, "verify_adb_target", side_effect=lambda adb, target, **kwargs: ("connected", f"ok:{target}")), \
|
||
patch.object(scan, "query_device_model", side_effect=lambda adb, target: f"model:{target}"), \
|
||
patch.object(scan, "discover_mdns_targets", return_value=[]), \
|
||
patch.object(scan, "_list_arp_ipv4_candidates", return_value=[]), \
|
||
patch.object(scan, "scan_open_ports", side_effect=fake_scan_ports):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
|
||
assert [d.target for d in devs] == [
|
||
"192.168.10.103:37697",
|
||
"192.168.10.104:5555",
|
||
]
|
||
assert devs[0].model == "Xiaomi 14"
|
||
assert calls
|
||
|
||
def test_last_port_hint_added_to_lightweight_scan_ports(self):
|
||
captured_ports = []
|
||
|
||
def fake_scan_ports(ips, **kwargs):
|
||
captured_ports.append(list(kwargs.get("ports") or []))
|
||
return []
|
||
|
||
with patch.object(scan, "get_local_subnets", return_value=["192.168.10.0/24"]), \
|
||
patch("gui.gui_core_pkg.config.get_last_wifi_target", return_value={"target": "192.168.10.103:37697"}), \
|
||
patch.object(scan, "verify_adb_target", return_value=("failed", "refused")), \
|
||
patch.object(scan, "discover_mdns_targets", return_value=[]), \
|
||
patch.object(scan, "scan_open_ports", side_effect=fake_scan_ports):
|
||
_ = scan.discover_adb_devices("/adb")
|
||
|
||
assert captured_ports
|
||
assert captured_ports[0][0] == 37697
|
||
assert 5555 in captured_ports[0]
|
||
assert 44219 in captured_ports[0]
|
||
assert len(captured_ports[0]) <= 8
|
||
assert captured_ports[1] == [5555]
|
||
|
||
def test_changed_subnet_scans_same_host_with_last_random_port(self):
|
||
calls = []
|
||
|
||
def fake_scan_ports(ips, **kwargs):
|
||
ports = list(kwargs.get("ports") or [])
|
||
calls.append((list(ips), ports))
|
||
if "192.168.10.102" in ips and 42047 in ports:
|
||
return [("192.168.10.102", 42047)]
|
||
return []
|
||
|
||
with patch.object(scan, "get_local_subnets", return_value=["192.168.10.0/24"]), \
|
||
patch("gui.gui_core_pkg.config.get_last_wifi_target", return_value={"target": "192.168.5.102:42047", "model": "PEPM00"}), \
|
||
patch.object(scan, "verify_adb_target", return_value=("connected", "ok")), \
|
||
patch.object(scan, "discover_mdns_targets", return_value=[]), \
|
||
patch.object(scan, "_list_arp_ipv4_candidates", return_value=[]), \
|
||
patch.object(scan, "scan_open_ports", side_effect=fake_scan_ports), \
|
||
patch.object(scan, "query_device_model", return_value="PEPM00"):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
|
||
assert len(devs) == 1
|
||
assert devs[0].target == "192.168.10.102:42047"
|
||
assert calls[0][0][0] == "192.168.10.102"
|
||
assert calls[0][1][0] == 42047
|
||
assert 5555 in calls[0][1]
|
||
|
||
def test_auto_mode_lightweight_port_scan_before_base_5555(self):
|
||
calls = []
|
||
|
||
def fake_scan_ports(ips, **kwargs):
|
||
ports = list(kwargs.get("ports") or [])
|
||
calls.append((list(ips), ports))
|
||
if 44219 in ports:
|
||
return [("192.168.10.55", 44219)]
|
||
return []
|
||
|
||
with patch.object(scan, "get_local_subnets", return_value=["192.168.10.0/24"]), \
|
||
patch("gui.gui_core_pkg.config.get_last_wifi_target", return_value={}), \
|
||
patch.object(scan, "discover_mdns_targets", return_value=[]), \
|
||
patch.object(scan, "_list_arp_ipv4_candidates", return_value=["192.168.10.55"]), \
|
||
patch.object(scan, "scan_open_ports", side_effect=fake_scan_ports), \
|
||
patch.object(scan, "verify_adb_target", return_value=("connected", "ok")), \
|
||
patch.object(scan, "query_device_model", return_value="M"):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
|
||
assert len(devs) == 1
|
||
assert calls[0][0] == ["192.168.10.55"]
|
||
assert calls[0][1][0] == scan.DEFAULT_ADB_PORT
|
||
assert 44219 in calls[0][1]
|
||
assert len(calls[0][1]) <= 8
|
||
assert calls[1][1] == [5555]
|
||
|
||
def test_hi_port_fallback_still_runs_when_last_port_hint_added(self):
|
||
calls = []
|
||
|
||
def fake_scan_ports(ips, **kwargs):
|
||
ports = list(kwargs.get("ports") or [])
|
||
calls.append((list(ips), ports))
|
||
if 44219 in ports:
|
||
return [("192.168.10.55", 44219)]
|
||
return []
|
||
|
||
with patch.object(scan, "get_local_subnets", return_value=["192.168.10.0/24"]), \
|
||
patch("gui.gui_core_pkg.config.get_last_wifi_target", return_value={"target": "192.168.10.2:37697"}), \
|
||
patch.object(scan, "verify_adb_target", return_value=("failed", "refused")), \
|
||
patch.object(scan, "discover_mdns_targets", return_value=[]), \
|
||
patch.object(scan, "_list_arp_ipv4_candidates", return_value=["192.168.10.55"]), \
|
||
patch.object(scan, "scan_open_ports", side_effect=fake_scan_ports), \
|
||
patch.object(scan, "query_device_model", return_value="M"):
|
||
devs = scan.discover_adb_devices("/adb")
|
||
|
||
assert len(devs) == 1
|
||
assert calls[0][0] == ["192.168.10.2", "192.168.10.55"]
|
||
assert calls[0][1][0] == 37697
|
||
assert 44219 in calls[0][1]
|
||
assert len(calls[0][1]) <= 8
|
||
assert calls[1][1] == [5555]
|
||
|
||
def test_lightweight_port_scan_covers_common_wifi_adb_ports(self):
|
||
ports = scan._build_quick_port_candidates()
|
||
|
||
assert ports[0] == scan.DEFAULT_ADB_PORT
|
||
assert 44219 in ports
|
||
assert len(ports) <= 8
|