Skip to content

One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.

16.8 KB
Raw Blame
import json
import unittest

from core import updates


def release(tag, **extra):
    return dict({"tag_name": tag, "html_url": f"https://github.com/kalkman-code/beamer/releases/tag/{tag}",
                 "draft": False, "prerelease": False}, **extra)


class NewerReleaseTests(unittest.TestCase):
    def test_patch_notification_policy_reads_only_the_machine_readable_mark(self):
        for body, notify in (
            (None, False), ("Small fixes.", False),
            ("Fixes a crash.\n<!-- announce -->", False),
            ("<!-- beamer-notify: important -->", True),
            ("Notes\n  <!-- beamer-notify: important -->  \nMore notes", True),
            ("<!-- beamer-notify: quiet -->", False),
            ("<!-- beamer-notify: typo -->", False),
            ("Text <!-- beamer-notify: important -->", False),
            (123, False),
        ):
            with self.subTest(body=body):
                found = updates.newer_release("1.5.10", release("v1.5.12", body=body))
                self.assertEqual(found[0], "1.5.12")
                self.assertEqual(found.notify, notify)

    def test_new_minor_or_major_alerts_even_when_latest_is_a_quiet_patch(self):
        for current, latest in (("1.4.9", "v1.5.12"), ("1.9.9", "v2.0.1"),
                                ("1.5.12", "v1.6.0")):
            with self.subTest(current=current, latest=latest):
                self.assertTrue(updates.newer_release(current, release(
                    latest, body="<!-- beamer-notify: quiet -->")).notify)

    def test_every_newer_stable_patch_is_offered(self):
        self.assertIsNotNone(updates.newer_release("1.4.0", release("v1.4.1", body="Small fixes.")))
        self.assertIsNotNone(updates.newer_release("1.4.0", release("v1.4.1")))
        self.assertIsNotNone(updates.newer_release("1.4.0", release("v1.4.1", body="Fixes a crash.\n<!-- announce -->")))

    def test_a_quiet_patch_still_offers_the_minor_version_someone_is_behind(self):
        self.assertIsNotNone(updates.newer_release("1.4.2", release("v1.5.1", body="Small fixes.")))
        self.assertIsNotNone(updates.newer_release("1.9.0", release("v2.0.1")))

    def test_a_newer_tag_is_offered_with_its_page(self):
        self.assertEqual(updates.newer_release("1.3.3", release("v1.4.0")),
                         updates.Release("1.4.0", "https://github.com/kalkman-code/beamer/releases/tag/v1.4.0"))

    def test_the_same_or_an_older_tag_is_not(self):
        self.assertIsNone(updates.newer_release("1.4.0", release("v1.4.0")))
        self.assertIsNone(updates.newer_release("1.4.0", release("v1.3.9")))

    def test_versions_compare_as_numbers(self):
        self.assertIsNotNone(updates.newer_release("1.9.0", release("v1.10.0")))
        self.assertIsNotNone(updates.newer_release("1.4", release("v1.4.1")))
        self.assertIsNotNone(updates.newer_release("1.5.9", release("v1.5.10")))
        self.assertIsNone(updates.newer_release("1.5.10", release("v1.5.9")))

    def test_drafts_prereleases_and_odd_tags_never_count(self):
        self.assertIsNone(updates.newer_release("1.3.3", release("v2.0.0", prerelease=True)))
        self.assertIsNone(updates.newer_release("1.3.3", release("v2.0.0", draft=True)))
        self.assertIsNone(updates.newer_release("1.3.3", release("v2.0.0-beta")))
        self.assertIsNone(updates.newer_release("1.3.3", {"message": "rate limited"}))
        self.assertIsNone(updates.newer_release("1.3.3", ["not", "a", "dict"]))

    def test_a_dev_build_is_never_told_to_update(self):
        self.assertIsNone(updates.newer_release("dev", release("v9.0.0")))

    def test_a_page_outside_the_project_is_replaced_by_the_releases_page(self):
        found = updates.newer_release("1.3.3", release("v1.4.0", html_url="https://example.com/beamer.exe"))
        self.assertEqual(found, updates.Release("1.4.0", updates.RELEASES_PAGE))


