Files
simplex-chat/scripts/simplex_build/test_smoke.py
T

1329 lines
66 KiB
Python

import contextlib
import itertools
import pathlib
import re
import sqlite3
import tempfile
import unittest
import zipfile
from unittest import mock
from .testing import Recorder, build_script, patch_all
class FakeApp:
"""Stands in for the app's process: alive until killed, or exited with returncode."""
def __init__(self, returncode=None):
self.pid = 4242
self.returncode = returncode
self.killed = False
def poll(self):
return self.returncode
def kill(self):
self.killed = True
def wait(self):
return self.returncode
def desktop_env(root):
"""The app's settings and data directories under root."""
return mock.patch.dict(build_script.os.environ, {"XDG_CONFIG_HOME": str(root / "config"), "XDG_DATA_HOME": str(root / "data")})
class SmokeTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = pathlib.Path(self.tmp.name)
self.out = self.root / "out"
self.out.mkdir()
def tearDown(self):
self.tmp.cleanup()
def test_cli_prints_its_version(self):
binary = self.root / "simplex-chat-ubuntu-22_04-x86_64"
binary.write_bytes(b"cli")
recorder = Recorder(answers={"--version": "SimpleX Chat v7.1.0.15\n"})
with patch_all("run", recorder), patch_all("host_platform", return_value=build_script.Platform.LINUX):
build_script.test_cli(binary, self.out)
self.assertEqual(recorder.commands, [[str(binary), "--version"]])
self.assertEqual((self.out / f"{binary.name}.txt").read_text(), "SimpleX Chat v7.1.0.15\n")
def test_cli_without_a_version_fails(self):
binary = self.root / "cli"
binary.write_bytes(b"cli")
with (
patch_all("run", Recorder(answers={"--version": "usage: ...\n"})),
patch_all("host_platform", return_value=build_script.Platform.LINUX),
self.assertRaises(build_script.BuildError),
):
build_script.test_cli(binary, self.out)
def test_windows_cli_runs_as_an_exe(self):
binary = self.root / "simplex-chat-windows-x86-64"
binary.write_bytes(b"cli")
recorder = Recorder(answers={"--version": "SimpleX Chat v7.1.0.15\n"})
with patch_all("run", recorder), patch_all("host_platform", return_value=build_script.Platform.WINDOWS):
build_script.test_cli(binary, self.out)
self.assertTrue(recorder.commands[0][0].endswith("simplex-chat-windows-x86-64.exe"))
def test_packages_install_as_users_install_them(self):
recorder = Recorder()
with patch_all("run", recorder), mock.patch.dict(build_script.os.environ, {"PROGRAMFILES": "C:/Program Files"}):
deb_app, deb_env = build_script.install_desktop(pathlib.Path("simplex-desktop-ubuntu-22_04-x86_64.deb"), self.root)
msi_app, _ = build_script.install_desktop(pathlib.Path("simplex-desktop-windows-x86_64.msi"), self.root)
self.assertEqual(deb_app, pathlib.Path("/opt/simplex/bin/simplex"))
self.assertEqual(deb_env["JAVA_TOOL_OPTIONS"], "-Dskiko.renderApi=SOFTWARE")
self.assertEqual(recorder.commands[0][:4], ["sudo", "apt-get", "install", "-y"])
self.assertEqual(msi_app, pathlib.Path("C:/Program Files/SimpleX/SimpleX.exe"))
self.assertEqual(recorder.commands[1][:2], ["msiexec", "/i"])
self.assertNotIn("/", recorder.commands[1][2])
self.assertIn("/qn", recorder.commands[1])
def test_appimage_is_copied_to_work_and_runs_without_fuse_extracted_there(self):
appimage = self.root / "simplex-desktop-x86_64.AppImage"
appimage.write_bytes(b"appimage")
work = self.root / "work"
work.mkdir()
app, env = build_script.install_desktop(appimage, work)
self.assertEqual(app, work / "simplex-desktop-x86_64.AppImage")
self.assertEqual(app.read_bytes(), b"appimage")
self.assertEqual(app.stat().st_mode & 0o777, 0o755)
self.assertEqual(env["APPIMAGE_EXTRACT_AND_RUN"], "1")
self.assertEqual(env["TMPDIR"], str(work))
def test_new_appimage_replaces_the_installed_one(self):
work = self.root / "work"
(self.root / "old").mkdir()
work.mkdir()
old, new = self.root / "old/simplex-desktop-x86_64.AppImage", self.root / "simplex-desktop-x86_64.AppImage"
old.write_bytes(b"v7.0.3")
new.write_bytes(b"new")
old_app, _ = build_script.install_desktop(old, work)
app, _ = build_script.install_desktop(new, work)
self.assertEqual(old_app, app)
self.assertEqual(app.read_bytes(), b"new")
def dmg_install(self, version):
def fake_run(args, **kwargs):
args = [str(a) for a in args]
if args[:2] == ["hdiutil", "attach"]:
macos = pathlib.Path(args[-2]) / "SimpleX.app/Contents/MacOS"
macos.mkdir(parents=True)
(macos / f"SimpleX-{version}").write_bytes(b"app")
if args[:2] == ["hdiutil", "detach"]:
build_script.remove_tree(pathlib.Path(args[-1]))
return recorder(args, **kwargs)
recorder = Recorder()
with patch_all("run", fake_run):
app, _ = build_script.install_desktop(pathlib.Path("simplex-desktop-macos-aarch64.dmg"), self.root)
return app, recorder.commands
def test_dmg_app_is_copied_out_and_the_image_detached(self):
app, commands = self.dmg_install("new")
self.assertEqual(app, self.root / "SimpleX.app/Contents/MacOS/SimpleX")
self.assertEqual(commands[-1][:2], ["hdiutil", "detach"])
def test_new_dmg_app_replaces_the_installed_bundle(self):
self.dmg_install("old")
self.dmg_install("new")
self.assertEqual([p.name for p in (self.root / "SimpleX.app/Contents/MacOS").iterdir()], ["SimpleX-new"])
def test_system_wide_packages_are_uninstalled_and_others_left_to_work(self):
recorder = Recorder()
with patch_all("run", recorder):
build_script.uninstall_desktop(pathlib.Path("simplex-desktop-ubuntu-22_04-x86_64.deb"), self.root)
build_script.uninstall_desktop(self.root / "simplex-desktop-windows-x86_64.msi", self.root)
build_script.uninstall_desktop(pathlib.Path("simplex-desktop-x86_64.AppImage"), self.root)
build_script.uninstall_desktop(pathlib.Path("simplex-desktop-macos-aarch64.dmg"), self.root)
deb, msi = recorder.commands
self.assertEqual(deb, ["sudo", "apt-get", "remove", "-y", "simplex"])
self.assertEqual(msi[:2], ["msiexec", "/x"])
self.assertTrue(msi[2].endswith("\\simplex-desktop-windows-x86_64.msi"))
self.assertNotIn("/", msi[2])
self.assertIn("/qn", msi)
def test_stop_app_kills_its_process_group_on_posix(self):
app = FakeApp()
with patch_all("host_platform", return_value=build_script.Platform.LINUX), mock.patch.object(build_script.os, "killpg") as killpg:
build_script.stop_app(app)
killpg.assert_called_once_with(4242, build_script.signal.SIGKILL)
self.assertFalse(app.killed)
def test_stop_app_whose_processes_already_exited(self):
with (
patch_all("host_platform", return_value=build_script.Platform.MACOS),
mock.patch.object(build_script.os, "killpg", side_effect=ProcessLookupError),
):
build_script.stop_app(FakeApp(returncode=1))
def test_stop_app_kills_the_process_on_windows(self):
app = FakeApp()
with patch_all("host_platform", return_value=build_script.Platform.WINDOWS), mock.patch.object(build_script.os, "killpg") as killpg:
build_script.stop_app(app)
self.assertTrue(app.killed)
killpg.assert_not_called()
def test_unknown_package_is_rejected(self):
with self.assertRaises(build_script.BuildError):
build_script.install_desktop(pathlib.Path("app.zip"), self.root)
def test_blank_linux_screenshot_fails(self):
with (
patch_all("run", Recorder(answers={"identify": "3"})),
patch_all("host_platform", return_value=build_script.Platform.LINUX),
self.assertRaises(build_script.BuildError),
):
build_script.screenshot(self.out / "app.png", {"DISPLAY": ":99"})
def test_app_exiting_before_its_window_fails(self):
with patch_all("host_platform", return_value=build_script.Platform.LINUX), self.assertRaises(build_script.BuildError):
build_script.window_open(FakeApp(returncode=1), {})
def desktop_run(self, app, popen=None):
with (
desktop_env(self.root),
patch_all("install_desktop", return_value=(pathlib.Path("/opt/simplex/bin/simplex"), {})),
patch_all("host_platform", return_value=build_script.Platform.MACOS),
patch_all("run", Recorder()),
mock.patch.object(build_script.subprocess, "Popen", side_effect=popen, return_value=app) as popen,
mock.patch.object(build_script.os, "killpg") as killpg,
mock.patch.object(build_script.time, "sleep"),
):
build_script.test_desktop(pathlib.Path("simplex-desktop-macos-aarch64.dmg"), self.out)
return popen, killpg
def test_desktop_app_that_keeps_running_passes_and_is_stopped_with_its_children(self):
popen, killpg = self.desktop_run(FakeApp())
self.assertTrue(popen.call_args.kwargs["start_new_session"])
killpg.assert_called_once_with(4242, build_script.signal.SIGKILL)
def test_fresh_desktop_app_runs_with_its_own_data_removed_after(self):
def fake_popen(args, **kwargs):
(self.root / "data/simplex").mkdir(parents=True)
return FakeApp()
self.desktop_run(FakeApp(), fake_popen)
self.assertFalse((self.root / "data/simplex").exists())
def test_fresh_desktop_app_refuses_to_run_with_existing_app_data(self):
(self.root / "config/simplex").mkdir(parents=True)
with self.assertRaises(build_script.BuildError) as raised:
self.desktop_run(FakeApp())
self.assertIn("config/simplex exists", str(raised.exception))
self.assertTrue((self.root / "config/simplex").exists())
def test_desktop_app_that_exits_after_its_window_fails(self):
app = FakeApp()
calls = iter([None, 1])
app.poll = lambda: next(calls, 1)
with self.assertRaises(build_script.BuildError) as raised:
self.desktop_run(app)
self.assertIn("after opening its window", str(raised.exception))
def test_desktop_app_waits_for_its_window_and_the_ready_condition_before_the_screenshot(self):
events = []
ready = iter([False, False, True])
def condition():
events.append("ready?")
return next(ready)
with (
patch_all("host_platform", return_value=build_script.Platform.MACOS),
patch_all("screenshot", lambda target, env: events.append(f"screenshot {target.name}")),
mock.patch.object(build_script.subprocess, "Popen", return_value=FakeApp()),
mock.patch.object(build_script.os, "killpg"),
mock.patch.object(build_script.time, "sleep"),
):
screen = build_script.run_desktop(pathlib.Path("app"), {}, {}, self.out, "app.v7.0.3", (condition, "database"))
self.assertEqual(events, ["ready?", "ready?", "ready?", "screenshot app.v7.0.3.png"])
self.assertEqual(screen, self.out / "app.v7.0.3.png")
self.assertTrue((self.out / "app.v7.0.3.log").exists())
def test_desktop_app_without_the_ready_condition_fails_naming_it(self):
with (
patch_all("host_platform", return_value=build_script.Platform.MACOS),
patch_all("screenshot") as screenshot,
patch_all("WINDOW_TIMEOUT_SECONDS", 0),
mock.patch.object(build_script.subprocess, "Popen", return_value=FakeApp()),
mock.patch.object(build_script.os, "killpg") as killpg,
mock.patch.object(build_script.time, "sleep"),
self.assertRaises(build_script.BuildError) as raised,
):
build_script.run_desktop(pathlib.Path("app"), {}, {}, self.out, "app", (lambda: False, "database with its key"))
self.assertIn("no database with its key", str(raised.exception))
screenshot.assert_not_called()
killpg.assert_called_once()
def apk_run(self, verify_returncode, pidof, screen='<hierarchy><node text="Get started"/></hierarchy>', database=None):
recorder = Recorder(answers={"pidof": pidof, "abilist": "x86_64,arm64-v8a\n", "uiautomator": screen})
def fake_run(args, **kwargs):
if [str(a) for a in args[:4]] == ["adb", "emu", "screenrecord", "screenshot"]:
(pathlib.Path(args[4]) / "Screenshot_1.png").write_bytes(b"png")
if args[1:2] == ["verify"]:
recorder.commands.append([str(a) for a in args])
return mock.Mock(returncode=verify_returncode, stdout="")
return recorder(args, **kwargs)
apk = self.root / "simplex-aarch64.apk"
with zipfile.ZipFile(apk, "w") as z:
z.writestr("lib/arm64-v8a/libsimplex.so", b"lib")
with (
patch_all("run", fake_run),
patch_all("require_tools"),
patch_all("find_apksigner", return_value="apksigner"),
mock.patch.object(build_script.time, "sleep"),
):
build_script.test_apk(apk, self.out, database)
return recorder.commands
def test_unsigned_apk_is_signed_with_a_throwaway_key(self):
commands = self.apk_run(verify_returncode=1, pidof="1234\n")
self.assertTrue(any(c[0] == "keytool" for c in commands))
install = next(c for c in commands if c[:2] == ["adb", "install"])
self.assertNotEqual(install[-1], str(self.root / "simplex-aarch64.apk"))
self.assertIn(["adb", "shell", "am", "start", "-W", "-n", "chat.simplex.app/.MainActivity"], commands)
def test_screenshot_comes_from_the_emulator(self):
commands = self.apk_run(verify_returncode=0, pidof="1234\n")
self.assertIn("screenrecord", [c[2] for c in commands if c[:2] == ["adb", "emu"]])
self.assertEqual((self.out / "simplex-aarch64.apk.png").read_bytes(), b"png")
def test_apk_for_an_abi_the_emulator_lacks_is_skipped(self):
apk = self.root / "simplex-armv7a.apk"
with zipfile.ZipFile(apk, "w") as z:
z.writestr("lib/armeabi-v7a/libsimplex.so", b"lib")
recorder = Recorder(answers={"abilist": "x86_64,arm64-v8a\n"})
with patch_all("run", recorder), patch_all("require_tools"), patch_all("warn") as warn:
build_script.test_apk(apk, self.out)
self.assertIn("armeabi-v7a", warn.call_args.args[0])
self.assertFalse(any(c[:2] == ["adb", "install"] for c in recorder.commands))
def test_apk_still_opening_its_database_fails_without_a_screenshot(self):
with patch_all("ANDROID_FIRST_SCREEN_SECONDS", 0), self.assertRaises(build_script.BuildError) as raised:
self.apk_run(verify_returncode=0, pidof="1234\n", screen='<hierarchy><node text="Opening database..."/></hierarchy>')
self.assertIn("database loading", str(raised.exception))
self.assertFalse((self.out / "simplex-aarch64.apk.png").exists())
def test_screenshot_waits_for_the_screen_after_the_database_loading(self):
commands = self.apk_run(verify_returncode=0, pidof="1234\n")
dump = commands.index(["adb", "exec-out", "uiautomator", "dump", "/dev/tty"])
screenshot = next(i for i, c in enumerate(commands) if c[:3] == ["adb", "emu", "screenrecord"])
self.assertLess(dump, screenshot)
def test_apk_gets_the_old_database_before_it_starts(self):
opened = []
with (
patch_all("push_android_old_database", lambda database: opened.append(("push", database))),
patch_all("open_android_old_database", lambda out, work: opened.append(("open",))),
):
commands = self.apk_run(verify_returncode=0, pidof="1234\n", database=self.root / "old")
self.assertEqual(opened, [("push", self.root / "old"), ("open",)])
install = next(c for c in commands if c[:2] == ["adb", "install"])
self.assertEqual(install[2], "-g")
def test_signed_apk_is_installed_as_it_is(self):
commands = self.apk_run(verify_returncode=0, pidof="1234\n")
self.assertFalse(any(c[0] == "keytool" for c in commands))
def test_apk_that_is_not_running_after_start_fails(self):
with self.assertRaises(build_script.BuildError):
self.apk_run(verify_returncode=0, pidof="")
class OldDatabaseTest(unittest.TestCase):
"""The previous release's encrypted database, opened by every new build."""
GROUPS = "Current user: alice\n#team (1 member)\n"
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = pathlib.Path(self.tmp.name)
self.out = self.root / "out"
self.out.mkdir()
self.database = self.root / "old"
self.database.mkdir()
for suffix in build_script.DATABASE_SUFFIXES:
(self.database / f"simplex{suffix}").write_bytes(f"encrypted{suffix}".encode())
def tearDown(self):
self.tmp.cleanup()
def cli_run(self, opens=True, wrong_key_opens=False):
"""Stands in for run(): the CLI opens the database with the old release's key, and with a wrong one only when told."""
commands = []
def fake_run(args, input=None, check=True, capture=False, **kwargs):
args = [str(a) for a in args]
commands.append(args)
if "--version" in args:
return mock.Mock(returncode=0, stdout="SimpleX Chat v7.1.0.15\n")
right_key = args[args.index("-k") + 1] == "old-release-key"
if right_key and opens or not right_key and wrong_key_opens:
return mock.Mock(returncode=0, stdout=self.GROUPS)
return mock.Mock(returncode=1, stdout="")
return fake_run, commands
def test_old_release_cli_makes_the_database_with_a_user_and_a_group(self):
recorder = Recorder()
fetched = []
def fake_fetch(url, digest, target):
fetched.append((url, digest))
target.write_bytes(b"old cli")
return target
with (
patch_all("run", recorder),
patch_all("fetch_pinned", fake_fetch),
mock.patch.object(build_script.platform, "machine", return_value="aarch64"),
):
build_script.make_old_database(self.root / "db")
self.assertEqual(
fetched,
[
(
"https://github.com/simplex-chat/simplex-chat/releases/download/v7.0.3/simplex-chat-ubuntu-22_04-aarch64",
"91f332edc813cab78a848da7ba75ed91bcb8d09abf1fc92eca74330dc29ec970",
)
],
)
(command,) = recorder.commands
self.assertEqual(
command[1:], ["-d", str(self.root / "db/simplex"), "-k", "old-release-key", "--user-display-name", "alice", "-e", "/g team"]
)
self.assertEqual(recorder.inputs, [""])
def test_old_database_needs_a_pinned_cli_for_the_machine(self):
with mock.patch.object(build_script.platform, "machine", return_value="riscv64"), self.assertRaises(build_script.BuildError):
build_script.make_old_database(self.root / "db")
def test_cli_opens_and_migrates_the_old_database_and_refuses_a_wrong_key(self):
binary = self.root / "simplex-chat-ubuntu-24_04-x86_64"
binary.write_bytes(b"cli")
fake_run, commands = self.cli_run()
with patch_all("run", fake_run), patch_all("host_platform", return_value=build_script.Platform.LINUX):
build_script.test_cli(binary, self.out, self.database)
opened, wrong = commands[1], commands[2]
self.assertEqual(opened[opened.index("-k") + 1 :], ["old-release-key", "--user-display-name", "alice", "-e", "/groups", "-y"])
self.assertEqual(wrong[wrong.index("-k") + 1], "not-old-release-key")
self.assertEqual((self.out / f"{binary.name}.database.txt").read_text(), self.GROUPS)
def test_cli_that_cannot_open_the_old_database_fails(self):
binary = self.root / "cli"
binary.write_bytes(b"cli")
fake_run, _ = self.cli_run(opens=False)
with (
patch_all("run", fake_run),
patch_all("host_platform", return_value=build_script.Platform.LINUX),
self.assertRaises(build_script.BuildError) as raised,
):
build_script.test_cli(binary, self.out, self.database)
self.assertIn("did not open the v7.0.3 database", str(raised.exception))
def test_cli_that_opens_the_database_with_a_wrong_key_fails(self):
binary = self.root / "cli"
binary.write_bytes(b"cli")
fake_run, _ = self.cli_run(wrong_key_opens=True)
with (
patch_all("run", fake_run),
patch_all("host_platform", return_value=build_script.Platform.LINUX),
self.assertRaises(build_script.BuildError) as raised,
):
build_script.test_cli(binary, self.out, self.database)
self.assertIn("wrong key", str(raised.exception))
def test_desktop_directories_follow_xdg_and_appdata(self):
env = {"XDG_CONFIG_HOME": "/cfg", "XDG_DATA_HOME": "/data", "APPDATA": "C:/Users/u/AppData/Roaming"}
with mock.patch.dict(build_script.os.environ, env), patch_all("host_platform", return_value=build_script.Platform.MACOS):
self.assertEqual(build_script.desktop_dirs(), (pathlib.Path("/cfg/simplex"), pathlib.Path("/data/simplex")))
with mock.patch.dict(build_script.os.environ, env), patch_all("host_platform", return_value=build_script.Platform.WINDOWS):
appdata = pathlib.Path("C:/Users/u/AppData/Roaming/SimpleX")
self.assertEqual(build_script.desktop_dirs(), (appdata, appdata))
def test_desktop_settings_store_the_key_as_the_desktop_cryptor_does(self):
settings = build_script.desktop_settings_with_key("old-release-key")
self.assertEqual(
settings.splitlines(),
[
"StoreDBPassphrase=true",
"EncryptedDBPassphrase=b2xkLXJlbGVhc2Uta2V5",
"InitializationVectorDBPassphrase=b2xkLXJlbGVhc2Uta2V5",
],
)
def test_desktop_old_database_is_where_the_app_opens_it_and_removed_after(self):
with desktop_env(self.root), patch_all("host_platform", return_value=build_script.Platform.LINUX):
with build_script.desktop_old_database(self.database) as prefix:
self.assertEqual(prefix, self.root / "data/simplex/simplex_v1")
self.assertEqual((self.root / "data/simplex/simplex_v1_chat.db").read_bytes(), b"encrypted_chat.db")
self.assertEqual((self.root / "data/simplex/simplex_v1_agent.db").read_bytes(), b"encrypted_agent.db")
self.assertIn("StoreDBPassphrase=true", (self.root / "config/simplex/settings.properties").read_text())
self.assertFalse((self.root / "data/simplex").exists())
self.assertFalse((self.root / "config/simplex").exists())
def test_desktop_old_database_refuses_to_replace_existing_app_data(self):
(self.root / "data/simplex").mkdir(parents=True)
(self.root / "data/simplex/simplex_v1_chat.db").write_bytes(b"someone's chats")
with (
desktop_env(self.root),
patch_all("host_platform", return_value=build_script.Platform.LINUX),
self.assertRaises(build_script.BuildError),
build_script.desktop_old_database(self.database),
):
pass
self.assertEqual((self.root / "data/simplex/simplex_v1_chat.db").read_bytes(), b"someone's chats")
def test_desktop_old_database_test_needs_the_cli(self):
with self.assertRaises(build_script.BuildError):
build_script.test_desktop(self.root / "SimpleX.deb", self.out, self.database, None)
def test_desktop_app_must_have_migrated_the_old_database(self):
package = self.root / "simplex-desktop-ubuntu-24_04-x86_64.deb"
cli = self.root / "simplex-chat"
cli.write_bytes(b"cli")
fake_run, commands = self.cli_run()
with (
desktop_env(self.root),
patch_all("run", fake_run),
patch_all("host_platform", return_value=build_script.Platform.MACOS),
patch_all("install_desktop", return_value=(self.root / "app", {})),
patch_all("window_open", return_value=True),
patch_all("screenshot"),
mock.patch.object(build_script.subprocess, "Popen", return_value=FakeApp()),
mock.patch.object(build_script.os, "killpg"),
mock.patch.object(build_script.time, "sleep"),
):
build_script.test_desktop(package, self.out, self.database, cli)
(check,) = commands
self.assertEqual(check[0], str(cli))
self.assertEqual(check[1:3], ["-d", str(self.root / "data/simplex/simplex_v1")])
self.assertNotIn("-y", check)
ANDROID_SCREEN = (
'<?xml version=\'1.0\' encoding=\'UTF-8\' standalone=\'yes\' ?><hierarchy rotation="0">'
'<node text="Database passphrase is required to open chat." bounds="[0,100][1080,200]" />'
'<node text="" class="android.widget.EditText" focused="true" bounds="[100,500][980,600]">'
'<node text="Enter passphrase…" bounds="[100,500][600,600]" /></node>'
'<node text="Save passphrase and open chat" bounds="[300,700][780,800]" />'
'<node text="Upgrade and open chat" bounds="[300,900][780,1000]" /></hierarchy>'
"UI hierchary dumped to: /dev/tty"
)
def passphrase_screen(self, typed):
"""ANDROID_SCREEN with typed characters of the passphrase in its field, masked as the app masks them."""
return self.ANDROID_SCREEN.replace('text="" class', f'text="{"*" * typed}" class')
def test_android_node_centre_from_uiautomator_dump(self):
self.assertEqual(build_script.android_node_centre(self.ANDROID_SCREEN, "Upgrade and"), (540, 950))
self.assertEqual(build_script.android_node_centre(self.ANDROID_SCREEN, "Enter passphrase"), (350, 550))
self.assertIsNone(build_script.android_node_centre(self.ANDROID_SCREEN, "Open chat"))
def test_android_old_database_is_pushed_as_the_app_owns_it(self):
recorder = Recorder(answers={"stat": "10123:10123\n"})
with patch_all("run", recorder):
build_script.push_android_old_database(self.database)
self.assertEqual(recorder.commands[:2], [["adb", "root"], ["adb", "wait-for-device"]])
target = "/data/user/0/chat.simplex.app/files_chat.db"
self.assertIn(["adb", "push", str(self.database / "simplex_chat.db"), target], recorder.commands)
self.assertIn(["adb", "shell", "chown", "10123:10123", target], recorder.commands)
self.assertIn(["adb", "shell", "restorecon", "/data/user/0/chat.simplex.app/files_agent.db"], recorder.commands)
def test_android_app_opens_the_old_database_with_its_key_and_confirms_its_upgrade(self):
chat_list = '<?xml version="1.0"?><hierarchy><node text="team" bounds="[0,300][1080,400]" /></hierarchy>'
screens = iter([self.ANDROID_SCREEN] * 3 + [self.passphrase_screen(8)] + [self.passphrase_screen(15)] * 4 + [chat_list])
recorder = Recorder()
with (
patch_all("run", recorder),
patch_all("android_screen", lambda: next(screens)),
mock.patch.object(build_script.time, "sleep"),
):
build_script.open_android_old_database(self.out, self.root)
self.assertEqual(
recorder.commands,
[
["adb", "shell", "input", "tap", "350", "550"],
["adb", "shell", "input", "text", "old-rele"],
["adb", "shell", "input", "text", "ase-key"],
["adb", "shell", "input", "tap", "540", "750"],
["adb", "shell", "input", "tap", "540", "950"],
],
)
def test_android_prompts_after_the_database_opens_are_dismissed(self):
notifications = (
'<?xml version="1.0"?><hierarchy><node text="Instant notifications!" bounds="[0,800][1080,900]" />'
'<node text="Disable notifications" bounds="[300,1400][700,1500]" /></hierarchy>'
)
receipts = '<?xml version="1.0"?><hierarchy><node text="Don\'t enable" bounds="[300,1950][800,2050]" /></hierarchy>'
chat_list = '<?xml version="1.0"?><hierarchy><node text="team" bounds="[0,300][1080,400]" /></hierarchy>'
typed = [self.ANDROID_SCREEN] * 3 + [self.passphrase_screen(8)] + [self.passphrase_screen(15)] * 2
screens = iter(typed + [notifications, notifications, receipts, receipts, chat_list])
recorder = Recorder()
with (
patch_all("run", recorder),
patch_all("android_screen", lambda: next(screens)),
mock.patch.object(build_script.time, "sleep"),
):
build_script.open_android_old_database(self.out, self.root)
taps = [["adb", "shell", "input", "tap", "500", "1450"], ["adb", "shell", "input", "tap", "550", "2000"]]
self.assertEqual(recorder.commands[-2:], taps)
def test_android_app_stuck_on_the_old_database_leaves_its_screen(self):
recorder = Recorder()
with (
patch_all("run", recorder),
patch_all(
"android_screen",
side_effect=itertools.chain(
[self.ANDROID_SCREEN] * 3,
[self.passphrase_screen(8)],
itertools.repeat(self.passphrase_screen(15).replace("Upgrade and open chat", "Opening")),
),
),
patch_all("emulator_screenshot") as screenshot,
patch_all("ANDROID_FIRST_SCREEN_SECONDS", 0),
mock.patch.object(build_script.time, "sleep"),
self.assertRaises(build_script.BuildError),
):
build_script.open_android_old_database(self.out, self.root)
self.assertIn("Save passphrase", (self.out / "android-old-database-screen.txt").read_text())
screenshot.assert_called_once_with(self.out / "android-old-database.png", self.root)
class DesktopUpgradeTest(unittest.TestCase):
"""The previous release's app makes its database, and the new package, installed over it, must migrate it."""
PACKAGE = "simplex-desktop-ubuntu-22_04-x86_64.deb"
# 32 bytes in base64, as DatabaseUtils.randomDatabasePassword makes the key
KEY = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8="
# as java.util.Properties.store writes them, with = escaped
SETTINGS = (
"#\n#Sat Oct 31 17:14:59 UTC 2026\nCurrentThemeIds={}\n"
"EncryptedDBPassphrase=QUFFQ0F3UUZCZ2NJQ1FvTERBME9EeEFSRWhNVUZSWVhHQmthR3h3ZEhoOD0\\=\n"
"LastMigratedVersionCode=381\nStoreDBPassphrase=true\n"
)
NO_KEY_SETTINGS = "#\nLastMigratedVersionCode=381\n"
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = pathlib.Path(self.tmp.name)
self.out = self.root / "out"
self.out.mkdir()
self.config, self.data = self.root / "config/simplex", self.root / "data/simplex"
self.package = self.root / "new" / self.PACKAGE
self.package.parent.mkdir()
self.package.write_bytes(b"new deb")
self.cli = self.root / "simplex-chat-ubuntu-22_04-x86_64"
self.cli.write_bytes(b"cli")
def tearDown(self):
self.tmp.cleanup()
def make_desktop_database(self, settings=SETTINGS):
self.data.mkdir(parents=True, exist_ok=True)
for suffix in build_script.DATABASE_SUFFIXES:
(self.data / f"simplex_v1{suffix}").write_bytes(b"encrypted")
self.config.mkdir(parents=True, exist_ok=True)
(self.config / "settings.properties").write_text(settings)
def test_java_properties_unescape_keys_and_values_and_skip_comments(self):
text = "#\n#Sat Oct 31 17:14:59 UTC 2026\nkey\\=1=value\\=\\=\nother:x\\:y\n\n!comment=no\n"
self.assertEqual(build_script.java_properties(text), {"key=1": "value==", "other": "x:y"})
def test_stored_key_is_decoded_from_the_settings_the_app_wrote(self):
self.make_desktop_database()
self.assertEqual(build_script.desktop_stored_key(self.config), self.KEY)
def test_no_stored_key_without_settings_or_without_the_key(self):
self.assertIsNone(build_script.desktop_stored_key(self.config))
self.make_desktop_database(self.NO_KEY_SETTINGS)
self.assertIsNone(build_script.desktop_stored_key(self.config))
def test_database_is_stored_once_both_files_and_the_key_exist(self):
self.assertFalse(build_script.desktop_database_stored(self.config, self.data))
self.make_desktop_database(self.NO_KEY_SETTINGS)
self.assertFalse(build_script.desktop_database_stored(self.config, self.data))
(self.config / "settings.properties").write_text(self.SETTINGS)
(self.data / "simplex_v1_agent.db").unlink()
self.assertFalse(build_script.desktop_database_stored(self.config, self.data))
(self.data / "simplex_v1_agent.db").write_bytes(b"encrypted")
self.assertTrue(build_script.desktop_database_stored(self.config, self.data))
def upgrade(self, cli_output="Current user: alice\nyou have no groups\n", cli_returncode=0, package=None):
"""Runs test_desktop_upgrade with stand-ins: the old app makes its database while it runs, the new app keeps it."""
self.events = events = []
recorder = Recorder()
def fake_fetch(url, digest, target):
events.append(("fetch", url, digest, target.parent.name))
target.write_bytes(b"old deb")
return target
def fake_install(package, work):
events.append(("install", package.read_bytes()))
return work / "simplex", {}
def fake_run_desktop(app, app_env, env, out, name, ready=None):
events.append(("run", name, ready[1] if ready else None))
if ready:
self.assertFalse(ready[0]())
self.make_desktop_database()
self.assertTrue(ready[0]())
return out / f"{name}.png"
def fake_run(args, input=None, check=True, capture=False, **kwargs):
recorder(args, input=input, check=check, capture=capture)
return mock.Mock(returncode=cli_returncode, stdout=cli_output)
with (
desktop_env(self.root),
patch_all("host_platform", return_value=build_script.Platform.MACOS),
patch_all("fetch_pinned", fake_fetch),
patch_all("install_desktop", fake_install),
patch_all("run_desktop", fake_run_desktop),
patch_all("uninstall_desktop", lambda package, work: events.append(("uninstall", package))),
patch_all("run", fake_run),
):
build_script.test_desktop_upgrade(package or self.package, self.out, self.cli)
return events, recorder.commands
def test_new_package_installs_over_the_old_app_and_its_database_opens_without_migrations(self):
events, commands = self.upgrade()
self.assertEqual(
events,
[
(
"fetch",
f"https://github.com/simplex-chat/simplex-chat/releases/download/v7.0.3/{self.PACKAGE}",
"21be1e78c1089c01567ccfec58cdf3e72a2733aa232c5288b8f155e6c7caba0b",
"v7.0.3",
),
("install", b"old deb"),
("run", f"{self.PACKAGE}.v7.0.3", "database with its key in the app's settings"),
("install", b"new deb"),
("run", f"{self.PACKAGE}.upgrade", None),
("uninstall", self.package),
],
)
(check,) = commands
self.assertEqual(check[0], str(self.cli))
self.assertEqual(check[1:], ["-d", str(self.data / "simplex_v1"), "-k", self.KEY, "--user-display-name", "alice", "-e", "/groups"])
self.assertEqual((self.out / f"{self.PACKAGE}.upgrade.database.txt").read_text(), "Current user: alice\nyou have no groups\n")
self.assertFalse(self.data.exists())
self.assertFalse(self.config.exists())
def test_database_that_the_new_cli_cannot_open_fails_and_the_app_is_uninstalled(self):
with self.assertRaises(build_script.BuildError) as raised:
self.upgrade(cli_output="Error opening database: ErrorMigration\n", cli_returncode=1)
self.assertIn("did not open the v7.0.3 database", str(raised.exception))
self.assertEqual(self.events[-1], ("uninstall", self.package))
self.assertFalse(self.data.exists())
def test_upgrade_needs_the_cli_that_checks_the_database(self):
with self.assertRaises(build_script.BuildError) as raised:
build_script.test_desktop_upgrade(self.package, self.out, None)
self.assertIn("needs the CLI", str(raised.exception))
def test_package_without_a_pinned_old_release_is_rejected(self):
with self.assertRaises(build_script.BuildError) as raised:
self.upgrade(package=self.root / "simplex-desktop-ubuntu-20_04-x86_64.deb")
self.assertIn("no v7.0.3 package is pinned", str(raised.exception))
def test_upgrade_refuses_to_run_with_existing_app_data(self):
self.make_desktop_database()
with self.assertRaises(build_script.BuildError) as raised:
self.upgrade()
self.assertIn("exists", str(raised.exception))
self.assertTrue((self.data / "simplex_v1_chat.db").exists())
def test_every_pinned_old_package_has_a_release_file_name_and_a_sha256(self):
packages = r"ubuntu-2[24]_04-(x86_64|aarch64)\.deb|(x86_64|aarch64)\.AppImage|macos-(x86_64|aarch64)\.dmg|windows-x86_64\.msi"
self.assertEqual(len(build_script.OLD_RELEASE_DESKTOP_SHA256), 9)
for name, digest in build_script.OLD_RELEASE_DESKTOP_SHA256.items():
self.assertRegex(name, f"^simplex-desktop-({packages})$")
self.assertRegex(digest, r"^[0-9a-f]{64}$")
NODE_HEIGHT = 100
def android_dump(*nodes):
"""A uiautomator dump with a node for each (text, content description) or (text, content description, attributes),
NODE_HEIGHT pixels below the one before."""
lines = "".join(
f'<node text="{text}" content-desc="{desc}" {"".join(attributes)}bounds="[0,{i * NODE_HEIGHT}][1000,{(i + 1) * NODE_HEIGHT}]" />'
for i, (text, desc, *attributes) in enumerate(nodes)
)
return f'<?xml version="1.0" encoding="UTF-8"?><hierarchy rotation="0">{lines}</hierarchy>UI hierchary dumped to: /dev/tty'
def texts(*labels):
return android_dump(*((label, "") for label in labels))
def field(text, focused=True):
"""A text field node for android_dump."""
return text, "", f'class="android.widget.EditText" focused="{str(focused).lower()}" '
def fields(*shown):
"""A screen for each text shown in the focused field."""
return [android_dump(field(text)) for text in shown]
class FakeAndroid:
"""Stands in for run() with adb: a dump shows the current screen, and each tap or typed text moves to the next one.
Taps are recorded by the label tapped, typed text as typed, key events as sent; other commands go to others, else
are recorded."""
def __init__(self, screens, others=None):
self.screens = [(screen, re.findall(r'text="([^"]*)" content-desc="([^"]*)"', screen)) for screen in screens]
self.dumps = 0
self.taps = []
self.typed = []
self.keys = []
self.commands = []
self.others = others
def __call__(self, args, **kwargs):
args = [str(a) for a in args]
dump, nodes = self.screens[0]
if args[:3] == ["adb", "exec-out", "uiautomator"]:
self.dumps += 1
return mock.Mock(returncode=0, stdout=dump)
if args[:4] == ["adb", "shell", "input", "tap"]:
text, desc = nodes[int(args[5]) // NODE_HEIGHT]
self.taps.append(text or desc)
self.next_screen()
elif args[:4] == ["adb", "shell", "input", "text"]:
self.typed.append(args[4])
self.next_screen()
elif args[:4] == ["adb", "shell", "input", "keyevent"]:
self.keys.append(args[4:])
self.next_screen()
elif self.others:
return self.others(args, **kwargs)
else:
self.commands.append(args)
return mock.Mock(returncode=0, stdout="")
def next_screen(self):
if len(self.screens) > 1:
self.screens.pop(0)
class AndroidUiTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = pathlib.Path(self.tmp.name)
self.out = self.root / "out"
self.out.mkdir()
self.work = self.root / "work"
self.work.mkdir()
patcher = mock.patch.object(build_script.time, "sleep")
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
self.tmp.cleanup()
def test_node_with_the_exact_text_wins_over_one_that_starts_with_it(self):
ui = texts("Messages, files and calls are protected", "Message")
self.assertEqual(build_script.android_node_centre(ui, "Message"), (500, 150))
self.assertEqual(build_script.android_node_centre(ui, "Messages, files"), (500, 50))
def test_node_is_found_by_its_content_description(self):
ui = android_dump(("app-to-peer", ""), ("", "Send Message"))
self.assertEqual(build_script.android_node_centre(ui, "Send Message"), (500, 150))
def test_node_off_the_screen_is_not_found(self):
ui = texts("pq_peer").replace("[0,0][1000,100]", "[0,0][0,0]")
self.assertIsNone(build_script.android_node_centre(ui, "pq_peer"))
def test_failed_or_cut_dump_has_no_nodes(self):
self.assertIsNone(build_script.android_node_centre("ERROR: could not get idle state.", "OK"))
self.assertIsNone(build_script.android_node_centre(texts("OK")[:80], "OK"))
def test_tap_on_a_dumped_screen_does_not_dump_again(self):
android = FakeAndroid([texts("Title", "Accept")])
with patch_all("run", android):
self.assertTrue(build_script.android_tap("Accept", texts("Title", "Accept")))
self.assertFalse(build_script.android_tap("Allow", texts("Title", "Accept")))
self.assertEqual(android.dumps, 0)
self.assertEqual(android.taps, ["Accept"])
def test_tap_waits_until_the_text_is_shown(self):
android = FakeAndroid([texts("Continue")])
screens = [texts("Opening database..."), texts("Opening database..."), texts("Continue")]
with patch_all("run", android), patch_all("android_screen", side_effect=screens):
build_script.android_tap_when_shown("Continue")
self.assertEqual(android.taps, ["Continue"])
def test_text_is_typed_a_few_characters_at_a_time_and_checked_on_the_field(self):
android = FakeAndroid(fields("", "app-to-p", "app-to-peer"))
with patch_all("run", android):
build_script.android_type("app-to-peer")
self.assertEqual(android.typed, ["app-to-p", "eer"])
self.assertEqual(android.keys, [])
def test_dropped_first_character_is_cleared_and_typed_again(self):
android = FakeAndroid(fields("", "pp-to-p", "", "app-to-p", "app-to-peer"))
with patch_all("run", android):
build_script.android_type("app-to-peer")
self.assertEqual(android.typed, ["app-to-p", "app-to-p", "eer"])
self.assertEqual(android.keys, [["KEYCODE_MOVE_END"] + ["KEYCODE_DEL"] * len("pp-to-p")])
def test_masked_field_short_of_the_text_is_cleared_and_typed_again(self):
android = FakeAndroid(fields("", "*" * 8, "*" * 14, "", "*" * 8, "*" * 15))
with patch_all("run", android):
build_script.android_type("old-release-key", masked=True)
self.assertEqual(android.typed, ["old-rele", "ase-key", "old-rele", "ase-key"])
self.assertEqual(android.keys, [["KEYCODE_MOVE_END"] + ["KEYCODE_DEL"] * 14])
def test_masked_field_with_the_texts_length_is_not_typed_again(self):
android = FakeAndroid(fields("", "*" * 8, "*" * 15))
with patch_all("run", android):
build_script.android_type("old-release-key", masked=True)
self.assertEqual(android.typed, ["old-rele", "ase-key"])
self.assertEqual(android.keys, [])
def test_field_that_shows_its_hint_while_empty_is_typed_in(self):
android = FakeAndroid(fields("Message", "app-to-p", "app-to-peer"))
with patch_all("run", android):
build_script.android_type("app-to-peer", hint="Message")
self.assertEqual(android.typed, ["app-to-p", "eer"])
self.assertEqual(android.keys, [])
def test_field_with_a_hint_is_cleared_back_to_it_and_typed_again(self):
android = FakeAndroid(fields("Message", "pp-to-p", "Message", "app-to-p", "app-to-peer"))
with patch_all("run", android):
build_script.android_type("app-to-peer", hint="Message")
self.assertEqual(android.typed, ["app-to-p", "app-to-p", "eer"])
self.assertEqual(android.keys, [["KEYCODE_MOVE_END"] + ["KEYCODE_DEL"] * len("pp-to-p")])
def test_field_with_text_before_typing_is_cleared_first(self):
android = FakeAndroid(fields("draft", "", "citester"))
with patch_all("run", android):
build_script.android_type("citester")
self.assertEqual(android.keys, [["KEYCODE_MOVE_END"] + ["KEYCODE_DEL"] * len("draft")])
self.assertEqual(android.typed, ["citester"])
def test_field_that_drops_a_character_at_every_attempt_fails(self):
android = FakeAndroid(fields("", "pp-to-p", "", "pp-to-p", "", "pp-to-p"))
with patch_all("run", android), self.assertRaises(build_script.BuildError) as raised:
build_script.android_type("app-to-peer")
self.assertEqual(android.typed, ["app-to-p"] * 3)
self.assertIn('the field shows "pp-to-p" in place of "app-to-peer" after 3 attempts', str(raised.exception))
def test_text_is_not_typed_without_a_focused_field(self):
android = FakeAndroid([android_dump(field("", focused=False), ("Message", ""))])
with patch_all("run", android), patch_all("ANDROID_STEP_SECONDS", 0), self.assertRaises(build_script.BuildError) as raised:
build_script.android_type("app-to-peer")
self.assertEqual(android.typed, [])
self.assertIn('no focused text field showing ""', str(raised.exception))
def test_focused_field_is_read_from_the_dump(self):
ui = android_dump(field("citester", focused=False), field("app-to-p"), ("app-to-peer", ""))
self.assertEqual(build_script.android_focused_field(ui), "app-to-p")
self.assertIsNone(build_script.android_focused_field(android_dump(field("app-to-p", focused=False))))
self.assertIsNone(build_script.android_focused_field("ERROR: could not get idle state."))
def test_field_the_app_fills_slowly_is_read_until_it_shows_the_text(self):
with patch_all("android_screen", side_effect=fields("app-", "app-", "app-", "app-to-", "app-to-p")) as screen:
self.assertEqual(build_script.android_settled_field("app-to-p"), "app-to-p")
self.assertEqual(screen.call_count, 5)
def test_field_read_is_settled_after_the_same_text_in_several_dumps(self):
with patch_all("android_screen", side_effect=fields("pp", *["pp-to-p"] * 5, "never read")) as screen:
self.assertEqual(build_script.android_settled_field("app-to-p"), "pp-to-p")
self.assertEqual(screen.call_count, 6)
def test_onboarding_makes_the_profile_and_answers_the_questions_up_to_the_chat_list(self):
android = FakeAndroid(
[
texts("New in v7.0", "OK"),
texts("Get started"),
texts("Create your profile", "Enter profile name…"),
android_dump(field("")),
android_dump(field("citester"), ("Create profile", "")),
texts("Your network", "Continue"),
texts("Use instant notifications?", "Allow"),
texts("Conditions of use", "Accept"),
texts("Your chats", "Talk to someone"),
]
)
with patch_all("run", android):
build_script.android_onboarding()
self.assertEqual(android.taps, ["OK", "Get started", "Enter profile name…", "Create profile", "Continue", "Allow", "Accept"])
self.assertEqual(android.typed, ["citester"])
def test_onboarding_before_android_13_taps_continue_again_and_ok(self):
android = FakeAndroid(
[
texts("Get started"),
texts("Enter profile name…"),
android_dump(field("")),
android_dump(field("citester"), ("Create profile", "")),
texts("Your network", "Continue"),
texts("Your network", "Continue"),
texts("Instant notifications", "To improve privacy, SimpleX runs in background", "OK"),
texts("Network commitments", "Accept"),
texts("Your chats", "Talk to someone"),
]
)
with patch_all("run", android):
build_script.android_onboarding()
self.assertEqual(android.taps[-4:], ["Continue", "Continue", "OK", "Accept"])
def test_failed_apk_test_saves_the_screen(self):
apk = self.root / "simplex-aarch64.apk"
with zipfile.ZipFile(apk, "w") as z:
z.writestr("lib/arm64-v8a/libsimplex.so", b"lib")
recorder = Recorder(answers={"abilist": "x86_64,arm64-v8a\n", "uiautomator": texts("Your network", "Continue")})
with (
patch_all("run", recorder),
patch_all("require_tools"),
patch_all("install_over_old_release", side_effect=build_script.BuildError("no chat list after onboarding")),
patch_all("emulator_screenshot", lambda target, work: target.write_bytes(b"png")),
self.assertRaises(build_script.BuildError),
):
build_script.test_apk(apk, self.out, upgrade=True)
self.assertIn('text="Continue"', (self.out / "simplex-aarch64.apk.upgraded.failed.xml").read_text())
self.assertEqual((self.out / "simplex-aarch64.apk.upgraded.failed.png").read_bytes(), b"png")
def test_chat_list_after_the_upgrade_closes_whats_new(self):
chat_list = ("", "Start new chat")
android = FakeAndroid([android_dump(("New in v7.1", ""), ("OK", ""), chat_list), android_dump(chat_list)])
with patch_all("run", android):
build_script.wait_android_chat_list()
self.assertEqual(android.taps, ["OK"])
def test_chat_list_waits_past_the_database_loading(self):
screens = [texts("Opening database..."), android_dump(("", "Start new chat"))]
with patch_all("android_screen", side_effect=screens) as screen:
build_script.wait_android_chat_list()
self.assertEqual(screen.call_count, 2)
def test_database_error_screen_after_the_upgrade_fails_at_once(self):
for title in ("Encrypted database", "Wrong database passphrase", "Database error", "Database upgrade"):
with (
self.subTest(title),
patch_all("run", FakeAndroid([texts(title, "Save passphrase and open chat")])),
self.assertRaises(build_script.BuildError) as raised,
):
build_script.wait_android_chat_list()
self.assertIn(f'"{title}" in place of its chat list', str(raised.exception))
def test_old_release_apk_is_the_pinned_one_for_the_apks_abi(self):
fetched = []
def fake_fetch(url, digest, target):
fetched.append((url, digest, target))
return target
apk = self.root / "simplex-armv7a.apk"
with zipfile.ZipFile(apk, "w") as z:
z.writestr("lib/armeabi-v7a/libsimplex.so", b"lib")
with patch_all("fetch_pinned", fake_fetch):
old = build_script.old_release_apk(apk, self.work)
url = "https://github.com/simplex-chat/simplex-chat/releases/download/v7.0.3/simplex-armv7a.apk"
digest = "3a89d2f825ce1a30ff51b30487c1b0b58de6eba03426d1500112b7417e659fdc"
self.assertEqual(fetched, [(url, digest, self.work / "v7.0.3/v7.0.3-simplex-armv7a.apk")])
self.assertEqual(old, self.work / "v7.0.3/v7.0.3-simplex-armv7a.apk")
def test_old_release_apk_needs_one_known_abi(self):
apk = self.root / "simplex-x86.apk"
with zipfile.ZipFile(apk, "w") as z:
z.writestr("lib/x86_64/libsimplex.so", b"lib")
with self.assertRaises(build_script.BuildError) as raised:
build_script.old_release_apk(apk, self.work)
self.assertIn("x86_64", str(raised.exception))
def test_apks_signed_in_one_work_directory_share_the_key(self):
recorder = Recorder()
def fake_run(args, **kwargs):
args = [str(a) for a in args]
if args[0] == "keytool":
pathlib.Path(args[args.index("-keystore") + 1]).write_bytes(b"key")
return recorder(args, **kwargs)
with patch_all("run", fake_run), patch_all("find_apksigner", return_value="apksigner"):
old = build_script.signed_for_test(self.root / "v7.0.3/v7.0.3-simplex-aarch64.apk", self.work)
new = build_script.signed_for_test(self.root / "simplex-aarch64.apk", self.work)
self.assertEqual([c[0] for c in recorder.commands], ["keytool", "apksigner", "apksigner"])
self.assertEqual({c[c.index("--ks") + 1] for c in recorder.commands[1:]}, {str(self.work / "test.keystore")})
self.assertEqual((old, new), (self.work / "v7.0.3-simplex-aarch64.apk", self.work / "simplex-aarch64.apk"))
def test_emulator_screenshots_in_one_work_directory(self):
def fake_run(args, **kwargs):
(pathlib.Path(args[4]) / "Screenshot_1.png").write_bytes(pathlib.Path(args[4]).name.encode())
return mock.Mock(returncode=0, stdout="")
with patch_all("run", fake_run):
build_script.emulator_screenshot(self.out / "old.png", self.work)
build_script.emulator_screenshot(self.out / "new.png", self.work)
self.assertNotEqual((self.out / "old.png").read_bytes(), (self.out / "new.png").read_bytes())
def install_over(self, versions):
steps = []
versions = iter(versions)
def fake_run(args, **kwargs):
command = " ".join(map(str, args))
if command == "adb shell dumpsys package chat.simplex.app":
return mock.Mock(returncode=0, stdout=f"Packages:\n versionCode=1 minSdk=28\n versionName={next(versions)}\n")
steps.append(command)
return mock.Mock(returncode=0, stdout="")
old = self.work / "v7.0.3/v7.0.3-simplex-aarch64.apk"
with (
patch_all("run", fake_run),
patch_all("old_release_apk", return_value=old),
patch_all("signed_for_test", lambda apk, work: work / f"signed-{apk.name}"),
patch_all("android_onboarding", lambda: steps.append("onboarding")),
patch_all("emulator_screenshot", lambda target, work: steps.append(f"screenshot {target.name}")),
):
build_script.install_over_old_release(self.root / "simplex-aarch64.apk", self.out, self.work)
return steps
def test_new_apk_installs_over_the_old_release_after_its_onboarding(self):
steps = self.install_over(["7.0.3", "7.1.0-beta.15"])
self.assertEqual(
steps,
[
f"adb install -g {self.work}/signed-v7.0.3-simplex-aarch64.apk",
"adb shell am start -W -n chat.simplex.app/.MainActivity",
"onboarding",
"screenshot simplex-aarch64.apk.v7.0.3.png",
f"adb install -r -g {self.work}/signed-simplex-aarch64.apk",
],
)
self.assertEqual(
(self.out / "simplex-aarch64.apk.upgrade.txt").read_text(),
"v7.0.3 installed as 7.0.3, then simplex-aarch64.apk as 7.1.0-beta.15\n",
)
def test_new_apk_that_keeps_the_old_version_fails(self):
with self.assertRaises(build_script.BuildError) as raised:
self.install_over(["7.0.3", "7.0.3"])
self.assertIn("the version of v7.0.3", str(raised.exception))
def test_version_of_a_missing_app_fails(self):
with (
patch_all("run", Recorder(answers={"dumpsys": "Unable to find package: chat.simplex.app\n"})),
self.assertRaises(build_script.BuildError),
):
build_script.android_app_version()
def upgrade_run(self, **kwargs):
steps = []
apk = self.root / "simplex-aarch64.apk"
with zipfile.ZipFile(apk, "w") as z:
z.writestr("lib/arm64-v8a/libsimplex.so", b"lib")
recorder = Recorder(answers={"pidof": "1234\n", "abilist": "x86_64,arm64-v8a\n"})
with (
patch_all("run", recorder),
patch_all("require_tools"),
patch_all("install_over_old_release", lambda apk, out, work: steps.append(("install over", apk.name))),
patch_all("wait_android_chat_list", lambda: steps.append(("chat list",))),
patch_all("emulator_screenshot", lambda target, work: steps.append(("screenshot", target.name))),
patch_all("connect_android_peer", lambda cli, profile, name, out, work: steps.append(("peer", cli, profile, name))),
):
build_script.test_apk(apk, self.out, **kwargs)
return steps, recorder.commands
def test_upgraded_app_opens_its_database_and_connects_with_the_peer(self):
steps, commands = self.upgrade_run(upgrade=True, cli=self.root / "simplex-chat")
self.assertEqual(
steps,
[
("install over", "simplex-aarch64.apk"),
("chat list",),
("screenshot", "simplex-aarch64.apk.upgraded.png"),
("peer", self.root / "simplex-chat", "citester", "simplex-aarch64.apk.upgraded"),
],
)
self.assertIn(["adb", "uninstall", "chat.simplex.app"], commands)
self.assertFalse(any(c[:2] == ["adb", "install"] for c in commands))
def test_peer_of_the_old_database_is_its_user(self):
opened = []
with (
patch_all("push_android_old_database", lambda database: opened.append("push")),
patch_all("open_android_old_database", lambda out, work: opened.append("open")),
patch_all("find_apksigner", return_value="apksigner"),
):
steps, _ = self.upgrade_run(database=self.root / "old", cli=self.root / "simplex-chat")
self.assertEqual(opened, ["push", "open"])
self.assertEqual(steps[-1], ("peer", self.root / "simplex-chat", "alice", "simplex-aarch64.apk"))
def test_upgrade_and_peer_options_that_do_not_go_together_fail(self):
for kwargs in ({"database": self.root / "old", "upgrade": True}, {"cli": self.root / "simplex-chat"}):
with self.subTest(kwargs), self.assertRaises(build_script.BuildError):
self.upgrade_run(**kwargs)
def peer_database(prefix, links):
"""The peer CLI's chat database with a connection for each one-time link, stored as the core stores it."""
prefix.parent.mkdir(parents=True, exist_ok=True)
with contextlib.closing(sqlite3.connect(f"{prefix}_chat.db")) as db, db:
db.execute("CREATE TABLE connections (connection_id INTEGER PRIMARY KEY, conn_req_inv BLOB)")
db.executemany("INSERT INTO connections (conn_req_inv) VALUES (?)", [(link,) for link in links])
class CliPeerTest(unittest.TestCase):
LINK = "simplex:/invitation#/?v=2-7&smp=smp%3A%2F%2Fhash%40smp4.simplex.im%2Fqueue%23%2F%3Fv%3D1-4&e2e=v%3D2-3%26x3dh%3DMEIw"
INVITATION = (
"pass this invitation link to your contact (via another channel): \n\nhttps://smp4.simplex.im/i#abc\n\n"
"and ask them to connect: /c <invitation_link_above>\n"
)
CONTACT = "contact ID: 2\nreceiving messages via: smp4.simplex.im\nquantum resistant end-to-end encryption\n"
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = pathlib.Path(self.tmp.name)
self.peer = build_script.CliPeer(self.root / "simplex-chat", self.root / "peer/pq_peer", self.root / "peer.log")
def tearDown(self):
self.tmp.cleanup()
def test_one_time_link_is_read_from_the_peers_database(self):
recorder = Recorder(answers={"/c": self.INVITATION})
def fake_run(args, **kwargs):
peer_database(pathlib.Path(args[args.index("-d") + 1]), [b"simplex:/invitation#/?v=old", self.LINK.encode(), None])
return recorder(args, **kwargs)
with patch_all("run", fake_run):
self.assertEqual(self.peer.invitation(), self.LINK)
cli, database = str(self.root / "simplex-chat"), str(self.root / "peer/pq_peer")
self.assertEqual(recorder.commands, [[cli, "-d", database, "--user-display-name", "pq_peer", "-e", "/c", "-t", "5"]])
self.assertEqual(recorder.inputs, [""])
self.assertEqual((self.root / "peer.log").read_text(), f"> /c\n{self.INVITATION}\n")
def test_database_without_a_link_fails(self):
peer_database(self.root / "peer/pq_peer", [None])
with patch_all("run", Recorder(answers={"/c": "error\n"})), self.assertRaises(build_script.BuildError) as raised:
self.peer.invitation()
self.assertIn("no one-time link", str(raised.exception))
def test_missing_database_fails(self):
with patch_all("run", Recorder()), self.assertRaises(build_script.BuildError) as raised:
self.peer.invitation()
self.assertIn("cannot read the peer CLI's database", str(raised.exception))
def test_wait_repeats_the_command_until_its_output_has_the_text(self):
outputs = iter(["no contact citester\n", "contact ID: 2\n", self.CONTACT])
with (
patch_all("run", lambda args, **kwargs: mock.Mock(returncode=0, stdout=next(outputs))),
mock.patch.object(build_script.time, "sleep"),
):
self.assertEqual(self.peer.wait("/i @citester", "quantum resistant", "contact"), self.CONTACT)
self.assertEqual((self.root / "peer.log").read_text().count("> /i @citester\n"), 3)
def test_wait_fails_when_the_text_never_comes(self):
with (
patch_all("run", lambda args, **kwargs: mock.Mock(returncode=0, stdout="no contact citester\n")),
patch_all("PEER_CONNECT_SECONDS", 0),
self.assertRaises(build_script.BuildError) as raised,
):
self.peer.wait("/i @citester", "quantum resistant", "quantum resistant contact")
self.assertIn("no quantum resistant contact", str(raised.exception))
class ConnectAndroidPeerTest(unittest.TestCase):
CHAT = (
("Messages, files and calls are protected by quantum resistant e2e encryption with perfect forward secrecy", ""),
("peer-to-app", ""),
)
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = pathlib.Path(self.tmp.name)
self.out = self.root / "out"
self.out.mkdir()
self.work = self.root / "work"
self.work.mkdir()
self.cli = self.root / "simplex-chat"
self.cli.write_bytes(b"cli")
self.peer_commands = []
def tearDown(self):
self.tmp.cleanup()
def peer(self, infos):
"""Stands in for the peer CLI: the contact appears at its second /i, then each /i answers the next of infos."""
infos = iter(["no contact citester\n", *infos])
def answer(args, **kwargs):
if args[:2] == ["adb", "emu"]:
(pathlib.Path(args[4]) / "Screenshot_1.png").write_bytes(b"png")
return mock.Mock(returncode=0, stdout="")
if args[0] == "adb":
return mock.Mock(returncode=0, stdout="")
command = args[args.index("-e") + 1]
self.peer_commands.append(command)
if command == "/c":
peer_database(pathlib.Path(args[args.index("-d") + 1]), [CliPeerTest.LINK.encode()])
stdout = {"/c": CliPeerTest.INVITATION, "/i @citester": "", "/tail @citester 5": "citester> app-to-peer\n"}.get(command, "")
return mock.Mock(returncode=0, stdout=next(infos) if command == "/i @citester" else stdout)
return answer
def connect(self, infos):
android = FakeAndroid(
[
texts("Connect via one-time link?", "Use current profile", "Use new incognito profile"),
texts("Connection request sent!", "OK"),
texts("pq_peer"),
android_dump(*self.CHAT, ("Message", "")),
android_dump(*self.CHAT, field("Message")),
android_dump(*self.CHAT, field("app-to-p")),
android_dump(*self.CHAT, field("app-to-peer"), ("", "Send Message")),
android_dump(*self.CHAT, ("app-to-peer", ""), ("Message", "")),
],
others=self.peer(infos),
)
starts = []
def fake_run(args, **kwargs):
if [str(a) for a in args[:3]] == ["adb", "shell", "am"]:
starts.append([str(a) for a in args])
return android(args, **kwargs)
with (
patch_all("run", fake_run),
patch_all("host_platform", return_value=build_script.Platform.LINUX),
mock.patch.object(build_script.time, "sleep"),
):
build_script.connect_android_peer(self.cli, "citester", "simplex-aarch64.apk.upgraded", self.out, self.work)
return android, starts
def test_app_opens_the_peers_link_and_they_exchange_messages_with_quantum_resistant_encryption(self):
android, starts = self.connect([CliPeerTest.CONTACT, CliPeerTest.CONTACT])
activity = "chat.simplex.app/.MainActivity"
view = ["adb", "shell", "am", "start", "-W", "-a", "android.intent.action.VIEW", "-d", f"'{CliPeerTest.LINK}'", "-n", activity]
self.assertEqual(starts, [view])
self.assertEqual(android.taps, ["Use current profile", "OK", "pq_peer", "Message", "Send Message"])
self.assertEqual(android.typed, ["app-to-p", "eer"])
self.assertEqual(
self.peer_commands, ["/c", "/i @citester", "/i @citester", "@citester peer-to-app", "/tail @citester 5", "/i @citester"]
)
self.assertEqual((self.out / "simplex-aarch64.apk.upgraded.peer-contact.txt").read_text(), CliPeerTest.CONTACT)
self.assertEqual((self.out / "simplex-aarch64.apk.upgraded.pq.png").read_bytes(), b"png")
self.assertIn("> @citester peer-to-app\n", (self.out / "simplex-aarch64.apk.upgraded.peer.log").read_text())
def test_contact_that_is_not_quantum_resistant_after_the_messages_fails(self):
with self.assertRaises(build_script.BuildError) as raised:
self.connect([CliPeerTest.CONTACT, "contact ID: 2\n"])
self.assertIn("not quantum resistant", str(raised.exception))