mirror of
https://github.com/yusufipk/dikte.git
synced 2026-09-11 10:56:10 +00:00
yusufipek
23d56acfb5
The releases page had nothing for Windows, so the only way in was a checkout, a Python and a pip install. What goes out now is one setup program per release: PyInstaller's directory, the pinned ffmpeg the disk image already uses, and Inno Setup around both. It installs for the account alone, so no administrator is asked for. Two executables over the one program there, because a windowed one on Windows has no standard output at all: Dikte.exe for the Start Menu and dikte.exe for the terminal, sharing everything they carry. The icon is drawn by Dikte itself into an .ico, the way the Mac's .icns and Linux's PNGs already are, so there is still no image file in the repository. Starting at sign-in is a registry value rather than a Startup shortcut, which is what lets the setup program, the uninstaller and `dikte integrate` all mean the same thing: the wizard asks once, and typing the command changes the answer later. The three builds move into build.yml, which release.yml now calls instead of holding its own copy, and which a pull request touching the packaging runs on its own. A broken build is then a red pull request rather than a failed release.
525 lines
23 KiB
Python
525 lines
23 KiB
Python
"""What a downloaded build writes into the desktop it landed on.
|
|
|
|
The half worth pinning is the restraint rather than the writing. Three things
|
|
write these same files, and the AppImage is the one a person is most likely to
|
|
run once out of curiosity: it has to leave a working installation alone, and it
|
|
has to notice AppImageLauncher's entry, which is not under the name ours is.
|
|
"""
|
|
|
|
import os
|
|
import pathlib
|
|
import plistlib
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from unittest import mock
|
|
|
|
from dikte import integrate
|
|
from tests.support import posix_only
|
|
|
|
|
|
class Frozen:
|
|
"""A build, standing in for one. The two facts everything here reads.
|
|
|
|
sys.frozen is what PyInstaller sets and nothing else does; APPIMAGE is what
|
|
the AppImage runtime exports, and is the file rather than the mount.
|
|
"""
|
|
|
|
def __init__(self, executable, appimage=None, home=None, platform=None):
|
|
self.patches = [
|
|
mock.patch.object(sys, "executable", executable),
|
|
mock.patch.object(sys, "frozen", True, create=True),
|
|
]
|
|
environment = {"APPIMAGE": appimage} if appimage else {}
|
|
if home:
|
|
environment["HOME"] = str(home)
|
|
environment["XDG_DATA_HOME"] = str(pathlib.Path(home) / ".local/share")
|
|
environment["XDG_CONFIG_HOME"] = str(pathlib.Path(home) / ".config")
|
|
self.patches.append(mock.patch.dict(os.environ, environment,
|
|
clear=bool(home)))
|
|
if platform:
|
|
self.patches.append(mock.patch.object(sys, "platform", platform))
|
|
|
|
def __enter__(self):
|
|
for patch in self.patches:
|
|
patch.start()
|
|
return self
|
|
|
|
def __exit__(self, *_):
|
|
for patch in reversed(self.patches):
|
|
patch.stop()
|
|
|
|
|
|
class Home(unittest.TestCase):
|
|
"""A test with a home directory of its own to be written into."""
|
|
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
# Resolved, because target() resolves what it is handed and a Mac's
|
|
# temporary directory is under /var, which is a symlink to /private/var.
|
|
# Left alone, every path here would be compared against the other
|
|
# spelling of itself.
|
|
self.home = pathlib.Path(self.tmp.name).resolve()
|
|
self.addCleanup(self.tmp.cleanup)
|
|
self.applications = self.home / ".local/share/applications"
|
|
self.autostart = self.home / ".config/autostart"
|
|
|
|
def entry(self, name, exec_line, application="Dikte"):
|
|
self.applications.mkdir(parents=True, exist_ok=True)
|
|
path = self.applications / name
|
|
path.write_text(f"[Desktop Entry]\nType=Application\nName={application}\n"
|
|
f"Exec={exec_line}\n", encoding="utf-8")
|
|
return path
|
|
|
|
|
|
class WhatToStart(unittest.TestCase):
|
|
def test_a_checkout_names_this_interpreter_and_the_entry_point(self):
|
|
self.assertFalse(integrate.packaged())
|
|
|
|
@posix_only
|
|
def test_an_appimage_names_the_file_and_not_the_mount(self):
|
|
"""The mount is a fresh /tmp path every run; a shortcut written to it
|
|
would work until the next login and never again."""
|
|
with Frozen("/tmp/.mount_Dikte1a/usr/bin/dikte",
|
|
appimage="/home/someone/Downloads/Dikte.AppImage"):
|
|
self.assertEqual(str(integrate.target()),
|
|
"/home/someone/Downloads/Dikte.AppImage")
|
|
|
|
@posix_only
|
|
def test_a_mac_names_the_bundle_and_not_the_executable_inside_it(self):
|
|
with Frozen("/Applications/Dikte.app/Contents/MacOS/Dikte",
|
|
platform="darwin"):
|
|
self.assertEqual(str(integrate.target()), "/Applications/Dikte.app")
|
|
|
|
def test_a_checkout_writes_nothing(self):
|
|
self.assertEqual(integrate.ensure(), [])
|
|
|
|
|
|
class BundledTools(unittest.TestCase):
|
|
"""The ffmpeg the disk image carries, and how anything finds it."""
|
|
|
|
@posix_only
|
|
def test_a_mac_looks_beside_the_bundle_not_beside_the_executable(self):
|
|
with Frozen("/Applications/Dikte.app/Contents/MacOS/Dikte",
|
|
platform="darwin"):
|
|
self.assertEqual(str(integrate.bundled_bin()),
|
|
"/Applications/Dikte.app/Contents/Resources/bin")
|
|
|
|
def test_a_checkout_has_none_and_leaves_the_path_alone(self):
|
|
with mock.patch.dict(os.environ, {"PATH": "/usr/bin"}):
|
|
self.assertFalse(integrate.add_bundled_tools())
|
|
self.assertEqual(os.environ["PATH"], "/usr/bin")
|
|
|
|
def test_the_directory_goes_in_front(self):
|
|
"""In front, so that a Mac with its own ffmpeg from Homebrew still gets
|
|
the build these format strings are known to work against."""
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
tools = pathlib.Path(tmp) / "bin"
|
|
tools.mkdir()
|
|
with Frozen(str(pathlib.Path(tmp) / "dikte")), \
|
|
mock.patch.dict(os.environ, {"PATH": "/usr/bin"}):
|
|
self.assertTrue(integrate.add_bundled_tools())
|
|
self.assertEqual(os.environ["PATH"], f"{tools}{os.pathsep}/usr/bin")
|
|
|
|
def test_a_build_carrying_nothing_leaves_the_path_alone(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
with Frozen(str(pathlib.Path(tmp) / "dikte")), \
|
|
mock.patch.dict(os.environ, {"PATH": "/usr/bin"}):
|
|
self.assertFalse(integrate.add_bundled_tools())
|
|
|
|
|
|
class LibraryPath(unittest.TestCase):
|
|
"""What a build hands to every process it starts.
|
|
|
|
The one that catches it first is the AppImage starting itself again, which
|
|
is what the command line does when no instance is running: that goes back
|
|
through AppImageLauncher, a system binary, which will not load against the
|
|
libstdc++ the build was made with. ffmpeg, ydotool and wl-copy are the same
|
|
problem arriving later and harder to trace.
|
|
"""
|
|
|
|
def test_what_was_there_before_is_put_back(self):
|
|
with mock.patch.dict(os.environ, {"LD_LIBRARY_PATH": "/tmp/.mount_x/_internal",
|
|
"LD_LIBRARY_PATH_ORIG": "/opt/cuda/lib"}):
|
|
self.assertTrue(integrate.restore_library_path())
|
|
self.assertEqual(os.environ["LD_LIBRARY_PATH"], "/opt/cuda/lib")
|
|
self.assertNotIn("LD_LIBRARY_PATH_ORIG", os.environ)
|
|
|
|
def test_nothing_there_before_means_unset_rather_than_empty(self):
|
|
"""An empty LD_LIBRARY_PATH is not the same as none: the loader reads it
|
|
as the current directory."""
|
|
with mock.patch.dict(os.environ, {"LD_LIBRARY_PATH": "/tmp/.mount_x/_internal"}):
|
|
self.assertTrue(integrate.restore_library_path())
|
|
self.assertNotIn("LD_LIBRARY_PATH", os.environ)
|
|
|
|
def test_a_mac_has_its_own_name_for_it(self):
|
|
with mock.patch.dict(os.environ, {"DYLD_LIBRARY_PATH": "/Dikte.app/Contents/Frameworks"}):
|
|
self.assertTrue(integrate.restore_library_path())
|
|
self.assertNotIn("DYLD_LIBRARY_PATH", os.environ)
|
|
|
|
def test_a_checkout_has_nothing_to_put_back(self):
|
|
with mock.patch.dict(os.environ, {}, clear=True):
|
|
self.assertFalse(integrate.restore_library_path())
|
|
|
|
|
|
class Certificates(unittest.TestCase):
|
|
"""Where a build looks for the certificates that say who it is talking to.
|
|
|
|
An AppImage built on Ubuntu carries an OpenSSL with /usr/lib/ssl compiled
|
|
into it, and Arch, Fedora and openSUSE have no such directory. Left alone
|
|
it is every HTTPS request failing at once, reported as a rejected key.
|
|
"""
|
|
|
|
def paths(self, cafile=None, capath=None):
|
|
"""ssl.get_default_verify_paths(), which reports only what really exists."""
|
|
import ssl
|
|
return mock.patch("ssl.get_default_verify_paths",
|
|
return_value=ssl.DefaultVerifyPaths(
|
|
cafile, capath, "SSL_CERT_FILE", "/usr/lib/ssl/cert.pem",
|
|
"SSL_CERT_DIR", "/usr/lib/ssl/certs"))
|
|
|
|
def test_a_store_the_build_cannot_find_is_looked_up(self):
|
|
with Frozen("/tmp/.mount_x/usr/bin/dikte"), \
|
|
mock.patch.dict(os.environ, {}, clear=True), \
|
|
self.paths(), \
|
|
mock.patch("os.path.isfile", lambda p: p == "/etc/ssl/cert.pem"):
|
|
self.assertEqual(integrate.use_system_certificates(), "/etc/ssl/cert.pem")
|
|
self.assertEqual(os.environ["SSL_CERT_FILE"], "/etc/ssl/cert.pem")
|
|
|
|
def test_a_directory_will_do_when_no_bundle_is_there(self):
|
|
with Frozen("/tmp/.mount_x/usr/bin/dikte"), \
|
|
mock.patch.dict(os.environ, {}, clear=True), \
|
|
self.paths(), \
|
|
mock.patch("os.path.isfile", return_value=False), \
|
|
mock.patch("os.path.isdir", lambda p: p == "/etc/ssl/certs"):
|
|
self.assertEqual(integrate.use_system_certificates(), "/etc/ssl/certs")
|
|
self.assertEqual(os.environ["SSL_CERT_DIR"], "/etc/ssl/certs")
|
|
|
|
def test_a_build_that_can_already_find_them_is_left_alone(self):
|
|
"""Which is the AppImage running on the distribution it was built on."""
|
|
with Frozen("/tmp/.mount_x/usr/bin/dikte"), \
|
|
mock.patch.dict(os.environ, {}, clear=True), \
|
|
self.paths(capath="/usr/lib/ssl/certs"):
|
|
self.assertIsNone(integrate.use_system_certificates())
|
|
self.assertNotIn("SSL_CERT_FILE", os.environ)
|
|
|
|
def test_somebody_who_has_said_where_is_not_argued_with(self):
|
|
"""A network that inspects its own traffic is made to work this way."""
|
|
with Frozen("/tmp/.mount_x/usr/bin/dikte"), \
|
|
mock.patch.dict(os.environ, {"SSL_CERT_FILE": "/opt/work/ca.pem"},
|
|
clear=True), \
|
|
self.paths():
|
|
self.assertIsNone(integrate.use_system_certificates())
|
|
self.assertEqual(os.environ["SSL_CERT_FILE"], "/opt/work/ca.pem")
|
|
|
|
def test_a_checkout_uses_the_python_it_was_installed_against(self):
|
|
with mock.patch.dict(os.environ, {}, clear=True):
|
|
self.assertIsNone(integrate.use_system_certificates())
|
|
|
|
|
|
@posix_only
|
|
class Linux(Home):
|
|
def install(self, appimage, force=False):
|
|
with Frozen("/tmp/.mount_x/usr/bin/dikte", appimage=str(appimage),
|
|
home=self.home, platform="linux"):
|
|
return integrate.install(force=force)
|
|
|
|
def test_it_writes_a_menu_entry_an_autostart_entry_and_the_command(self):
|
|
appimage = self.home / "Downloads" / "Dikte.AppImage"
|
|
appimage.parent.mkdir(parents=True)
|
|
appimage.touch()
|
|
self.install(appimage)
|
|
|
|
menu = (self.applications / "dikte.desktop").read_text(encoding="utf-8")
|
|
self.assertIn(f"Exec={appimage}", menu)
|
|
self.assertIn("Categories=", menu)
|
|
autostart = (self.autostart / "dikte.desktop").read_text(encoding="utf-8")
|
|
self.assertIn(f"Exec={appimage}", autostart)
|
|
self.assertNotIn("Categories=", autostart)
|
|
self.assertEqual(os.readlink(self.home / ".local/bin/dikte"), str(appimage))
|
|
|
|
def test_running_it_again_changes_nothing(self):
|
|
appimage = self.home / "Dikte.AppImage"
|
|
appimage.touch()
|
|
self.install(appimage)
|
|
self.assertEqual(self.install(appimage), [])
|
|
|
|
def test_moving_the_appimage_rewrites_the_entries(self):
|
|
"""The run after a move is the only moment a stale entry can be
|
|
noticed, which is why this is done on every start."""
|
|
first, second = self.home / "a.AppImage", self.home / "b.AppImage"
|
|
first.touch()
|
|
self.install(first)
|
|
first.rename(second)
|
|
self.install(second)
|
|
self.assertIn(f"Exec={second}",
|
|
(self.applications / "dikte.desktop").read_text())
|
|
self.assertEqual(os.readlink(self.home / ".local/bin/dikte"), str(second))
|
|
|
|
def test_it_stands_aside_for_a_checkout_that_install_sh_set_up(self):
|
|
checkout = self.home / "src" / "dikte" / "__main__.py"
|
|
checkout.parent.mkdir(parents=True)
|
|
checkout.touch()
|
|
self.entry("dikte.desktop", f"/usr/bin/python3 {checkout}")
|
|
appimage = self.home / "Dikte.AppImage"
|
|
appimage.touch()
|
|
|
|
self.assertEqual(self.install(appimage), [])
|
|
self.assertIn(str(checkout),
|
|
(self.applications / "dikte.desktop").read_text())
|
|
self.assertFalse((self.autostart / "dikte.desktop").exists())
|
|
|
|
def test_it_stands_aside_for_appimagelauncher(self):
|
|
"""Which writes appimagekit_<hash>-dikte.desktop rather than ours, and
|
|
moves the file, so ours beside it would be a second Dikte in the menu
|
|
naming somewhere the AppImage no longer is."""
|
|
moved = self.home / "Applications" / "Dikte_abc.AppImage"
|
|
moved.parent.mkdir(parents=True)
|
|
moved.touch()
|
|
self.entry("appimagekit_abc-dikte.desktop", str(moved))
|
|
appimage = self.home / "Downloads" / "Dikte.AppImage"
|
|
appimage.parent.mkdir(parents=True)
|
|
appimage.touch()
|
|
|
|
self.assertEqual(self.install(appimage), [])
|
|
|
|
def test_an_entry_naming_a_file_that_is_gone_is_not_in_the_way(self):
|
|
self.entry("dikte.desktop", "/removed/last/week/Dikte.AppImage")
|
|
appimage = self.home / "Dikte.AppImage"
|
|
appimage.touch()
|
|
self.assertTrue(self.install(appimage))
|
|
|
|
def test_asking_outright_overrules_all_of_that(self):
|
|
checkout = self.home / "src" / "__main__.py"
|
|
checkout.parent.mkdir(parents=True)
|
|
checkout.touch()
|
|
self.entry("dikte.desktop", f"/usr/bin/python3 {checkout}")
|
|
appimage = self.home / "Dikte.AppImage"
|
|
appimage.touch()
|
|
|
|
self.assertTrue(self.install(appimage, force=True))
|
|
self.assertIn(str(appimage),
|
|
(self.applications / "dikte.desktop").read_text())
|
|
|
|
def test_a_command_somebody_else_put_there_is_left_alone(self):
|
|
"""install.sh points it into a checkout, and that checkout is a working
|
|
installation this has no business redirecting."""
|
|
command = self.home / ".local/bin/dikte"
|
|
command.parent.mkdir(parents=True)
|
|
command.write_text("#!/bin/sh\nexec python3 /somewhere/__main__.py\n")
|
|
appimage = self.home / "Dikte.AppImage"
|
|
appimage.touch()
|
|
|
|
self.install(appimage)
|
|
self.assertIn("/somewhere/__main__.py", command.read_text())
|
|
|
|
def test_a_path_with_a_space_in_it_is_quoted(self):
|
|
appimage = self.home / "My Programs" / "Dikte.AppImage"
|
|
appimage.parent.mkdir(parents=True)
|
|
appimage.touch()
|
|
self.install(appimage)
|
|
self.assertIn(f'Exec="{appimage}"',
|
|
(self.applications / "dikte.desktop").read_text())
|
|
|
|
def test_removing_takes_back_what_it_wrote(self):
|
|
appimage = self.home / "Dikte.AppImage"
|
|
appimage.touch()
|
|
self.install(appimage)
|
|
with Frozen("/tmp/.mount_x/usr/bin/dikte", appimage=str(appimage),
|
|
home=self.home, platform="linux"):
|
|
integrate.remove()
|
|
self.assertFalse((self.applications / "dikte.desktop").exists())
|
|
self.assertFalse((self.autostart / "dikte.desktop").exists())
|
|
self.assertFalse((self.home / ".local/bin/dikte").is_symlink())
|
|
|
|
def test_removing_leaves_a_command_that_is_not_ours(self):
|
|
command = self.home / ".local/bin/dikte"
|
|
command.parent.mkdir(parents=True)
|
|
command.symlink_to("/somewhere/dikte/__main__.py")
|
|
appimage = self.home / "Dikte.AppImage"
|
|
appimage.touch()
|
|
with Frozen("/tmp/.mount_x/usr/bin/dikte", appimage=str(appimage),
|
|
home=self.home, platform="linux"):
|
|
integrate.remove()
|
|
self.assertTrue(command.is_symlink())
|
|
|
|
def test_a_home_it_cannot_write_to_is_not_a_reason_to_refuse_to_start(self):
|
|
appimage = self.home / "Dikte.AppImage"
|
|
appimage.touch()
|
|
with Frozen("/tmp/.mount_x/usr/bin/dikte", appimage=str(appimage),
|
|
home=self.home, platform="linux"), \
|
|
mock.patch.object(integrate, "_linux_install",
|
|
side_effect=PermissionError):
|
|
self.assertEqual(integrate.ensure(), [])
|
|
|
|
|
|
@posix_only
|
|
class MacOS(Home):
|
|
def agent(self):
|
|
return self.home / "Library/LaunchAgents/io.github.yusufipk.dikte.plist"
|
|
|
|
def install(self, app, force=False):
|
|
with Frozen(str(app / "Contents/MacOS/Dikte"), home=self.home,
|
|
platform="darwin"), \
|
|
mock.patch.object(integrate, "_launchctl_reload"):
|
|
return integrate.install(force=force)
|
|
|
|
def remove(self):
|
|
with Frozen("/Applications/Dikte.app/Contents/MacOS/Dikte",
|
|
home=self.home, platform="darwin"), \
|
|
mock.patch("subprocess.run"):
|
|
return integrate.remove()
|
|
|
|
def test_it_writes_a_login_item_and_the_command(self):
|
|
app = self.home / "Applications" / "Dikte.app"
|
|
(app / "Contents/MacOS").mkdir(parents=True)
|
|
self.install(app)
|
|
|
|
plist = plistlib.loads(self.agent().read_bytes())
|
|
self.assertEqual(plist["Label"], integrate.AGENT_ID)
|
|
# Through `open` rather than the executable, so that the process is one
|
|
# LaunchServices started and the permissions are the bundle's.
|
|
self.assertEqual(plist["ProgramArguments"][:2], ["/usr/bin/open", "-a"])
|
|
self.assertEqual(plist["ProgramArguments"][2], str(app))
|
|
self.assertFalse(plist["KeepAlive"])
|
|
|
|
command = self.home / ".local/bin/dikte"
|
|
self.assertIn(str(app / "Contents/MacOS/Dikte"), command.read_text())
|
|
self.assertTrue(os.access(command, os.X_OK))
|
|
|
|
def test_running_it_again_changes_nothing(self):
|
|
app = self.home / "Applications" / "Dikte.app"
|
|
(app / "Contents/MacOS").mkdir(parents=True)
|
|
self.install(app)
|
|
self.assertEqual(self.install(app), [])
|
|
|
|
def test_it_stands_aside_for_a_bundle_install_mac_sh_built(self):
|
|
"""That one goes under ~/Applications, a disk image is dragged to
|
|
/Applications, and two of them starting at login is one too many."""
|
|
theirs = self.home / "Applications" / "Dikte.app"
|
|
theirs.mkdir(parents=True)
|
|
agent = self.agent()
|
|
agent.parent.mkdir(parents=True)
|
|
agent.write_bytes(plistlib.dumps({
|
|
"Label": integrate.AGENT_ID,
|
|
"ProgramArguments": ["/usr/bin/open", "-a", str(theirs)],
|
|
}))
|
|
|
|
mine = self.home / "Volumes" / "Dikte.app"
|
|
(mine / "Contents/MacOS").mkdir(parents=True)
|
|
self.assertEqual(self.install(mine), [])
|
|
self.assertIn(str(theirs), agent.read_text(encoding="utf-8"))
|
|
|
|
def test_a_login_item_naming_a_bundle_that_is_gone_is_not_in_the_way(self):
|
|
agent = self.agent()
|
|
agent.parent.mkdir(parents=True)
|
|
agent.write_bytes(plistlib.dumps({
|
|
"Label": integrate.AGENT_ID,
|
|
"ProgramArguments": ["/usr/bin/open", "-a", "/gone/Dikte.app"],
|
|
}))
|
|
app = self.home / "Applications" / "Dikte.app"
|
|
(app / "Contents/MacOS").mkdir(parents=True)
|
|
self.assertTrue(self.install(app))
|
|
|
|
def test_a_command_install_mac_sh_wrote_is_left_alone(self):
|
|
command = self.home / ".local/bin/dikte"
|
|
command.parent.mkdir(parents=True)
|
|
command.write_text("#!/bin/sh\n# Written by install-mac.sh.\n"
|
|
"exec /opt/homebrew/bin/python3 /src/__main__.py \"$@\"\n")
|
|
app = self.home / "Applications" / "Dikte.app"
|
|
(app / "Contents/MacOS").mkdir(parents=True)
|
|
self.install(app)
|
|
self.assertIn("install-mac.sh", command.read_text())
|
|
|
|
def test_removing_takes_back_the_login_item_and_command_it_wrote(self):
|
|
app = self.home / "Applications" / "Dikte.app"
|
|
(app / "Contents/MacOS").mkdir(parents=True)
|
|
self.install(app)
|
|
command = self.home / ".local/bin/dikte"
|
|
|
|
self.assertEqual(self.remove(), [self.agent(), command])
|
|
self.assertFalse(self.agent().exists())
|
|
self.assertFalse(command.exists())
|
|
|
|
def test_removing_leaves_another_installers_command_alone(self):
|
|
command = self.home / ".local/bin/dikte"
|
|
command.parent.mkdir(parents=True)
|
|
command.write_text("#!/bin/sh\n# Written by install-mac.sh.\n"
|
|
"exec /usr/local/bin/python3 /src/__main__.py \"$@\"\n")
|
|
|
|
self.assertEqual(self.remove(), [])
|
|
self.assertIn("install-mac.sh", command.read_text())
|
|
|
|
|
|
class Windows(unittest.TestCase):
|
|
"""The half of the Windows install the setup program cannot do.
|
|
|
|
It writes the Start Menu entry, the command and the uninstaller as it runs,
|
|
and asks once whether Dikte should start at sign-in. Changing that answer
|
|
afterwards is what is left here, and the value is faked rather than the
|
|
registry, so that all of it is read on every platform the tests run on.
|
|
"""
|
|
|
|
def setUp(self):
|
|
self.value = ""
|
|
for name, function in (("_run_entry", lambda: self.value),
|
|
("_write_run_entry", self._write),
|
|
("_delete_run_entry", self._delete)):
|
|
patch = mock.patch.object(integrate, name, function)
|
|
patch.start()
|
|
self.addCleanup(patch.stop)
|
|
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.tmp.cleanup)
|
|
self.installed = pathlib.Path(self.tmp.name).resolve()
|
|
self.app = self.installed / "Dikte.exe"
|
|
self.app.write_text("")
|
|
|
|
def _write(self, command):
|
|
self.value = command
|
|
|
|
def _delete(self):
|
|
there, self.value = bool(self.value), ""
|
|
return there
|
|
|
|
def install(self, force=False):
|
|
with Frozen(str(self.app), platform="win32"):
|
|
return integrate.install(force=force)
|
|
|
|
def remove(self):
|
|
with Frozen(str(self.app), platform="win32"):
|
|
return integrate.remove()
|
|
|
|
def test_the_windowed_executable_is_what_starts_at_sign_in(self):
|
|
"""The console one is what the `dikte` command runs, and a sign-in that
|
|
started that would open a console window nobody asked for."""
|
|
with Frozen(str(self.installed / "dikte.exe"), platform="win32"):
|
|
self.assertEqual(integrate.target(), self.app)
|
|
|
|
def test_a_start_does_not_turn_it_on_for_somebody_who_said_no(self):
|
|
self.assertEqual(self.install(), [])
|
|
self.assertEqual(self.value, "")
|
|
|
|
def test_typing_it_turns_starting_at_sign_in_on(self):
|
|
self.assertEqual(len(self.install(force=True)), 1)
|
|
self.assertEqual(self.value, f'"{self.app}"')
|
|
|
|
def test_an_installation_that_moved_is_pointed_at_where_it_is_now(self):
|
|
self.value = '"D:\\Dikte\\Dikte.exe"'
|
|
self.assertEqual(len(self.install()), 1)
|
|
self.assertEqual(self.value, f'"{self.app}"')
|
|
|
|
def test_running_it_again_changes_nothing(self):
|
|
self.install(force=True)
|
|
self.assertEqual(self.install(), [])
|
|
|
|
def test_removing_stops_it_starting_and_says_so_once(self):
|
|
self.install(force=True)
|
|
self.assertEqual(len(self.remove()), 1)
|
|
self.assertEqual(self.value, "")
|
|
self.assertEqual(self.remove(), [])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|