pyappify 1.0.5__tar.gz → 1.0.7__tar.gz

{pyappify-1.0.5 → pyappify-1.0.7}/PKG-INFO

@@ -1,12 +1,12 @@
-Metadata-Version: 2.4
-Name: pyappify
-Version: 1.0.5
-Summary: My awesome Python application
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: build; extra == "dev"
+Metadata-Version: 2.4
+Name: pyappify
+Version: 1.0.7
+Summary: My awesome Python application
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: build; extra == "dev"

{pyappify-1.0.5 → pyappify-1.0.7}/pyappify/__init__.py

@@ -10,13 +10,36 @@ import urllib.request
 import zipfile
 import threading
 import time
+import tempfile
+import uuid
+import sys
+from pathlib import Path
+
+from .app_config import (
+    UPDATE_METHOD_AUTO,
+    UPDATE_METHOD_AUTO_PRE_RELEASE,
+    UPDATE_METHOD_MANUAL,
+    add_app_config_listener,
+    configure_app_json,
+    get_app_config,
+    get_app_json_path,
+    get_auto_start,
+    get_update_method,
+    remove_app_config_listener,
+    set_auto_start,
+    set_update_method,
+    start_app_config_watcher,
+    stop_app_config_watcher,
+    update_app_config,
+)
 
 app_version = os.environ.get("PYAPPIFY_APP_VERSION")
 app_starting_version = os.environ.get("PYAPPIFY_APP_STARTING_VERSION") or app_version
 update_note = os.environ.get("PYAPPIFY_UPDATE_NOTE")
 app_profile = os.environ.get("PYAPPIFY_APP_PROFILE")
+app_locale = os.environ.get("PYAPPIFY_LOCALE") or "en"
 pyappify_version = os.environ.get("PYAPPIFY_VERSION")
-pyappify_executable = os.environ.get("PYAPPIFY_EXECUTABLE")
+app_json_path = configure_app_json(os.environ.get("PYAPPIFY_APP_JSON_PATH"))
 
 pyappify_upgradeable = os.environ.get("PYAPPIFY_UPGRADEABLE") == '1'
 logger = None
@@ -27,14 +50,41 @@ try:
 except (ValueError, TypeError):
     pid = None
 
-import sys
-
 try:
     import ctypes
 except ImportError:
     ctypes = None
 
 
+def find_pyappify_executable(start_dir=None, environ=None):
+    """Find the launcher configured by PyAppify or in a parent directory."""
+    environ = os.environ if environ is None else environ
+    configured = environ.get("PYAPPIFY_EXECUTABLE")
+    if configured:
+        configured_path = Path(configured).expanduser()
+        if configured_path.is_file():
+            return str(configured_path.resolve())
+
+    current = Path(start_dir or os.getcwd()).expanduser()
+    if current.is_file():
+        current = current.parent
+    try:
+        current = current.resolve()
+    except OSError:
+        current = current.absolute()
+
+    executable_names = ("pyappify.exe", "pyappify")
+    for directory in (current,) + tuple(current.parents):
+        for executable_name in executable_names:
+            candidate = directory / executable_name
+            if candidate.is_file():
+                return str(candidate.resolve())
+    return None
+
+
+pyappify_executable = find_pyappify_executable()
+
+
 def _get_logger():
     global _console_logger
 
@@ -189,16 +239,18 @@ def show_pyappify(args=None, cwd=None, env=None):
     global pid
 
     log = _get_logger()
-    if _is_process_running(pid):
+    already_running = _is_process_running(pid)
+    if already_running and not args:
         log.info(f"PyAppify is already running with PID: {pid}")
         bring_window_to_front_by_pid(pid)
         return pid
 
-    if not pyappify_executable:
-        log.error("PYAPPIFY_EXECUTABLE is not configured.")
+    executable = pyappify_executable or find_pyappify_executable()
+    if not executable:
+        log.error("PyAppify executable was not found.")
         return None
 
-    command = [pyappify_executable]
+    command = [executable]
     if args:
         if isinstance(args, str):
             command.append(args)
@@ -208,15 +260,208 @@ def show_pyappify(args=None, cwd=None, env=None):
     try:
         process = subprocess.Popen(
             command,
-            cwd=cwd or os.path.dirname(pyappify_executable) or None,
+            cwd=cwd or os.path.dirname(executable) or None,
             env=env,
         )
