154 lines
5.9 KiB
Python
154 lines
5.9 KiB
Python
import hashlib
|
|
import json
|
|
import unittest
|
|
|
|
from core.device_id import is_valid_egid
|
|
from core.device_profile import (
|
|
DeviceProfile,
|
|
DeviceProfileGenerator,
|
|
load_device_profile,
|
|
save_device_profile,
|
|
)
|
|
|
|
|
|
class DeviceProfileTests(unittest.TestCase):
|
|
def test_generator_creates_consistent_local_identity(self):
|
|
profile = DeviceProfileGenerator(seed=1234).new_profile()
|
|
|
|
self.assertEqual(len(profile.android_id), 16)
|
|
self.assertEqual(profile.android_id, profile.android_id.lower())
|
|
int(profile.android_id, 16)
|
|
self.assertEqual(profile.o_did, f"ANDROID_{profile.android_id}")
|
|
self.assertTrue(profile.local_did.startswith("ANDROID_"))
|
|
self.assertEqual(profile.did, profile.local_did)
|
|
|
|
expected_rdid = hashlib.md5(profile.g_rdi2.encode("utf-8")).hexdigest()[16:32]
|
|
self.assertEqual(profile.rdid, f"ANDROID_{expected_rdid}")
|
|
self.assertTrue(is_valid_egid(profile.egid))
|
|
self.assertIn(profile.egid, profile.runtime_hints.sted_cache_json)
|
|
self.assertTrue(profile.runtime_hints.persisted_cache_m)
|
|
|
|
def test_profile_persistence_roundtrip(self):
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
path = Path(tmp) / "device.json"
|
|
profile = DeviceProfileGenerator(seed=5678).new_profile()
|
|
|
|
save_device_profile(profile, path)
|
|
loaded = load_device_profile(path)
|
|
|
|
self.assertEqual(loaded, profile)
|
|
self.assertEqual(
|
|
json.loads(path.read_text(encoding="utf-8"))["android_id"],
|
|
profile.android_id,
|
|
)
|
|
|
|
def test_apply_cloud_identity_updates_only_server_fields(self):
|
|
profile = DeviceProfileGenerator(seed=9012).new_profile()
|
|
old_android_id = profile.android_id
|
|
old_o_did = profile.o_did
|
|
old_rdid = profile.rdid
|
|
|
|
profile.apply_cloud_identity(
|
|
did="ANDROID_e8dfd2f16b618053",
|
|
cdid_tag=2,
|
|
egid="DFP68CA12B5D3C714E4439D5E255B197DA809D63CB77139F1420A763F53FE718",
|
|
)
|
|
|
|
self.assertEqual(profile.did, "ANDROID_e8dfd2f16b618053")
|
|
self.assertEqual(profile.cdid_tag, 2)
|
|
self.assertEqual(
|
|
profile.egid,
|
|
"DFP68CA12B5D3C714E4439D5E255B197DA809D63CB77139F1420A763F53FE718",
|
|
)
|
|
self.assertEqual(profile.android_id, old_android_id)
|
|
self.assertEqual(profile.o_did, old_o_did)
|
|
self.assertEqual(profile.rdid, old_rdid)
|
|
|
|
def test_env_export_contains_expected_identity_keys(self):
|
|
profile = DeviceProfileGenerator(seed=3456).new_profile()
|
|
env_text = profile.to_env()
|
|
|
|
self.assertIn(f"KS_ANDROID_ID={profile.android_id}", env_text)
|
|
self.assertIn(f"KS_DID={profile.did}", env_text)
|
|
self.assertIn(f"KS_ODID={profile.o_did}", env_text)
|
|
self.assertIn(f"KS_RDID={profile.rdid}", env_text)
|
|
self.assertIn(f"KS_LOCAL_DID={profile.local_did}", env_text)
|
|
self.assertIn(f"KS_EGID={profile.egid}", env_text)
|
|
|
|
def test_generated_profile_contains_stable_hardware_fields(self):
|
|
profile = DeviceProfileGenerator(seed=4567).new_profile()
|
|
|
|
self.assertEqual(profile.package_name, "com.kuaishou.nebula")
|
|
self.assertEqual(profile.app_version, "14.5.50.11631")
|
|
self.assertEqual(profile.android_release, "16")
|
|
self.assertTrue(profile.manufacturer)
|
|
self.assertTrue(profile.brand)
|
|
self.assertTrue(profile.model)
|
|
self.assertGreater(profile.screen_width, 0)
|
|
self.assertGreater(profile.screen_height, 0)
|
|
self.assertGreater(profile.total_memory_mb, 0)
|
|
self.assertTrue(profile.board_platform)
|
|
self.assertTrue(profile.soc_name)
|
|
self.assertGreater(profile.max_memory, 0)
|
|
self.assertTrue(profile.device_bit)
|
|
self.assertIn(profile.isp, {"CUCC", "CTCC", "CMCC"})
|
|
self.assertIn(f"KS_APPVER={profile.app_version}", profile.to_env())
|
|
self.assertIn(f"KS_SOC_NAME={profile.soc_name}", profile.to_env())
|
|
|
|
def test_generated_profile_contains_runtime_hints(self):
|
|
profile = DeviceProfileGenerator(seed=4567).new_profile()
|
|
hints = profile.runtime_hints
|
|
|
|
self.assertTrue(hints.k4_native)
|
|
self.assertGreater(hints.storage_available_bytes, 0)
|
|
self.assertEqual(len(hints.k51_native), 16)
|
|
self.assertEqual(len(hints.k84_native), 16)
|
|
self.assertTrue(hints.boot_id)
|
|
self.assertTrue(hints.grdi)
|
|
self.assertIn("::", hints.grdi)
|
|
self.assertTrue(hints.keeper_seed)
|
|
self.assertTrue(hints.du)
|
|
self.assertTrue(hints.sted_cache_json)
|
|
self.assertIn(profile.egid, hints.sted_cache_json)
|
|
self.assertTrue(hints.persisted_cache_m)
|
|
self.assertTrue(hints.manus)
|
|
self.assertTrue(hints.gaid)
|
|
self.assertIn("KS_K105=", profile.to_env())
|
|
|
|
def test_runtime_hints_persist_roundtrip(self):
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
path = Path(tmp) / "device.json"
|
|
profile = DeviceProfileGenerator(seed=5678).new_profile()
|
|
|
|
save_device_profile(profile, path)
|
|
loaded = load_device_profile(path)
|
|
|
|
self.assertEqual(loaded.runtime_hints, profile.runtime_hints)
|
|
|
|
def test_profile_validation_rejects_invalid_identity_fields(self):
|
|
cases = [
|
|
("android_id", "XYZ"),
|
|
("local_did", "BAD"),
|
|
("did", "BAD"),
|
|
("o_did", "BAD"),
|
|
("rdid", "BAD"),
|
|
("egid", "BAD"),
|
|
]
|
|
for field, value in cases:
|
|
with self.subTest(field=field):
|
|
data = DeviceProfileGenerator(seed=7890).new_profile().to_dict()
|
|
data[field] = value
|
|
|
|
with self.assertRaises(ValueError):
|
|
DeviceProfile.from_dict(data)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|