class BetaTests(unittest.TestCase):
    def test_a_beta_reads_its_own_version(self):
        self.assertIsNotNone(updates.parse_version("1.5.0-beta.1"))
        self.assertIsNone(updates.parse_version("1.5.0-beta"))
        self.assertIsNone(updates.parse_version("1.5.0-rc.1"))

    def test_the_public_release_is_offered_to_a_beta_without_an_announce(self):
        self.assertEqual(updates.newer_release("1.5.0-beta.1", release("v1.5.0"))[0], "1.5.0")
        self.assertEqual(updates.newer_release("1.5.0-beta.1", release("v1.5.1"))[0], "1.5.1")
        self.assertEqual(updates.newer_release("1.5.0-beta.3", release("v1.6.0"))[0], "1.6.0")

    def test_an_older_release_is_not_offered_to_a_beta(self):
        self.assertIsNone(updates.newer_release("1.5.0-beta.1", release("v1.4.3")))
        self.assertIsNone(updates.newer_release("1.5.0-beta.1", release("v1.4.9", body="<!-- announce -->")))

    def test_a_beta_is_never_offered_to_anyone(self):
        self.assertIsNone(updates.newer_release("1.4.3", release("v1.5.0-beta.2")))
        self.assertIsNone(updates.newer_release("1.4.3", release("v1.5.0-beta.2", prerelease=True)))
        self.assertIsNone(updates.newer_release("1.5.0-beta.1", release("v1.5.0-beta.2")))
        self.assertIsNone(updates.newer_release("1.5.0-beta.1", release("v1.5.0-beta.2", prerelease=True)))
        self.assertIsNone(updates.newer_release("1.4.3", release("v1.5.0", prerelease=True)))

    def test_a_beta_checks_for_updates_like_any_install(self):
        results = []
        checker = updates.Checker("1.5.0-beta.1", lambda: True, results.append,
                                  fetcher=lambda: json.dumps(release("v1.5.0")).encode("utf-8"),
                                  logger=updates.logging.getLogger("test-updates"))
        checker.check_once()
        self.assertEqual([r[0] for r in results], ["1.5.0"])


