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 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 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. """ # 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_()