From 5784c0cbc659a4691c603e1a74d39132208b0720 Mon Sep 17 00:00:00 2001 From: Foo Date: Fri, 19 Aug 2016 22:46:11 +0300 Subject: [PATCH] Use powerline daemon for running awesome bindings Also adds functional tests for awesome bindings. Replaces #1641 --- docs/source/configuration/reference.rst | 7 + powerline/__init__.py | 7 + .../bindings/awesome/powerline-awesome.py | 41 +--- powerline/bindings/awesome/powerline.lua | 5 +- powerline/bindings/bar/powerline-bar.py | 3 +- powerline/bindings/config.py | 2 +- powerline/bindings/wm/__init__.py | 9 + powerline/bindings/wm/awesome.py | 53 +++++ powerline/commands/main.py | 18 +- powerline/config_files/config.json | 3 +- powerline/lint/__init__.py | 3 +- scripts/powerline-daemon | 78 ++++++- scripts/powerline-render | 5 +- tests/run_awesome_tests.sh | 193 ++++++++++++++++++ tests/test_awesome/path/awesome-client | 3 + tests/test_awesome/powerline/config.json | 7 + .../powerline/themes/wm/default.json | 18 ++ .../test_awesome/powerline/themes/wm/dvi.json | 18 ++ tests/test_cmdline.py | 2 +- tests/test_shells/test.sh | 2 +- 20 files changed, 421 insertions(+), 56 deletions(-) create mode 100644 powerline/bindings/wm/awesome.py create mode 100755 tests/run_awesome_tests.sh create mode 100755 tests/test_awesome/path/awesome-client create mode 100644 tests/test_awesome/powerline/config.json create mode 100644 tests/test_awesome/powerline/themes/wm/default.json create mode 100644 tests/test_awesome/powerline/themes/wm/dvi.json diff --git a/docs/source/configuration/reference.rst b/docs/source/configuration/reference.rst index c93cc0ce..23f9bae5 100644 --- a/docs/source/configuration/reference.rst +++ b/docs/source/configuration/reference.rst @@ -215,6 +215,13 @@ Common configuration is a subdictionary that is a value of ``ext`` key in All components are enabled by default. +.. _config-ext-update_interval: + +``update_interval`` + Determines how often WM status bars need to be updated, in seconds. Only + valid for WM extensions which use ``powerline-daemon``. Defaults to + 2 seconds. + .. _config-colors: Color definitions diff --git a/powerline/__init__.py b/powerline/__init__.py index cd9e47d9..f0fb65da 100644 --- a/powerline/__init__.py +++ b/powerline/__init__.py @@ -409,6 +409,11 @@ def _get_log_keys(common_config): )) +DEFAULT_UPDATE_INTERVAL = 2 +'''Default value for :ref:`update_interval ` +''' + + class Powerline(object): '''Main powerline class, entrance point for all powerline uses. Sets powerline up and loads the configuration. @@ -504,6 +509,7 @@ class Powerline(object): self.setup_args = () self.setup_kwargs = {} self.imported_modules = set() + self.update_interval = DEFAULT_UPDATE_INTERVAL get_encoding = staticmethod(get_preferred_output_encoding) '''Get encoding used by the current application @@ -628,6 +634,7 @@ class Powerline(object): or self.ext_config.get('local_themes') != self.prev_ext_config.get('local_themes') ): self.renderer_options['local_themes'] = self.get_local_themes(self.ext_config.get('local_themes')) + self.update_interval = self.ext_config.get('update_interval', 2) load_colorscheme = ( load_colorscheme or not self.prev_ext_config diff --git a/powerline/bindings/awesome/powerline-awesome.py b/powerline/bindings/awesome/powerline-awesome.py index 914a9a18..500d47d7 100755 --- a/powerline/bindings/awesome/powerline-awesome.py +++ b/powerline/bindings/awesome/powerline-awesome.py @@ -4,38 +4,17 @@ from __future__ import (unicode_literals, division, absolute_import, print_funct import sys -from time import sleep -from subprocess import Popen, PIPE - -from powerline import Powerline -from powerline.lib.monotonic import monotonic - -powerline = Powerline('wm', renderer_module='pango_markup') -powerline.update_renderer() - -try: - interval = float(sys.argv[1]) -except IndexError: - interval = 2 +from powerline.bindings.wm import DEFAULT_UPDATE_INTERVAL +from powerline.bindings.wm.awesome import run -def read_to_log(pl, client): - for line in client.stdout: - if line: - pl.info(line, prefix='awesome-client') - for line in client.stderr: - if line: - pl.error(line, prefix='awesome-client') - if client.wait(): - pl.error('Client exited with {0}', client.returncode, prefix='awesome') +def main(): + try: + interval = float(sys.argv[1]) + except IndexError: + interval = DEFAULT_UPDATE_INTERVAL + run(interval=interval) -while True: - start_time = monotonic() - s = powerline.render(side='right') - request = 'powerline_widget:set_markup(\'' + s.replace('\\', '\\\\').replace('\'', '\\\'') + '\')\n' - client = Popen(['awesome-client'], shell=False, stdout=PIPE, stderr=PIPE, stdin=PIPE) - client.stdin.write(request.encode('utf-8')) - client.stdin.close() - read_to_log(powerline.pl, client) - sleep(max(interval - (monotonic() - start_time), 0.1)) +if __name__ == '__main__': + main() diff --git a/powerline/bindings/awesome/powerline.lua b/powerline/bindings/awesome/powerline.lua index 659fade4..82a245e0 100644 --- a/powerline/bindings/awesome/powerline.lua +++ b/powerline/bindings/awesome/powerline.lua @@ -6,6 +6,5 @@ powerline_widget:set_align('right') function powerline(mode, widget) end -bindings_path = string.gsub(debug.getinfo(1).source:match('@(.*)$'), '/[^/]+$', '') -powerline_cmd = bindings_path .. '/powerline-awesome.py' -awful.util.spawn_with_shell('ps -C powerline-awesome.py || ' .. powerline_cmd) +awful.util.spawn_with_shell('powerline-daemon -q') +awful.util.spawn_with_shell('powerline wm.awesome') diff --git a/powerline/bindings/bar/powerline-bar.py b/powerline/bindings/bar/powerline-bar.py index 05ef7685..71e8ae3e 100755 --- a/powerline/bindings/bar/powerline-bar.py +++ b/powerline/bindings/bar/powerline-bar.py @@ -11,6 +11,7 @@ from argparse import ArgumentParser from powerline.lemonbar import LemonbarPowerline from powerline.lib.encoding import get_unicode_writer +from powerline.bindings.wm import DEFAULT_UPDATE_INTERVAL if __name__ == '__main__': @@ -29,7 +30,7 @@ if __name__ == '__main__': def render(reschedule=False): if reschedule: - Timer(0.5, render, kwargs={'reschedule': True}).start() + Timer(DEFAULT_UPDATE_INTERVAL, render, kwargs={'reschedule': True}).start() global lock with lock: diff --git a/powerline/bindings/config.py b/powerline/bindings/config.py index 0db902be..f0617f10 100644 --- a/powerline/bindings/config.py +++ b/powerline/bindings/config.py @@ -99,7 +99,7 @@ class EmptyArgs(object): def init_tmux_environment(pl, args, set_tmux_environment=set_tmux_environment): '''Initialize tmux environment from tmux configuration ''' - powerline = ShellPowerline(finish_args(os.environ, EmptyArgs('tmux', args.config_path))) + powerline = ShellPowerline(finish_args(None, os.environ, EmptyArgs('tmux', args.config_path))) # TODO Move configuration files loading out of Powerline object and use it # directly powerline.update_renderer() diff --git a/powerline/bindings/wm/__init__.py b/powerline/bindings/wm/__init__.py index 0f2cc9d6..c635db54 100644 --- a/powerline/bindings/wm/__init__.py +++ b/powerline/bindings/wm/__init__.py @@ -5,6 +5,10 @@ import re from powerline.theme import requires_segment_info from powerline.lib.shell import run_cmd +from powerline.bindings.wm.awesome import AwesomeThread + + +DEFAULT_UPDATE_INTERVAL = 0.5 conn = None @@ -36,3 +40,8 @@ def get_connected_xrandr_outputs(pl): return (match.groupdict() for match in XRANDR_OUTPUT_RE.finditer( run_cmd(pl, ['xrandr', '-q']) )) + + +wm_threads = { + 'awesome': AwesomeThread, +} diff --git a/powerline/bindings/wm/awesome.py b/powerline/bindings/wm/awesome.py new file mode 100644 index 00000000..eab2bf0a --- /dev/null +++ b/powerline/bindings/wm/awesome.py @@ -0,0 +1,53 @@ +# vim:fileencoding=utf-8:noet +from __future__ import (unicode_literals, division, absolute_import, print_function) + +import sys + +from threading import Thread, Event +from time import sleep +from subprocess import Popen, PIPE + +from powerline import Powerline +from powerline.lib.monotonic import monotonic + + +def read_to_log(pl, client): + for line in client.stdout: + if line: + pl.info(line, prefix='awesome-client') + for line in client.stderr: + if line: + pl.error(line, prefix='awesome-client') + if client.wait(): + pl.error('Client exited with {0}', client.returncode, prefix='awesome') + + +def run(shutdown_event=None, interval=None): + powerline = Powerline('wm', renderer_module='pango_markup') + powerline.update_renderer() + + if not shutdown_event: + shutdown_event = powerline.shutdown_event + + while not shutdown_event.is_set(): + # powerline.update_interval may change over time + used_interval = interval or powerline.update_interval + start_time = monotonic() + s = powerline.render(side='right') + request = 'powerline_widget:set_markup(\'' + s.translate({'\'': '\\\'', '\\': '\\\\'}) + '\')\n' + client = Popen(['awesome-client'], shell=False, stdout=PIPE, stderr=PIPE, stdin=PIPE) + client.stdin.write(request.encode('utf-8')) + client.stdin.close() + read_to_log(powerline.pl, client) + shutdown_event.wait(max(used_interval - (monotonic() - start_time), 0.1)) + + +class AwesomeThread(Thread): + __slots__ = ('powerline_shutdown_event',) + + def __init__(self, shutdown_event): + super(AwesomeThread, self).__init__() + self.powerline_shutdown_event = shutdown_event + + def run(self): + run(shutdown_event=self.powerline_shutdown_event) diff --git a/powerline/commands/main.py b/powerline/commands/main.py index a5b27ef7..366eba2a 100644 --- a/powerline/commands/main.py +++ b/powerline/commands/main.py @@ -11,6 +11,7 @@ from powerline.lib.overrides import parsedotval, parse_override_var from powerline.lib.dict import mergeargs from powerline.lib.encoding import get_preferred_arguments_encoding from powerline.lib.unicode import u, unicode +from powerline.bindings.wm import wm_threads if sys.version_info < (3,): @@ -23,7 +24,7 @@ else: return s -def finish_args(environ, args): +def finish_args(parser, environ, args, is_daemon=False): '''Do some final transformations Transforms ``*_override`` arguments into dictionaries, adding overrides from @@ -61,7 +62,13 @@ def finish_args(environ, args): [path for path in environ.get('POWERLINE_CONFIG_PATHS', '').split(':') if path] + (args.config_path or []) ) - args.side = args.side[0] + if args.ext[0].startswith('wm.'): + if not is_daemon: + parser.error('WM bindings must be used with daemon only') + elif args.ext[0][3:] not in wm_threads: + parser.error('WM binding not found') + elif not args.side: + parser.error('expected one argument') return args @@ -77,15 +84,16 @@ def get_argparser(ArgumentParser=argparse.ArgumentParser): parser.add_argument( 'ext', nargs=1, help='Extension: application for which powerline command is launched ' - '(usually `shell\' or `tmux\').' + '(usually `shell\' or `tmux\'). Also supports `wm.\' extensions: ' + + ', '.join(('`wm.' + key + '\'' for key in wm_threads.keys())) + '.' ) parser.add_argument( - 'side', nargs=1, choices=('left', 'right', 'above', 'aboveleft'), + 'side', nargs='?', choices=('left', 'right', 'above', 'aboveleft'), help='Side: `left\' and `right\' represent left and right side ' 'respectively, `above\' emits lines that are supposed to be printed ' 'just above the prompt and `aboveleft\' is like concatenating ' '`above\' with `left\' with the exception that only one Python ' - 'instance is used in this case.' + 'instance is used in this case. May be omitted for `wm.*\' extensions.' ) parser.add_argument( '-r', '--renderer-module', metavar='MODULE', type=str, diff --git a/powerline/config_files/config.json b/powerline/config_files/config.json index bd2cf2bb..44918856 100644 --- a/powerline/config_files/config.json +++ b/powerline/config_files/config.json @@ -46,7 +46,8 @@ }, "wm": { "colorscheme": "default", - "theme": "default" + "theme": "default", + "update_interval": 2 } } } diff --git a/powerline/lint/__init__.py b/powerline/lint/__init__.py index 6f7fa4b2..8c682718 100644 --- a/powerline/lint/__init__.py +++ b/powerline/lint/__init__.py @@ -130,7 +130,8 @@ main_spec = (Spec( local_themes=Spec().unknown_spec( Spec().re('^[0-9A-Za-z-]+$'), ext_theme_spec() - ).optional() + ).optional(), + update_interval=Spec().cmp('gt', 0.0).optional(), ).optional(), ).unknown_spec( check_ext, diff --git a/scripts/powerline-daemon b/scripts/powerline-daemon index c5dba47b..758c0a7f 100755 --- a/scripts/powerline-daemon +++ b/scripts/powerline-daemon @@ -13,11 +13,14 @@ from signal import signal, SIGTERM from time import sleep from functools import partial from io import BytesIO +from threading import Event +from itertools import chain from powerline.shell import ShellPowerline from powerline.commands.main import finish_args, write_output from powerline.lib.monotonic import monotonic from powerline.lib.encoding import get_preferred_output_encoding, get_preferred_arguments_encoding, get_unicode_writer +from powerline.bindings.wm import wm_threads from powerline.commands.main import get_argparser as get_main_argparser from powerline.commands.daemon import get_argparser as get_daemon_argparser @@ -28,6 +31,7 @@ use_filesystem = not sys.platform.lower().startswith('linux') address = None pidfile = None +ts_shutdown_event = Event() class NonInteractiveArgParser(ArgumentParser): @@ -52,6 +56,7 @@ powerlines = {} logger = None config_loader = None home = os.path.expanduser('~') +started_wm_threads = {} class PowerlineDaemon(ShellPowerline): @@ -62,10 +67,21 @@ class PowerlineDaemon(ShellPowerline): return super(PowerlineDaemon, self).get_log_handler() +def start_wm(args, environ, cwd): + wm_name = args.ext[0][3:] + if wm_name in started_wm_threads: + return b'' + shutdown_event = Event() + thread = wm_threads[wm_name](shutdown_event=shutdown_event) + thread.start() + started_wm_threads[wm_name] = (thread, shutdown_event) + return b'' + + def render(args, environ, cwd): global logger global config_loader - cwd = cwd or environ.get('PWD', '/') + segment_info = { 'getcwd': lambda: cwd, 'home': environ.get('HOME', home), @@ -82,7 +98,7 @@ def render(args, environ, cwd): environ.get('POWERLINE_CONFIG_OVERRIDES', ''), environ.get('POWERLINE_CONFIG_PATHS', ''), ) - finish_args(environ, args) + powerline = None try: powerline = powerlines[key] @@ -93,6 +109,7 @@ def render(args, environ, cwd): logger=logger, config_loader=config_loader, run_once=False, + shutdown_event=ts_shutdown_event, ) if logger is None: logger = powerline.logger @@ -174,12 +191,18 @@ def parse_args(req, encoding=get_preferred_arguments_encoding()): shell_args = parser.parse_args(args[1:numargs + 1]) cwd = args[numargs + 1] environ = dict(((k, v) for k, v in (x.partition('=')[0::2] for x in args[numargs + 2:]))) + cwd = cwd or environ.get('PWD', '/') return shell_args, environ, cwd -def do_render(req): +def get_answer(req): try: - return safe_bytes(render(*parse_args(req))) + args, environ, cwd = parse_args(req) + finish_args(parser, environ, args, is_daemon=True) + if args.ext[0].startswith('wm.'): + return safe_bytes(start_wm(args, environ, cwd)) + else: + return safe_bytes(render(args, environ, cwd)) except Exception as e: return safe_bytes(str(e)) @@ -214,7 +237,7 @@ def do_one(sock, read_sockets, write_sockets, result_map): if req == EOF: raise SystemExit(0) elif req: - ans = do_render(req) + ans = get_answer(req) result_map[s] = ans write_sockets.add(s) else: @@ -230,6 +253,39 @@ def do_one(sock, read_sockets, write_sockets, result_map): s.close() +def shutdown(sock, read_sockets, write_sockets): + '''Perform operations necessary for nicely shutting down daemon + + Specifically it + + #. Closes all sockets. + #. Notifies segments based on + :py:class:`powerline.lib.threaded.ThreadedSegment` and WM-specific + threads that daemon is shutting down. + #. Waits for threads to finish, but no more then 2 seconds total. + #. Waits so that total execution time of this function is 2 seconds in order + to allow ThreadedSegments to finish. + ''' + total_wait_time = 2 + shutdown_start_time = monotonic() + + for s in chain((sock,), read_sockets, write_sockets): + s.close() + + # Notify ThreadedSegments + ts_shutdown_event.set() + for thread, shutdown_event in started_wm_threads.values(): + shutdown_event.set() + + for thread, shutdown_event in started_wm_threads.values(): + wait_time = total_wait_time - (monotonic() - shutdown_start_time) + if wait_time > 0: + thread.join(wait_time) + + wait_time = total_wait_time - (monotonic() - shutdown_start_time) + sleep(wait_time) + + def main_loop(sock): sock.listen(128) sock.setblocking(0) @@ -237,10 +293,14 @@ def main_loop(sock): read_sockets, write_sockets = set(), set() result_map = {} try: - while True: - do_one(sock, read_sockets, write_sockets, result_map) - except KeyboardInterrupt: - raise SystemExit(0) + try: + while True: + do_one(sock, read_sockets, write_sockets, result_map) + except KeyboardInterrupt: + raise SystemExit(0) + except SystemExit as e: + shutdown(sock, read_sockets, write_sockets) + raise e return 0 diff --git a/scripts/powerline-render b/scripts/powerline-render index 4b8a3a0a..8b71b00b 100755 --- a/scripts/powerline-render +++ b/scripts/powerline-render @@ -23,8 +23,9 @@ else: if __name__ == '__main__': - args = get_argparser().parse_args() - finish_args(os.environ, args) + parser = get_argparser() + args = parser.parse_args() + finish_args(parser, os.environ, args) powerline = ShellPowerline(args, run_once=True) segment_info = {'args': args, 'environ': os.environ} write_output(args, powerline, segment_info, get_unicode_writer()) diff --git a/tests/run_awesome_tests.sh b/tests/run_awesome_tests.sh new file mode 100755 index 00000000..b3dac2cd --- /dev/null +++ b/tests/run_awesome_tests.sh @@ -0,0 +1,193 @@ +#!/bin/sh +. tests/common.sh + +enter_suite awesome + +TEST_ROOT="$ROOT/tests/awesome" +TEST_PATH="$TEST_ROOT/path" +TEST_STATIC_ROOT="$ROOT/tests/test_awesome" + +test -d "$TEST_ROOT" && rm -r "$TEST_ROOT" +mkdir "$TEST_ROOT" +cp -r "$TEST_STATIC_ROOT/path" "$TEST_ROOT" +cp -r "$TEST_STATIC_ROOT/powerline" "$TEST_ROOT" + +export PYTHONPATH="$ROOT${PYTHONPATH:+:}$PYTHONPATH" + +ln -s "$(which "${PYTHON}")" "$TEST_PATH"/python +ln -s "$(which cat)" "$TEST_PATH" +ln -s "$(which sh)" "$TEST_PATH" +ln -s "$(which env)" "$TEST_PATH" +if which socat ; then + ln -s "$(which socat)" "$TEST_PATH" +fi +for pexe in powerline powerline.sh powerline.py ; do + if test -e scripts/$pexe ; then + ln -s "$PWD/scripts/$pexe" $TEST_ROOT/path + elif test -e client/$pexe ; then + ln -s "$PWD/client/$pexe" $TEST_ROOT/path + elif which $pexe ; then + ln -s "$(which $pexe)" $TEST_ROOT/path + else + continue + fi + if test "x$pexe" != 'xpowerline.sh' || test -e "$TEST_PATH/socat" ; then + POWERLINE_COMMAND="$pexe" + break + fi +done + +DEPRECATED_SCRIPT="$ROOT/powerline/bindings/awesome/powerline-awesome.py" +POWERLINE_DAEMON="scripts/powerline-daemon" + +run() { + env -i \ + LANG=C \ + PATH="$TEST_PATH" \ + XDG_CONFIG_HOME="$TEST_ROOT" \ + XDG_CONFIG_DIRS="$TEST_ROOT/dummy" \ + PYTHONPATH="$PYTHONPATH" \ + TEST_ROOT="$TEST_ROOT" \ + LD_LIBRARY_PATH="$LD_LIBRARY_PATH" \ + "$@" || true +} + +display_log() { + local log_file="$1" + echo "$log_file:" + echo '============================================================' + cat -v "$log_file" + echo + echo '____________________________________________________________' +} + +check_log() { + local args_file="$TEST_ROOT/results/args" + local log_file="$TEST_ROOT/results/requests" + local line="$(head -n1 "$log_file")" + local linenum="$(cat "$log_file" | wc -l)" + echo "Number of runs: $linenum (expected approx 5 / 0.5 = 10 runs)" + if test $linenum -lt 5 ; then + fail "log:lt" F "Script was run not enough times: $linenum < 5" + return 1 + elif test $linenum -gt 15 ; then + fail "log:gt" E "Script was run too many times: $linenum > 15" + return 1 + fi + local expline="powerline_widget:set_markup(' default-right ')" + if test "x$expline" != "x$line" ; then + echo "Line: '$line'" + echo "Expected: '$expline'" + fail "log:line" F "Unexpected line" + return 1 + fi + local ret=0 + while test $linenum -gt 0 ; do + echo "$line" >> "$TEST_ROOT/ok" + linenum=$(( linenum - 1 )) + done + if ! diff "$TEST_ROOT/ok" "$log_file" ; then + fail "log:diff" F "Unexpected output" + ret=1 + fi + rm "$TEST_ROOT/ok" + return $ret +} + +killscript() { + kill -KILL $1 || true +} + +if ! test -e "$DEPRECATED_SCRIPT" ; then + # TODO: uncomment when skip is available + # skip "deprecated" "Missing deprecated bar bindings script" + : +else + enter_suite "deprecated" + for args in "" "0.5"; do + rm -rf "$TEST_ROOT/results" + mkdir "$TEST_ROOT/results" + DEPRECATED_LOG="$TEST_ROOT/deprecated.log" + run env \ + DEPRECATED_SCRIPT="$DEPRECATED_SCRIPT" \ + args="$args" \ + DEPRECATED_LOG="$DEPRECATED_LOG" \ + TEST_ROOT="$TEST_ROOT" \ + sh -c ' + echo $$ > "$TEST_ROOT/$args-pid" + exec "$DEPRECATED_SCRIPT" $args > "$DEPRECATED_LOG" 2>&1 + ' & + sleep 5 + killscript "$(cat "$TEST_ROOT/$args-pid")" + rm "$TEST_ROOT/$args-pid" + if test "x$(cat "$DEPRECATED_LOG")" != "x" ; then + display_log "$DEPRECATED_LOG" + fail "output" E "Nonempty $DEPRECATED_SCRIPT output" + fi + rm "$DEPRECATED_LOG" + if ! check_log ; then + display_log "$TEST_ROOT/results/args" + fail "log" F "Checking log failed" + fi + done + exit_suite --continue +fi + +enter_suite "awesome" +ADDRESS="powerline-ipc-test-$$" +echo "Powerline address: $ADDRESS" +rm -rf "$TEST_ROOT/results" +mkdir "$TEST_ROOT/results" +run env \ + POWERLINE_DAEMON="$POWERLINE_DAEMON" \ + TEST_ROOT="$TEST_ROOT" \ + ADDRESS="$ADDRESS" \ + sh -c ' + echo $$ > "$TEST_ROOT/dpid" + exec python "$POWERLINE_DAEMON" --socket $ADDRESS --foreground > "$TEST_ROOT/daemon.log" 2>&1 + ' & +DPID=$! +sleep 2 +run "$POWERLINE_COMMAND" --socket $ADDRESS wm.awesome > "$TEST_ROOT/output.log.1" 2>&1 +run "$POWERLINE_COMMAND" --socket $ADDRESS wm.awesome > "$TEST_ROOT/output.log.2" 2>&1 +run "$POWERLINE_COMMAND" --socket $ADDRESS wm.awesome > "$TEST_ROOT/output.log.3" 2>&1 +run "$POWERLINE_COMMAND" --socket $ADDRESS wm.awesome > "$TEST_ROOT/output.log.4" 2>&1 +run "$POWERLINE_COMMAND" --socket $ADDRESS wm.awesome > "$TEST_ROOT/output.log.5" 2>&1 +for log_file in "$TEST_ROOT"/output.log.* ; do + if test "x$(cat "$log_file")" != "x" ; then + display_log "$log_file" + fail "output" E "Nonempty $POWERLINE_COMMAND output at run ${log_file#*.}" + fi + rm "$log_file" +done +sleep 5 +run python "$POWERLINE_DAEMON" --socket $ADDRESS --quiet --kill > "$TEST_ROOT/kill.log" 2>&1 +if test "x$(cat "$TEST_ROOT/kill.log")" != "x" ; then + display_log "$TEST_ROOT/kill.log" + fail "daemonlog" E "Nonempty kill log" +fi +rm "$TEST_ROOT/kill.log" +wait $DPID +if test "x$(cat "$TEST_ROOT/daemon.log")" != "x" ; then + display_log "$TEST_ROOT/daemon.log" + fail "daemonlog" E "Nonempty daemon log" +fi +rm "$TEST_ROOT/daemon.log" +if ! check_log ; then + display_log "$TEST_ROOT/results/args" + fail "log" F "Checking log failed" +fi +exit_suite --continue + +if ! powerline-lint \ + -p "$ROOT/powerline/config_files" \ + -p "$TEST_STATIC_ROOT/powerline" +then + fail "lint" F "Checking test config failed" +fi + +if test $FAILED -eq 0 ; then + rm -r "$TEST_ROOT" +fi + +exit_suite diff --git a/tests/test_awesome/path/awesome-client b/tests/test_awesome/path/awesome-client new file mode 100755 index 00000000..2088ff0f --- /dev/null +++ b/tests/test_awesome/path/awesome-client @@ -0,0 +1,3 @@ +#!/bin/sh +echo "$@" >> "$TEST_ROOT/results/args" +cat >> "$TEST_ROOT/results/requests" diff --git a/tests/test_awesome/powerline/config.json b/tests/test_awesome/powerline/config.json new file mode 100644 index 00000000..b8dfd017 --- /dev/null +++ b/tests/test_awesome/powerline/config.json @@ -0,0 +1,7 @@ +{ + "ext": { + "wm": { + "update_interval": 0.5 + } + } +} diff --git a/tests/test_awesome/powerline/themes/wm/default.json b/tests/test_awesome/powerline/themes/wm/default.json new file mode 100644 index 00000000..d9eaf5f8 --- /dev/null +++ b/tests/test_awesome/powerline/themes/wm/default.json @@ -0,0 +1,18 @@ +{ + "segments": { + "left": [ + { + "type": "string", + "highlight_groups": ["time"], + "contents": "default-left" + } + ], + "right": [ + { + "type": "string", + "highlight_groups": ["time"], + "contents": "default-right" + } + ] + } +} diff --git a/tests/test_awesome/powerline/themes/wm/dvi.json b/tests/test_awesome/powerline/themes/wm/dvi.json new file mode 100644 index 00000000..4cf3731b --- /dev/null +++ b/tests/test_awesome/powerline/themes/wm/dvi.json @@ -0,0 +1,18 @@ +{ + "segments": { + "left": [ + { + "type": "string", + "highlight_groups": ["time"], + "contents": "dvi-left" + } + ], + "right": [ + { + "type": "string", + "highlight_groups": ["time"], + "contents": "dvi-right" + } + ] + } +} diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py index ddabab2b..cd021be6 100644 --- a/tests/test_cmdline.py +++ b/tests/test_cmdline.py @@ -127,7 +127,7 @@ class TestParser(TestCase): }), ]: args = parser.parse_args(argv) - finish_args({}, args) + finish_args(parser, {}, args) for key, val in expargs.items(): self.assertEqual(getattr(args, key), val) for key, val in args.__dict__.items(): diff --git a/tests/test_shells/test.sh b/tests/test_shells/test.sh index 40ab938a..0cc79716 100755 --- a/tests/test_shells/test.sh +++ b/tests/test_shells/test.sh @@ -311,7 +311,7 @@ if test -z "${ONLY_SHELL}" || test "x${ONLY_SHELL%sh}" != "x${ONLY_SHELL}" || te if test $TEST_TYPE = daemon ; then sh -c ' echo $$ > tests/shell/daemon_pid - $PYTHON ./scripts/powerline-daemon -s$ADDRESS -f >tests/shell/daemon_log 2>&1 + exec $PYTHON ./scripts/powerline-daemon -s$ADDRESS -f >tests/shell/daemon_log 2>&1 ' & fi echo "> Testing $TEST_TYPE"