class CheckerTests(unittest.TestCase):
    def test_skipped_quiet_patch_does_not_consume_a_later_important_notice(self):
        results = []
        checker = updates.Checker("1.5.10", lambda: True, results.append,
                                  fetcher=lambda: json.dumps(release("v1.5.11")).encode())
        checker.check_once()
        self.assertEqual(checker.latest[0], "1.5.11")
        self.assertIsNone(updates.visible_notice(results[-1], True, ""))
        checker.fetcher = lambda: json.dumps(release(
            "v1.5.12", body="<!-- beamer-notify: important -->")).encode()
        checker.check_once()
        important = results[-1]
        self.assertEqual(updates.visible_notice(important, True, ""), important)
        checker.check_once()
        self.assertIsNone(updates.visible_notice(results[-1], True, "1.5.12"))

    def test_manual_request_arriving_after_worker_reads_flag_is_not_lost(self):
        import threading
        from unittest.mock import patch

        finished = threading.Event()
        checker = updates.Checker("1.5.11", lambda: False, lambda found: None,
                                  fetcher=lambda: json.dumps(release("v1.5.11")).encode(),
                                  on_check=lambda state, found: finished.set() if state == "current" else None)
        original = checker._manual.is_set
        injected = False

        def read_before_request():
            nonlocal injected
            pending = original()
            if not injected:
                injected = True
                checker.check_now(manual=True)
            return pending

        with patch.object(checker._manual, "is_set", side_effect=read_before_request):
            checker.check_now()
            checker.start()
            try:
                self.assertTrue(finished.wait(2), "an explicit request was lost at the wake boundary")
            finally:
                checker.stop()
                checker._thread.join(2)

    def test_error_payload_is_not_reported_as_up_to_date(self):
        checks = []
        checker = updates.Checker("1.5.11", lambda: True, lambda found: None,
                                  fetcher=lambda: b'{"message":"rate limited"}',
                                  on_check=lambda state, found: checks.append(state))
        checker.check_once(manual=True)
        self.assertEqual(checks, ["checking", "failed"])

    def test_explicit_check_works_with_automatic_checks_off_without_changing_setting(self):
        automatic, checks = [], []
        checker = updates.Checker("1.5.9", lambda: False, automatic.append,
                                  fetcher=lambda: json.dumps(release("v1.5.11")).encode(),
                                  on_check=lambda state, found: checks.append((state, found)))
        checker.check_once(manual=True)
        self.assertEqual(automatic, [])
        self.assertEqual(checks, [("checking", None), ("available", checker.latest)])
        self.assertEqual(checker.latest[0], "1.5.11")
        self.assertFalse(checker.enabled())

    def test_explicit_check_reports_current_and_failure_without_discarding_cached_update(self):
        checks = []
        checker = updates.Checker("1.5.11", lambda: True, lambda found: None,
                                  fetcher=lambda: json.dumps(release("v1.5.11")).encode(),
                                  on_check=lambda state, found: checks.append((state, found)))
        checker.check_once(manual=True)
        self.assertEqual(checks[-1], ("current", None))
        checker.latest = ("1.5.12", updates.RELEASES_PAGE)
        checker.fetcher = lambda: (_ for _ in ()).throw(OSError("offline"))
        checker.check_once(manual=True)
        self.assertEqual(checks[-1], ("failed", None))
        self.assertEqual(checker.latest[0], "1.5.12")

    def test_explicit_request_wakes_the_worker_and_finishes(self):
        import threading
        finished = threading.Event()
        checks = []
        def checked(state, found):
            checks.append(state)
            if state == "current":
                finished.set()
        checker = updates.Checker("1.5.11", lambda: False, lambda found: None,
                                  fetcher=lambda: json.dumps(release("v1.5.11")).encode(),
                                  on_check=checked)
        checker.start()
        try:
            checker.check_now(manual=True)
            self.assertTrue(finished.wait(2))
            self.assertEqual(checks, ["checking", "current"])
        finally:
            checker.stop()
            checker._thread.join(2)

    def test_switching_off_during_a_request_discards_its_answer(self):
        enabled = True
        results = []

        def fetcher():
            nonlocal enabled
            enabled = False
            return json.dumps(release("v1.6.0")).encode()

        checker = updates.Checker("1.5.9", lambda: enabled, results.append, fetcher=fetcher)
        checker.check_once()
        self.assertEqual(results, [])
        self.assertIsNone(checker.latest)

    def make(self, payload=None, enabled=True, error=None):
        results = []

        def fetcher():
            if error:
                raise error
            return json.dumps(payload).encode("utf-8")

        checker = updates.Checker("1.3.3", lambda: enabled, results.append, fetcher=fetcher,
                                  logger=updates.logging.getLogger("test-updates"))
        return checker, results

    def test_reports_a_newer_release(self):
        checker, results = self.make(release("v1.4.0"))
        checker.check_once()
        self.assertEqual(results, [updates.Release("1.4.0", "https://github.com/kalkman-code/beamer/releases/tag/v1.4.0")])

    def test_reports_none_when_current(self):
        checker, results = self.make(release("v1.3.3"))
        checker.check_once()
        self.assertEqual(results, [None])

    def test_switched_off_it_asks_nothing(self):
        checker, results = self.make(error=AssertionError("fetched while switched off"), enabled=False)
        checker.check_once()
        self.assertEqual(results, [])

    def test_a_failed_check_keeps_the_last_answer(self):
        checker, results = self.make(release("v1.4.0"))
        checker.check_once()
        checker.fetcher = lambda: (_ for _ in ()).throw(OSError("offline"))
        checker.check_once()
        self.assertEqual(checker.latest[0], "1.4.0")
        self.assertEqual(len(results), 1)


