def _gather_crash_info(self):
"""Gather crash information to display.
Args:
pages: A list of lists of the open pages (URLs as strings)
cmdhist: A list with the command history (as strings)
exc: An exception tuple (type, value, traceback)
"""
try:
application = QApplication.instance()
launch_time = application.launch_time.ctime()
self._crash_info.append(('Launch time', launch_time))
except Exception:
self._crash_info.append(("Launch time", traceback.format_exc()))
try:
self._crash_info.append(("Version info", version.version()))
except Exception:
self._crash_info.append(("Version info", traceback.format_exc()))
try:
conf = objreg.get('config')
self._crash_info.append(("Config", conf.dump_userconfig()))
except Exception:
self._crash_info.append(("Config", traceback.format_exc()))
try:
self._crash_info.append(
("Environment", _get_environment_vars()))
except Exception:
self._crash_info.append(("Environment", traceback.format_exc()))
def _gather_crash_info(self):
"""Gather crash information to display.
Args:
pages: A list of lists of the open pages (URLs as strings)
cmdhist: A list with the command history (as strings)
exc: An exception tuple (type, value, traceback)
"""
try:
application = QApplication.instance()
launch_time = application.launch_time.ctime()
crash_time = datetime.datetime.now().ctime()
text = 'Launch: {}\nCrash: {}'.format(launch_time, crash_time)
self._crash_info.append(('Timestamps', text))
except Exception:
self._crash_info.append(("Launch time", traceback.format_exc()))
try:
self._crash_info.append(("Version info", version.version()))
except Exception:
self._crash_info.append(("Version info", traceback.format_exc()))
try:
self._crash_info.append(("Config",
config.instance.dump_userconfig()))
except Exception:
self._crash_info.append(("Config", traceback.format_exc()))
try:
self._crash_info.append(("Environment", _get_environment_vars()))
except Exception:
self._crash_info.append(("Environment", traceback.format_exc()))
def _gather_crash_info(self):
"""Gather crash information to display.
Args:
pages: A list of lists of the open pages (URLs as strings)
cmdhist: A list with the command history (as strings)
exc: An exception tuple (type, value, traceback)
"""
try:
application = QApplication.instance()
launch_time = application.launch_time.ctime()
self._crash_info.append(('Launch time', launch_time))
except Exception:
self._crash_info.append(("Launch time", traceback.format_exc()))
try:
self._crash_info.append(("Version info", version.version()))
except Exception:
self._crash_info.append(("Version info", traceback.format_exc()))
try:
conf = objreg.get('config')
self._crash_info.append(("Config", conf.dump_userconfig()))
except Exception:
self._crash_info.append(("Config", traceback.format_exc()))
try:
self._crash_info.append(("Environment", _get_environment_vars()))
except Exception:
self._crash_info.append(("Environment", traceback.format_exc()))
def _gather_crash_info(self):
"""Gather crash information to display.
Args:
pages: A list of the open pages (URLs as strings)
cmdhist: A list with the command history (as strings)
exc: An exception tuple (type, value, traceback)
"""
self._crash_info = [
("How did it happen?", ""),
]
try:
self._crash_info.append(("Contact info",
"User: {}".format(getpass.getuser())))
except Exception:
self._crash_info.append(("Contact info", traceback.format_exc()))
try:
self._crash_info.append(("Version info", version.version()))
except Exception:
self._crash_info.append(("Version info", traceback.format_exc()))
try:
conf = objreg.get('config')
self._crash_info.append(("Config", conf.dump_userconfig()))
except Exception:
self._crash_info.append(("Config", traceback.format_exc()))
def qute_version(_win_id, _request):
"""Handler for qute:version. Return HTML content as bytes."""
html = jinja.env.get_template('version.html').render(
title='Version info',
version=version.version(),
copyright=qutebrowser.__copyright__)
return html.encode('UTF-8', errors='xmlcharrefreplace')
def qute_version(_url):
"""Handler for qute://version."""
src = jinja.render('version.html',
title='Version info',
version=version.version(),
copyright=qutebrowser.__copyright__)
return 'text/html', src
def dump_exception_info(exc, pages, cmdhist, objects):
"""Dump exception info to stderr.
Args:
exc: An exception tuple (type, value, traceback)
pages: A list of lists of the open pages (URLs as strings)
cmdhist: A list with the command history (as strings)
objects: A list of all QObjects as string.
"""
print(file=sys.stderr)
print("\n\n===== Handling exception with --no-err-windows... =====\n\n",
file=sys.stderr)
print("\n---- Exceptions ----", file=sys.stderr)
print(''.join(traceback.format_exception(*exc)), file=sys.stderr)
print("\n---- Version info ----", file=sys.stderr)
try:
print(version.version(), file=sys.stderr)
except Exception:
traceback.print_exc()
print("\n---- Config ----", file=sys.stderr)
try:
conf = objreg.get('config')
print(conf.dump_userconfig(), file=sys.stderr)
except Exception:
traceback.print_exc()
print("\n---- Commandline args ----", file=sys.stderr)
print(' '.join(sys.argv[1:]), file=sys.stderr)
print("\n---- Open pages ----", file=sys.stderr)
print('\n\n'.join('\n'.join(e) for e in pages), file=sys.stderr)
print("\n---- Command history ----", file=sys.stderr)
print('\n'.join(cmdhist), file=sys.stderr)
print("\n---- Objects ----", file=sys.stderr)
print(objects, file=sys.stderr)
def dump_exception_info(exc, pages, cmdhist, objects):
"""Dump exception info to stderr.
Args:
exc: An exception tuple (type, value, traceback)
pages: A list of lists of the open pages (URLs as strings)
cmdhist: A list with the command history (as strings)
objects: A list of all QObjects as string.
"""
print(file=sys.stderr)
print("\n\n===== Handling exception with --no-err-windows... =====\n\n",
file=sys.stderr)
print("\n---- Exceptions ----", file=sys.stderr)
print(''.join(traceback.format_exception(*exc)), file=sys.stderr)
print("\n---- Version info ----", file=sys.stderr)
try:
print(version.version(), file=sys.stderr)
except Exception:
traceback.print_exc()
print("\n---- Config ----", file=sys.stderr)
try:
conf = objreg.get('config')
print(conf.dump_userconfig(), file=sys.stderr)
except Exception:
traceback.print_exc()
print("\n---- Commandline args ----", file=sys.stderr)
print(' '.join(sys.argv[1:]), file=sys.stderr)
print("\n---- Open pages ----", file=sys.stderr)
print('\n\n'.join('\n'.join(e) for e in pages), file=sys.stderr)
print("\n---- Command history ----", file=sys.stderr)
print('\n'.join(cmdhist), file=sys.stderr)
print("\n---- Objects ----", file=sys.stderr)
print(objects, file=sys.stderr)
def test_qt_version(self, monkeypatch):
"""Test the python version in the output."""
monkeypatch.setattr('qutebrowser.utils.version.QT_VERSION_STR', '12.3')
monkeypatch.setattr('qutebrowser.utils.version.qVersion',
lambda: '45.6')
lines = version.version().splitlines()
assert lines[3] == 'Qt: 12.3, runtime: 45.6'
def _gather_crash_info(self):
"""Gather crash information to display.
Args:
pages: A list of lists of the open pages (URLs as strings)
cmdhist: A list with the command history (as strings)
exc: An exception tuple (type, value, traceback)
"""
self._crash_info = [
("How did it happen?", ""),
]
try:
self._crash_info.append(
("Contact info", "User: {}".format(getpass.getuser())))
except Exception:
self._crash_info.append(("Contact info", traceback.format_exc()))
try:
self._crash_info.append(("Version info", version.version()))
except Exception:
self._crash_info.append(("Version info", traceback.format_exc()))
try:
conf = objreg.get('config')
self._crash_info.append(("Config", conf.dump_userconfig()))
except Exception:
self._crash_info.append(("Config", traceback.format_exc()))
def run(args):
"""Initialize everthing and run the application."""
# pylint: disable=too-many-statements
if args.version:
print(version.version())
print()
print()
print(qutebrowser.__copyright__)
print()
print(version.GPL_BOILERPLATE.strip())
sys.exit(0)
quitter = Quitter(args)
objreg.register('quitter', quitter)
global qApp
qApp = Application(args)
qApp.lastWindowClosed.connect(quitter.on_last_window_closed)
crash_handler = crashsignal.CrashHandler(app=qApp,
quitter=quitter,
args=args,
parent=qApp)
crash_handler.activate()
objreg.register('crash-handler', crash_handler)
signal_handler = crashsignal.SignalHandler(app=qApp,
quitter=quitter,
parent=qApp)
signal_handler.activate()
objreg.register('signal-handler', signal_handler)
try:
sent = ipc.send_to_running_instance(args.command)
if sent:
sys.exit(0)
log.init.debug("Starting IPC server...")
server = ipc.IPCServer(qApp)
objreg.register('ipc-server', server)
server.got_args.connect(
lambda args, cwd: process_pos_args(args, cwd=cwd, via_ipc=True))
except ipc.AddressInUseError as e:
# This could be a race condition...
log.init.debug("Got AddressInUseError, trying again.")
time.sleep(500)
sent = ipc.send_to_running_instance(args.command)
if sent:
sys.exit(0)
else:
ipc.display_error(e)
sys.exit(1)
except ipc.Error as e:
ipc.display_error(e)
# We didn't really initialize much so far, so we just quit hard.
sys.exit(1)
init(args, crash_handler)
ret = qt_mainloop()
return ret
def run(args):
"""Initialize everthing and run the application."""
# pylint: disable=too-many-statements
if args.version:
print(version.version())
print()
print()
print(qutebrowser.__copyright__)
print()
print(version.GPL_BOILERPLATE.strip())
sys.exit(usertypes.Exit.ok)
if args.temp_basedir:
args.basedir = tempfile.mkdtemp(prefix='qutebrowser-basedir-')
quitter = Quitter(args)
objreg.register('quitter', quitter)
global qApp
qApp = Application(args)
qApp.lastWindowClosed.connect(quitter.on_last_window_closed)
crash_handler = crashsignal.CrashHandler(
app=qApp, quitter=quitter, args=args, parent=qApp)
crash_handler.activate()
objreg.register('crash-handler', crash_handler)
signal_handler = crashsignal.SignalHandler(app=qApp, quitter=quitter,
parent=qApp)
signal_handler.activate()
objreg.register('signal-handler', signal_handler)
try:
sent = ipc.send_to_running_instance(args)
if sent:
sys.exit(usertypes.Exit.ok)
log.init.debug("Starting IPC server...")
server = ipc.IPCServer(args, qApp)
objreg.register('ipc-server', server)
server.got_args.connect(lambda args, cwd:
process_pos_args(args, cwd=cwd, via_ipc=True))
except ipc.AddressInUseError as e:
# This could be a race condition...
log.init.debug("Got AddressInUseError, trying again.")
time.sleep(500)
sent = ipc.send_to_running_instance(args)
if sent:
sys.exit(usertypes.Exit.ok)
else:
ipc.display_error(e, args)
sys.exit(usertypes.Exit.err_ipc)
except ipc.Error as e:
ipc.display_error(e, args)
# We didn't really initialize much so far, so we just quit hard.
sys.exit(usertypes.Exit.err_ipc)
init(args, crash_handler)
ret = qt_mainloop()
return ret
def test_frozen(self, monkeypatch, frozen, expected):
"""Test "Frozen: ..." in the version output."""
if frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
lines = version.version().splitlines()
assert lines[9] == expected
def test_platform(self, monkeypatch):
"""Test platform in the version output."""
monkeypatch.setattr('qutebrowser.utils.version.platform.platform',
lambda: 'toaster')
monkeypatch.setattr('qutebrowser.utils.version.platform.architecture',
lambda: ('64bit', ''))
lines = version.version().splitlines()
assert lines[10] == 'Platform: toaster, 64bit'
def run(args):
"""Initialize everything and run the application."""
if args.temp_basedir:
args.basedir = tempfile.mkdtemp(prefix='qutebrowser-basedir-')
quitter = Quitter(args)
objreg.register('quitter', quitter)
log.init.debug("Initializing directories...")
standarddir.init(args)
utils.preload_resources()
log.init.debug("Initializing config...")
configinit.early_init(args)
global qApp
qApp = Application(args)
qApp.setOrganizationName("qutebrowser")
qApp.setApplicationName("qutebrowser")
qApp.setDesktopFileName("qutebrowser")
qApp.setApplicationVersion(qutebrowser.__version__)
qApp.lastWindowClosed.connect(quitter.on_last_window_closed)
if args.version:
print(version.version())
sys.exit(usertypes.Exit.ok)
crash_handler = crashsignal.CrashHandler(app=qApp,
quitter=quitter,
args=args,
parent=qApp)
crash_handler.activate()
objreg.register('crash-handler', crash_handler)
signal_handler = crashsignal.SignalHandler(app=qApp,
quitter=quitter,
parent=qApp)
signal_handler.activate()
objreg.register('signal-handler', signal_handler)
try:
server = ipc.send_or_listen(args)
except ipc.Error:
# ipc.send_or_listen already displays the error message for us.
# We didn't really initialize much so far, so we just quit hard.
sys.exit(usertypes.Exit.err_ipc)
if server is None:
if args.backend is not None:
log.init.warning("Backend from the running instance will be used")
sys.exit(usertypes.Exit.ok)
else:
server.got_args.connect(lambda args, target_arg, cwd: process_pos_args(
args, cwd=cwd, via_ipc=True, target_arg=target_arg))
init(args, crash_handler)
ret = qt_mainloop()
return ret
def run(args):
"""Initialize everything and run the application."""
if args.temp_basedir:
args.basedir = tempfile.mkdtemp(prefix='qutebrowser-basedir-')
quitter = Quitter(args)
objreg.register('quitter', quitter)
log.init.debug("Initializing directories...")
standarddir.init(args)
utils.preload_resources()
log.init.debug("Initializing config...")
configinit.early_init(args)
global q_app
q_app = Application(args)
q_app.setOrganizationName("qutebrowser")
q_app.setApplicationName("qutebrowser")
q_app.setDesktopFileName("qutebrowser")
q_app.setApplicationVersion(qutebrowser.__version__)
q_app.lastWindowClosed.connect(quitter.on_last_window_closed)
if args.version:
print(version.version())
sys.exit(usertypes.Exit.ok)
crash_handler = crashsignal.CrashHandler(
app=q_app, quitter=quitter, args=args, parent=q_app)
crash_handler.activate()
objreg.register('crash-handler', crash_handler)
signal_handler = crashsignal.SignalHandler(app=q_app, quitter=quitter,
parent=q_app)
signal_handler.activate()
objreg.register('signal-handler', signal_handler)
try:
server = ipc.send_or_listen(args)
except ipc.Error:
# ipc.send_or_listen already displays the error message for us.
# We didn't really initialize much so far, so we just quit hard.
sys.exit(usertypes.Exit.err_ipc)
if server is None:
if args.backend is not None:
log.init.warning(
"Backend from the running instance will be used")
sys.exit(usertypes.Exit.ok)
else:
server.got_args.connect(lambda args, target_arg, cwd:
process_pos_args(args, cwd=cwd, via_ipc=True,
target_arg=target_arg))
init(args, crash_handler)
ret = qt_mainloop()
return ret
def test_python_version(self, monkeypatch):
"""Test the python version in the output."""
monkeypatch.setattr(
'qutebrowser.utils.version.platform.python_implementation',
lambda: 'python_implementation')
monkeypatch.setattr(
'qutebrowser.utils.version.platform.python_version',
lambda: 'python_version')
lines = version.version().splitlines()
assert lines[2] == 'python_implementation: python_version'
def run(args):
"""Initialize everything and run the application."""
# pylint: disable=too-many-statements
if args.version:
print(version.version(short=True))
print()
print()
print(qutebrowser.__copyright__)
print()
print(version.GPL_BOILERPLATE.strip())
sys.exit(usertypes.Exit.ok)
if args.temp_basedir:
args.basedir = tempfile.mkdtemp(prefix='qutebrowser-basedir-')
quitter = Quitter(args)
objreg.register('quitter', quitter)
global qApp
qApp = Application(args)
qApp.setOrganizationName("qutebrowser")
qApp.setApplicationName("qutebrowser")
qApp.setApplicationVersion(qutebrowser.__version__)
qApp.lastWindowClosed.connect(quitter.on_last_window_closed)
crash_handler = crashsignal.CrashHandler(app=qApp,
quitter=quitter,
args=args,
parent=qApp)
crash_handler.activate()
objreg.register('crash-handler', crash_handler)
signal_handler = crashsignal.SignalHandler(app=qApp,
quitter=quitter,
parent=qApp)
signal_handler.activate()
objreg.register('signal-handler', signal_handler)
try:
server = ipc.send_or_listen(args)
except ipc.Error:
# ipc.send_or_listen already displays the error message for us.
# We didn't really initialize much so far, so we just quit hard.
sys.exit(usertypes.Exit.err_ipc)
if server is None:
sys.exit(usertypes.Exit.ok)
else:
server.got_args.connect(lambda args, target_arg, cwd: process_pos_args(
args, cwd=cwd, via_ipc=True, target_arg=target_arg))
init(args, crash_handler)
ret = qt_mainloop()
return ret
def run(args):
"""Initialize everything and run the application."""
# pylint: disable=too-many-statements
if args.version:
print(version.version(short=True))
print()
print()
print(qutebrowser.__copyright__)
print()
print(version.GPL_BOILERPLATE.strip())
sys.exit(usertypes.Exit.ok)
if args.temp_basedir:
args.basedir = tempfile.mkdtemp(prefix='qutebrowser-basedir-')
quitter = Quitter(args)
objreg.register('quitter', quitter)
global qApp
qApp = Application(args)
qApp.setOrganizationName("qutebrowser")
qApp.setApplicationName("qutebrowser")
qApp.setApplicationVersion(qutebrowser.__version__)
qApp.lastWindowClosed.connect(quitter.on_last_window_closed)
crash_handler = crashsignal.CrashHandler(
app=qApp, quitter=quitter, args=args, parent=qApp)
crash_handler.activate()
objreg.register('crash-handler', crash_handler)
signal_handler = crashsignal.SignalHandler(app=qApp, quitter=quitter,
parent=qApp)
signal_handler.activate()
objreg.register('signal-handler', signal_handler)
try:
server = ipc.send_or_listen(args)
except ipc.Error:
# ipc.send_or_listen already displays the error message for us.
# We didn't really initialize much so far, so we just quit hard.
sys.exit(usertypes.Exit.err_ipc)
if server is None:
sys.exit(usertypes.Exit.ok)
else:
server.got_args.connect(lambda args, target_arg, cwd:
process_pos_args(args, cwd=cwd, via_ipc=True,
target_arg=target_arg))
init(args, crash_handler)
ret = qt_mainloop()
return ret
def run(args):
"""Initialize everything and run the application."""
if args.temp_basedir:
args.basedir = tempfile.mkdtemp(prefix='qutebrowser-basedir-')
log.init.debug("Initializing directories...")
standarddir.init(args)
utils.preload_resources()
log.init.debug("Initializing config...")
configinit.early_init(args)
log.init.debug("Initializing application...")
global q_app
q_app = Application(args)
q_app.setOrganizationName("qutebrowser")
q_app.setApplicationName("qutebrowser")
q_app.setDesktopFileName("org.qutebrowser.qutebrowser")
q_app.setApplicationVersion(qutebrowser.__version__)
if args.version:
print(version.version())
sys.exit(usertypes.Exit.ok)
quitter.init(args)
crashsignal.init(q_app=q_app, args=args, quitter=quitter.instance)
try:
server = ipc.send_or_listen(args)
except ipc.Error:
# ipc.send_or_listen already displays the error message for us.
# We didn't really initialize much so far, so we just quit hard.
sys.exit(usertypes.Exit.err_ipc)
if server is None:
if args.backend is not None:
log.init.warning(
"Backend from the running instance will be used")
sys.exit(usertypes.Exit.ok)
else:
quitter.instance.shutting_down.connect(server.shutdown)
server.got_args.connect(lambda args, target_arg, cwd:
process_pos_args(args, cwd=cwd, via_ipc=True,
target_arg=target_arg))
init(args=args)
ret = qt_mainloop()
return ret
def test_module_versions(self, monkeypatch):
"""Test module versions in the output."""
monkeypatch.setattr('qutebrowser.utils.version._module_versions',
lambda: ['Hello', 'World'])
lines = version.version().splitlines()
assert (lines[5], lines[6]) == ('Hello', 'World')
def test_webkit_version(self, monkeypatch):
"""Test the webkit version in the output."""
monkeypatch.setattr('qutebrowser.utils.version.qWebKitVersion',
lambda: '567.1')
lines = version.version().splitlines()
assert lines[5] == 'Webkit: 567.1'
def test_version_output(git_commit, frozen, style, with_webkit, stubs,
monkeypatch):
"""Test version.version()."""
class FakeWebEngineProfile:
def httpUserAgent(self):
return 'Toaster/4.0.4 Chrome/CHROMIUMVERSION Teapot/4.1.8'
import_path = os.path.abspath('/IMPORTPATH')
patches = {
'qutebrowser.__file__':
os.path.join(import_path, '__init__.py'),
'qutebrowser.__version__':
'VERSION',
'_git_str':
lambda: ('GIT COMMIT' if git_commit else None),
'platform.python_implementation':
lambda: 'PYTHON IMPLEMENTATION',
'platform.python_version':
lambda: 'PYTHON VERSION',
'PYQT_VERSION_STR':
'PYQT VERSION',
'QT_VERSION_STR':
'QT VERSION',
'qVersion':
lambda: 'QT VERSION',
'_module_versions':
lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
'_pdfjs_version':
lambda: 'PDFJS VERSION',
'QSslSocket':
FakeQSslSocket('SSL VERSION'),
'platform.platform':
lambda: 'PLATFORM',
'platform.architecture':
lambda: ('ARCHITECTURE', ''),
'_os_info':
lambda: ['OS INFO 1', 'OS INFO 2'],
'_path_info':
lambda: {
'PATH DESC': 'PATH NAME'
},
'QApplication': (stubs.FakeQApplication(style='STYLE')
if style else stubs.FakeQApplication(instance=None)),
'QLibraryInfo.location': (lambda _loc: 'QT PATH')
}
substitutions = {
'git_commit': '\nGit commit: GIT COMMIT' if git_commit else '',
'style': '\nStyle: STYLE' if style else '',
'qt': 'QT VERSION',
'frozen': str(frozen),
'import_path': import_path,
}
if with_webkit:
patches['qWebKitVersion'] = lambda: 'WEBKIT VERSION'
patches['objects.backend'] = usertypes.Backend.QtWebKit
patches['QWebEngineProfile'] = None
if with_webkit == 'ng':
patches['qtutils.is_qtwebkit_ng'] = lambda v: True
substitutions['backend'] = 'QtWebKit-NG (WebKit WEBKIT VERSION)'
else:
patches['qtutils.is_qtwebkit_ng'] = lambda v: False
substitutions['backend'] = 'QtWebKit (WebKit WEBKIT VERSION)'
else:
patches['qWebKitVersion'] = None
patches['objects.backend'] = usertypes.Backend.QtWebEngine
patches['QWebEngineProfile'] = FakeWebEngineProfile
substitutions['backend'] = 'QtWebEngine (Chromium CHROMIUMVERSION)'
for attr, val in patches.items():
monkeypatch.setattr('qutebrowser.utils.version.' + attr, val)
if frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
template = textwrap.dedent("""
qutebrowser vVERSION{git_commit}
Backend: {backend}
PYTHON IMPLEMENTATION: PYTHON VERSION
Qt: {qt}
PyQt: PYQT VERSION
MODULE VERSION 1
MODULE VERSION 2
pdf.js: PDFJS VERSION
SSL: SSL VERSION
{style}
Platform: PLATFORM, ARCHITECTURE
Frozen: {frozen}
Imported from {import_path}
Qt library executable path: QT PATH, data path: QT PATH
OS INFO 1
OS INFO 2
Paths:
PATH DESC: PATH NAME
""".lstrip('\n'))
expected = template.rstrip('\n').format(**substitutions)
assert version.version() == expected
def test_pyqt_version(self, monkeypatch):
"""Test the PyQt version in the output."""
monkeypatch.setattr('qutebrowser.utils.version.PYQT_VERSION_STR',
'78.9')
lines = version.version().splitlines()
assert lines[4] == 'PyQt: 78.9'
def test_no_git_commit(self, monkeypatch):
"""Test the git commit with _git_str returning None."""
monkeypatch.setattr('qutebrowser.utils.version._git_str',
lambda: None)
lines = version.version().splitlines()
assert not lines[1].startswith('Git commit:')
def test_version_output(git_commit, harfbuzz, frozen, short, stubs, monkeypatch):
"""Test version.version()."""
patches = {
"qutebrowser.__version__": "VERSION",
"_git_str": lambda: ("GIT COMMIT" if git_commit else None),
"platform.python_implementation": lambda: "PYTHON IMPLEMENTATION",
"platform.python_version": lambda: "PYTHON VERSION",
"QT_VERSION_STR": "QT VERSION",
"qVersion": lambda: "QT RUNTIME VERSION",
"PYQT_VERSION_STR": "PYQT VERSION",
"_module_versions": lambda: ["MODULE VERSION 1", "MODULE VERSION 2"],
"qWebKitVersion": lambda: "WEBKIT VERSION",
"QSslSocket": FakeQSslSocket("SSL VERSION"),
"platform.platform": lambda: "PLATFORM",
"platform.architecture": lambda: ("ARCHITECTURE", ""),
"_os_info": lambda: ["OS INFO 1", "OS INFO 2"],
"QApplication": stubs.FakeQApplication(style="STYLE"),
}
for attr, val in patches.items():
monkeypatch.setattr("qutebrowser.utils.version." + attr, val)
monkeypatch.setenv("DESKTOP_SESSION", "DESKTOP")
if harfbuzz:
monkeypatch.setenv("QT_HARFBUZZ", "HARFBUZZ")
else:
monkeypatch.delenv("QT_HARFBUZZ", raising=False)
if frozen:
monkeypatch.setattr(sys, "frozen", True, raising=False)
else:
monkeypatch.delattr(sys, "frozen", raising=False)
template = textwrap.dedent(
"""
qutebrowser vVERSION
{git_commit}
PYTHON IMPLEMENTATION: PYTHON VERSION
Qt: QT VERSION, runtime: QT RUNTIME VERSION
PyQt: PYQT VERSION
""".lstrip(
"\n"
)
)
if git_commit:
substitutions = {"git_commit": "Git commit: GIT COMMIT\n"}
else:
substitutions = {"git_commit": ""}
if not short:
template += textwrap.dedent(
"""
Style: STYLE
Desktop: DESKTOP
MODULE VERSION 1
MODULE VERSION 2
Webkit: WEBKIT VERSION
Harfbuzz: {harfbuzz}
SSL: SSL VERSION
Frozen: {frozen}
Platform: PLATFORM, ARCHITECTURE
OS INFO 1
OS INFO 2
""".lstrip(
"\n"
)
)
substitutions["harfbuzz"] = "HARFBUZZ" if harfbuzz else "system"
substitutions["frozen"] = str(frozen)
expected = template.rstrip("\n").format(**substitutions)
assert version.version(short=short) == expected
def test_version_output(git_commit, frozen, style, equal_qt, with_webkit,
stubs, monkeypatch):
"""Test version.version()."""
import_path = os.path.abspath('/IMPORTPATH')
patches = {
'qutebrowser.__file__': os.path.join(import_path, '__init__.py'),
'qutebrowser.__version__': 'VERSION',
'_git_str': lambda: ('GIT COMMIT' if git_commit else None),
'platform.python_implementation': lambda: 'PYTHON IMPLEMENTATION',
'platform.python_version': lambda: 'PYTHON VERSION',
'PYQT_VERSION_STR': 'PYQT VERSION',
'QT_VERSION_STR': 'QT VERSION',
'qVersion': (lambda:
'QT VERSION' if equal_qt else 'QT RUNTIME VERSION'),
'_module_versions': lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
'_pdfjs_version': lambda: 'PDFJS VERSION',
'qWebKitVersion': (lambda: 'WEBKIT VERSION') if with_webkit else None,
'QSslSocket': FakeQSslSocket('SSL VERSION'),
'platform.platform': lambda: 'PLATFORM',
'platform.architecture': lambda: ('ARCHITECTURE', ''),
'_os_info': lambda: ['OS INFO 1', 'OS INFO 2'],
'_path_info': lambda: {'PATH DESC': 'PATH NAME'},
'QApplication': (stubs.FakeQApplication(style='STYLE') if style else
stubs.FakeQApplication(instance=None)),
'objects.backend': (usertypes.Backend.QtWebKit if with_webkit
else usertypes.Backend.QtWebEngine),
'qtutils.is_qtwebkit_ng': (lambda v:
True if with_webkit == 'ng' else False),
'QLibraryInfo.location': (lambda _loc: 'QT PATH')
}
for attr, val in patches.items():
monkeypatch.setattr('qutebrowser.utils.version.' + attr, val)
if frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
template = textwrap.dedent("""
qutebrowser vVERSION{git_commit}
Backend: {backend}
PYTHON IMPLEMENTATION: PYTHON VERSION
Qt: {qt}
PyQt: PYQT VERSION
MODULE VERSION 1
MODULE VERSION 2
pdf.js: PDFJS VERSION
Webkit: {webkit}
SSL: SSL VERSION
{style}
Platform: PLATFORM, ARCHITECTURE
Frozen: {frozen}
Imported from {import_path}
Qt library executable path: QT PATH, data path: QT PATH
OS INFO 1
OS INFO 2
Paths:
PATH DESC: PATH NAME
""".lstrip('\n'))
substitutions = {
'git_commit': '\nGit commit: GIT COMMIT' if git_commit else '',
'style': '\nStyle: STYLE' if style else '',
'qt': ('QT VERSION' if equal_qt else
'QT RUNTIME VERSION (compiled QT VERSION)'),
'frozen': str(frozen),
'import_path': import_path,
'webkit': 'WEBKIT VERSION' if with_webkit else 'no',
}
backends = {
True: 'QtWebKit',
False: 'QtWebEngine',
'ng': 'QtWebKit-NG',
}
substitutions['backend'] = backends[with_webkit]
expected = template.rstrip('\n').format(**substitutions)
assert version.version() == expected
def test_git_commit(self, monkeypatch):
"""Test the git commit in the output."""
monkeypatch.setattr('qutebrowser.utils.version._git_str',
lambda: 'deadbeef')
lines = version.version().splitlines()
assert lines[1] == 'Git commit: deadbeef'
def test_harfbuzz_none(self, monkeypatch):
"""Test harfbuzz output with QT_HARFBUZZ unset."""
monkeypatch.delenv('QT_HARFBUZZ', raising=False)
lines = version.version().splitlines()
assert lines[6] == 'Harfbuzz: system'
def test_ssl(self, monkeypatch):
"""Test SSL version in the output."""
monkeypatch.setattr('qutebrowser.utils.version.QSslSocket',
FakeQSslSocket('1.0.1'))
lines = version.version().splitlines()
assert lines[7] == 'SSL: 1.0.1'
def qute_version(_win_id, _request):
"""Handler for qute:version. Return HTML content as bytes."""
html = jinja.env.get_template('version.html').render(
title='Version info', version=version.version(),
copyright=qutebrowser.__copyright__)
return html.encode('UTF-8', errors='xmlcharrefreplace')
def test_version_output(git_commit, frozen, style, equal_qt, with_webkit,
stubs, monkeypatch):
"""Test version.version()."""
import_path = os.path.abspath('/IMPORTPATH')
patches = {
'qutebrowser.__file__':
os.path.join(import_path, '__init__.py'),
'qutebrowser.__version__':
'VERSION',
'_git_str':
lambda: ('GIT COMMIT' if git_commit else None),
'platform.python_implementation':
lambda: 'PYTHON IMPLEMENTATION',
'platform.python_version':
lambda: 'PYTHON VERSION',
'PYQT_VERSION_STR':
'PYQT VERSION',
'QT_VERSION_STR':
'QT VERSION',
'qVersion': (lambda: 'QT VERSION'
if equal_qt else 'QT RUNTIME VERSION'),
'_module_versions':
lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
'_pdfjs_version':
lambda: 'PDFJS VERSION',
'qWebKitVersion': (lambda: 'WEBKIT VERSION') if with_webkit else None,
'QSslSocket':
FakeQSslSocket('SSL VERSION'),
'platform.platform':
lambda: 'PLATFORM',
'platform.architecture':
lambda: ('ARCHITECTURE', ''),
'_os_info':
lambda: ['OS INFO 1', 'OS INFO 2'],
'QApplication': (stubs.FakeQApplication(style='STYLE')
if style else stubs.FakeQApplication(instance=None)),
}
for attr, val in patches.items():
monkeypatch.setattr('qutebrowser.utils.version.' + attr, val)
if frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
template = textwrap.dedent("""
qutebrowser vVERSION
{git_commit}
PYTHON IMPLEMENTATION: PYTHON VERSION
Qt: {qt}
PyQt: PYQT VERSION
MODULE VERSION 1
MODULE VERSION 2
pdf.js: PDFJS VERSION
Webkit: {webkit}
SSL: SSL VERSION
{style}
Platform: PLATFORM, ARCHITECTURE
Frozen: {frozen}
Imported from {import_path}
OS INFO 1
OS INFO 2
""".lstrip('\n'))
substitutions = {
'git_commit':
'Git commit: GIT COMMIT\n' if git_commit else '',
'style':
'\nStyle: STYLE' if style else '',
'qt': ('QT VERSION'
if equal_qt else 'QT RUNTIME VERSION (compiled QT VERSION)'),
'frozen':
str(frozen),
'import_path':
import_path,
'webkit':
'WEBKIT VERSION' if with_webkit else 'no'
}
expected = template.rstrip('\n').format(**substitutions)
assert version.version() == expected
def __init__(self, args):
"""Constructor.
Args:
Argument namespace from argparse.
"""
# pylint: disable=too-many-statements
self._quit_status = {
'crash': True,
'tabs': False,
'main': False,
}
self.geometry = None
self._shutting_down = False
self._crashdlg = None
self._crashlogfile = None
qt_args = qtutils.get_args(args)
log.init.debug("Qt arguments: {}, based on {}".format(qt_args, args))
super().__init__(qt_args)
sys.excepthook = self._exception_hook
self._args = args
objreg.register('args', args)
objreg.register('app', self)
if self._args.version:
print(version.version())
print()
print()
print(qutebrowser.__copyright__)
print()
print(version.GPL_BOILERPLATE.strip())
sys.exit(0)
try:
sent = ipc.send_to_running_instance(self._args.command)
if sent:
sys.exit(0)
log.init.debug("Starting IPC server...")
ipc.init()
except ipc.IPCError as e:
text = ('{}\n\nMaybe another instance is running but '
'frozen?'.format(e))
msgbox = QMessageBox(QMessageBox.Critical, "Error while "
"connecting to running instance!", text)
msgbox.exec_()
# We didn't really initialize much so far, so we just quit hard.
sys.exit(1)
log.init.debug("Starting init...")
self.setQuitOnLastWindowClosed(False)
self.setOrganizationName("qutebrowser")
self.setApplicationName("qutebrowser")
self.setApplicationVersion(qutebrowser.__version__)
self._init_icon()
utils.actute_warning()
try:
self._init_modules()
except (OSError, UnicodeDecodeError) as e:
msgbox = QMessageBox(
QMessageBox.Critical, "Error while initializing!",
"Error while initializing: {}".format(e))
msgbox.exec_()
sys.exit(1)
QTimer.singleShot(0, self._process_args)
log.init.debug("Initializing eventfilter...")
self._event_filter = modeman.EventFilter(self)
self.installEventFilter(self._event_filter)
log.init.debug("Connecting signals...")
self._connect_signals()
log.init.debug("Setting up signal handlers...")
self._setup_signals()
QDesktopServices.setUrlHandler('http', self.open_desktopservices_url)
QDesktopServices.setUrlHandler('https', self.open_desktopservices_url)
QDesktopServices.setUrlHandler('qute', self.open_desktopservices_url)
log.init.debug("Init done!")
if self._crashdlg is not None:
self._crashdlg.raise_()
def test_version_output(params, stubs, monkeypatch, config_stub):
"""Test version.version()."""
config.instance.config_py_loaded = params.config_py_loaded
import_path = os.path.abspath('/IMPORTPATH')
patches = {
'qutebrowser.__file__':
os.path.join(import_path, '__init__.py'),
'qutebrowser.__version__':
'VERSION',
'_git_str':
lambda: ('GIT COMMIT' if params.git_commit else None),
'platform.python_implementation':
lambda: 'PYTHON IMPLEMENTATION',
'platform.python_version':
lambda: 'PYTHON VERSION',
'sys.executable':
'EXECUTABLE PATH',
'PYQT_VERSION_STR':
'PYQT VERSION',
'earlyinit.qt_version':
lambda: 'QT VERSION',
'_module_versions':
lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
'_pdfjs_version':
lambda: 'PDFJS VERSION',
'QSslSocket':
FakeQSslSocket('SSL VERSION', params.ssl_support),
'platform.platform':
lambda: 'PLATFORM',
'platform.architecture':
lambda: ('ARCHITECTURE', ''),
'_os_info':
lambda: ['OS INFO 1', 'OS INFO 2'],
'_path_info':
lambda: {
'PATH DESC': 'PATH NAME'
},
'QApplication':
(stubs.FakeQApplication(style='STYLE', platform_name='PLATFORM')
if params.qapp else stubs.FakeQApplication(instance=None)),
'QLibraryInfo.location': (lambda _loc: 'QT PATH'),
'sql.version':
lambda: 'SQLITE VERSION',
'_uptime':
lambda: datetime.timedelta(hours=1, minutes=23, seconds=45),
'config.instance.yaml_loaded':
params.autoconfig_loaded,
}
substitutions = {
'git_commit': '\nGit commit: GIT COMMIT' if params.git_commit else '',
'style': '\nStyle: STYLE' if params.qapp else '',
'platform_plugin':
('\nPlatform plugin: PLATFORM' if params.qapp else ''),
'qt': 'QT VERSION',
'frozen': str(params.frozen),
'import_path': import_path,
'python_path': 'EXECUTABLE PATH',
'uptime': "1:23:45",
'autoconfig_loaded': "yes" if params.autoconfig_loaded else "no",
}
ua = _QTWE_USER_AGENT.format('CHROMIUMVERSION')
if version.webenginesettings is None:
patches['_chromium_version'] = lambda: 'CHROMIUMVERSION'
else:
version.webenginesettings._init_user_agent_str(ua)
if params.config_py_loaded:
substitutions["config_py_loaded"] = "{} has been loaded".format(
standarddir.config_py())
else:
substitutions["config_py_loaded"] = "no config.py was loaded"
if params.with_webkit:
patches['qWebKitVersion'] = lambda: 'WEBKIT VERSION'
patches['objects.backend'] = usertypes.Backend.QtWebKit
patches['webenginesettings'] = None
substitutions['backend'] = 'new QtWebKit (WebKit WEBKIT VERSION)'
else:
monkeypatch.delattr(version, 'qtutils.qWebKitVersion', raising=False)
patches['objects.backend'] = usertypes.Backend.QtWebEngine
substitutions['backend'] = 'QtWebEngine (Chromium CHROMIUMVERSION)'
if params.known_distribution:
patches['distribution'] = lambda: version.DistributionInfo(
parsed=version.Distribution.arch,
version=None,
pretty='LINUX DISTRIBUTION',
id='arch')
substitutions['linuxdist'] = ('\nLinux distribution: '
'LINUX DISTRIBUTION (arch)')
substitutions['osinfo'] = ''
else:
patches['distribution'] = lambda: None
substitutions['linuxdist'] = ''
substitutions['osinfo'] = 'OS INFO 1\nOS INFO 2\n'
substitutions['ssl'] = 'SSL VERSION' if params.ssl_support else 'no'
for name, val in patches.items():
monkeypatch.setattr('qutebrowser.utils.version.' + name, val)
if params.frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
template = textwrap.dedent("""
qutebrowser vVERSION{git_commit}
Backend: {backend}
Qt: {qt}
PYTHON IMPLEMENTATION: PYTHON VERSION
PyQt: PYQT VERSION
MODULE VERSION 1
MODULE VERSION 2
pdf.js: PDFJS VERSION
sqlite: SQLITE VERSION
QtNetwork SSL: {ssl}
{style}{platform_plugin}
Platform: PLATFORM, ARCHITECTURE{linuxdist}
Frozen: {frozen}
Imported from {import_path}
Using Python from {python_path}
Qt library executable path: QT PATH, data path: QT PATH
{osinfo}
Paths:
PATH DESC: PATH NAME
Autoconfig loaded: {autoconfig_loaded}
Config.py: {config_py_loaded}
Uptime: {uptime}
""".lstrip('\n'))
expected = template.rstrip('\n').format(**substitutions)
assert version.version() == expected
def test_version_output(git_commit, harfbuzz, frozen, short, stubs,
monkeypatch):
"""Test version.version()."""
patches = {
'qutebrowser.__version__': 'VERSION',
'_git_str': lambda: ('GIT COMMIT' if git_commit else None),
'platform.python_implementation': lambda: 'PYTHON IMPLEMENTATION',
'platform.python_version': lambda: 'PYTHON VERSION',
'QT_VERSION_STR': 'QT VERSION',
'qVersion': lambda: 'QT RUNTIME VERSION',
'PYQT_VERSION_STR': 'PYQT VERSION',
'_module_versions': lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
'qWebKitVersion': lambda: 'WEBKIT VERSION',
'QSslSocket': FakeQSslSocket('SSL VERSION'),
'platform.platform': lambda: 'PLATFORM',
'platform.architecture': lambda: ('ARCHITECTURE', ''),
'_os_info': lambda: ['OS INFO 1', 'OS INFO 2'],
'QApplication': stubs.FakeQApplication(style='STYLE'),
}
for attr, val in patches.items():
monkeypatch.setattr('qutebrowser.utils.version.' + attr, val)
monkeypatch.setenv('DESKTOP_SESSION', 'DESKTOP')
if harfbuzz:
monkeypatch.setenv('QT_HARFBUZZ', 'HARFBUZZ')
else:
monkeypatch.delenv('QT_HARFBUZZ', raising=False)
if frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
template = textwrap.dedent("""
qutebrowser vVERSION
{git_commit}
PYTHON IMPLEMENTATION: PYTHON VERSION
Qt: QT VERSION, runtime: QT RUNTIME VERSION
PyQt: PYQT VERSION
""".lstrip('\n'))
if git_commit:
substitutions = {'git_commit': 'Git commit: GIT COMMIT\n'}
else:
substitutions = {'git_commit': ''}
if not short:
template += textwrap.dedent("""
Style: STYLE
Desktop: DESKTOP
MODULE VERSION 1
MODULE VERSION 2
Webkit: WEBKIT VERSION
Harfbuzz: {harfbuzz}
SSL: SSL VERSION
Frozen: {frozen}
Platform: PLATFORM, ARCHITECTURE
OS INFO 1
OS INFO 2
""".lstrip('\n'))
substitutions['harfbuzz'] = 'HARFBUZZ' if harfbuzz else 'system'
substitutions['frozen'] = str(frozen)
expected = template.rstrip('\n').format(**substitutions)
assert version.version(short=short) == expected
def test_harfbuzz_set(self, monkeypatch):
"""Test harfbuzz output with QT_HARFBUZZ set."""
monkeypatch.setenv('QT_HARFBUZZ', 'new')
lines = version.version().splitlines()
assert lines[6] == 'Harfbuzz: new'
def __init__(self, args):
"""Constructor.
Args:
Argument namespace from argparse.
"""
self._quit_status = {
'crash': True,
'tabs': False,
'main': False,
}
self._shutting_down = False
self._crashdlg = None
self._crashlogfile = None
self._commandrunner = None
if args.debug:
# We don't enable this earlier because some imports trigger
# warnings (which are not our fault).
warnings.simplefilter('default')
qt_args = qtutils.get_args(args)
log.init.debug("Qt arguments: {}, based on {}".format(qt_args, args))
super().__init__(qt_args)
sys.excepthook = self._exception_hook
self._args = args
objreg.register('args', args)
QTimer.singleShot(0, self._process_init_args)
objreg.register('app', self)
if self._args.version:
print(version.version())
print()
print()
print(qutebrowser.__copyright__)
print()
print(version.GPL_BOILERPLATE.strip())
sys.exit(0)
log.init.debug("Starting init...")
self.setQuitOnLastWindowClosed(False)
self.setOrganizationName("qutebrowser")
self.setApplicationName("qutebrowser")
self.setApplicationVersion(qutebrowser.__version__)
utils.actute_warning()
self._init_modules()
log.init.debug("Initializing eventfilter...")
mode_manager = objreg.get('mode-manager')
self.installEventFilter(mode_manager)
log.init.debug("Connecting signals...")
self._connect_signals()
modeman.enter(usertypes.KeyMode.normal, 'init')
log.init.debug("Showing mainwindow...")
if not args.nowindow:
objreg.get('main-window').show()
log.init.debug("Applying python hacks...")
self._python_hacks()
log.init.debug("Init done!")
if self._crashdlg is not None:
self._crashdlg.raise_()
def test_version_output(git_commit, frozen, style, equal_qt, with_webkit,
stubs, monkeypatch):
"""Test version.version()."""
import_path = os.path.abspath('/IMPORTPATH')
patches = {
'qutebrowser.__file__': os.path.join(import_path, '__init__.py'),
'qutebrowser.__version__': 'VERSION',
'_git_str': lambda: ('GIT COMMIT' if git_commit else None),
'platform.python_implementation': lambda: 'PYTHON IMPLEMENTATION',
'platform.python_version': lambda: 'PYTHON VERSION',
'PYQT_VERSION_STR': 'PYQT VERSION',
'QT_VERSION_STR': 'QT VERSION',
'qVersion': (lambda:
'QT VERSION' if equal_qt else 'QT RUNTIME VERSION'),
'_module_versions': lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
'_pdfjs_version': lambda: 'PDFJS VERSION',
'qWebKitVersion': (lambda: 'WEBKIT VERSION') if with_webkit else None,
'QSslSocket': FakeQSslSocket('SSL VERSION'),
'platform.platform': lambda: 'PLATFORM',
'platform.architecture': lambda: ('ARCHITECTURE', ''),
'_os_info': lambda: ['OS INFO 1', 'OS INFO 2'],
'_path_info': lambda: {'PATH DESC': 'PATH NAME'},
'QApplication': (stubs.FakeQApplication(style='STYLE') if style else
stubs.FakeQApplication(instance=None)),
}
for attr, val in patches.items():
monkeypatch.setattr('qutebrowser.utils.version.' + attr, val)
if frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
template = textwrap.dedent("""
qutebrowser vVERSION
{git_commit}
PYTHON IMPLEMENTATION: PYTHON VERSION
Qt: {qt}
PyQt: PYQT VERSION
MODULE VERSION 1
MODULE VERSION 2
pdf.js: PDFJS VERSION
Webkit: {webkit}
SSL: SSL VERSION
{style}
Platform: PLATFORM, ARCHITECTURE
Frozen: {frozen}
Imported from {import_path}
OS INFO 1
OS INFO 2
Paths:
PATH DESC: PATH NAME
""".lstrip('\n'))
substitutions = {
'git_commit': 'Git commit: GIT COMMIT\n' if git_commit else '',
'style': '\nStyle: STYLE' if style else '',
'qt': ('QT VERSION' if equal_qt else
'QT RUNTIME VERSION (compiled QT VERSION)'),
'frozen': str(frozen),
'import_path': import_path,
'webkit': 'WEBKIT VERSION' if with_webkit else 'no'
}
expected = template.rstrip('\n').format(**substitutions)
assert version.version() == expected
def test_qutebrowser_version(self, monkeypatch):
"""Test the qutebrowser version in the output."""
monkeypatch.setattr(
'qutebrowser.utils.version.qutebrowser.__version__', '23.42')
lines = version.version().splitlines()
assert lines[0] == 'qutebrowser v23.42'
def test_os_info(self, monkeypatch):
"""Test OS info in the output."""
monkeypatch.setattr('qutebrowser.utils.version._os_info',
lambda: ['Hello', 'World'])
lines = version.version().splitlines()
assert (lines[11], lines[12]) == ('Hello', 'World')
def test_version_output(params, stubs, monkeypatch):
"""Test version.version()."""
class FakeWebEngineProfile:
def httpUserAgent(self):
return 'Toaster/4.0.4 Chrome/CHROMIUMVERSION Teapot/4.1.8'
import_path = os.path.abspath('/IMPORTPATH')
patches = {
'qutebrowser.__file__': os.path.join(import_path, '__init__.py'),
'qutebrowser.__version__': 'VERSION',
'_git_str': lambda: ('GIT COMMIT' if params.git_commit else None),
'platform.python_implementation': lambda: 'PYTHON IMPLEMENTATION',
'platform.python_version': lambda: 'PYTHON VERSION',
'PYQT_VERSION_STR': 'PYQT VERSION',
'earlyinit.qt_version': lambda: 'QT VERSION',
'_module_versions': lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
'_pdfjs_version': lambda: 'PDFJS VERSION',
'QSslSocket': FakeQSslSocket('SSL VERSION', params.ssl_support),
'platform.platform': lambda: 'PLATFORM',
'platform.architecture': lambda: ('ARCHITECTURE', ''),
'_os_info': lambda: ['OS INFO 1', 'OS INFO 2'],
'_path_info': lambda: {'PATH DESC': 'PATH NAME'},
'QApplication': (stubs.FakeQApplication(style='STYLE')
if params.style else
stubs.FakeQApplication(instance=None)),
'QLibraryInfo.location': (lambda _loc: 'QT PATH'),
'sql.version': lambda: 'SQLITE VERSION',
}
substitutions = {
'git_commit': '\nGit commit: GIT COMMIT' if params.git_commit else '',
'style': '\nStyle: STYLE' if params.style else '',
'qt': 'QT VERSION',
'frozen': str(params.frozen),
'import_path': import_path,
}
if params.with_webkit:
patches['qWebKitVersion'] = lambda: 'WEBKIT VERSION'
patches['objects.backend'] = usertypes.Backend.QtWebKit
patches['QWebEngineProfile'] = None
substitutions['backend'] = 'new QtWebKit (WebKit WEBKIT VERSION)'
else:
monkeypatch.delattr(version, 'qtutils.qWebKitVersion', raising=False)
patches['objects.backend'] = usertypes.Backend.QtWebEngine
patches['QWebEngineProfile'] = FakeWebEngineProfile
substitutions['backend'] = 'QtWebEngine (Chromium CHROMIUMVERSION)'
if params.known_distribution:
patches['distribution'] = lambda: version.DistributionInfo(
parsed=version.Distribution.arch, version=None,
pretty='LINUX DISTRIBUTION', id='arch')
substitutions['linuxdist'] = ('\nLinux distribution: '
'LINUX DISTRIBUTION (arch)')
substitutions['osinfo'] = ''
else:
patches['distribution'] = lambda: None
substitutions['linuxdist'] = ''
substitutions['osinfo'] = 'OS INFO 1\nOS INFO 2\n'
substitutions['ssl'] = 'SSL VERSION' if params.ssl_support else 'no'
for name, val in patches.items():
monkeypatch.setattr('qutebrowser.utils.version.' + name, val)
if params.frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
template = textwrap.dedent("""
qutebrowser vVERSION{git_commit}
Backend: {backend}
PYTHON IMPLEMENTATION: PYTHON VERSION
Qt: {qt}
PyQt: PYQT VERSION
MODULE VERSION 1
MODULE VERSION 2
pdf.js: PDFJS VERSION
sqlite: SQLITE VERSION
QtNetwork SSL: {ssl}
{style}
Platform: PLATFORM, ARCHITECTURE{linuxdist}
Frozen: {frozen}
Imported from {import_path}
Qt library executable path: QT PATH, data path: QT PATH
{osinfo}
Paths:
PATH DESC: PATH NAME
""".lstrip('\n'))
expected = template.rstrip('\n').format(**substitutions)
assert version.version() == expected
def qute_version(_url):
"""Handler for qute:version."""
html = jinja.render('version.html', title='Version info',
version=version.version(),
copyright=qutebrowser.__copyright__)
return 'text/html', html
def __init__(self, args):
"""Constructor.
Args:
Argument namespace from argparse.
"""
self._quit_status = {
'crash': True,
'tabs': False,
'main': False,
}
self.geometry = None
self._shutting_down = False
self._crashdlg = None
self._crashlogfile = None
if args.debug:
# We don't enable this earlier because some imports trigger
# warnings (which are not our fault).
warnings.simplefilter('default')
qt_args = qtutils.get_args(args)
log.init.debug("Qt arguments: {}, based on {}".format(qt_args, args))
super().__init__(qt_args)
sys.excepthook = self._exception_hook
self._args = args
objreg.register('args', args)
objreg.register('app', self)
if self._args.version:
print(version.version())
print()
print()
print(qutebrowser.__copyright__)
print()
print(version.GPL_BOILERPLATE.strip())
sys.exit(0)
sent = ipc.send_to_running_instance(self._args.command)
if sent:
sys.exit(0)
log.init.debug("Starting init...")
self.setQuitOnLastWindowClosed(False)
self.setOrganizationName("qutebrowser")
self.setApplicationName("qutebrowser")
self.setApplicationVersion(qutebrowser.__version__)
utils.actute_warning()
self._init_modules()
QTimer.singleShot(0, self._open_pages)
log.init.debug("Initializing eventfilter...")
self._event_filter = modeman.EventFilter(self)
self.installEventFilter(self._event_filter)
log.init.debug("Connecting signals...")
self._connect_signals()
log.init.debug("Applying python hacks...")
self._python_hacks()
log.init.debug("Starting IPC server...")
ipc.init()
QDesktopServices.setUrlHandler('http', self.open_desktopservices_url)
QDesktopServices.setUrlHandler('https', self.open_desktopservices_url)
QDesktopServices.setUrlHandler('qute', self.open_desktopservices_url)
log.init.debug("Init done!")
if self._crashdlg is not None:
self._crashdlg.raise_()
def test_version_output(git_commit, harfbuzz, frozen, short, stubs,
monkeypatch):
"""Test version.version()."""
patches = {
'qutebrowser.__version__': 'VERSION',
'_git_str': lambda: ('GIT COMMIT' if git_commit else None),
'platform.python_implementation': lambda: 'PYTHON IMPLEMENTATION',
'platform.python_version': lambda: 'PYTHON VERSION',
'QT_VERSION_STR': 'QT VERSION',
'qVersion': lambda: 'QT RUNTIME VERSION',
'PYQT_VERSION_STR': 'PYQT VERSION',
'_module_versions': lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
'_pdfjs_version': lambda: 'PDFJS VERSION',
'qWebKitVersion': lambda: 'WEBKIT VERSION',
'QSslSocket': FakeQSslSocket('SSL VERSION'),
'platform.platform': lambda: 'PLATFORM',
'platform.architecture': lambda: ('ARCHITECTURE', ''),
'_os_info': lambda: ['OS INFO 1', 'OS INFO 2'],
'QApplication': stubs.FakeQApplication(style='STYLE'),
}
for attr, val in patches.items():
monkeypatch.setattr('qutebrowser.utils.version.' + attr, val)
monkeypatch.setenv('DESKTOP_SESSION', 'DESKTOP')
if harfbuzz:
monkeypatch.setenv('QT_HARFBUZZ', 'HARFBUZZ')
else:
monkeypatch.delenv('QT_HARFBUZZ', raising=False)
if frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
template = textwrap.dedent("""
qutebrowser vVERSION
{git_commit}
PYTHON IMPLEMENTATION: PYTHON VERSION
Qt: QT VERSION, runtime: QT RUNTIME VERSION
PyQt: PYQT VERSION
""".lstrip('\n'))
if git_commit:
substitutions = {'git_commit': 'Git commit: GIT COMMIT\n'}
else:
substitutions = {'git_commit': ''}
if not short:
template += textwrap.dedent("""
Style: STYLE
Desktop: DESKTOP
MODULE VERSION 1
MODULE VERSION 2
pdf.js: PDFJS VERSION
Webkit: WEBKIT VERSION
Harfbuzz: {harfbuzz}
SSL: SSL VERSION
Frozen: {frozen}
Platform: PLATFORM, ARCHITECTURE
OS INFO 1
OS INFO 2
""".lstrip('\n'))
substitutions['harfbuzz'] = 'HARFBUZZ' if harfbuzz else 'system'
substitutions['frozen'] = str(frozen)
expected = template.rstrip('\n').format(**substitutions)
assert version.version(short=short) == expected
def test_version_output(params, stubs, monkeypatch):
"""Test version.version()."""
class FakeWebEngineProfile:
def httpUserAgent(self):
return 'Toaster/4.0.4 Chrome/CHROMIUMVERSION Teapot/4.1.8'
import_path = os.path.abspath('/IMPORTPATH')
patches = {
'qutebrowser.__file__':
os.path.join(import_path, '__init__.py'),
'qutebrowser.__version__':
'VERSION',
'_git_str':
lambda: ('GIT COMMIT' if params.git_commit else None),
'platform.python_implementation':
lambda: 'PYTHON IMPLEMENTATION',
'platform.python_version':
lambda: 'PYTHON VERSION',
'sys.executable':
'EXECUTABLE PATH',
'PYQT_VERSION_STR':
'PYQT VERSION',
'earlyinit.qt_version':
lambda: 'QT VERSION',
'_module_versions':
lambda: ['MODULE VERSION 1', 'MODULE VERSION 2'],
'_pdfjs_version':
lambda: 'PDFJS VERSION',
'QSslSocket':
FakeQSslSocket('SSL VERSION', params.ssl_support),
'platform.platform':
lambda: 'PLATFORM',
'platform.architecture':
lambda: ('ARCHITECTURE', ''),
'_os_info':
lambda: ['OS INFO 1', 'OS INFO 2'],
'_path_info':
lambda: {
'PATH DESC': 'PATH NAME'
},
'QApplication': (stubs.FakeQApplication(style='STYLE') if params.style
else stubs.FakeQApplication(instance=None)),
'QLibraryInfo.location': (lambda _loc: 'QT PATH'),
'sql.version':
lambda: 'SQLITE VERSION',
'_uptime':
lambda: datetime.timedelta(hours=1, minutes=23, seconds=45),
}
substitutions = {
'git_commit': '\nGit commit: GIT COMMIT' if params.git_commit else '',
'style': '\nStyle: STYLE' if params.style else '',
'qt': 'QT VERSION',
'frozen': str(params.frozen),
'import_path': import_path,
'python_path': 'EXECUTABLE PATH',
}
if params.with_webkit:
patches['qWebKitVersion'] = lambda: 'WEBKIT VERSION'
patches['objects.backend'] = usertypes.Backend.QtWebKit
patches['QWebEngineProfile'] = None
substitutions['backend'] = 'new QtWebKit (WebKit WEBKIT VERSION)'
else:
monkeypatch.delattr(version, 'qtutils.qWebKitVersion', raising=False)
patches['objects.backend'] = usertypes.Backend.QtWebEngine
patches['QWebEngineProfile'] = FakeWebEngineProfile
substitutions['backend'] = 'QtWebEngine (Chromium CHROMIUMVERSION)'
if params.known_distribution:
patches['distribution'] = lambda: version.DistributionInfo(
parsed=version.Distribution.arch,
version=None,
pretty='LINUX DISTRIBUTION',
id='arch')
substitutions['linuxdist'] = ('\nLinux distribution: '
'LINUX DISTRIBUTION (arch)')
substitutions['osinfo'] = ''
else:
patches['distribution'] = lambda: None
substitutions['linuxdist'] = ''
substitutions['osinfo'] = 'OS INFO 1\nOS INFO 2\n'
substitutions['ssl'] = 'SSL VERSION' if params.ssl_support else 'no'
for name, val in patches.items():
monkeypatch.setattr('qutebrowser.utils.version.' + name, val)
if params.frozen:
monkeypatch.setattr(sys, 'frozen', True, raising=False)
else:
monkeypatch.delattr(sys, 'frozen', raising=False)
substitutions['uptime'] = "1:23:45"
template = textwrap.dedent("""
qutebrowser vVERSION{git_commit}
Backend: {backend}
PYTHON IMPLEMENTATION: PYTHON VERSION
Qt: {qt}
PyQt: PYQT VERSION
MODULE VERSION 1
MODULE VERSION 2
pdf.js: PDFJS VERSION
sqlite: SQLITE VERSION
QtNetwork SSL: {ssl}
{style}
Platform: PLATFORM, ARCHITECTURE{linuxdist}
Frozen: {frozen}
Imported from {import_path}
Using Python from {python_path}
Qt library executable path: QT PATH, data path: QT PATH
{osinfo}
Paths:
PATH DESC: PATH NAME
Uptime: {uptime}
""".lstrip('\n'))
expected = template.rstrip('\n').format(**substitutions)
assert version.version() == expected
def __init__(self, args):
"""Constructor.
Args:
Argument namespace from argparse.
"""
self._quit_status = {
'crash': True,
'tabs': False,
'main': False,
}
self.geometry = None
self._shutting_down = False
self._crashdlg = None
self._crashlogfile = None
if args.debug:
# We don't enable this earlier because some imports trigger
# warnings (which are not our fault).
warnings.simplefilter('default')
qt_args = qtutils.get_args(args)
log.init.debug("Qt arguments: {}, based on {}".format(qt_args, args))
super().__init__(qt_args)
sys.excepthook = self._exception_hook
self._args = args
objreg.register('args', args)
objreg.register('app', self)
if self._args.version:
print(version.version())
print()
print()
print(qutebrowser.__copyright__)
print()
print(version.GPL_BOILERPLATE.strip())
sys.exit(0)
sent = ipc.send_to_running_instance(self._args.command)
if sent:
sys.exit(0)
log.init.debug("Starting init...")
self.setQuitOnLastWindowClosed(False)
self.setOrganizationName("qutebrowser")
self.setApplicationName("qutebrowser")
self.setApplicationVersion(qutebrowser.__version__)
utils.actute_warning()
self._init_modules()
QTimer.singleShot(0, self._open_pages)
log.init.debug("Initializing eventfilter...")
self._event_filter = modeman.EventFilter(self)
self.installEventFilter(self._event_filter)
log.init.debug("Connecting signals...")
self._connect_signals()
log.init.debug("Applying python hacks...")
self._python_hacks()
log.init.debug("Starting IPC server...")
ipc.init()
QDesktopServices.setUrlHandler('http', self.open_desktopservices_url)
QDesktopServices.setUrlHandler('https', self.open_desktopservices_url)
QDesktopServices.setUrlHandler('qute', self.open_desktopservices_url)
log.init.debug("Init done!")
if self._crashdlg is not None:
self._crashdlg.raise_()
def __init__(self, args):
"""Constructor.
Args:
Argument namespace from argparse.
"""
# pylint: disable=too-many-statements
self._quit_status = {
'crash': True,
'tabs': False,
'main': False,
}
self.geometry = None
self._shutting_down = False
self._crashdlg = None
self._crashlogfile = None
if args.debug:
# We don't enable this earlier because some imports trigger
# warnings (which are not our fault).
warnings.simplefilter('default')
qt_args = qtutils.get_args(args)
log.init.debug("Qt arguments: {}, based on {}".format(qt_args, args))
super().__init__(qt_args)
sys.excepthook = self._exception_hook
self._args = args
objreg.register('args', args)
objreg.register('app', self)
if self._args.version:
print(version.version())
print()
print()
print(qutebrowser.__copyright__)
print()
print(version.GPL_BOILERPLATE.strip())
sys.exit(0)
try:
sent = ipc.send_to_running_instance(self._args.command)
if sent:
sys.exit(0)
log.init.debug("Starting IPC server...")
ipc.init()
except ipc.IPCError as e:
text = ('{}\n\nMaybe another instance is running but '
'frozen?'.format(e))
msgbox = QMessageBox(
QMessageBox.Critical, "Error while "
"connecting to running instance!", text)
msgbox.exec_()
# We didn't really initialize much so far, so we just quit hard.
sys.exit(1)
log.init.debug("Starting init...")
self.setQuitOnLastWindowClosed(False)
self.setOrganizationName("qutebrowser")
self.setApplicationName("qutebrowser")
self.setApplicationVersion(qutebrowser.__version__)
self._init_icon()
utils.actute_warning()
try:
self._init_modules()
except (OSError, UnicodeDecodeError) as e:
msgbox = QMessageBox(QMessageBox.Critical,
"Error while initializing!",
"Error while initializing: {}".format(e))
msgbox.exec_()
sys.exit(1)
QTimer.singleShot(0, self._open_pages)
log.init.debug("Initializing eventfilter...")
self._event_filter = modeman.EventFilter(self)
self.installEventFilter(self._event_filter)
log.init.debug("Connecting signals...")
self._connect_signals()
log.init.debug("Applying python hacks...")
self._python_hacks()
QDesktopServices.setUrlHandler('http', self.open_desktopservices_url)
QDesktopServices.setUrlHandler('https', self.open_desktopservices_url)
QDesktopServices.setUrlHandler('qute', self.open_desktopservices_url)
log.init.debug("Init done!")
if self._crashdlg is not None:
self._crashdlg.raise_()
