Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

23.6 KB
Raw Blame
"""CLI tests for ``vibe vault fetch`` around avault delivery.

Avibe validates policy and passes an envelope/request to avault. It never receives the
secret value.
"""

from __future__ import annotations

import argparse
import json
import threading
import time

import pytest

from storage import vault_service
from storage.vault_crypto import Sealed
from vibe import cli


def _ns(**kw):
    base = dict(
        name=None,
        stdin=False,
        from_file=None,
        group=None,
        tag=None,
        description=None,
        allow_host=None,
        auth_header=None,
        auth_query=None,
        auth=None,
        url=None,
        method="GET",
        header=None,
        data=None,
        data_file=None,
        output=None,
        approval_wait=0,
        no_approval_wait=False,
        json=False,
    )
    base.update(kw)
    return argparse.Namespace(**base)


def _sealed(suffix: str = "1") -> Sealed:
    return Sealed(ciphertext=f"ct-{suffix}", nonce=f"n-{suffix}", wrap_meta=f"wm-{suffix}")


def _create_standard_secret(
    name: str,
    *,
    allow_host: list[str] | None = None,
    auth_header: str | None = None,
    auth_query: str | None = None,
    sealed: Sealed | None = None,
    default_field: str | None = None,
    fields: list[dict] | None = None,
) -> None:
    policy: dict = {}
    if allow_host:
        policy["allowed_hosts"] = allow_host
    if auth_header:
        policy["auth"] = {"type": "header", "name": auth_header}
    elif auth_query:
        policy["auth"] = {"type": "query", "name": auth_query}
    with cli._open_vault_engine().begin() as conn:
        vault_service.create_secret(
            conn,
            name=name,
            sealed=sealed or _sealed(name.lower()),
            policy=policy or None,
            default_field=default_field,
            fields=fields,
        )


def _grant_from_request(conn, request: dict, *, session_id: str | None = None) -> dict:
    option = request["card"]["grant_options"][0]
    return vault_service.create_grant(
        conn,
        member_names=option["member_snapshot"],
        source_selector=option["source_selector"],
        purpose=option["purpose"],
        session_id=session_id,
        request_id=request["id"],
    )


def _set_protected_grant(name: str, *, allow_host: list[str], session_id: str | None = None) -> dict:
    with cli._open_vault_engine().begin() as conn:
        vault_service.create_secret(
            conn,
            name=name,
            protection="protected",
            sealed=_sealed(name.lower()),
            policy={"allowed_hosts": allow_host},
        )
        req = vault_service.create_access_request(
            conn,
            name,
            purpose="fetch",
            requester={"source": "cli", "session_id": session_id} if session_id else {"source": "cli"},
            delivery={"session_id": session_id, "mode": "fetch"} if session_id else {"mode": "fetch"},
        )
        return _grant_from_request(conn, req, session_id=session_id)


APPROVAL_POLL_TIMEOUT = 30.0


def _approve_next_pending_access_request(*, session_id: str | None = None) -> dict:
    # Generous: the loop returns as soon as the request appears, so the only
    # thing this bounds is how long a genuinely broken run hangs. A tight
    # budget raced the CLI's own approval wait and flaked on loaded runners.
    deadline = time.monotonic() + APPROVAL_POLL_TIMEOUT
    while time.monotonic() < deadline:
        with cli._open_vault_engine().begin() as conn:
            requests = []
            for request in vault_service.list_requests(conn, status="pending"):
                card = request.get("card") or {}
                if request.get("request_type") == "access" and card.get("grant_options"):
                    requests.append(request)
            if requests:
                request = requests[0]
                grant = _grant_from_request(conn, request, session_id=session_id)
                return {"request": request, "grant": grant}
        time.sleep(0.01)
    raise AssertionError("pending access request was not created")


def _set_always_ask_grant(name: str, *, allow_host: list[str]) -> dict:
    with cli._open_vault_engine().begin() as conn:
        vault_service.create_secret(
            conn,
            name=name,
            sealed=_sealed(name.lower()),
            policy={"always_ask": True, "allowed_hosts": allow_host},
        )
        req = vault_service.create_access_request(
            conn,
            name,
            purpose="fetch",
            requester={"source": "cli"},
            delivery={"mode": "fetch"},
        )
        return _grant_from_request(conn, req)