-        pid = process.pid
+        if not already_running:
+            pid = process.pid
         return pid
     except Exception as e:
-        log.error(f"Failed to start PyAppify executable {pyappify_executable}: {e}")
+        log.error(f"Failed to start PyAppify executable {executable}: {e}")
+        return None
+
+
+def _require_pyappify_executable():
+    global pyappify_executable
+
+    if pyappify_executable and os.path.isfile(pyappify_executable):
+        return os.path.abspath(pyappify_executable)
+    pyappify_executable = find_pyappify_executable()
+    if not pyappify_executable:
+        raise FileNotFoundError(
+            "PyAppify executable was not found. Set PYAPPIFY_EXECUTABLE to an "
+            "existing executable or place pyappify.exe in this directory or a parent directory."
+        )
+    return pyappify_executable
+
+
+def _run_launcher_api(arguments, timeout=300):
+    executable = _require_pyappify_executable()
+    response_path = os.path.join(
+        tempfile.gettempdir(),
+        "pyappify-response-{}-{}.json".format(os.getpid(), uuid.uuid4().hex),
+    )
+    command = list(arguments) + ["--response-file", response_path]
+    try:
+        subprocess.Popen(
+            [executable] + command,
+            cwd=os.path.dirname(executable) or None,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except OSError as error:
+        raise RuntimeError(
+            "Failed to execute PyAppify at '{}': {}".format(executable, error)
+        )
+
+    deadline = time.monotonic() + timeout
+    try:
+        while time.monotonic() < deadline:
+            try:
+                with open(response_path, "r", encoding="utf-8") as response_file:
+                    response = json.load(response_file)
+                if isinstance(response, dict) and response.get("error"):
+                    raise RuntimeError(response["error"])
+                return response
+            except FileNotFoundError:
+                pass
+            except json.JSONDecodeError:
+                # The running launcher may still be completing the response write.
+                pass
+            time.sleep(0.05)
+    finally:
+        try:
+            os.remove(response_path)
+        except FileNotFoundError:
+            pass
+
+    raise TimeoutError("Timed out waiting for a response from PyAppify")
+
+
+def get_version_list(number_versions=10, release_only=True, timeout=300):
+    """Return the latest versions and each version's notes since its predecessor."""
+    if isinstance(number_versions, bool) or not isinstance(number_versions, int):
+        raise TypeError("number_versions must be an integer")
+    if number_versions <= 0:
+        raise ValueError("number_versions must be greater than zero")
+    if not isinstance(release_only, bool):
+        raise TypeError("release_only must be a boolean")
+
+    if "PYAPPIFY_PYTHON_TEST" in os.environ:
+        time.sleep(5)
+        return _get_mock_version_list(number_versions)
+
+    response = _run_launcher_api(
+        [
+            "--get-version-list",
+            "--number-versions",
+            str(number_versions),
+            "--release-only",
+            str(release_only).lower(),
+        ],
+        timeout=timeout,
+    )
+    if not isinstance(response, list):
+        raise RuntimeError("PyAppify returned an invalid version-list response")
+    return response
+
+
+def get_versions(number_versions=10, release_only=True, timeout=300):
+    """Alias for get_version_list."""
+    return get_version_list(number_versions, release_only, timeout)
+
+
+def calculate_update_notes(update_notes, current_version, target_version):
+    """Return descending notes without including versions newer than the target."""
+    if not isinstance(update_notes, list):
+        raise TypeError("update_notes must be a list")
+
+    versions = [
+        item for item in update_notes
+        if isinstance(item, dict) and item.get("version")
+    ]
+
+    def normalize(version):
+        return str(version or "").lstrip("v")
+
+    def find_index(version):
+        normalized = normalize(version)
+        return next(
+            (index for index, item in enumerate(versions)
+             if normalize(item["version"]) == normalized),
+            None,
+        )
+
+    target_index = find_index(target_version)
+    if target_index is None:
+        return []
+
+    current_index = find_index(current_version)
+    if current_index is None:
+        selected_versions = versions[target_index:]
+    else:
+        first = min(current_index, target_index)
+        last = max(current_index, target_index)
+        selected_versions = versions[first:last + 1]
+
+    notes = []
+    for item in selected_versions:
+        raw_notes = item.get("update_note") or []
+        notes.extend(raw_notes if isinstance(raw_notes, list) else [raw_notes])
+    return [str(note) for note in notes]
+
+
+def update_to_version(version, timeout=300):
+    """Start PyAppify (or forward to it) and update the managed app to version."""
+    if not isinstance(version, str) or not version.strip():
+        raise ValueError("version must be a non-empty string")
+    if "PYAPPIFY_PYTHON_TEST" in os.environ:
+        return {"updated": True, "version": version, "mocked": True}
+    response = _run_launcher_api(
+        ["--update-to-version", version],
+        timeout=timeout,
+    )
+    if not isinstance(response, dict) or not response.get("updated"):
+        raise RuntimeError("PyAppify returned an invalid update response")
+    return response
+
+
+def _get_mock_version_list(number_versions):
+    """Return deterministic launcher data for UI and integration tests."""
+    current = app_version or "v1.0.0"
+    prefix = "v" if current.startswith("v") else ""
+    try:
+        parts = [int(part) for part in current.lstrip("v").split(".")]
+    except (TypeError, ValueError):
+        parts = [1, 0, 0]
+        prefix = "v"
+    parts = (parts + [0, 0, 0])[:3]
+
+    def previous_parts(version_parts):
+        major, minor, patch = version_parts
+        if patch > 0:
+            return [major, minor, patch - 1]
+        if minor > 0:
+            return [major, minor - 1, 9]
+        if major > 0:
+            return [major - 1, 9, 9]
         return None
 
+    version_parts = [[100, 1, 1], parts[:2] + [parts[2] + 2], parts[:2] + [parts[2] + 1], parts]
+    previous = previous_parts(parts)
+    while len(version_parts) < number_versions:
+        if previous is not None:
+            version_parts.append(previous)
+            previous = previous_parts(previous)
+        else:
+            break
+
+    versions = []
+    for item_parts in version_parts:
+        item_prefix = "v" if item_parts == [100, 1, 1] else prefix
+        version = item_prefix + ".".join(str(part) for part in item_parts)
+        previous_item = previous_parts(item_parts)
+        previous = item_prefix + ".".join(str(part) for part in previous_item) if previous_item else version
+        versions.append({
+            "version": version,
+            "previous_version": previous,
+            "update_note": [
+                f"Mock update note for {version}",
+                f"Changes since {previous}",
+            ],
+        })
+    return versions[:number_versions]
+
 
 def _replace_executable(source_path, target_path, timeout=30):
     deadline = time.monotonic() + timeout
@@ -349,6 +594,10 @@ def get_update_note():
     return get_update_notes()
 
 
+def get_locale():
+    return app_locale
+
+
 def is_greater_version(version1, version2):
     """
     Compares two semantic version strings.

pyappify-1.0.7/pyappify/app_config.py

@@ -0,0 +1,244 @@
+import atexit
+import json
+import logging
+import os
+import tempfile
+import threading
+
+
+UPDATE_METHOD_MANUAL = "MANUAL_UPDATE"
+UPDATE_METHOD_AUTO = "AUTO_UPDATE"
+UPDATE_METHOD_AUTO_PRE_RELEASE = "AUTO_UPDATE_PRE_RELEASE"
+UPDATE_METHODS = {
+    UPDATE_METHOD_MANUAL,
+    UPDATE_METHOD_AUTO,
+    UPDATE_METHOD_AUTO_PRE_RELEASE,
+}
+
+_UNSET = object()
+_LOG = logging.getLogger("pyappify.app_config")
+
+
+class AppConfigAPI:
+    """Thread-safe access to the app preferences stored by PyAppify."""
+
+    def __init__(self, path=None, watch=False, watch_interval=0.5):
+        self._lock = threading.RLock()
+        self._path = None
+        self._preferences = {
+            "auto_start": False,
+            "update_method": UPDATE_METHOD_AUTO,
+        }
+        self._listeners = set()
+        self._watch_interval = watch_interval
+        self._watch_stop = None
+        self._watch_thread = None
+        if path:
+            self.configure(path, watch=watch, watch_interval=watch_interval)
+
+    @property
+    def path(self):
+        with self._lock:
+            return self._path
+
+    def configure(self, path, watch=True, watch_interval=0.5):
+        self.stop_watcher()
+        normalized_path = os.path.abspath(os.path.expanduser(path)) if path else None
+        with self._lock:
+            self._path = normalized_path
+            self._watch_interval = watch_interval
+            self._preferences = {
+                "auto_start": False,
+                "update_method": UPDATE_METHOD_AUTO,
+            }
+        if normalized_path:
+            self.refresh(notify=False)
+            if watch:
+                self.start_watcher()
+        return normalized_path
+
+    def _read_document(self):
+        path = self.path
+        if not path:
+            raise RuntimeError("PYAPPIFY_APP_JSON_PATH is not configured")
+        with open(path, "r", encoding="utf-8") as config_file:
+            document = json.load(config_file)
+        if not isinstance(document, dict):
+            raise ValueError("app.json must contain a JSON object")
+        return document
+
+    @staticmethod
+    def _preferences_from_document(document):
+        auto_start = document.get("auto_start", False)
+        update_method = document.get("update_method", UPDATE_METHOD_AUTO)
+        if not isinstance(auto_start, bool):
+            raise ValueError("auto_start must be a boolean")
+        if not isinstance(update_method, str) or update_method not in UPDATE_METHODS:
+            raise ValueError("Unsupported update_method: {}".format(update_method))
+        return {
+            "auto_start": auto_start,
+            "update_method": update_method,
+        }
+
+    def _store_preferences(self, preferences, notify=True):
+        with self._lock:
+            changed = preferences != self._preferences
+            self._preferences = dict(preferences)
+            listeners = tuple(self._listeners) if changed and notify else ()
+            result = dict(self._preferences)
+        for listener in listeners:
+            try:
+                listener(dict(result))
+            except Exception:
+                _LOG.exception("An app config listener failed")
+        return result
+
+    def refresh(self, notify=True):
+        with self._lock:
+            preferences = self._preferences_from_document(self._read_document())
+        return self._store_preferences(preferences, notify=notify)
+
+    def get(self, refresh=True):
+        if refresh and self.path:
+            return self.refresh()
+        with self._lock:
+            return dict(self._preferences)
+
+    def update(self, auto_start=_UNSET, update_method=_UNSET):
+        if auto_start is not _UNSET and not isinstance(auto_start, bool):
+            raise ValueError("auto_start must be a boolean")
+        if update_method is not _UNSET and (
+            not isinstance(update_method, str) or update_method not in UPDATE_METHODS
+        ):
+            raise ValueError("Unsupported update_method: {}".format(update_method))
+
+        with self._lock:
+            document = self._read_document()
+            if auto_start is not _UNSET:
+                document["auto_start"] = auto_start
+            if update_method is not _UNSET:
+                document["update_method"] = update_method
+            preferences = self._preferences_from_document(document)
+            config_dir = os.path.dirname(self._path) or os.curdir
+            temporary_path = None
+            try:
+                with tempfile.NamedTemporaryFile(
+                    mode="w",
+                    encoding="utf-8",
+                    dir=config_dir,
+                    prefix=".app-json-",
+                    suffix=".tmp",
+                    delete=False,
+                ) as temporary_file:
+                    temporary_path = temporary_file.name
+                    json.dump(document, temporary_file, indent=2, ensure_ascii=False)
+                    temporary_file.write("\n")
+                    temporary_file.flush()
+                    os.fsync(temporary_file.fileno())
+                os.replace(temporary_path, self._path)
+                temporary_path = None
+            finally:
+                if temporary_path and os.path.exists(temporary_path):
+                    os.unlink(temporary_path)
+        return self._store_preferences(preferences)
+
+    def add_listener(self, listener):
+        if not callable(listener):
+            raise TypeError("listener must be callable")
+        with self._lock:
+            self._listeners.add(listener)
+        return listener
+
+    def remove_listener(self, listener):
+        with self._lock:
+            self._listeners.discard(listener)
+
+    def start_watcher(self):
+        with self._lock:
+            if not self._path:
+                raise RuntimeError("PYAPPIFY_APP_JSON_PATH is not configured")
+            if self._watch_thread and self._watch_thread.is_alive():
+                return self._watch_thread
+            stop_event = threading.Event()
+            self._watch_stop = stop_event
+            thread = threading.Thread(
+                target=self._watch_loop,
+                args=(stop_event,),
+                name="pyappify-app-config-watch",
+                daemon=True,
+            )
+            self._watch_thread = thread
+            thread.start()
+            return thread
+
+    def stop_watcher(self):
+        with self._lock:
+            stop_event = self._watch_stop
+            thread = self._watch_thread
+            self._watch_stop = None
+            self._watch_thread = None
+        if stop_event:
+            stop_event.set()
+        if thread and thread is not threading.current_thread():
+            thread.join(timeout=max(1.0, self._watch_interval * 2))
+
+    def _watch_loop(self, stop_event):
+        while not stop_event.wait(self._watch_interval):
+            try:
+                self.refresh()
+            except (OSError, ValueError, json.JSONDecodeError):
+                _LOG.exception("Failed to refresh app preferences from %s", self.path)
+
+
+_api = AppConfigAPI()
+
+
+def configure_app_json(path=None, watch=True, watch_interval=0.5):
+    return _api.configure(path, watch=watch, watch_interval=watch_interval)
+
+
+def get_app_json_path():
+    return _api.path
+
+
+def get_app_config():
+    return _api.get()
+
+
+def update_app_config(auto_start=_UNSET, update_method=_UNSET):
+    return _api.update(auto_start=auto_start, update_method=update_method)
+
+
+def get_auto_start():
+    return get_app_config()["auto_start"]
+
+
+def set_auto_start(auto_start):
+    return update_app_config(auto_start=auto_start)["auto_start"]
+
+
+def get_update_method():
+    return get_app_config()["update_method"]
+
+
+def set_update_method(update_method):
+    return update_app_config(update_method=update_method)["update_method"]
+
+
+def add_app_config_listener(listener):
+    return _api.add_listener(listener)
+
+
+def remove_app_config_listener(listener):
+    _api.remove_listener(listener)
+
+
+def start_app_config_watcher():
+    return _api.start_watcher()
+
+
+def stop_app_config_watcher():
+    _api.stop_watcher()
+
+
+atexit.register(stop_app_config_watcher)

pyappify-1.0.7/pyappify/main.py

@@ -0,0 +1,2 @@
+def main():
+    print("PyAppify Hello world")

{pyappify-1.0.5 → pyappify-1.0.7}/pyappify.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
-Metadata-Version: 2.4
-Name: pyappify
-Version: 1.0.5
-Summary: My awesome Python application
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: build; extra == "dev"
+Metadata-Version: 2.4
+Name: pyappify
+Version: 1.0.7
+Summary: My awesome Python application
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: build; extra == "dev"

{pyappify-1.0.5 → pyappify-1.0.7}/pyappify.egg-info/SOURCES.txt

@@ -1,14 +1,10 @@
 pyproject.toml
 pyappify/__init__.py
+pyappify/app_config.py
 pyappify/main.py
 pyappify.egg-info/PKG-INFO
 pyappify.egg-info/SOURCES.txt
 pyappify.egg-info/dependency_links.txt
 pyappify.egg-info/entry_points.txt
 pyappify.egg-info/requires.txt
-pyappify.egg-info/top_level.txt
-tests/TestProcessControls.py
-tests/TestUpdateEnv.py
-tests/TestUpgrade.py
-tests/TestUpgradeOnline.py
-tests/TestVersion.py
+pyappify.egg-info/top_level.txt

{pyappify-1.0.5 → pyappify-1.0.7}/pyproject.toml

@@ -1,25 +1,25 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "pyappify"
-version = "1.0.5"
-description = "My awesome Python application"
-readme = "README.md"
-requires-python = ">=3.7"
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-]
-
-[project.scripts]
-pyappify = "pyappify.main:main"
-
-[project.optional-dependencies]
-dev = ["twine", "build"]
-
-[tool.setuptools.packages.find]
-where = ["."]
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyappify"
+version = "1.0.7"
+description = "My awesome Python application"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+pyappify = "pyappify.main:main"
+
+[project.optional-dependencies]
+dev = ["twine", "build"]
+
+[tool.setuptools.packages.find]
+where = ["."]
 include = ["pyappify"]

{pyappify-1.0.5 → pyappify-1.0.7}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyappify-1.0.5/pyappify/main.py

@@ -1,2 +0,0 @@
-def main():
-    print("PyAppify Hello world")

pyappify-1.0.5/tests/TestProcessControls.py

@@ -1,77 +0,0 @@
-import os
-import signal
-import unittest
-from unittest import mock
-
-import pyappify
-
-
-class TestProcessControls(unittest.TestCase):
-    def setUp(self):
-        self.old_pid = pyappify.pid
-        self.old_executable = pyappify.pyappify_executable
-        self.old_logger = pyappify.logger
-        pyappify.logger = mock.Mock()
-
-    def tearDown(self):
-        pyappify.pid = self.old_pid
-        pyappify.pyappify_executable = self.old_executable
-        pyappify.logger = self.old_logger
-
-    def test_kill_pyappify_exe_terminates_configured_pid(self):
-        pyappify.pid = 1234
-
-        with mock.patch.object(pyappify.os, "kill") as kill, mock.patch.object(
-            pyappify, "_wait_for_process_exit", return_value=True
-        ) as wait:
-            self.assertTrue(pyappify.kill_pyappify_exe(timeout=5))
-
-        kill.assert_called_once_with(1234, signal.SIGTERM)
-        wait.assert_called_once_with(1234, 5)
-
-    def test_show_pyappify_brings_existing_window_to_front(self):
-        pyappify.pid = 1234
-
-        with mock.patch.object(
-            pyappify, "_is_process_running", return_value=True
-        ) as is_running, mock.patch.object(
-            pyappify, "bring_window_to_front_by_pid", return_value=True
-        ) as bring_to_front, mock.patch.object(pyappify.subprocess, "Popen") as popen:
-            self.assertEqual(1234, pyappify.show_pyappify())
-
-        is_running.assert_called_once_with(1234)
-        bring_to_front.assert_called_once_with(1234)
-        popen.assert_not_called()
-
-    def test_show_pyappify_starts_executable_when_not_running(self):
-        executable = os.path.abspath("pyappify.exe")
-        pyappify.pid = 1234
-        pyappify.pyappify_executable = executable
-        process = mock.Mock()
-        process.pid = 5678
-
-        with mock.patch.object(
-            pyappify, "_is_process_running", return_value=False
-        ), mock.patch.object(pyappify.subprocess, "Popen", return_value=process) as popen:
-            self.assertEqual(
-                5678,
-                pyappify.show_pyappify(args=["--profile", "dev"]),
-            )
-
-        popen.assert_called_once_with(
-            [executable, "--profile", "dev"],
-            cwd=os.path.dirname(executable),
-            env=None,
-        )
-        self.assertEqual(5678, pyappify.pid)
-
-    def test_show_pyappify_returns_none_without_executable(self):
-        pyappify.pid = None
-        pyappify.pyappify_executable = None
-
-        with mock.patch.object(pyappify, "_is_process_running", return_value=False):
-            self.assertIsNone(pyappify.show_pyappify())
-
-
-if __name__ == "__main__":
-    unittest.main()

pyappify-1.0.5/tests/TestUpdateEnv.py

@@ -1,94 +0,0 @@
-import importlib
-import os
-import unittest
-
-import pyappify
-
-
-ENV_KEYS = (
-    "PYAPPIFY_APP_VERSION",
-    "PYAPPIFY_APP_STARTING_VERSION",
-    "PYAPPIFY_UPDATE_NOTE",
-)
-
-
-class TestUpdateEnv(unittest.TestCase):
-    def setUp(self):
-        self._saved_env = {key: os.environ.get(key) for key in ENV_KEYS}
-
-    def tearDown(self):
-        for key, value in self._saved_env.items():
-            if value is None:
-                os.environ.pop(key, None)
-            else:
-                os.environ[key] = value
-        importlib.reload(pyappify)
-
-    def _reload_with_env(self, **env):
-        for key in ENV_KEYS:
-            os.environ.pop(key, None)
-        for key, value in env.items():
-            os.environ[key] = value
-        return importlib.reload(pyappify)
-
-    def test_starting_version_falls_back_to_app_version(self):
-        module = self._reload_with_env(PYAPPIFY_APP_VERSION="1.2.3")
-
-        self.assertEqual("1.2.3", module.app_version)
-        self.assertEqual("1.2.3", module.app_starting_version)
-        self.assertFalse(module.is_app_updated())
-        self.assertFalse(module.is_updated())
-        self.assertFalse(module.is_app_downgraded())
-        self.assertFalse(module.is_downgrade())
-
-    def test_missing_versions_are_not_update_or_downgrade(self):
-        module = self._reload_with_env()
-
-        self.assertIsNone(module.app_version)
-        self.assertIsNone(module.app_starting_version)
-        self.assertFalse(module.is_app_updated())
-        self.assertFalse(module.is_app_downgraded())
-
-    def test_detects_update_and_downgrade(self):
-        module = self._reload_with_env(
-            PYAPPIFY_APP_VERSION="2.0.0",
-            PYAPPIFY_APP_STARTING_VERSION="1.0.0",
-        )
-
-        self.assertTrue(module.is_app_updated())
-        self.assertTrue(module.is_updated())
-        self.assertFalse(module.is_app_downgraded())
-        self.assertFalse(module.is_downgrade())
-
-        module = self._reload_with_env(
-            PYAPPIFY_APP_VERSION="1.0.0",
-            PYAPPIFY_APP_STARTING_VERSION="2.0.0",
-        )
-
-        self.assertFalse(module.is_app_updated())
-        self.assertFalse(module.is_updated())
-        self.assertTrue(module.is_app_downgraded())
-        self.assertTrue(module.is_downgrade())
-
-    def test_returns_update_notes_from_json_array(self):
-        module = self._reload_with_env(
-            PYAPPIFY_UPDATE_NOTE='["first change", "second change"]'
-        )
-
-        self.assertEqual(["first change", "second change"], module.get_update_notes())
-        self.assertEqual(["first change", "second change"], module.get_update_note())
-
-    def test_invalid_or_missing_update_notes_return_empty_list(self):
-        self.assertEqual([], self._reload_with_env().get_update_notes())
-        self.assertEqual(
-            [],
-            self._reload_with_env(PYAPPIFY_UPDATE_NOTE="not json").get_update_notes(),
-        )
-        self.assertEqual(
-            [],
-            self._reload_with_env(PYAPPIFY_UPDATE_NOTE='"single note"').get_update_notes(),
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

pyappify-1.0.5/tests/TestUpgrade.py

@@ -1,110 +0,0 @@
-import hashlib
-import logging
-import os
-import shutil
-import subprocess
-import tempfile
-import time
-import unittest
-from pathlib import Path
-
-import pyappify
-
-
-EXECUTABLE_SHA256 = "50ef2557c193ca1f97c1e699bab3dad35b3966c9e8e8b860fb609bd5fb3861d1"
-
-
-def _sha256(path):
-    digest = hashlib.sha256()
-    with open(path, "rb") as file:
-        for block in iter(lambda: file.read(1024 * 1024), b""):
-            digest.update(block)
-    return digest.hexdigest()
-
-
-def assert_upgrade_kills_running_executable_and_replaces_it(
-    test_case, zip_url, timeout_seconds
-):
-    source_executable = Path(os.environ["WINDIR"]) / "System32" / "PING.EXE"
-    test_case.assertTrue(source_executable.exists(), "Windows PING.EXE is required")
-
-    old_cwd = os.getcwd()
-    old_upgradeable = pyappify.pyappify_upgradeable
-    old_version = pyappify.pyappify_version
-    old_executable = pyappify.pyappify_executable
-    old_pid = pyappify.pid
-    old_logger = pyappify.logger
-
-    with tempfile.TemporaryDirectory() as temporary_directory:
-        executable = Path(temporary_directory) / "ok-ww.exe"
-        upgrade_temporary_directory = Path(temporary_directory) / "pyappify_tmp"
-        shutil.copy2(source_executable, executable)
-        test_case.assertNotEqual(_sha256(executable), EXECUTABLE_SHA256)
-
-        process = subprocess.Popen(
-            [str(executable), "-t", "127.0.0.1"],
-            cwd=temporary_directory,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-        try:
-            time.sleep(1)
-            test_case.assertIsNone(
-                process.poll(), "the current executable exited before upgrade began"
-            )
-
-            pyappify.pyappify_upgradeable = True
-            pyappify.pyappify_version = "v3.3.45"
-            pyappify.pyappify_executable = str(executable)
-            pyappify.pid = process.pid
-            pyappify.logger = logging.getLogger(__name__)
-            os.chdir(temporary_directory)
-
-            pyappify.upgrade("v3.3.46", EXECUTABLE_SHA256, [zip_url])
-
-            deadline = time.monotonic() + timeout_seconds
-            while time.monotonic() < deadline:
-                process_stopped = process.poll() is not None
-                upgraded = (
-                    executable.exists()
-                    and _sha256(executable) == EXECUTABLE_SHA256
-                )
-                update_finished = not upgrade_temporary_directory.exists()
-                if process_stopped and upgraded and update_finished:
-                    break
-                time.sleep(0.1)
-
-            test_case.assertIsNotNone(
-                process.poll(), "upgrade did not stop the old process"
-            )
-            test_case.assertEqual(EXECUTABLE_SHA256, _sha256(executable))
-        finally:
-            os.chdir(old_cwd)
-            pyappify.pyappify_upgradeable = old_upgradeable
-            pyappify.pyappify_version = old_version
-            pyappify.pyappify_executable = old_executable
-            pyappify.pid = old_pid
-            pyappify.logger = old_logger
-            if process.poll() is None:
-                process.terminate()
-                try:
-                    process.wait(timeout=5)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    process.wait(timeout=5)
-
-
-class TestUpgrade(unittest.TestCase):
-    LOCAL_ZIP = Path(__file__).with_name("ok-ww-win32.zip")
-
-    @unittest.skipUnless(os.name == "nt", "executable replacement test is Windows-only")
-    def test_upgrade_from_local_zip_kills_running_executable_and_replaces_it(self):
-        self.assertTrue(self.LOCAL_ZIP.exists(), "tests/ok-ww-win32.zip is required")
-        assert_upgrade_kills_running_executable_and_replaces_it(
-            self,
-            self.LOCAL_ZIP.as_uri(), timeout_seconds=30
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

pyappify-1.0.5/tests/TestUpgradeOnline.py

@@ -1,21 +0,0 @@
-import os
-import unittest
-
-from tests.TestUpgrade import assert_upgrade_kills_running_executable_and_replaces_it
-
-
-class TestUpgradeOnline(unittest.TestCase):
-    ZIP_URL = (
-        "https://github.com/ok-oldking/ok-wuthering-waves/"
-        "releases/download/v3.3.46/ok-ww-win32.zip"
-    )
-
-    @unittest.skipUnless(os.name == "nt", "executable replacement test is Windows-only")
-    def test_upgrade_from_online_zip_kills_running_executable_and_replaces_it(self):
-        assert_upgrade_kills_running_executable_and_replaces_it(
-            self, self.ZIP_URL, timeout_seconds=600
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

pyappify-1.0.5/tests/TestVersion.py

@@ -1,33 +0,0 @@
-# filename: test_pyappify.is_greater_version.py
-import unittest
-import pyappify
-
-class TestIsGreaterVersion(unittest.TestCase):
-
-    def test_version1_is_greater(self):
-        self.assertTrue(pyappify.is_greater_version("2.0.0", "1.9.9"))
-        self.assertTrue(pyappify.is_greater_version("1.2.0", "v1.1.9"))
-        self.assertTrue(pyappify.is_greater_version("v1.1.2", "1.1.1"))
-        self.assertTrue(pyappify.is_greater_version("1.1.0", "1.1"))
-        self.assertTrue(pyappify.is_greater_version("v10.0.0", "9.0.0"))
-
-    def test_version1_is_not_greater(self):
-        self.assertFalse(pyappify.is_greater_version("v1.0.0", "2.0.0"))
-        self.assertFalse(pyappify.is_greater_version("1.1.0", "v1.2.0"))
-        self.assertFalse(pyappify.is_greater_version("1.1.1", "1.1.2"))
-        self.assertFalse(pyappify.is_greater_version("1.1", "1.1.0"))
-
-    def test_versions_are_equal(self):
-        self.assertFalse(pyappify.is_greater_version("qwer", "1.0.0"))
-        self.assertFalse(pyappify.is_greater_version("1.2.3", "1.2.3"))
-
-    def test_invalid_or_edge_cases(self):
-        self.assertFalse(pyappify.is_greater_version(None, "1.0.0"))
-        self.assertFalse(pyappify.is_greater_version("1.0.0", None))
-        self.assertFalse(pyappify.is_greater_version(None, None))
-        self.assertFalse(pyappify.is_greater_version("v1.a.0", "1.0.0"))
-        self.assertFalse(pyappify.is_greater_version("1.0.0", "invalid"))
-        self.assertFalse(pyappify.is_greater_version("", "1.0.0"))
-
-if __name__ == '__main__':
-    unittest.main(argv=['first-arg-is-ignored'], exit=False)