Skip to content

CLI for SidePulse

Python
27.6 KB
Raw Blame
from __future__ import annotations

import io
import json
import os
import sys
import tempfile
import unittest
import urllib.error
from pathlib import Path
from unittest.mock import MagicMock, patch


ROOT = Path(__file__).resolve().parents[1]
SRC = ROOT / "src"
if str(SRC) not in sys.path:
    sys.path.insert(0, str(SRC))

from sidepulse.cli import sidepulse_main  # noqa: E402
from sidepulse.links import (  # noqa: E402
    IOSLink,
    LinkError,
    iter_sse_messages,
    load_ios_links,
    new_pairing_channel,
    normalize_apns_token,
    pairing_url,
    parse_ios_registration,
    render_terminal_qr,
    remove_ios_link,
    save_ios_links,
    send_ios_program,
    store_ios_link,
)


TOKEN_A = "a" * 64
TOKEN_B = "b" * 64
DEV_TOKEN_A = "dev_" + TOKEN_A


class LinkStorageTests(unittest.TestCase):
    def test_token_is_normalized_and_validated(self) -> None:
        self.assertEqual(normalize_apns_token("AA " * 32), TOKEN_A)
        self.assertEqual(normalize_apns_token(" DEV_" + "AA " * 32), DEV_TOKEN_A)
        for invalid in (
            "",
            "a" * 63,
            "g" * 64,
            "dev_",
            "dev_" + "a" * 63,
            "dev_dev_" + TOKEN_A,
            "test_" + TOKEN_A,
            "dev_" + "g" * 64,
            "dev_" + "a" * 65,
        ):
            with self.subTest(invalid=invalid):
                with self.assertRaises(LinkError):
                    normalize_apns_token(invalid)

    def test_shared_key_case_is_preserved_through_pairing_and_storage(self) -> None:
        for prefix in ("", "dev_"):
            token = prefix + TOKEN_A + "_CaseSensitive_key-1234"
            self.assertEqual(normalize_apns_token(prefix.upper() + TOKEN_A.upper() + "_CaseSensitive_key-1234"), token)
            response = json.dumps({"v": 1, "type": "ios_registration", "device": {
                "name": "iPhone", "bundle_id": "io.sidepulse.ios", "push_token": token,
            }})
            link = parse_ios_registration(response, server="https://bridge.sidepulse.io")
            self.assertEqual(link.token, token)
            with tempfile.TemporaryDirectory() as temporary:
                path = Path(temporary) / "links.json"
                save_ios_links((link,), path)
                self.assertEqual(load_ios_links(path), (link,))

    def test_pairing_with_a_new_key_replaces_the_same_device_link(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            path = Path(temporary) / "links.json"
            store_ios_link(IOSLink("iPhone", TOKEN_A), path)
            store_ios_link(IOSLink("iPhone", TOKEN_A + "_old-key"), path)
            latest = IOSLink("iPhone", TOKEN_A + "_new-key")
            self.assertEqual(store_ios_link(latest, path), (latest,))
            self.assertEqual(load_ios_links(path), (latest,))

    def test_malformed_shared_key_suffix_is_rejected(self) -> None:
        for suffix in ("", "a" * 129, "bad/key", "bad.key", "bad key", "é"):
            with self.subTest(suffix=suffix), self.assertRaises(LinkError):
                normalize_apns_token(TOKEN_A + "_" + suffix)

    def test_development_registration_response_keeps_prefix(self) -> None:
        response = json.dumps(
            {
                "v": 1,
                "type": "ios_registration",
                "device": {
                    "name": "Peter's iPhone",
                    "platform": "ios",
                    "bundle_id": "io.sidepulse.ios",
                    "push_token": DEV_TOKEN_A.upper(),
                },
            }
        )
        link = parse_ios_registration(response, server="https://bridge.sidepulse.io")
        self.assertEqual(link.token, DEV_TOKEN_A)

    def test_links_round_trip_with_private_permissions(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            path = Path(temporary) / "links.json"
            link = IOSLink("Peter's iPhone", TOKEN_A, linked_at="now")
            save_ios_links((link,), path)
            self.assertEqual(load_ios_links(path), (link,))
            self.assertEqual(path.stat().st_mode & 0o777, 0o600)

    def test_links_round_trip_development_and_legacy_production_tokens(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            path = Path(temporary) / "links.json"
            # Version 1 files created before development tokens contain plain hex.
            path.write_text(
                json.dumps({"version": 1, "ios": [{"name": "Old iPhone", "token": TOKEN_A}]}),
                encoding="utf-8",
            )
            old_link = load_ios_links(path)[0]
            dev_link = IOSLink("Development iPhone", DEV_TOKEN_A)

            stored = store_ios_link(dev_link, path)

            self.assertEqual(stored, (old_link, dev_link))
            self.assertEqual(load_ios_links(path), (old_link, dev_link))
            payload = json.loads(path.read_text(encoding="utf-8"))
            self.assertEqual([item["token"] for item in payload["ios"]], [TOKEN_A, DEV_TOKEN_A])

    def test_production_and_development_tokens_are_distinct_destinations(self) -> None:
        production = IOSLink("iPhone", TOKEN_A)
        development = IOSLink("iPhone", DEV_TOKEN_A)
        self.assertNotEqual(production.link_id, development.link_id)

        with tempfile.TemporaryDirectory() as temporary:
            path = Path(temporary) / "links.json"
            self.assertEqual(store_ios_link(production, path), (production,))
            self.assertEqual(store_ios_link(development, path), (production, development))
            self.assertEqual(remove_ios_link(DEV_TOKEN_A, path), development)
            self.assertEqual(load_ios_links(path), (production,))

    def test_relinking_a_token_updates_instead_of_duplicating(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            path = Path(temporary) / "links.json"
            store_ios_link(IOSLink("Old name", TOKEN_A), path)
            stored = store_ios_link(IOSLink("New name", TOKEN_A), path)
            self.assertEqual(len(stored), 1)
            self.assertEqual(stored[0].name, "New name")

    def test_remove_ios_link_removes_only_matching_phone(self) -> None:
        with tempfile.TemporaryDirectory() as temp_dir:
            path = Path(temp_dir) / "links.json"
            first = IOSLink("Phone A", TOKEN_A)
            second = IOSLink("Phone B", TOKEN_B)
            save_ios_links((first, second), path)

            removed = remove_ios_link(TOKEN_A, path)

            self.assertEqual(removed, first)
            self.assertEqual(load_ios_links(path), (second,))

    def test_pairing_channel_is_an_eleven_character_base64url_secret(self) -> None:
        channels = {new_pairing_channel() for _ in range(100)}
        self.assertEqual(len(channels), 100)
        self.assertTrue(all(len(channel) == 11 for channel in channels))
        alphabet = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")
        self.assertTrue(all(set(channel) <= alphabet for channel in channels))

    def test_default_pairing_url_contains_only_the_compact_channel(self) -> None:
        channel = "7kP2_xQ9mLs"
        url = pairing_url("https://bridge.sidepulse.io/", channel, "Studio Mac")
        self.assertEqual(url, "sidepulse://p/7kP2_xQ9mLs")

    def test_custom_server_pairing_url_keeps_connection_details(self) -> None:
        url = pairing_url("https://bridge.example.com", "7kP2_xQ9mLs", "Studio Mac")
        self.assertIn("sidepulse://pair?", url)
        self.assertIn("server=https%3A%2F%2Fbridge.example.com", url)
        self.assertIn("channel=7kP2_xQ9mLs", url)
        self.assertIn("sender=Studio+Mac", url)

    def test_pairing_qr_renders_without_printing_the_raw_link(self) -> None:
        url = pairing_url(
            "https://bridge.sidepulse.io",
            "7kP2_xQ9mLs",
            "Studio Mac",
        )
        rendered = render_terminal_qr(url)
        lines = rendered.splitlines()
        self.assertIn("██", rendered)
        self.assertLessEqual(len(lines), 40)
        self.assertLessEqual(max(map(len, lines)), 80)
        self.assertNotIn("sidepulse://", rendered)

    def test_pairing_qr_uses_solid_backgrounds_in_ansi_terminals(self) -> None:
        rendered = render_terminal_qr("sidepulse://p/7kP2_xQ9mLs", ansi=True)
        self.assertIn("\033[107m", rendered)
        self.assertIn("\033[40m", rendered)
        self.assertTrue(all(line.endswith("\033[0m") for line in rendered.splitlines()))

    def test_sse_parser_returns_complete_data_events(self) -> None:
        response = iter(
            [
                b": keepalive\n",
                b"data: first\n",
                b"data: second\n",
                b"\n",
            ]
        )
        self.assertEqual(list(iter_sse_messages(response)), ["first\nsecond"])

    def test_registration_response_becomes_a_link(self) -> None:
        response = json.dumps(
            {
                "v": 1,
                "type": "ios_registration",
                "device": {
                    "name": "Peter's iPhone",
                    "platform": "ios",
                    "bundle_id": "io.sidepulse.ios",
                    "push_token": TOKEN_B.upper(),
                },
            }
        )
        link = parse_ios_registration(response, server="https://bridge.sidepulse.io")
        self.assertEqual(link.name, "Peter's iPhone")
        self.assertEqual(link.token, TOKEN_B)


class UnlinkCLITests(unittest.TestCase):
    def test_unlink_lists_and_removes_only_exact_id_when_names_match(self) -> None:
        production = IOSLink("iPhone", TOKEN_A)
        development = IOSLink("iPhone", DEV_TOKEN_A)
        with tempfile.TemporaryDirectory() as temporary:
            path = Path(temporary) / "links.json"
            save_ios_links((production, development), path)
            with patch("sidepulse.links.default_links_path", return_value=path):
                stdout = io.StringIO()
                with patch("sys.stdout", stdout):
                    self.assertEqual(sidepulse_main(["unlink"]), 0)
                self.assertIn(production.link_id, stdout.getvalue())
                self.assertIn(development.link_id, stdout.getvalue())

                stderr = io.StringIO()
                with patch("sys.stderr", stderr):
                    self.assertEqual(sidepulse_main(["unlink", "iPhone"]), 1)
                self.assertEqual(load_ios_links(path), (production, development))

                stdout = io.StringIO()
                with patch("sys.stdout", stdout):
                    self.assertEqual(sidepulse_main(["unlink", development.link_id]), 0)
                self.assertIn(development.link_id, stdout.getvalue())
                self.assertEqual(load_ios_links(path), (production,))

    def test_unlink_refuses_colliding_displayed_ids(self) -> None:
        first = IOSLink("iPhone", DEV_TOKEN_A)
        second = IOSLink("iPhone", "dev_" + "a" * 8 + "b" * 56)
        self.assertEqual(first.link_id, second.link_id)
        with tempfile.TemporaryDirectory() as temporary:
            path = Path(temporary) / "links.json"
            save_ios_links((first, second), path)
            stderr = io.StringIO()
            with (
                patch("sidepulse.links.default_links_path", return_value=path),
                patch("sys.stderr", stderr),
            ):
                self.assertEqual(sidepulse_main(["unlink", first.link_id]), 1)
            self.assertIn("matches multiple links", stderr.getvalue())
            self.assertEqual(load_ios_links(path), (first, second))


class WriteFallbackTests(unittest.TestCase):
    def test_write_requires_selection_when_multiple_linked_phones_exist(self) -> None:
        links = (IOSLink("Phone A", TOKEN_A), IOSLink("Phone B", TOKEN_B))
        stderr = io.StringIO()
        with (
            patch("sidepulse.cli.discover_devices", return_value=[]),
            patch("sidepulse.cli.load_ios_links", return_value=links),
            patch("sidepulse.cli.send_ios_program") as send,
            patch("sys.stderr", stderr),
        ):
            result = sidepulse_main(["write", r"off\nrepeat"])

        self.assertEqual(result, 2)
        send.assert_not_called()
        self.assertIn("--to", stderr.getvalue())
        self.assertIn("--all", stderr.getvalue())

    def test_write_all_uses_all_linked_phones(self) -> None:
        links = (IOSLink("Phone A", TOKEN_A), IOSLink("Phone B", TOKEN_B))
        sent: list[tuple[IOSLink, str | None, dict[str, object]]] = []

        def send(link: IOSLink, program: str | None, **kwargs) -> str:
            sent.append((link, program, kwargs))
            return "OK"

        with (
            patch("sidepulse.cli.discover_devices", return_value=[]),
            patch("sidepulse.cli.load_ios_links", return_value=links),
            patch("sidepulse.cli._remote_event_data", return_value={"source": {"name": "Mac"}}),
            patch("sidepulse.cli.send_ios_program", side_effect=send),
        ):
            result = sidepulse_main(["write", r"off\nrepeat", "--all"])

        self.assertEqual(result, 0)
        self.assertEqual([item[0].name for item in sent], ["Phone A", "Phone B"])
        self.assertTrue(all(item[1] == "off\nrepeat" for item in sent))
        self.assertEqual(len({item[2]["event_id"] for item in sent}), 1)

    def test_write_does_not_contact_phone_when_local_device_exists(self) -> None:
        stdout = io.StringIO()
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary) / "SidePulseDot"
            root.mkdir()
            candidate = type("Candidate", (), {"root": root, "target": root / "LEDS.LED"})()
            with (
                patch("sidepulse.cli.discover_devices", return_value=[candidate]),
                patch("sidepulse.cli.send_ios_program") as send,
                patch("sys.stdout", stdout),
            ):
                result = sidepulse_main(["write", "off", "--device", str(root)])
            self.assertEqual(result, 0)
            send.assert_not_called()
            self.assertEqual((root / "LEDS.LED").read_text(), "off")

    def test_write_prefers_discovered_local_device_over_phone(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary) / "SidePulseDot"
            root.mkdir()
            candidate = type("Candidate", (), {"root": root, "target": root / "LEDS.LED"})()
            with (
                patch("sidepulse.cli.discover_devices", return_value=[candidate]),
                patch("sidepulse.cli.load_ios_links", return_value=(IOSLink("Phone", TOKEN_A),)),
                patch("sidepulse.cli.send_ios_program") as send,
            ):
                result = sidepulse_main(["write", r"off\nrepeat"])

            self.assertEqual(result, 0)
            send.assert_not_called()
            self.assertEqual((root / "LEDS.LED").read_text(), "off\nrepeat")

    def test_missing_local_and_linked_devices_points_to_link_command(self) -> None:
        stderr = io.StringIO()
        with (
            patch("sidepulse.cli.discover_devices", return_value=[]),
            patch("sidepulse.cli.load_ios_links", return_value=()),
            patch("sys.stderr", stderr),
        ):
            result = sidepulse_main(["write", "off"])
        self.assertEqual(result, 2)
        self.assertIn("sidepulse link", stderr.getvalue())

    def test_notification_prefers_phone_over_local_device(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary) / "SidePulseDot"
            root.mkdir()
            candidate = type("Candidate", (), {"root": root, "target": root / "LEDS.LED"})()
            phone = IOSLink("Peter's iPhone", TOKEN_A)
            with (
                patch("sidepulse.cli.discover_devices", return_value=[candidate]),
                patch("sidepulse.cli.load_ios_links", return_value=(phone,)),
                patch("sidepulse.cli._remote_event_data", return_value={}),
                patch("sidepulse.cli.send_ios_program", return_value="OK") as send,
            ):
                result = sidepulse_main(
                    ["write", "off", "--title", "Build complete", "--message", "All tests passed"]
                )

            self.assertEqual(result, 0)
            self.assertFalse((root / "LEDS.LED").exists())
            send.assert_called_once()
            self.assertEqual(send.call_args.args, (phone, "off"))
            self.assertEqual(send.call_args.kwargs["title"], "Build complete")
            self.assertEqual(send.call_args.kwargs["message"], "All tests passed")

    def test_write_selects_phone_by_short_id(self) -> None:
        phones = (IOSLink("Phone A", TOKEN_A), IOSLink("Phone B", TOKEN_B))
        with (
            patch("sidepulse.cli.discover_devices", return_value=[]),
            patch("sidepulse.cli.load_ios_links", return_value=phones),
            patch("sidepulse.cli._remote_event_data", return_value={}),
            patch("sidepulse.cli.send_ios_program", return_value="OK") as send,
        ):
            result = sidepulse_main(["write", "off", "--to", "bbbb"])

        self.assertEqual(result, 0)
        self.assertEqual(send.call_args.args[:2], (phones[1], "off"))

    def test_write_selects_production_and_development_destinations_separately(self) -> None:
        phones = (IOSLink("iPhone", TOKEN_A), IOSLink("iPhone", DEV_TOKEN_A))
        for phone in phones:
            with self.subTest(link_id=phone.link_id):
                with (
                    patch("sidepulse.cli.discover_devices", return_value=[]),
                    patch("sidepulse.cli.load_ios_links", return_value=phones),
                    patch("sidepulse.cli._remote_event_data", return_value={}),
                    patch("sidepulse.cli.send_ios_program", return_value="OK") as send,
                ):
                    result = sidepulse_main(["write", "off", "--to", phone.link_id])
                self.assertEqual(result, 0)
                self.assertEqual(send.call_args.args[0], phone)

    def test_notification_cannot_target_local_device(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary) / "SidePulseDot"
            root.mkdir()
            candidate = type("Candidate", (), {"root": root, "target": root / "LEDS.LED"})()
            stderr = io.StringIO()
            with (
                patch("sidepulse.cli.discover_devices", return_value=[candidate]),
                patch("sidepulse.cli.load_ios_links", return_value=()),
                patch("sys.stderr", stderr),
            ):
                result = sidepulse_main(["write", "off", "--message", "Hello", "--to", "local"])

        self.assertEqual(result, 2)
        self.assertIn("cannot display notifications", stderr.getvalue())

    def test_push_uses_same_payload_options_and_prefers_phone(self) -> None:
        phone = IOSLink("Peter's iPhone", TOKEN_A)
        local = type(
            "Candidate",
            (),
            {"root": Path("/Volumes/SidePulseDot"), "target": Path("/Volumes/SidePulseDot/LEDS.LED")},
        )()
        with (
            patch("sidepulse.cli.discover_devices", return_value=[local]),
            patch("sidepulse.cli.load_ios_links", return_value=(phone,)),
            patch("sidepulse.cli._remote_event_data", return_value={}),
            patch("sidepulse.cli.send_ios_program", return_value="OK") as send,
        ):
            result = sidepulse_main(
                [
                    "push",
                    r"off\n#ff0000 pulse",
                    "--title",
                    "Agent needs input",
                    "--message",
                    "Choose a deployment region",
                ]
            )

        self.assertEqual(result, 0)
        self.assertEqual(send.call_args.args, (phone, "off\n#ff0000 pulse"))
        self.assertEqual(send.call_args.kwargs["title"], "Agent needs input")
        self.assertEqual(send.call_args.kwargs["message"], "Choose a deployment region")

    def test_led_only_push_sends_update_notification(self) -> None:
        phone = IOSLink("Phone", TOKEN_A)
        response = MagicMock()
        response.__enter__.return_value.read.return_value = b"OK"
        with (
            patch("sidepulse.cli.discover_devices", return_value=[]),
            patch("sidepulse.cli.load_ios_links", return_value=(phone,)),
            patch("sidepulse.cli._remote_event_data", return_value={}),
            patch("sidepulse.links.urllib.request.urlopen", return_value=response) as open_url,
        ):
            result = sidepulse_main(["push", r"off\n#ff0000 pulse"])

        self.assertEqual(result, 0)
        payload = json.loads(open_url.call_args.args[0].data)
        self.assertEqual(payload["leds"], "off\n#ff0000 pulse")
        self.assertEqual(payload["title"], "Update")
        self.assertEqual(payload["aps"]["alert"], {"title": "Update"})
        self.assertNotIn("body", payload)

    def test_led_only_push_can_fall_back_to_local_device(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary) / "SidePulseDot"
            root.mkdir()
            candidate = type("Candidate", (), {"root": root, "target": root / "LEDS.LED"})()
            with (
                patch("sidepulse.cli.discover_devices", return_value=[candidate]),
                patch("sidepulse.cli.load_ios_links", return_value=()),
                patch("sidepulse.cli.send_ios_program") as send,
            ):
                result = sidepulse_main(["push", "off"])

            self.assertEqual(result, 0)
            self.assertEqual((root / "LEDS.LED").read_text(), "off")
            send.assert_not_called()

    def test_write_all_sends_leds_locally_and_combined_payload_to_phone(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary) / "SidePulseDot"
            root.mkdir()
            candidate = type("Candidate", (), {"root": root, "target": root / "LEDS.LED"})()
            phone = IOSLink("Phone", TOKEN_A)
            with (
                patch("sidepulse.cli.discover_devices", return_value=[candidate]),
                patch("sidepulse.cli.load_ios_links", return_value=(phone,)),
                patch("sidepulse.cli._remote_event_data", return_value={}),
                patch("sidepulse.cli.send_ios_program", return_value="OK") as send,
            ):
                result = sidepulse_main(
                    ["write", "off", "--title", "Done", "--message", "Tests passed", "--all"]
                )

            self.assertEqual(result, 0)
            self.assertEqual((root / "LEDS.LED").read_text(), "off")
            self.assertEqual(send.call_args.args, (phone, "off"))
            self.assertEqual(send.call_args.kwargs["title"], "Done")

    def test_notification_only_write_is_supported(self) -> None:
        phone = IOSLink("Phone", TOKEN_A)
        with (
            patch("sidepulse.cli.discover_devices", return_value=[]),
            patch("sidepulse.cli.load_ios_links", return_value=(phone,)),
            patch("sidepulse.cli._remote_event_data", return_value={}),
            patch("sidepulse.cli.send_ios_program", return_value="OK") as send,
        ):
            result = sidepulse_main(["write", "--title", "Done", "--message", "Tests passed"])

        self.assertEqual(result, 0)
        self.assertEqual(send.call_args.args, (phone, None))

    def test_write_requires_content(self) -> None:
        stderr = io.StringIO()
        with patch("sys.stderr", stderr):
            result = sidepulse_main(["write"])

        self.assertEqual(result, 2)
        self.assertIn("Provide an LED program", stderr.getvalue())

    def test_write_reads_led_program_from_explicit_stdin(self) -> None:
        phone = IOSLink("Peter's iPhone", TOKEN_A)
        with (
            patch("sidepulse.cli.discover_devices", return_value=[]),
            patch("sidepulse.cli.load_ios_links", return_value=(phone,)),
            patch("sidepulse.cli._remote_event_data", return_value={}),
            patch("sidepulse.cli.send_ios_program", return_value="OK") as send,
            patch("sys.stdin", io.StringIO(r"off\nrepeat")),
        ):
            result = sidepulse_main(["write", "-"])

        self.assertEqual(result, 0)
        self.assertEqual(send.call_args.args, (phone, "off\nrepeat"))


class IOSPayloadTests(unittest.TestCase):
    def test_notification_payload_contains_visible_alert_leds_and_metadata(self) -> None:
        response = MagicMock()
        response.__enter__.return_value.read.return_value = b"OK"
        with patch("sidepulse.links.urllib.request.urlopen", return_value=response) as open_url:
            result = send_ios_program(
                IOSLink("Phone", TOKEN_A),
                "off",
                event_id="event-1",
                title="Build complete",
                message="All tests passed",
                data={"source": {"name": "Studio Mac"}},
            )

        self.assertEqual(result, "OK")
        request = open_url.call_args.args[0]
        payload = json.loads(request.data)
        self.assertEqual(payload["leds"], "off")
        self.assertEqual(payload["title"], "Build complete")
        self.assertEqual(payload["body"], "All tests passed")
        self.assertEqual(
            payload["aps"],
            {
                "content-available": 1,
                "alert": {"title": "Build complete", "body": "All tests passed"},
            },
        )
        self.assertEqual(payload["data"]["sidepulse_event_id"], "event-1")
        self.assertEqual(payload["data"]["source"]["name"], "Studio Mac")

    def test_led_only_payload_stays_silent(self) -> None:
        response = MagicMock()
        response.__enter__.return_value.read.return_value = b"OK"
        with patch("sidepulse.links.urllib.request.urlopen", return_value=response) as open_url:
            send_ios_program(IOSLink("Phone", TOKEN_A), "off", event_id="event-1")

        payload = json.loads(open_url.call_args.args[0].data)
        self.assertEqual(payload["aps"], {"content-available": 1})
        self.assertNotIn("title", payload)
        self.assertNotIn("body", payload)

    def test_outgoing_url_preserves_production_and_development_routing(self) -> None:
        response = MagicMock()
        response.__enter__.return_value.read.return_value = b"OK"
        for token, expected_url in (
            (TOKEN_A, f"https://bridge.sidepulse.io/api/leds/apns_{TOKEN_A}"),
            (DEV_TOKEN_A, f"https://bridge.sidepulse.io/api/leds/apns_dev_{TOKEN_A}"),
            (TOKEN_A + "_CaseSensitive_key", f"https://bridge.sidepulse.io/api/leds/apns_{TOKEN_A}_CaseSensitive_key"),
            (DEV_TOKEN_A + "_CaseSensitive_key", f"https://bridge.sidepulse.io/api/leds/apns_dev_{TOKEN_A}_CaseSensitive_key"),
        ):
            with self.subTest(token_prefix=token[:4]), patch(
                "sidepulse.links.urllib.request.urlopen", return_value=response
            ) as open_url:
                send_ios_program(IOSLink("Phone", token), "off")
                self.assertEqual(open_url.call_args.args[0].full_url, expected_url)

    def test_apns_rejection_produces_failed_cli_result(self) -> None:
        phone = IOSLink("Development iPhone", DEV_TOKEN_A)
        stderr = io.StringIO()
        apns_error = urllib.error.HTTPError(
            "https://bridge.sidepulse.io/api/leds/apns_dev_" + TOKEN_A,
            410,
            "Gone",
            {},
            io.BytesIO(b"APNs rejected token"),
        )
        with (
            patch("sidepulse.cli.discover_devices", return_value=[]),
            patch("sidepulse.cli.load_ios_links", return_value=(phone,)),
            patch("sidepulse.cli._remote_event_data", return_value={}),
            patch("sidepulse.links.urllib.request.urlopen", side_effect=apns_error),
            patch("sys.stderr", stderr),
        ):
            result = sidepulse_main(["write", "off", "--to", phone.link_id])

        self.assertEqual(result, 1)
        self.assertIn("APNs rejected token", stderr.getvalue())


if __name__ == "__main__":
    unittest.main()