mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/devkit/testflight_routes.py

@@ -0,0 +1,111 @@
+"""The API behind `mobster testflight` for Mobster for Mac, registered by testkit/register.py under /api/tests."""
+
+from pathlib import Path
+
+from . import DevError
+
+STATUS = {"outcome_unknown": 409, "needs_tap": 409}
+
+
+def _fail(error):
+    from ..api_routes import Response
+    from . import asc
+    code = "outcome_unknown" if isinstance(error, asc.UnknownOutcome) else \
+        "needs_tap" if isinstance(error, asc.NeedsTap) else "testflight"
+    return Response.error(error.line(), STATUS.get(code, 400), code)
+
+
+def _project(value):
+    """The project folder a request names, or None for the shared key. ValueError when it isn't a folder."""
+    if value in (None, ""):
+        return None
+    if not isinstance(value, str) or not Path(value).is_absolute() or not Path(value).is_dir():
+        raise ValueError("project is the absolute path of a folder on this Mac.")
+    from ..verify.checks import project_root
+    return Path(project_root(Path(value))).resolve()
+
+
+def _text(value, name, limit=200):
+    if not isinstance(value, str) or not value.strip() or len(value) > limit:
+        raise ValueError(f"{name} is text of at most {limit} characters.")
+    return value.strip()
+
+
+def _gate(request):
+    gate = getattr(request.runtime, "plan_gate", None)
+    if gate is not None:
+        gate.require()
+
+
+def _client(root, store=None):
+    from . import asc
+    return asc.Client(asc.load_key(store=store, project=root))
+
+
+def builds(request):
+    from ..api_routes import Response
+    from . import testflight
+    try:
+        _gate(request)
+        root = _project((request.query.get("project") or [None])[0])
+        bundle = _text((request.query.get("bundle") or [None])[0], "bundle")
+        app, rows = testflight.builds(_client(root), bundle)
+    except DevError as error:
+        return _fail(error)
+    return Response.json({"app": app, "builds": rows})
+
+
+def install(request):
+    from ..api_routes import Response
+    from ..phone_io import PhoneIOError, choose_device, wda
+    from . import testflight
+    body = request.body if isinstance(request.body, dict) else {}
+    unknown = [key for key in body if key not in ("project", "bundle", "build", "version", "device")]
+    if unknown:
+        raise ValueError(f"Unknown field {unknown[0]}.")
+    root = _project(body.get("project"))
+    if root is None:
+        raise ValueError("project is the absolute path of the project's folder.")
+    bundle = _text(body.get("bundle"), "bundle")
+    build = _text(str(body["build"]), "build", 40) if body.get("build") is not None else None
+    version = _text(body["version"], "version", 40) if body.get("version") is not None else None
+    try:
+        _gate(request)
+        record = choose_device(_text(body["device"], "device") if body.get("device") else None)
+        done = testflight.install(_client(root), record, wda, bundle, root=root, build=build, version=version)
+    except DevError as error:
+        return _fail(error)
+    except PhoneIOError as error:
+        return Response.error(f"{error} {error.fix or ''}".strip(), 409, "no_device")
+    row = done["row"]
+    return Response.json({"result": done["result"], "device": record.get("name"),
+                          "build": {"version": row["version"], "build": row["build"]}})
+
+
+def key(request):
+    from ..api_routes import Response
+    from . import asc
+    if request.method == "POST":
+        body = request.body if isinstance(request.body, dict) else {}
+        unknown = [name for name in body if name not in ("project", "keyId", "issuerId", "p8")]
+        if unknown:
+            raise ValueError(f"Unknown field {unknown[0]}.")
+        root = _project(body.get("project"))
+        try:
+            saved = asc.save_key(_text(body.get("keyId"), "keyId", 20),
+                                 _text(body["issuerId"], "issuerId", 40) if body.get("issuerId") else None,
+                                 _text(body.get("p8"), "p8", 4000), project=root)
+        except DevError as error:
+            return _fail(error)
+        return Response.json({"configured": True, **saved.public()})
+    root = _project((request.query.get("project") or [None])[0])
+    if request.method == "DELETE":
+        try:
+            asc.remove_key(project=root)
+        except Exception:
+            return Response.error("The Keychain didn't remove the key.", 503, "keychain")
+        return Response.json({"configured": False})
+    try:
+        return Response.json({"configured": True, **asc.load_key(project=root).public()})
+    except DevError:
+        return Response.json({"configured": False})