def test_fetch_passes_bearer_request_to_avault_and_writes_stdout(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("GH_PAT", allow_host=["api.github.com"])
    fetch = Mock(return_value={"status": 200, "headers": {"content-type": "application/json"}, "body": '{"ok":true}'})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    code = cli.cmd_vault_fetch(_ns(auth="GH_PAT", url="https://api.github.com/repos/o/r"))
    captured = capfd.readouterr()

    assert code == 0
    assert captured.out == '{"ok":true}'
    assert "ghp-never-returned" not in captured.out
    assert "ghp-never-returned" not in captured.err
    fetch.assert_called_once()
    name, sealed, request = fetch.call_args.args
    assert name == "GH_PAT"
    assert sealed == _sealed("gh_pat")
    assert request["allowed_hosts"] == ["api.github.com"]
    assert request["inject"] == {"type": "bearer"}
    assert request["method"] == "GET"
    assert request["url"] == "https://api.github.com/repos/o/r"
    with cli._open_vault_engine().connect() as conn:
        assert vault_service.get_secret_meta(conn, "GH_PAT")["use_count"] == 1


@pytest.mark.parametrize(
    ("auth", "expected_name", "expected_sealed", "expected_field"),
    [
        ("GH_LOGIN.password", "GH_LOGIN", _sealed("password"), "password"),
        ("GH_LOGIN.username", "GH_LOGIN.username", _sealed("username"), "username"),
    ],
)
def test_fetch_canonicalizes_record_name_and_uses_secret_policy(
    capfd,
    monkeypatch,
    auth,
    expected_name,
    expected_sealed,
    expected_field,
):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret(
        "GH_LOGIN",
        allow_host=["api.github.com"],
        sealed=_sealed("password"),
        default_field="password",
        fields=[{"name": "username", "sealed": _sealed("username")}],
    )
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    assert cli.cmd_vault_fetch(_ns(auth=auth, url="https://api.github.com/user")) == 0
    capfd.readouterr()

    name, sealed, request = fetch.call_args.args
    assert name == expected_name
    assert sealed == expected_sealed
    assert request["allowed_hosts"] == ["api.github.com"]
    with cli._open_vault_engine().connect() as conn:
        assert vault_service.get_secret_meta(conn, "GH_LOGIN")["use_count"] == 1
        audit_rows = vault_service.list_audit(conn, secret_name="GH_LOGIN")
    proxied = [row for row in audit_rows if row["event"] == "proxied"]
    assert json.loads(proxied[-1]["delivery"])["field"] == expected_field


def test_fetch_rejects_keypair_before_avault_delivery(capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    with cli._open_vault_engine().begin() as conn:
        vault_service.create_secret(
            conn,
            name="ETH_KEY",
            sealed=_sealed("eth"),
            kind="keypair",
            signer_kind="local",
        )
    fetch = Mock()
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    code = cli.cmd_vault_fetch(_ns(auth="ETH_KEY", url="https://api.example.com/v1/thing"))
    captured = capfd.readouterr()

    assert code == 1
    assert json.loads(captured.err)["code"] == "keypair_not_value_deliverable"
    fetch.assert_not_called()


def test_fetch_uses_agent_delivery_for_protected_grant(capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    grant = _set_protected_grant("GH_PAT", allow_host=["api.github.com"])
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": '{"ok":true}'})
    monkeypatch.setattr(api, "avault_agent_deliver_fetch", fetch)
    monkeypatch.setattr(api, "avault_deliver_fetch", Mock())

    code = cli.cmd_vault_fetch(_ns(auth="GH_PAT", url="https://api.github.com/repos/o/r"))
    captured = capfd.readouterr()

    assert code == 0
    assert captured.out == '{"ok":true}'
    fetch.assert_called_once()
    assert fetch.call_args.kwargs["grant_id"] == grant["id"]
    assert fetch.call_args.kwargs["sealed"] == _sealed("gh_pat")
    assert "value" not in repr(fetch.call_args.kwargs)


def test_fetch_persists_protected_approval_request_without_grant(capfd):
    with cli._open_vault_engine().begin() as conn:
        vault_service.create_secret(
            conn,
            name="GH_PAT",
            protection="protected",
            sealed=_sealed("gh_pat"),
            policy={"allowed_hosts": ["api.github.com"]},
        )

    code = cli.cmd_vault_fetch(_ns(auth="GH_PAT", url="https://api.github.com/repos/o/r"))
    captured = capfd.readouterr()

    assert code == 1
    assert json.loads(captured.err)["code"] == "approval_required"
    with cli._open_vault_engine().connect() as conn:
        requests = vault_service.list_requests(conn, status="pending")
    assert len(requests) == 1
    assert requests[0]["secret_name"] == "GH_PAT"
    assert requests[0]["delivery"]["mode"] == "fetch"
    assert requests[0]["delivery"]["host"] == "api.github.com"


def test_fetch_waits_for_protected_approval_then_delivers(capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    with cli._open_vault_engine().begin() as conn:
        vault_service.create_secret(
            conn,
            name="GH_PAT",
            protection="protected",
            sealed=_sealed("gh_pat"),
            policy={"allowed_hosts": ["api.github.com"]},
        )
    approved: dict = {}

    def approve_request():
        approved.update(_approve_next_pending_access_request(session_id="ses_cli"))

    approver = threading.Thread(target=approve_request)
    approver.start()
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": '{"ok":true}'})
    monkeypatch.setattr(api, "avault_agent_deliver_fetch", fetch)
    monkeypatch.setattr(api, "avault_deliver_fetch", Mock())

    code = cli.cmd_vault_fetch(
        _ns(auth="GH_PAT", url="https://api.github.com/repos/o/r", session_id="ses_cli", approval_wait=APPROVAL_POLL_TIMEOUT)
    )
    approver.join(timeout=APPROVAL_POLL_TIMEOUT)
    captured = capfd.readouterr()

    assert code == 0
    assert captured.out == '{"ok":true}'
    assert "Waiting for Vault approval in the browser for vault fetch" in captured.err
    assert not approver.is_alive()
    fetch.assert_called_once()
    assert fetch.call_args.kwargs["grant_id"] == approved["grant"]["id"]


def test_fetch_revalidates_policy_after_approval_wait(capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    with cli._open_vault_engine().begin() as conn:
        vault_service.create_secret(
            conn,
            name="GH_PAT",
            protection="protected",
            sealed=_sealed("gh_pat"),
            policy={"allowed_hosts": ["api.github.com"]},
        )

    def approve_and_change_policy(args, exc, *, timeout, help_command, operation):
        request_id = exc.details["request_id"]
        with cli._open_vault_engine().begin() as conn:
            request = vault_service.get_request(conn, request_id, audience=vault_service.REQUEST_AUDIENCE_AGENT)
            _grant_from_request(conn, request, session_id="ses_cli")
            conn.execute(
                vault_service.vault_secrets.update()
                .where(vault_service.vault_secrets.c.name == "GH_PAT")
                .values(policy=json.dumps({"allowed_hosts": ["api.example.com"]}))
            )

    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(cli, "_wait_for_vault_delivery_approval", approve_and_change_policy)
    monkeypatch.setattr(api, "avault_agent_deliver_fetch", fetch)
    monkeypatch.setattr(api, "avault_deliver_fetch", Mock())

    code = cli.cmd_vault_fetch(
        _ns(auth="GH_PAT", url="https://api.github.com/repos/o/r", session_id="ses_cli", approval_wait=2)
    )
    captured = capfd.readouterr()

    assert code == 1
    assert json.loads(captured.err)["code"] == "host_not_allowed"
    fetch.assert_not_called()


def test_fetch_revalidates_output_after_approval_wait(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    out = tmp_path / "response.json"
    with cli._open_vault_engine().begin() as conn:
        vault_service.create_secret(
            conn,
            name="GH_PAT",
            protection="protected",
            sealed=_sealed("gh_pat"),
            policy={"allowed_hosts": ["api.github.com"]},
        )

    def approve_and_block_output(args, exc, *, timeout, help_command, operation):
        request_id = exc.details["request_id"]
        with cli._open_vault_engine().begin() as conn:
            request = vault_service.get_request(conn, request_id, audience=vault_service.REQUEST_AUDIENCE_AGENT)
            _grant_from_request(conn, request, session_id="ses_cli")
        out.mkdir()

    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(cli, "_wait_for_vault_delivery_approval", approve_and_block_output)
    monkeypatch.setattr(api, "avault_agent_deliver_fetch", fetch)
    monkeypatch.setattr(api, "avault_deliver_fetch", Mock())

    code = cli.cmd_vault_fetch(
        _ns(
            auth="GH_PAT",
            url="https://api.github.com/repos/o/r",
            session_id="ses_cli",
            approval_wait=2,
            output=str(out),
        )
    )
    captured = capfd.readouterr()

    assert code == 1
    assert json.loads(captured.err)["code"] == "output_unwritable"
    fetch.assert_not_called()


def test_fetch_header_auth_request_shape(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("SVC_KEY", allow_host=["api.example.com"], auth_header="X-Api-Key")
    fetch = Mock(return_value={"status": 204, "headers": {}, "body": ""})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    assert cli.cmd_vault_fetch(_ns(auth="SVC_KEY", url="https://api.example.com/v1/thing")) == 0
    request = fetch.call_args.args[2]
    assert request["inject"] == {"type": "header", "name": "X-Api-Key"}


def test_fetch_query_auth_request_shape(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("QUERY_KEY", allow_host=["api.example.com"], auth_query="api_key")
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    assert cli.cmd_vault_fetch(_ns(auth="QUERY_KEY", url="https://api.example.com/v1/thing")) == 0
    request = fetch.call_args.args[2]
    assert request["inject"] == {"type": "query", "name": "api_key"}


def test_fetch_post_body_and_headers_pass_to_avault(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("POST_KEY", allow_host=["api.example.com"])
    fetch = Mock(return_value={"status": 201, "headers": {}, "body": "created"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    assert cli.cmd_vault_fetch(
        _ns(
            auth="POST_KEY",
            url="https://api.example.com/create",
            method="POST",
            header=["X-Trace: 123"],
            data='{"x":1}',
        )
    ) == 0
    request = fetch.call_args.args[2]
    assert request["method"] == "POST"
    assert request["headers"] == {"X-Trace": "123"}
    assert request["body"] == '{"x":1}'


def test_fetch_writes_mocked_response_to_output_file(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("OUT_KEY", allow_host=["api.example.com"])
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "file body"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)
    out = tmp_path / "resp.txt"

    assert cli.cmd_vault_fetch(_ns(auth="OUT_KEY", url="https://api.example.com/x", output=str(out))) == 0
    assert capfd.readouterr().out == ""
    assert out.read_text() == "file body"


@pytest.mark.parametrize(
    ("url", "code"),
    [
        ("https://evil.example.com/x", "host_not_allowed"),
        ("http://api.example.com/x", "insecure_transport"),
    ],
)
def test_fetch_preflights_reject_before_avault(tmp_path, capfd, monkeypatch, url, code):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("BOUND_KEY", allow_host=["api.example.com"])
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    result = cli.cmd_vault_fetch(_ns(auth="BOUND_KEY", url=url))
    captured = capfd.readouterr()

    assert result == 1
    assert json.loads(captured.err)["code"] == code
    fetch.assert_not_called()


def test_fetch_refuses_unbound_secret_before_avault(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("UNBOUND_KEY")
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    code = cli.cmd_vault_fetch(_ns(auth="UNBOUND_KEY", url="https://api.example.com/x"))
    captured = capfd.readouterr()
    assert code == 1
    assert json.loads(captured.err)["code"] == "proxy_unbound"
    fetch.assert_not_called()


def test_fetch_rejects_trace_method_before_avault(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("GH_PAT", allow_host=["api.example.com"])
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    code = cli.cmd_vault_fetch(_ns(auth="GH_PAT", url="https://api.example.com/x", method="TRACE"))
    captured = capfd.readouterr()
    assert code == 1
    assert json.loads(captured.err)["code"] == "method_not_allowed"
    fetch.assert_not_called()


def test_fetch_rejects_host_header_override_before_avault(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("GH_PAT", allow_host=["api.example.com"])
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    code = cli.cmd_vault_fetch(_ns(auth="GH_PAT", url="https://api.example.com/x", header=["Host: evil.example.com"]))
    captured = capfd.readouterr()
    assert code == 1
    assert json.loads(captured.err)["code"] == "forbidden_header"
    fetch.assert_not_called()


def test_fetch_rejects_stored_host_auth_policy_before_avault(capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("HOST_AUTH_KEY", allow_host=["api.example.com"], auth_header="Host")
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    code = cli.cmd_vault_fetch(_ns(auth="HOST_AUTH_KEY", url="https://api.example.com/x"))
    captured = capfd.readouterr()
    assert code == 1
    assert json.loads(captured.err)["code"] == "forbidden_header"
    fetch.assert_not_called()


def test_fetch_output_unwritable_is_preflighted_before_avault(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("GH_PAT", allow_host=["api.example.com"])
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    bad_out = tmp_path / "no_such_dir" / "resp.json"
    code = cli.cmd_vault_fetch(_ns(auth="GH_PAT", url="https://api.example.com/x", method="POST", output=str(bad_out)))
    captured = capfd.readouterr()
    assert code == 1
    assert json.loads(captured.err)["code"] == "output_unwritable"
    fetch.assert_not_called()


def test_fetch_returns_response_even_if_audit_fails(tmp_path, capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _create_standard_secret("GH_PAT", allow_host=["api.example.com"])
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    def _boom(*a, **k):
        raise RuntimeError("db locked")

    monkeypatch.setattr(vault_service, "record_proxy_use", _boom)
    code = cli.cmd_vault_fetch(_ns(auth="GH_PAT", url="https://api.example.com/x"))
    captured = capfd.readouterr()
    assert code == 0
    assert captured.out == "ok"
    fetch.assert_called_once()


def test_fetch_returns_response_even_if_one_shot_cleanup_fails(capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    _set_always_ask_grant("ASK_KEY", allow_host=["api.example.com"])
    fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
    cleanup = Mock(side_effect=RuntimeError("db locked"))
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)
    monkeypatch.setattr(api, "consume_one_shot_grants", cleanup)

    code = cli.cmd_vault_fetch(_ns(auth="ASK_KEY", url="https://api.example.com/x", method="POST"))
    captured = capfd.readouterr()

    assert code == 0
    assert captured.out == "ok"
    fetch.assert_called_once()
    cleanup.assert_called_once()


def test_fetch_consumes_one_shot_grant_when_avault_errors_after_possible_egress(capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    grant = _set_always_ask_grant("ASK_KEY", allow_host=["api.example.com"])
    fetch = Mock(side_effect=api.AvaultError("timed out after sending request"))
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    code = cli.cmd_vault_fetch(_ns(auth="ASK_KEY", url="https://api.example.com/x", method="POST"))
    captured = capfd.readouterr()

    assert code == 1
    assert json.loads(captured.err)["code"] == "request_failed"
    fetch.assert_called_once()
    with cli._open_vault_engine().connect() as conn:
        status = conn.execute(
            vault_service.vault_grants.select().where(vault_service.vault_grants.c.id == grant["id"])
        ).mappings().one()["status"]
    assert status == "expired"


def test_fetch_releases_one_shot_grant_when_avault_fails_before_handoff(capfd, monkeypatch):
    from unittest.mock import Mock

    from vibe import api

    grant = _set_always_ask_grant("ASK_KEY", allow_host=["api.example.com"])
    fetch = Mock(side_effect=api.AvaultPreHandoffError("avault is required for vault fetch"))
    monkeypatch.setattr(api, "avault_deliver_fetch", fetch)

    code = cli.cmd_vault_fetch(_ns(auth="ASK_KEY", url="https://api.example.com/x", method="POST"))
    captured = capfd.readouterr()

    assert code == 1
    assert json.loads(captured.err)["code"] == "request_failed"
    fetch.assert_called_once()
    with cli._open_vault_engine().connect() as conn:
        status = conn.execute(
            vault_service.vault_grants.select().where(vault_service.vault_grants.c.id == grant["id"])
        ).mappings().one()["status"]
    assert status == "active"


def test_host_allowed_is_case_insensitive():
    assert cli._host_allowed("api.github.com", ["API.GITHUB.COM"]) is True
    assert cli._host_allowed("api.github.com", [".GitHub.com"]) is True
    assert cli._host_allowed("API.GITHUB.COM", ["api.github.com"]) is True