class NoticeTests(unittest.TestCase):
    def test_a_quiet_patch_never_becomes_a_notice_even_after_an_explicit_check(self):
        found = updates.newer_release("1.5.10", release("v1.5.12"))
        self.assertIsNone(updates.visible_notice(found, True, ""))
        self.assertIsNone(updates.visible_notice(found, False, "", requested=True))

    def test_explicit_request_resurfaces_a_dismissed_release_with_automatic_checks_off(self):
        found = updates.Release("1.5.11", updates.RELEASES_PAGE)
        self.assertEqual(updates.visible_notice(found, False, "1.5.11", requested=True), found)
        self.assertIsNone(updates.visible_notice(found, False, "1.5.11"))
        self.assertIsNone(updates.visible_notice(found, True, "1.5.11"))

    def test_dismissal_survives_a_new_check_but_not_a_newer_version(self):
        found = updates.Release("1.5.10", "https://github.com/kalkman-code/beamer/releases/tag/v1.5.10")
        self.assertEqual(updates.visible_notice(found, True, ""), found)
        self.assertIsNone(updates.visible_notice(found, True, "1.5.10"))
        newer = updates.Release("1.5.11", updates.RELEASES_PAGE)
        self.assertEqual(updates.visible_notice(newer, True, "1.5.10"), newer)

    def test_off_setting_hides_a_cached_result_and_none_stays_hidden(self):
        self.assertIsNone(updates.visible_notice(updates.Release("1.6.0", updates.RELEASES_PAGE), False, ""))
        self.assertIsNone(updates.visible_notice(None, True, ""))


class PortableCheckerTests(unittest.TestCase):
    NAME = "Beamer-Portable-1.5.10-windows-x64.zip"
    URL = "https://github.com/kalkman-code/beamer/releases/download/v1.5.10/" + NAME

    def make(self, assets, portable=True):
        payload = release("v1.5.10", assets=assets)
        results = []
        checker = updates.Checker("1.5.9", lambda: True, results.append,
                                  fetcher=lambda: json.dumps(payload).encode(), portable=portable)
        checker.check_once()
        return checker, results

    def test_portable_download_keeps_the_release_page_for_whats_new(self):
        checker, results = self.make([{"name": self.NAME, "browser_download_url": self.URL}])
        page = "https://github.com/kalkman-code/beamer/releases/tag/v1.5.10"
        self.assertEqual(checker.download_url, self.URL)
        self.assertEqual(checker.latest, updates.Release("1.5.10", page, False))
        self.assertEqual(results, [checker.latest])

    def test_missing_portable_zip_never_offers_the_installer(self):
        for assets in (None, [], {}, [None, "asset"],
                       [{"name": "Beamer-Setup-1.5.10.exe", "browser_download_url": self.URL}]):
            with self.subTest(assets=assets):
                checker, results = self.make(assets)
                self.assertEqual(checker.latest[0], "1.5.10")
                self.assertIsNone(checker.download_url)
                self.assertEqual(results, [checker.latest])

    def test_untrusted_or_wrong_release_assets_are_rejected(self):
        for url in (self.URL.replace("github.com", "github.com.evil.invalid"),
                    self.URL.replace("https:", "http:"),
                    self.URL.replace("/beamer/", "/another-project/"),
                    self.URL.replace("/v1.5.10/", "/v1.5.9/"),
                    self.URL + "?source=untrusted", self.URL + "#fragment",
                    self.URL.replace(self.NAME, "Beamer-Setup-1.5.10.exe"),
                    "https://evil.invalid/" + self.NAME):
            with self.subTest(url=url):
                checker, _ = self.make([{"name": self.NAME, "browser_download_url": url}])
                self.assertIsNone(checker.download_url)

    def test_installed_checker_keeps_its_existing_release_page_behaviour(self):
        checker, results = self.make([{"name": self.NAME, "browser_download_url": self.URL}],
                                     portable=False)
        self.assertIsNone(checker.download_url)
        self.assertEqual(results, [checker.latest])

    def test_new_answer_clears_an_asset_from_the_previous_answer(self):
        checker, _ = self.make([{"name": self.NAME, "browser_download_url": self.URL}])
        checker.fetcher = lambda: json.dumps(release("v1.5.11", assets=[])).encode()
        checker.check_once()
        self.assertEqual(checker.latest[0], "1.5.11")
        self.assertIsNone(checker.download_url)
        checker.fetcher = lambda: json.dumps(release("v1.5.9")).encode()
        checker.check_once()
        self.assertIsNone(checker.latest)
        self.assertIsNone(checker.download_url)

    def test_failed_request_keeps_matching_cached_page_and_asset(self):
        checker, _ = self.make([{"name": self.NAME, "browser_download_url": self.URL}])
        previous = checker.latest
        checker.fetcher = lambda: (_ for _ in ()).throw(OSError("synthetic offline"))
        checker.check_once()
        self.assertEqual(checker.latest, previous)
        self.assertEqual(checker.download_url, self.URL)


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