mirror of
https://github.com/niess/python-appimage.git
synced 2025-09-06 09:40:10 +02:00
275 lines
8.1 KiB
Python
Executable File
275 lines
8.1 KiB
Python
Executable File
#! /usr/bin/env python3
|
|
import argparse
|
|
import inspect
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
from types import FunctionType
|
|
from typing import NamedTuple
|
|
|
|
|
|
from python_appimage.manylinux import PythonVersion
|
|
|
|
|
|
ARGS = None
|
|
|
|
|
|
def assert_eq(expected, found):
|
|
if expected != found:
|
|
raise AssertionError('expected "{}", found "{}"'.format(
|
|
expected, found))
|
|
|
|
|
|
class Script(NamedTuple):
|
|
'''Python script wrapper'''
|
|
|
|
content: str
|
|
|
|
def run(self, appimage: Path):
|
|
'''Run the script through an appimage'''
|
|
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
script = f'{tmpdir}/script.py'
|
|
with open(script, 'w') as f:
|
|
f.write(inspect.getsource(assert_eq))
|
|
f.write(os.linesep)
|
|
f.write(self.content)
|
|
return system(f'{appimage} {script}')
|
|
|
|
|
|
def system(cmd):
|
|
'''Run a system command'''
|
|
|
|
r = subprocess.run(cmd, capture_output=True, shell=True)
|
|
|
|
if r.returncode != 0:
|
|
raise ValueError(r.stderr.decode())
|
|
else:
|
|
return r.stdout.decode()
|
|
|
|
|
|
class TestContext:
|
|
'''Context for testing an image'''
|
|
|
|
def __init__(self, appimage):
|
|
self.appimage = appimage
|
|
|
|
# Guess python version from appimage name.
|
|
version, _, abi, *_ = appimage.name.split('-', 3)
|
|
version = version[6:]
|
|
if abi.endswith('t'):
|
|
version += '-nogil'
|
|
self.version = PythonVersion.from_str(version)
|
|
|
|
# Get some specific AppImage env variables.
|
|
self.env = eval(Script('''
|
|
import os
|
|
appdir = os.environ['APPDIR']
|
|
env = {}
|
|
for var in ('SSL_CERT_FILE', 'TCL_LIBRARY', 'TK_LIBRARY', 'TKPATH'):
|
|
env[var] = os.environ[var].replace(appdir, '$APPDIR')
|
|
print(env)
|
|
''').run(appimage))
|
|
|
|
# Extract the AppImage.
|
|
tmpdir = tempfile.TemporaryDirectory()
|
|
dst = Path(tmpdir.name) / appimage.name
|
|
shutil.copy(appimage, dst)
|
|
system(f'cd {tmpdir.name} && ./{appimage.name} --appimage-extract')
|
|
self.appdir = Path(tmpdir.name) / 'squashfs-root'
|
|
self.tmpdir = tmpdir
|
|
|
|
def list_content(self, path=None):
|
|
'''List the content of an extracted directory'''
|
|
|
|
path = self.appdir if path is None else self.appdir / path
|
|
return sorted(os.listdir(path))
|
|
|
|
def run(self):
|
|
'''Run all tests'''
|
|
|
|
tests = []
|
|
for key, value in self.__class__.__dict__.items():
|
|
if isinstance(value, FunctionType):
|
|
if key.startswith('test_'):
|
|
tests.append(value)
|
|
|
|
n = len(tests)
|
|
m = max(len(test.__doc__) for test in tests)
|
|
for i, test in enumerate(tests):
|
|
sys.stdout.write(
|
|
f'[ {self.appimage.name} | {i + 1:2}/{n} ] {test.__doc__:{m}}'
|
|
)
|
|
sys.stdout.flush()
|
|
try:
|
|
test(self)
|
|
except Exception as e:
|
|
sys.stdout.write(f' -> FAILED ({test.__name__}){os.linesep}')
|
|
sys.stdout.flush()
|
|
raise e
|
|
else:
|
|
sys.stdout.write(f' -> OK{os.linesep}')
|
|
sys.stdout.flush()
|
|
|
|
|
|
def test_root_content(self):
|
|
'''Check the appimage root content'''
|
|
|
|
content = self.list_content()
|
|
expected = ['.DirIcon', 'AppRun', 'opt', 'python.png',
|
|
f'python{self.version.long()}.desktop', 'usr']
|
|
assert_eq(expected, content)
|
|
|
|
def test_python_content(self):
|
|
'''Check the appimage python content'''
|
|
|
|
prefix = f'opt/python{self.version.flavoured()}'
|
|
content = self.list_content(prefix)
|
|
assert_eq(['bin', 'include', 'lib'], content)
|
|
content = self.list_content(f'{prefix}/bin')
|
|
assert_eq(
|
|
[f'pip{self.version.short()}', f'python{self.version.flavoured()}'],
|
|
content
|
|
)
|
|
content = self.list_content(f'{prefix}/include')
|
|
assert_eq([f'python{self.version.flavoured()}'], content)
|
|
content = self.list_content(f'{prefix}/lib')
|
|
assert_eq([f'python{self.version.flavoured()}'], content)
|
|
|
|
def test_system_content(self):
|
|
'''Check the appimage system content'''
|
|
|
|
content = self.list_content('usr')
|
|
assert_eq(['bin', 'lib', 'share'], content)
|
|
content = self.list_content('usr/bin')
|
|
expected = [
|
|
'pip', f'pip{self.version.major}', f'pip{self.version.short()}',
|
|
'python', f'python{self.version.major}',
|
|
f'python{self.version.short()}'
|
|
]
|
|
assert_eq(expected, content)
|
|
|
|
def test_tcltk_bundling(self):
|
|
'''Check Tcl/Tk bundling'''
|
|
|
|
for var in ('TCL_LIBRARY', 'TK_LIBRARY', 'TKPATH'):
|
|
path = Path(self.env[var].replace('$APPDIR', str(self.appdir)))
|
|
assert path.exists()
|
|
|
|
def test_ssl_bundling(self):
|
|
'''Check SSL certs bundling'''
|
|
|
|
var = 'SSL_CERT_FILE'
|
|
path = Path(self.env[var].replace('$APPDIR', str(self.appdir)))
|
|
assert path.exists()
|
|
|
|
def test_bin_symlinks(self):
|
|
'''Check /usr/bin symlinks'''
|
|
|
|
assert_eq(
|
|
(self.appdir /
|
|
f'opt/python{self.version.flavoured()}/bin/pip{self.version.short()}'),
|
|
(self.appdir / f'usr/bin/pip{self.version.short()}').resolve()
|
|
)
|
|
assert_eq(
|
|
f'pip{self.version.short()}',
|
|
str((self.appdir / f'usr/bin/pip{self.version.major}').readlink())
|
|
)
|
|
assert_eq(
|
|
f'pip{self.version.major}',
|
|
str((self.appdir / 'usr/bin/pip').readlink())
|
|
)
|
|
assert_eq(
|
|
f'python{self.version.short()}',
|
|
str((self.appdir / f'usr/bin/python{self.version.major}').readlink())
|
|
)
|
|
assert_eq(
|
|
f'python{self.version.major}',
|
|
str((self.appdir / 'usr/bin/python').readlink())
|
|
)
|
|
|
|
def test_appimage_hook(self):
|
|
'''Test the appimage hook'''
|
|
|
|
Script(f'''
|
|
import os
|
|
assert_eq(os.environ['APPIMAGE_COMMAND'], '{self.appimage}')
|
|
|
|
import sys
|
|
assert_eq('{self.appimage}', sys.executable)
|
|
assert_eq('{self.appimage}', sys._base_executable)
|
|
''').run(self.appimage)
|
|
|
|
def test_python_prefix(self):
|
|
'''Test the python prefix'''
|
|
|
|
Script(f'''
|
|
import os
|
|
import sys
|
|
expected = os.environ["APPDIR"] + '/opt/python{self.version.flavoured()}'
|
|
assert_eq(expected, sys.prefix)
|
|
''').run(self.appimage)
|
|
|
|
def test_ssl_request(self):
|
|
'''Test SSL request (see issue #24)'''
|
|
|
|
if self.version.major > 2:
|
|
Script('''
|
|
from http import HTTPStatus
|
|
import urllib.request
|
|
with urllib.request.urlopen('https://wikipedia.org') as r:
|
|
assert_eq(r.status, HTTPStatus.OK)
|
|
''').run(self.appimage)
|
|
|
|
def test_pip_install(self):
|
|
'''Test pip installing to an extracted AppImage'''
|
|
|
|
r = system(f'{self.appdir}/AppRun -m pip install pip-install-test')
|
|
assert('Successfully installed pip-install-test' in r)
|
|
path = self.appdir / f'opt/python{self.version.flavoured()}/lib/python{self.version.flavoured()}/site-packages/pip_install_test'
|
|
assert(path.exists())
|
|
|
|
def test_tkinter_usage(self):
|
|
'''Test basic tkinter usage'''
|
|
|
|
tkinter = 'tkinter' if self.version.major > 2 else 'Tkinter'
|
|
Script(f'''
|
|
import {tkinter} as tkinter
|
|
tkinter.Tk()
|
|
''').run(self.appimage)
|
|
|
|
def test_venv_usage(self):
|
|
'''Test venv creation'''
|
|
|
|
if self.version.major > 2:
|
|
system(' && '.join((
|
|
f'cd {self.tmpdir.name}',
|
|
f'./{self.appimage.name} -m venv ENV',
|
|
'. ENV/bin/activate',
|
|
)))
|
|
python = Path(f'{self.tmpdir.name}/ENV/bin/python')
|
|
assert_eq(self.appimage.name, str(python.readlink()))
|
|
|
|
|
|
def test():
|
|
'''Test Python AppImage(s)'''
|
|
|
|
for appimage in ARGS.appimage:
|
|
context = TestContext(appimage)
|
|
context.run()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
parser = argparse.ArgumentParser(description = test.__doc__)
|
|
parser.add_argument('appimage',
|
|
help = 'path to appimage(s)',
|
|
nargs = '+',
|
|
type = lambda x: Path(x).absolute()
|
|
)
|
|
|
|
ARGS = parser.parse_args()
|
|
test()
|