009: publish AXPR23 final source and public documentation

tests/test_intellirrat.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Host-side guards for the IntelliRAT v0.1 manual prototype."""
+
+from pathlib import Path
+import os
+import subprocess
+import tempfile
+import unittest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+MODULE = ROOT / "modules/intellirat"
+CONTROLLER = MODULE / "system/bin/intellirat"
+
+
+class IntelliRatTest(unittest.TestCase):
+    def test_prototype_is_manual_and_uses_modern_command(self) -> None:
+        script = CONTROLLER.read_text()
+        service = (MODULE / "service.sh").read_text()
+        self.assertIn("get-allowed-network-types-for-users", script)
+        self.assertIn("set-allowed-network-types-for-users", script)
+        self.assertIn("capture", script)
+        self.assertIn("original_mask", script)
+        self.assertIn("call_in_progress", script)
+        self.assertNotIn("setPreferredNetworkType", script)
+        self.assertNotIn("preferred_network_mode", script)
+        self.assertNotIn("Xposed", script)
+        self.assertNotIn("intellirat high", service)
+        self.assertNotIn("intellirat low", service)
+
+    def test_companion_app_has_menu_and_persistent_notification_surface(self) -> None:
+        manifest = (MODULE / "app/AndroidManifest.xml").read_text()
+        activity = (MODULE / "app/src/com/axp/intellirat/MainActivity.java").read_text()
+        service = (MODULE / "app/src/com/axp/intellirat/IntelliRatService.java").read_text()
+        boot = (MODULE / "app/src/com/axp/intellirat/BootReceiver.java").read_text()
+        tile = (MODULE / "app/src/com/axp/intellirat/IntelliRatTileService.java").read_text()
+        self.assertIn("POST_NOTIFICATIONS", manifest)
+        self.assertIn("RECEIVE_BOOT_COMPLETED", manifest)
+        self.assertIn("PACKAGE_USAGE_STATS", manifest)
+        self.assertIn("foregroundServiceType=\"specialUse\"", manifest)
+        for command in ("status", "capture", "high", "low", "restore"):
+            self.assertIn(f'addButton(actions, "', activity)
+            self.assertIn(f'"{command}")', activity)
+        self.assertIn("startForeground", service)
+        self.assertIn("KeyguardManager", service)
+        self.assertIn("isKeyguardLocked", service)
+        self.assertIn("Automatic unlocked HIGH", service)
+        self.assertIn("AUTO_UNLOCK_DELAY_SECONDS", service)
+        self.assertIn("AUTO_DELAY_SECONDS", service)
+        self.assertIn("AUTO_EXCEPTIONS", service)
+        self.assertIn("UsageStatsManager", service)
+        self.assertIn("START_STICKY", service)
+        self.assertIn("BOOT_COMPLETED", manifest)
+        self.assertIn("startForegroundService", boot)
+        self.assertIn("Automatic lock policy", activity)
+        self.assertIn("Apply automatic policy", activity)
+        self.assertIn("Exception packages", activity)
+        self.assertIn("IntelliRatTileService", manifest)
+        self.assertIn("onClick", tile)
+        self.assertIn('"low"', tile)
+        self.assertIn('"high"', tile)
+        self.assertIn('action("HIGH", "high"', service)
+        self.assertIn('action("LOW", "low"', service)
+        self.assertIn('action("RESTORE", "restore"', service)
+
+    def test_shell_files_parse(self) -> None:
+        for path in (CONTROLLER, MODULE / "service.sh"):
+            result = subprocess.run(["sh", "-n", str(path)], capture_output=True, text=True)
+            self.assertEqual(result.returncode, 0, result.stderr)
+
+    def test_capture_low_restore_and_call_guard(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            bin_dir = root / "bin"
+            bin_dir.mkdir()
+            fake_state = root / "network"
+            fake_state.write_text(
+                "GSM|GPRS|EDGE|UMTS|HSDPA|HSUPA|HSPA|LTE|HSPAP|TD_SCDMA\n"
+            )
+            fake_call = root / "call"
+            fake_call.write_text("IDLE\n")
+
+            (bin_dir / "cmd").write_text(
+                """#!/bin/sh
+state=${FAKE_NETWORK_STATE:?}
+if [ "$2" = get-allowed-network-types-for-users ]; then
+    tr -d '\\n' < "$state"
+    exit 0
+fi
+if [ "$2" = set-allowed-network-types-for-users ]; then
+    case "$5" in
+        00011100001110000111)
+            printf '%s\\n' 'GSM|GPRS|EDGE|UMTS|HSDPA|HSUPA|HSPA|HSPAP|TD_SCDMA' > "$state" ;;
+        00011101001110000111)
+            printf '%s\\n' 'GSM|GPRS|EDGE|UMTS|HSDPA|HSUPA|HSPA|LTE|HSPAP|TD_SCDMA' > "$state" ;;
+        *) printf 'unexpected mask\\n' >&2; exit 1 ;;
+    esac
+    printf '%s\\n' 'set-allowed-network-types-for-users completed'
+    exit 0
+fi
+printf 'unexpected command\\n' >&2
+exit 1
+"""
+            )
+            (bin_dir / "dumpsys").write_text(
+                """#!/bin/sh
+cat "$FAKE_CALL"
+"""
+            )
+            for path in (bin_dir / "cmd", bin_dir / "dumpsys"):
+                path.chmod(0o755)
+
+            env = os.environ.copy()
+            env.update(
+                {
+                    "INTELLIRAT_STATE_DIR": str(root / "state"),
+                    "INTELLIRAT_CMD": str(bin_dir / "cmd"),
+                    "INTELLIRAT_DUMPSYS": str(bin_dir / "dumpsys"),
+                    "FAKE_NETWORK_STATE": str(fake_state),
+                    "FAKE_CALL": str(fake_call),
+                }
+            )
+
+            def run(*args: str) -> subprocess.CompletedProcess[str]:
+                return subprocess.run(
+                    ["sh", str(CONTROLLER), *args],
+                    env=env,
+                    capture_output=True,
+                    text=True,
+                )
+
+            self.assertEqual(run("capture", "0").returncode, 0)
+            low = run("low", "0")
+            self.assertEqual(low.returncode, 0, low.stderr + low.stdout)
+            self.assertIn("state=LOW", run("status", "0").stdout)
+            self.assertEqual(run("restore", "0").returncode, 0)
+            self.assertIn("state=HIGH", run("status", "0").stdout)
+
+            fake_call.write_text("mCallState=ACTIVE\n")
+            blocked = run("low", "0")
+            self.assertNotEqual(blocked.returncode, 0)
+            self.assertIn("call is active", blocked.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()