summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorLars Wirzenius <liw@liw.fi>2020-10-14 09:35:39 +0300
committerLars Wirzenius <liw@liw.fi>2020-10-14 09:35:39 +0300
commit739d624d6f60776a9baba905e23c818d23dc52e0 (patch)
tree55594594602a8a2647dc79b2d0eb0f528142a4f6
parent8cc1a68d733762ad6baaec439360a84ab8450d3a (diff)
downloadewww-739d624d6f60776a9baba905e23c818d23dc52e0.tar.gz
chore: update subplot/runcmd.* from Subplot
Also fix everything that needs fixing. Tests pass.
-rw-r--r--subplot/daemon.py8
-rw-r--r--subplot/http.py26
-rw-r--r--subplot/runcmd.py272
-rw-r--r--subplot/runcmd.yaml86
4 files changed, 318 insertions, 74 deletions
diff --git a/subplot/daemon.py b/subplot/daemon.py
index c454b9b..00c9d2d 100644
--- a/subplot/daemon.py
+++ b/subplot/daemon.py
@@ -9,8 +9,8 @@ import signal
# Start a process in the background.
def start_daemon(ctx, name, argv):
- runcmd = globals()["runcmd"]
- exit_code_is = globals()["exit_code_is"]
+ runcmd_run = globals()["runcmd_run"]
+ runcmd_exit_code_is = globals()["runcmd_exit_code_is"]
logging.debug(f"Starting daemon {name}")
logging.debug(f" ctx={ctx.as_dict()}")
@@ -25,7 +25,7 @@ def start_daemon(ctx, name, argv):
"stderr": f"{name}.stderr",
"stdout": f"{name}.stdout",
}
- runcmd(
+ runcmd_run(
ctx,
[
"/usr/sbin/daemonize",
@@ -40,7 +40,7 @@ def start_daemon(ctx, name, argv):
]
+ argv,
)
- exit_code_is(ctx, 0)
+ runcmd_exit_code_is(ctx, 0)
this["pid"] = int(open("ewww.pid").read().strip())
assert process_exists(this["pid"])
diff --git a/subplot/http.py b/subplot/http.py
index 424b2b1..cfe8968 100644
--- a/subplot/http.py
+++ b/subplot/http.py
@@ -6,36 +6,40 @@ import logging
# Make an HTTP request.
def http_request(ctx, host=None, method=None, url=None):
- runcmd = globals()["runcmd"]
- exit_code_is = globals()["exit_code_is"]
+ runcmd_run = globals()["runcmd_run"]
+ runcmd_exit_code_is = globals()["runcmd_exit_code_is"]
logging.debug(f"Make HTTP request: {method} {url}")
- runcmd(ctx, ["curl", "-ksv", "-X", method, f"-HHost: {host}", url])
- exit_code_is(ctx, 0)
+ runcmd_run(ctx, ["curl", "-ksv", "-X", method, f"-HHost: {host}", url])
+ runcmd_exit_code_is(ctx, 0)
# Check status code of latest HTTP request.
def http_status_code_is(ctx, code=None):
assert_eq = globals()["assert_eq"]
+ runcmd_get_stderr = globals()["runcmd_get_stderr"]
+ stderr = runcmd_get_stderr(ctx)
logging.debug(f"Verifying status code of previous HTTP request is {code}")
- logging.debug(f" stderr={ctx['stderr']}")
+ logging.debug(f" stderr={stderr}")
pattern = f"\n< HTTP/2 {code} "
- assert_eq(pattern in ctx["stderr"], True)
+ assert_eq(pattern in stderr, True)
# Check a HTTP response header for latest request has a given value.
def http_header_is(ctx, header=None, value=None):
assert_eq = globals()["assert_eq"]
+ runcmd_get_stderr = globals()["runcmd_get_stderr"]
+ stderr = runcmd_get_stderr(ctx)
logging.debug(f"Verifying response has header {header}: {value}")
- s = ctx["stderr"]
pattern = f"\n< {header}: {value}"
- assert_eq(pattern in s, True)
+ assert_eq(pattern in stderr, True)
# Check a HTTP body response for latest request has a given value.
def http_body_is(ctx, body=None):
assert_eq = globals()["assert_eq"]
+ runcmd_get_stdout = globals()["runcmd_get_stdout"]
+ stdout = runcmd_get_stdout(ctx)
logging.debug(f"Verifying response body is {body!r}")
- logging.debug(f" actual body={ctx['stdout']!r}")
- s = ctx["stdout"]
+ logging.debug(f" actual body={stdout!r}")
body = body.encode("UTF8").decode("unicode-escape")
- assert_eq(body, s)
+ assert_eq(body, stdout)
diff --git a/subplot/runcmd.py b/subplot/runcmd.py
index 631d8c0..532b60b 100644
--- a/subplot/runcmd.py
+++ b/subplot/runcmd.py
@@ -1,73 +1,243 @@
-# Some step implementations for running commands and capturing the result.
-
import logging
import os
+import re
+import shlex
import subprocess
-# Run a command, capture its stdout, stderr, and exit code in context.
-def runcmd(ctx, argv, **kwargs):
- logging.debug(f"Running program")
- logging.debug(f" cwd={os.getcwd()}")
- logging.debug(f" argv={argv}")
- logging.debug(f" kwargs={argv}")
- p = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)
+#
+# Helper functions.
+#
+
+# Get exit code or other stored data about the latest command run by
+# runcmd_run.
+
+
+def _runcmd_get(ctx, name):
+ ns = ctx.declare("_runcmd")
+ return ns[name]
+
+
+def runcmd_get_exit_code(ctx):
+ return _runcmd_get(ctx, "exit")
+
+
+def runcmd_get_stdout(ctx):
+ return _runcmd_get(ctx, "stdout")
+
+
+def runcmd_get_stdout_raw(ctx):
+ return _runcmd_get(ctx, "stdout.raw")
+
+
+def runcmd_get_stderr(ctx):
+ return _runcmd_get(ctx, "stderr")
+
+
+def runcmd_get_stderr_raw(ctx):
+ return _runcmd_get(ctx, "stderr.raw")
+
+
+def runcmd_get_argv(ctx):
+ return _runcmd_get(ctx, "argv")
+
+
+# Run a command, given an argv and other arguments for subprocess.Popen.
+#
+# This is meant to be a helper function, not bound directly to a step. The
+# stdout, stderr, and exit code are stored in the "_runcmd" namespace in the
+# ctx context.
+def runcmd_run(ctx, argv, **kwargs):
+ ns = ctx.declare("_runcmd")
+ env = dict(os.environ)
+ pp = ns.get("path-prefix")
+ if pp:
+ env["PATH"] = pp + ":" + env["PATH"]
+
+ logging.debug(f"runcmd_run")
+ logging.debug(f" argv: {argv}")
+ logging.debug(f" env: {env}")
+ p = subprocess.Popen(
+ argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, **kwargs
+ )
stdout, stderr = p.communicate("")
- ctx["argv"] = argv
- ctx["stdout"] = stdout.decode("utf-8")
- ctx["stderr"] = stderr.decode("utf-8")
- ctx["exit"] = p.returncode
+ ns["argv"] = argv
+ ns["stdout.raw"] = stdout
+ ns["stderr.raw"] = stderr
+ ns["stdout"] = stdout.decode("utf-8")
+ ns["stderr"] = stderr.decode("utf-8")
+ ns["exit"] = p.returncode
+ logging.debug(f" ctx: {ctx}")
+ logging.debug(f" ns: {ns}")
+
+
+# Step: prepend srcdir to PATH whenever runcmd runs a command.
+def runcmd_helper_srcdir_path(ctx):
+ srcdir = globals()["srcdir"]
+ runcmd_prepend_to_path(ctx, srcdir)
+
+
+# Step: This creates a helper script.
+def runcmd_helper_script(ctx, filename=None):
+ get_file = globals()["get_file"]
+ with open(filename, "wb") as f:
+ f.write(get_file(filename))
+
+
+#
+# Step functions for running commands.
+#
+
+
+def runcmd_prepend_to_path(ctx, dirname=None):
+ ns = ctx.declare("_runcmd")
+ pp = ns.get("path-prefix", "")
+ if pp:
+ pp = f"{pp}:{dirname}"
+ else:
+ pp = dirname
+ ns["path-prefix"] = pp
+
+
+def runcmd_step(ctx, argv0=None, args=None):
+ runcmd_try_to_run(ctx, argv0=argv0, args=args)
+ runcmd_exit_code_is_zero(ctx)
+
+
+def runcmd_try_to_run(ctx, argv0=None, args=None):
+ argv = [shlex.quote(argv0)] + shlex.split(args)
+ runcmd_run(ctx, argv)
+
+
+#
+# Step functions for examining exit codes.
+#
+
+
+def runcmd_exit_code_is_zero(ctx):
+ runcmd_exit_code_is(ctx, exit=0)
+
+
+def runcmd_exit_code_is(ctx, exit=None):
+ assert_eq = globals()["assert_eq"]
+ assert_eq(runcmd_get_exit_code(ctx), int(exit))
+
+
+def runcmd_exit_code_is_nonzero(ctx):
+ runcmd_exit_code_is_not(ctx, exit=0)
+
+
+def runcmd_exit_code_is_not(ctx, exit=None):
+ assert_ne = globals()["assert_ne"]
+ assert_ne(runcmd_get_exit_code(ctx), int(exit))
+
+
+#
+# Step functions and helpers for examining output in various ways.
+#
+
+
+def runcmd_stdout_is(ctx, text=None):
+ _runcmd_output_is(runcmd_get_stdout(ctx), text)
+
+
+def runcmd_stdout_isnt(ctx, text=None):
+ _runcmd_output_isnt(runcmd_get_stdout(ctx), text)
+
+
+def runcmd_stderr_is(ctx, text=None):
+ _runcmd_output_is(runcmd_get_stderr(ctx), text)
+
+
+def runcmd_stderr_isnt(ctx, text=None):
+ _runcmd_output_isnt(runcmd_get_stderr(ctx), text)
+
+
+def _runcmd_output_is(actual, wanted):
+ assert_eq = globals()["assert_eq"]
+ wanted = bytes(wanted, "utf8").decode("unicode_escape")
+ logging.debug("_runcmd_output_is:")
+ logging.debug(f" actual: {actual!r}")
+ logging.debug(f" wanted: {wanted!r}")
+ assert_eq(actual, wanted)
+
+
+def _runcmd_output_isnt(actual, wanted):
+ assert_ne = globals()["assert_ne"]
+ wanted = bytes(wanted, "utf8").decode("unicode_escape")
+ logging.debug("_runcmd_output_isnt:")
+ logging.debug(f" actual: {actual!r}")
+ logging.debug(f" wanted: {wanted!r}")
+ assert_ne(actual, wanted)
+
+
+def runcmd_stdout_contains(ctx, text=None):
+ _runcmd_output_contains(runcmd_get_stdout(ctx), text)
+
+
+def runcmd_stdout_doesnt_contain(ctx, text=None):
+ _runcmd_output_doesnt_contain(runcmd_get_stdout(ctx), text)
+
+
+def runcmd_stderr_contains(ctx, text=None):
+ _runcmd_output_contains(runcmd_get_stderr(ctx), text)
+
+
+def runcmd_stderr_doesnt_contain(ctx, text=None):
+ _runcmd_output_doesnt_contain(runcmd_get_stderr(ctx), text)
-# Check that latest exit code captured by runcmd was a specific one.
-def exit_code_is(ctx, wanted):
- logging.debug(f"Verifying exit code is {wanted} (it is {ctx.get('exit')})")
- assert_eq(ctx.get("exit"), wanted)
+def _runcmd_output_contains(actual, wanted):
+ assert_eq = globals()["assert_eq"]
+ wanted = bytes(wanted, "utf8").decode("unicode_escape")
+ logging.debug("_runcmd_output_contains:")
+ logging.debug(f" actual: {actual!r}")
+ logging.debug(f" wanted: {wanted!r}")
+ assert_eq(wanted in actual, True)
-# Check that latest exit code captured by runcmd was not a specific one.
-def exit_code_is_not(ctx, unwanted):
- logging.debug(f"Verifying exit code is NOT {unwanted} (it is {ctx.get('exit')})")
- assert_ne(ctx.get("exit"), wanted)
+def _runcmd_output_doesnt_contain(actual, wanted):
+ assert_ne = globals()["assert_ne"]
+ wanted = bytes(wanted, "utf8").decode("unicode_escape")
+ logging.debug("_runcmd_output_doesnt_contain:")
+ logging.debug(f" actual: {actual!r}")
+ logging.debug(f" wanted: {wanted!r}")
+ assert_ne(wanted in actual, True)
-# Check that latest exit code captured by runcmd was zero.
-def exit_code_zero(ctx):
- exit_code_is(ctx, 0)
+def runcmd_stdout_matches_regex(ctx, regex=None):
+ _runcmd_output_matches_regex(runcmd_get_stdout(ctx), regex)
-# Check that latest exit code captured by runcmd was not zero.
-def exit_code_nonzero(ctx):
- exit_code_is_not(ctx, 0)
+def runcmd_stdout_doesnt_match_regex(ctx, regex=None):
+ _runcmd_output_doesnt_match_regex(runcmd_get_stdout(ctx), regex)
-# Check that stdout of latest runcmd contains a specific string.
-def stdout_contains(ctx, pattern=None):
- logging.debug(f"Verifying stdout contains {pattern}")
- logging.debug(f" stdout is {ctx.get('stdout', '')})")
- stdout = ctx.get("stdout", "")
- assert_eq(pattern in stdout, True)
+def runcmd_stderr_matches_regex(ctx, regex=None):
+ _runcmd_output_matches_regex(runcmd_get_stderr(ctx), regex)
-# Check that stdout of latest runcmd does not contain a specific string.
-def stdout_does_not_contain(ctx, pattern=None):
- logging.debug(f"Verifying stdout does NOT contain {pattern}")
- logging.debug(f" stdout is {ctx.get('stdout', '')})")
- stdout = ctx.get("stdout", "")
- assert_eq(pattern not in stdout, True)
+def runcmd_stderr_doesnt_match_regex(ctx, regex=None):
+ _runcmd_output_doesnt_match_regex(runcmd_get_stderr(ctx), regex)
-# Check that stderr of latest runcmd does contains a specific string.
-def stderr_contains(ctx, pattern=None):
- logging.debug(f"Verifying stderr contains {pattern}")
- logging.debug(f" stderr is {ctx.get('stderr', '')})")
- stderr = ctx.get("stderr", "")
- assert_eq(pattern in stderr, True)
+def _runcmd_output_matches_regex(actual, regex):
+ assert_ne = globals()["assert_ne"]
+ r = re.compile(regex)
+ m = r.search(actual)
+ logging.debug("_runcmd_output_matches_regex:")
+ logging.debug(f" actual: {actual!r}")
+ logging.debug(f" regex: {regex!r}")
+ logging.debug(f" match: {m}")
+ assert_ne(m, None)
-# Check that stderr of latest runcmd does not contain a specific string.
-def stderr_does_not_contain(ctx, pattern=None):
- logging.debug(f"Verifying stderr does NOT contain {pattern}")
- logging.debug(f" stderr is {ctx.get('stderr', '')})")
- stderr = ctx.get("stderr", "")
- assert_eq(pattern not in stderr, True)
+def _runcmd_output_doesnt_match_regex(actual, regex):
+ assert_eq = globals()["assert_eq"]
+ r = re.compile(regex)
+ m = r.search(actual)
+ logging.debug("_runcmd_output_doesnt_match_regex:")
+ logging.debug(f" actual: {actual!r}")
+ logging.debug(f" regex: {regex!r}")
+ logging.debug(f" match: {m}")
+ assert_eq(m, None)
diff --git a/subplot/runcmd.yaml b/subplot/runcmd.yaml
index 02e5ee1..48dde90 100644
--- a/subplot/runcmd.yaml
+++ b/subplot/runcmd.yaml
@@ -1,13 +1,83 @@
-- then: exit code is non-zero
- function: exit_code_nonzero
+# Steps to run commands.
-- then: output matches /(?P<pattern>.+)/
- function: stdout_contains
+- given: helper script {filename} for runcmd
+ function: runcmd_helper_script
+
+- given: srcdir is in the PATH
+ function: runcmd_helper_srcdir_path
+
+- when: I run (?P<argv0>\S+)(?P<args>.*)
regex: true
+ function: runcmd_step
-- then: stderr matches /(?P<pattern>.+)/
- function: stderr_contains
+- when: I try to run (?P<argv0>\S+)(?P<args>.*)
regex: true
+ function: runcmd_try_to_run
+
+# Steps to examine exit code of latest command.
+
+- then: exit code is {exit}
+ function: runcmd_exit_code_is
+
+- then: exit code is not {exit}
+ function: runcmd_exit_code_is_not
+
+- then: command is successful
+ function: runcmd_exit_code_is_zero
+
+- then: command fails
+ function: runcmd_exit_code_is_nonzero
+
+# Steps to examine stdout/stderr for exact content.
+
+- then: stdout is exactly "(?P<text>.*)"
+ regex: true
+ function: runcmd_stdout_is
+
+- then: "stdout isn't exactly \"(?P<text>.*)\""
+ regex: true
+ function: runcmd_stdout_isnt
+
+- then: stderr is exactly "(?P<text>.*)"
+ regex: true
+ function: runcmd_stderr_is
+
+- then: "stderr isn't exactly \"(?P<text>.*)\""
+ regex: true
+ function: runcmd_stderr_isnt
+
+# Steps to examine stdout/stderr for sub-strings.
-- then: program finished successfully
- function: exit_code_zero
+- then: stdout contains "(?P<text>.*)"
+ regex: true
+ function: runcmd_stdout_contains
+
+- then: "stdout doesn't contain \"(?P<text>.*)\""
+ regex: true
+ function: runcmd_stdout_doesnt_contain
+
+- then: stderr contains "(?P<text>.*)"
+ regex: true
+ function: runcmd_stderr_contains
+
+- then: "stderr doesn't contain \"(?P<text>.*)\""
+ regex: true
+ function: runcmd_stderr_doesnt_contain
+
+# Steps to match stdout/stderr against regular expressions.
+
+- then: stdout matches regex (?P<regex>.*)
+ regex: true
+ function: runcmd_stdout_matches_regex
+
+- then: stdout doesn't match regex (?P<regex>.*)
+ regex: true
+ function: runcmd_stdout_doesnt_match_regex
+
+- then: stderr matches regex (?P<regex>.*)
+ regex: true
+ function: runcmd_stderr_matches_regex
+
+- then: stderr doesn't match regex (?P<regex>.*)
+ regex: true
+ function: runcmd_stderr_doesnt_match_regex