mobile_agent/devkit/xcode.py

@@ -0,0 +1,236 @@
+"""Xcode: your checks run by themselves after each simulator build, from a post-action in the scheme."""
+
+import json
+import os
+import shlex
+import signal
+import subprocess
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+from . import DevError, agent_argv
+
+TITLE = "Mobster checks"
+ACTION_TYPE = "Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction"
+STATE_DIR = ".mobster/xcode"
+
+
+def scheme_file(project, scheme):
+    """The shared scheme's file in an .xcodeproj or .xcworkspace, else DevError."""
+    project = Path(project)
+    for candidate in (project / "xcshareddata" / "xcschemes" / f"{scheme}.xcscheme",):
+        if candidate.is_file():
+            return candidate
+    if project.suffix == ".xcworkspace":
+        for sibling in project.parent.glob("*.xcodeproj"):
+            candidate = sibling / "xcshareddata" / "xcschemes" / f"{scheme}.xcscheme"
+            if candidate.is_file():
+                return candidate
+    raise DevError(f"{project.name} has no shared scheme named {scheme}.",
+                   "In Xcode, open Product › Scheme › Manage Schemes and tick Shared for it, then try again.")
+
+
+def command_line(*, sims=(), tags=(), agent=None):
+    """The post-action's script: Mobster for Mac's agent when it's installed, else this Mobster."""
+    if agent is None:
+        argv = agent_argv()[0]
+    else:
+        argv = [agent]
+    argv = list(argv) + ["xcode", "after-build", "--background"]
+    for sim in sims:
+        argv += ["--sim", sim]
+    for tag in tags:
+        argv += ["--tag", tag]
+    return " ".join(shlex.quote(str(item)) for item in argv) + " > /dev/null 2>&1"
+
+
+def _buildable(root):
+    """The scheme's app target, for EnvironmentBuildable (so the script sees BUILT_PRODUCTS_DIR and the rest)."""
+    for entry in root.iter("BuildActionEntry"):
+        reference = entry.find("BuildableReference")
+        if reference is not None and str(reference.get("BuildableName", "")).endswith(".app"):
+            return reference
+    reference = root.find(".//BuildableReference")
+    if reference is None:
+        raise DevError("The scheme builds nothing Mobster can find.", "Pick the scheme that builds your app.")
+    return reference
+
+
+def _ours(action):
+    content = action.find("ActionContent")
+    return content is not None and content.get("title") == TITLE
+
+
+def hook(project, scheme, *, sims=(), tags=(), agent=None):
+    """Add (or replace) the post-action. Returns the scheme file."""
+    path = scheme_file(project, scheme)
+    try:
+        tree = ET.parse(path)
+    except ET.ParseError:
+        raise DevError(f"{path.name} isn't a scheme Mobster can read.") from None
+    root = tree.getroot()
+    build = root.find("BuildAction")
+    if build is None:
+        raise DevError(f"{path.name} has no build action.")
+    reference = _buildable(root)
+    post = build.find("PostActions")
+    if post is None:
+        post = ET.Element("PostActions")
+        children = list(build)
+        at = next((i for i, child in enumerate(children) if child.tag == "BuildActionEntries"), len(children))
+        build.insert(at, post)
+    for action in [a for a in post.findall("ExecutionAction") if _ours(a)]:
+        post.remove(action)
+    action = ET.SubElement(post, "ExecutionAction", {"ActionType": ACTION_TYPE})
+    content = ET.SubElement(action, "ActionContent", {"title": TITLE, "scriptText": command_line(
+        sims=sims, tags=tags, agent=agent), "shellToInvoke": "/bin/sh"})
+    environment = ET.SubElement(content, "EnvironmentBuildable")
+    environment.append(ET.fromstring(ET.tostring(reference)))
+    _write(tree, path)
+    return path
+
+
+def unhook(project, scheme):
+    """Take Mobster's post-action out. Returns True when there was one."""
+    path = scheme_file(project, scheme)
+    tree = ET.parse(path)
+    build = tree.getroot().find("BuildAction")
+    post = build.find("PostActions") if build is not None else None
+    if post is None:
+        return False
+    ours = [a for a in post.findall("ExecutionAction") if _ours(a)]
+    for action in ours:
+        post.remove(action)
+    if not list(post):
+        build.remove(post)
+    if ours:
+        _write(tree, path)
+    return bool(ours)
+
+
+def _attribute(value):
+    return (str(value).replace("&", "&amp;").replace('"', "&quot;").replace("<", "&lt;").replace(">", "&gt;")
+            .replace("\n", "&#10;"))
+
+
+# Written the way Xcode writes a scheme, so a scheme Mobster rewrites diffs only where its post-action is.
+def xcode_xml(element, depth=0):
+    pad = "   " * depth
+    lines = [f"{pad}<{element.tag}"]
+    items = list(element.attrib.items())
+    if items:
+        lines += [f"{pad}   {name} = \"{_attribute(value)}\"" for name, value in items]
+        lines[-1] += ">"
+    else:
+        lines[-1] += ">"
+    for child in element:
+        lines.append(xcode_xml(child, depth + 1))
+    lines.append(f"{pad}</{element.tag}>")
+    return "\n".join(lines)
+
+
+def _write(tree, path):
+    text = '<?xml version="1.0" encoding="UTF-8"?>\n' + xcode_xml(tree.getroot()) + "\n"
+    temporary = Path(path).with_suffix(".xcscheme.tmp")
+    temporary.write_text(text, encoding="utf-8")
+    os.replace(temporary, path)
+
+
+# -- after a build ------------------------------------------------------------------------------------------------
+
+def built_app(environ):
+    """(the .app Xcode built, its platform) from the post-action's environment, or DevError."""
+    folder, name = environ.get("BUILT_PRODUCTS_DIR"), environ.get("FULL_PRODUCT_NAME") or environ.get("WRAPPER_NAME")
+    if not folder or not name:
+        raise DevError("This runs from Xcode's post-action, which sets BUILT_PRODUCTS_DIR and FULL_PRODUCT_NAME.",
+                       "Add it with `mobster xcode hook --scheme NAME`.")
+    return Path(folder) / name, environ.get("PLATFORM_NAME") or ""
+
+
+KEEP = ("PATH", "HOME", "USER", "LOGNAME", "SHELL", "LANG", "TMPDIR", "BUILT_PRODUCTS_DIR", "FULL_PRODUCT_NAME",
+        "WRAPPER_NAME", "PLATFORM_NAME", "SRCROOT", "PYTHONPATH")
+
+
+# Xcode's build settings (SDKROOT, ARCHS and hundreds more) would leak into the builds the checks start.
+def clean_env(environ):
+    return {key: value for key, value in environ.items()
+            if key in KEEP or key.startswith(("LC_", "MOBSTER_", "ANTHROPIC_", "OPENAI_"))}
+
+
+def spawn_background(root, argv, env, *, popen=None, kill=os.kill):
+    folder = Path(root) / STATE_DIR
+    folder.mkdir(parents=True, exist_ok=True)
+    pidfile = folder / "run.pid"
+    try:
+        kill(-int(pidfile.read_text().strip()), signal.SIGTERM)
+    except (OSError, ValueError):
+        pass
+    with open(folder / "last.log", "wb") as log:
+        process = (popen or subprocess.Popen)(argv, cwd=str(root), stdin=subprocess.DEVNULL, stdout=log,
+                                              stderr=subprocess.STDOUT, start_new_session=True,
+                                              env=clean_env(env))
+    pidfile.write_text(f"{process.pid}\n")
+    return process.pid
+
+
+def checks_for(entries, app_path, bundle):
+    """The checks of the app Xcode built, pointed at that build."""
+    from ..testkit.prrun import with_build
+    mine = [entry for entry in entries if entry.check is not None and (
+        (entry.check.bundle_id and entry.check.bundle_id == bundle) or
+        (not entry.check.bundle_id and entry.check.app_path and Path(entry.check.app_path).name == app_path.name))]
+    return with_build(mine, {"path": str(app_path), "bundle": bundle}, ())
+
+
+def bundle_of(app_path):
+    import plistlib
+    try:
+        with open(Path(app_path) / "Info.plist", "rb") as handle:
+            return plistlib.load(handle).get("CFBundleIdentifier")
+    except (OSError, ValueError, plistlib.InvalidFileException):
+        return None
+
+
+def notify(title, text, *, run=None):
+    """A macOS notification (no window). Never raises."""
+    script = f"display notification {json.dumps(text)} with title {json.dumps(title)}"
+    try:
+        (run or (lambda argv: subprocess.run(argv, capture_output=True, timeout=10)))(["osascript", "-e", script])
+    except Exception:
+        pass
+
+
+def run_checks(root, app_path, *, sims=(), tags=(), plan=None, execute=None, progress=None, notifier=None):
+    """Run the checks of ``app_path`` and say the verdict. Returns (exit code, headline)."""
+    from dataclasses import replace
+
+    from ..testkit.api import Options, UsageError
+    from ..testkit.reports import counts_text
+    if plan is None:
+        from ..testkit.api import plan
+    if execute is None:
+        from ..testkit.api import execute
+    progress = progress or (lambda line: None)
+    bundle = bundle_of(app_path)
+    options = Options(sims=tuple(sims), tags=tuple(tags), command="mobster xcode after-build")
+    try:
+        planned = plan(options, cwd=root)
+    except UsageError as error:
+        raise DevError(str(error)) from None
+    entries = checks_for(planned.entries, app_path, bundle)
+    folder = Path(root) / STATE_DIR
+    folder.mkdir(parents=True, exist_ok=True)
+    name = Path(app_path).stem
+    if not entries:
+        headline = f"No check covers {bundle or name}"
+        (folder / "last.json").write_text(json.dumps({"app": str(app_path), "headline": headline, "exitCode": 0}))
+        return 0, headline
+    progress(f"{len(entries)} check{'' if len(entries) == 1 else 's'} of {name}, on the build Xcode just made")
+    doc, paths = execute(replace(planned, entries=entries), progress=progress)
+    headline = counts_text(doc.get("summary") or {})
+    code = int(doc.get("exitCode", 3))
+    (folder / "last.json").write_text(json.dumps({"app": str(app_path), "headline": headline, "exitCode": code,
+                                                  "report": str(paths.get("html") or "")}, indent=1))
+    (notifier or notify)(f"Mobster checks: {name}", headline + ("" if code == 0 else
+                                                                ". The report is in .mobster/test-results."))
+    return code, headline

mobile_agent/devkit/xcode_cli.py

@@ -0,0 +1,101 @@
+"""`mobster xcode`: your checks after every simulator build in Xcode (xcode.py does the work)."""
+
+import os
+import sys
+from pathlib import Path
+
+from . import DevError, main, say, self_argv, subcommands
+
+
+def add_arguments(parser, helpers):
+    add = subcommands(parser, "xcode_command")
+
+    for name, text in (("hook", "run your checks after every simulator build in Xcode"),
+                       ("unhook", "stop running your checks after Xcode builds")):
+        sub = add(name, help=text,
+                  description="Add Mobster's post-action to a shared scheme's build: after each simulator build, "
+                              "the checks of the app Xcode built run in the background on that build, and the "
+                              "verdict comes as a notification." if name == "hook" else
+                              "Take Mobster's post-action out of the scheme. Nothing else in it changes.")
+        sub.add_argument("--scheme", metavar="NAME", help="the shared scheme (default: the only one, or the one "
+                                                          "named like the project)")
+        sub.add_argument("--project", metavar="PATH", help="the .xcodeproj or .xcworkspace (default: the one here)")
+        if name == "hook":
+            sub.add_argument("--sim", action="append", metavar="TYPE[@RUNTIME]",
+                             help="run the checks on this simulator; repeatable (default: each check's own)")
+            sub.add_argument("--tag", action="append", metavar="TAG",
+                             help="only the checks with this tag, such as smoke; repeatable")
+    after = add("after-build", help="run the checks of the app Xcode just built (the post-action runs it)",
+                description="Run the checks whose app is the one Xcode just built, on that build. It reads "
+                            "BUILT_PRODUCTS_DIR, FULL_PRODUCT_NAME, PLATFORM_NAME and SRCROOT from Xcode. A build "
+                            "for a device is left alone.")
+    after.add_argument("--background", action="store_true",
+                       help="return at once and run in the background, stopping an older build's run")
+    after.add_argument("--sim", action="append", metavar="TYPE[@RUNTIME]", help="a simulator to run on; repeatable")
+    after.add_argument("--tag", action="append", metavar="TAG", help="only the checks with this tag; repeatable")
+
+
+def run(args, *, cwd=None, environ=None):
+    environ = os.environ if environ is None else environ
+    handlers = {"hook": _hook, "unhook": _unhook, "after-build": _after}
+    return main("xcode", handlers, args, cwd=Path(cwd or Path.cwd()), environ=environ)
+
+
+def _project(args, cwd):
+    from ..testkit import prbuild
+    try:
+        found = prbuild.project_arg(cwd / args.project) if args.project else prbuild.find_project(cwd)
+        if found is None:
+            raise DevError("There's no Xcode project here.", "Run it from your project's folder, or pass --project.")
+        scheme = args.scheme or prbuild.pick_scheme(found, cwd=cwd)
+    except prbuild.BuildError as error:
+        raise DevError(error.message, error.fix) from None
+    return found[1], scheme
+
+
+def _hook(args, cwd, environ):
+    from . import xcode
+    project, scheme = _project(args, cwd)
+    path = xcode.hook(project, scheme, sims=tuple(args.sim or ()), tags=tuple(args.tag or ()))
+    say(f"Added the \"{xcode.TITLE}\" post-action to {path.relative_to(cwd) if path.is_relative_to(cwd) else path}.\n"
+         f"After each simulator build of {scheme}, Mobster runs the checks of the app you built, in the background, "
+         "and says the verdict in a notification. The log is .mobster/xcode/last.log.\n"
+         f"Commit the scheme to share it with your team. Take it out with: mobster xcode unhook --scheme {scheme}")
+    return 0
+
+
+def _unhook(args, cwd, environ):
+    from . import xcode
+    project, scheme = _project(args, cwd)
+    if xcode.unhook(project, scheme):
+        say(f"Took the \"{xcode.TITLE}\" post-action out of {scheme}.")
+    else:
+        say(f"{scheme} has no Mobster post-action.")
+    return 0
+
+
+def _after(args, cwd, environ):
+    from ..verify.checks import project_root
+    from . import xcode
+    app, platform = xcode.built_app(environ)
+    root = project_root(Path(environ.get("SRCROOT") or cwd))
+    if platform != "iphonesimulator":
+        built = platform or "an unknown platform"
+        say(f"Skipped: Xcode built for {built}, and the post-action runs checks on simulator builds.")
+        return 0
+    if args.background:
+        argv, extra = self_argv()
+        argv = argv + ["xcode", "after-build"] + [item for sim in args.sim or () for item in ("--sim", sim)] + \
+            [item for tag in args.tag or () for item in ("--tag", tag)]
+        pid = xcode.spawn_background(root, argv, {**environ, **extra})
+        say(f"Running the checks of {app.name} in the background (pid {pid}).")
+        return 0
+    from ..devtools import ProgressLines
+    progress = ProgressLines(sys.stderr)
+    try:
+        code, headline = xcode.run_checks(root, app, sims=tuple(args.sim or ()), tags=tuple(args.tag or ()),
+                                          progress=progress)
+    finally:
+        progress.end()
+    say(headline)
+    return code