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.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
from __future__ import annotations
import json
import pytest
from sqlalchemy import select
from storage import resource_access_service, vault_service
from storage.db import create_sqlite_engine
from storage.models import (
metadata,
resource_access_groups,
resource_access_policies,
state_meta,
vault_grants,
vault_requests,
vault_secrets,
)
from storage.vault_crypto import Sealed
from vibe import api, remote_access
def _context(
subject: str,
*,
group_ids: frozenset[str] | None = frozenset({"group-engineering"}),
role: str = "member",
instance_role: str = "editor",
is_remote: bool = True,
) -> resource_access_service.ResourceUserContext:
return resource_access_service.ResourceUserContext(
subject=subject,
email=f"{subject}@example.com",
organization_id="org-1",
organization_member_id=f"member-{subject}",
organization_role=role,
group_ids=group_ids,
instance_role=instance_role,
instance_access_source="organization_group",
is_remote=is_remote,
)
def _external_guest_context() -> resource_access_service.ResourceUserContext:
return resource_access_service.ResourceUserContext(
subject="guest-1",
instance_role="viewer",
instance_access_source="email",
is_remote=True,
)
@pytest.fixture
def vault(tmp_path):
vault_service.GRANT_RUNTIME_CACHE.clear()
engine = create_sqlite_engine(tmp_path / "vault_acl.sqlite")
metadata.create_all(engine)
try:
yield engine
finally:
engine.dispose()
def _sealed(name: str) -> Sealed:
return Sealed(ciphertext=f"ciphertext-{name}", nonce=f"nonce-{name}", wrap_meta=f"wrap-{name}")
def _create_secret(conn, name: str, **kwargs) -> None:
vault_service.create_secret(conn, name=name, sealed=_sealed(name), **kwargs)
def _secret_id(conn, name: str) -> str:
return str(conn.execute(select(vault_secrets.c.id).where(vault_secrets.c.name == name)).scalar_one())
def _set_policy(
conn,
name: str,
*,
access_level: str,
group_ids: list[str] | None = None,
owner_user_id: str = "owner-1",
) -> str:
resource_id = _secret_id(conn, name)
resource_access_service.ensure_resource_policy(
conn,
resource_kind="vault_secret",
resource_id=resource_id,
organization_id="org-1",
owner_user_id=owner_user_id,
access_level=access_level,
group_ids=group_ids,
policy_revision=1,
last_applied_control_plane_revision=1,
)
return resource_id
def _grant_from_request(conn, request: dict, *, user_context) -> 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"],
request_id=request["id"],
user_context=user_context,
)
def test_active_org_members_list_all_vault_metadata_without_envelopes(vault) -> None:
with vault.begin() as conn:
_create_secret(conn, "PRIVATE_KEY")
_create_secret(conn, "PUBLIC_KEY")
_create_secret(conn, "SCOPED_KEY")
_set_policy(conn, "PRIVATE_KEY", access_level="private")
_set_policy(conn, "PUBLIC_KEY", access_level="public")
_set_policy(conn, "SCOPED_KEY", access_level="scope", group_ids=["group-engineering"])
with vault.connect() as conn:
owner_rows = vault_service.list_secrets(conn, user_context=_context("owner-1"))
member_rows = vault_service.list_secrets(conn, user_context=_context("member-1"))
no_group_rows = vault_service.list_secrets(conn, user_context=_context("member-2", group_ids=None))
assert {row["name"] for row in owner_rows} == {"PRIVATE_KEY", "PUBLIC_KEY", "SCOPED_KEY"}
assert {row["name"] for row in member_rows} == {"PRIVATE_KEY", "PUBLIC_KEY", "SCOPED_KEY"}
assert {row["name"] for row in no_group_rows} == {"PRIVATE_KEY", "PUBLIC_KEY", "SCOPED_KEY"}
serialized = json.dumps(member_rows)
assert "ciphertext-" not in serialized
assert "nonce-" not in serialized
assert "wrap-" not in serialized
assert "ciphertext" not in serialized
assert "wrap_meta" not in serialized
def test_editor_vault_use_keeps_protected_secret_behind_approval(vault) -> None:
editor = _context("member-1")
with vault.begin() as conn:
_create_secret(conn, "PROTECTED_USE", protection="protected")
_set_policy(conn, "PROTECTED_USE", access_level="public")
metadata_payload = vault_service.get_secret_meta(
conn,
"PROTECTED_USE",
user_context=editor,
)
access = vault_service.resolve_secret_access(
conn,
"PROTECTED_USE",
session_id="ses-editor",
user_context=editor,
)
assert metadata_payload["name"] == "PROTECTED_USE"
assert access["status"] == "approval_required"
assert access["request"]["status"] == "pending"
assert access.get("envelope") is None
assert access["request"]["card"]["value"] is None
serialized_metadata = json.dumps(metadata_payload)
assert "ciphertext-PROTECTED_USE" not in serialized_metadata
assert "nonce-PROTECTED_USE" not in serialized_metadata
assert "wrap-PROTECTED_USE" not in serialized_metadata
def test_active_org_members_create_private_vault_requests_and_grants(vault) -> None:
owner = _context("owner-1", instance_role="owner")
member = _context("member-1")
with vault.begin() as conn:
_create_secret(conn, "PRIVATE_ACCESS", protection="protected")
_create_secret(conn, "PRIVATE_SIGN", kind="keypair", signer_kind="local")
_set_policy(conn, "PRIVATE_ACCESS", access_level="private")
_set_policy(conn, "PRIVATE_SIGN", access_level="private")
owner_request = vault_service.create_access_request(conn, "PRIVATE_ACCESS", user_context=owner)
member_access_request = vault_service.create_access_request(
conn,
"PRIVATE_ACCESS",
user_context=member,
)
member_sign_request = vault_service.create_sign_request(
conn,
"PRIVATE_SIGN",
digest="00" * 32,
scheme="ecdsa-secp256k1-recoverable",
user_context=member,
)
member_grant = _grant_from_request(conn, owner_request, user_context=member)
requests = list(conn.execute(select(vault_requests)).mappings())
grants = list(conn.execute(select(vault_grants)).mappings())
assert {row["id"] for row in requests} == {
owner_request["id"],
member_access_request["id"],
member_sign_request["id"],
}
statuses = {row["id"]: row["status"] for row in requests}
assert statuses == {
owner_request["id"]: "approved",
member_access_request["id"]: "pending",
member_sign_request["id"]: "pending",
}
assert [row["id"] for row in grants] == [member_grant["id"]]
assert member_grant["status"] == "active"
def test_active_org_member_reads_and_denies_all_vault_requests(vault) -> None:
owner = _context("owner-1", instance_role="owner")
member = _context("member-1")
with vault.begin() as conn:
_create_secret(conn, "PRIVATE_REQUEST", protection="protected")
_create_secret(conn, "PUBLIC_REQUEST", protection="protected")
_set_policy(conn, "PRIVATE_REQUEST", access_level="private")
_set_policy(conn, "PUBLIC_REQUEST", access_level="public")
private_request = vault_service.create_access_request(conn, "PRIVATE_REQUEST", user_context=owner)
public_request = vault_service.create_access_request(conn, "PUBLIC_REQUEST", user_context=owner)
visible = vault_service.list_requests(conn, user_context=member)
private_payload = vault_service.get_request(
conn,
private_request["id"],
user_context=member,
)
private_denied = vault_service.deny_request(
conn,
private_request["id"],
user_context=member,
)
public_denied = vault_service.deny_request(
conn,
public_request["id"],
user_context=member,
)
statuses = dict(
conn.execute(select(vault_requests.c.id, vault_requests.c.status)).all()
)
assert {request["id"] for request in visible} == {
private_request["id"],
public_request["id"],
}
assert "secret_unlock_material" in private_payload["card"]
assert statuses == {
private_request["id"]: "denied",
public_request["id"]: "denied",
}
assert private_denied["status"] == "denied"
assert public_denied["status"] == "denied"
def test_delete_request_approval_requires_resource_management(vault) -> None:
owner = _context("owner-1", instance_role="owner")
member = _context("member-1")
with vault.begin() as conn:
_create_secret(conn, "PRIVATE_DELETE")
_set_policy(conn, "PRIVATE_DELETE", access_level="private")
request = vault_service.create_delete_request(conn, "PRIVATE_DELETE", user_context=owner)
with pytest.raises(vault_service.VaultSecretAccessError):
vault_service.approve_delete_request(conn, request["id"], user_context=member)
row = conn.execute(select(vault_requests).where(vault_requests.c.id == request["id"])).mappings().one()
assert row["status"] == "pending"
def test_active_org_member_can_lookup_pending_provision_requests(vault, monkeypatch) -> None:
member = _context("member-1")
with vault.begin() as conn:
provision = vault_service.create_provision_request(conn, "MISSING_SECRET")
visible, ambiguous = vault_service.resolve_pending_provision_request_by_name(
conn,
"MISSING_SECRET",
user_context=member,
)
visible_by_id = vault_service.get_pending_provision_request(
conn,
provision["id"],
user_context=member,
)
assert visible is not None
assert visible["id"] == provision["id"]
assert ambiguous is False
assert visible_by_id is not None
assert visible_by_id["id"] == provision["id"]
monkeypatch.setattr(api, "_vault_engine", lambda: vault)
monkeypatch.setattr(api, "resolve_resource_access_context", lambda: member)
api_by_name = api.get_vault_provision_request_by_name("MISSING_SECRET")
api_by_id = api.get_vault_provision_request(provision["id"])
assert api_by_name["request"]["id"] == provision["id"]
assert api_by_name["ambiguous"] is False
assert api_by_id["request"]["id"] == provision["id"]
def test_active_org_vault_request_limit_applies_to_complete_result_set(vault) -> None:
owner = _context("owner-1", instance_role="owner")
member = _context("member-1")
with vault.begin() as conn:
_create_secret(conn, "VISIBLE_REQUEST", protection="protected")
_create_secret(conn, "HIDDEN_REQUEST", protection="protected")
_set_policy(conn, "VISIBLE_REQUEST", access_level="public")
_set_policy(conn, "HIDDEN_REQUEST", access_level="private")
visible_request = vault_service.create_access_request(conn, "VISIBLE_REQUEST", user_context=owner)
private_request = vault_service.create_access_request(conn, "HIDDEN_REQUEST", user_context=owner)
conn.execute(
vault_requests.update()
.where(vault_requests.c.id == visible_request["id"])
.values(created_at="2026-01-01T00:00:00+00:00")
)
conn.execute(
vault_requests.update()
.where(vault_requests.c.id == private_request["id"])
.values(created_at="2026-01-01T00:00:01+00:00")
)
visible = vault_service.list_requests(conn, limit=1, user_context=member)
assert [request["id"] for request in visible] == [private_request["id"]]
def test_active_org_member_lists_and_revokes_all_vault_grants(vault) -> None:
owner = _context("owner-1", instance_role="owner")
member = _context("member-1")
with vault.begin() as conn:
_create_secret(conn, "OWNER_GRANT", protection="protected")
_create_secret(conn, "MEMBER_GRANT", protection="protected")
_set_policy(conn, "OWNER_GRANT", access_level="private")
_set_policy(conn, "MEMBER_GRANT", access_level="private", owner_user_id="member-1")
owner_request = vault_service.create_access_request(conn, "OWNER_GRANT", user_context=owner)
member_request = vault_service.create_access_request(conn, "MEMBER_GRANT", user_context=member)
owner_grant = _grant_from_request(conn, owner_request, user_context=owner)
member_grant = _grant_from_request(conn, member_request, user_context=member)
visible = vault_service.list_grants(conn, user_context=member)
revoked_owner = vault_service.revoke_grant(
conn,
owner_grant["id"],
user_context=member,
)
revoked_member = vault_service.revoke_grant(
conn,
member_grant["id"],
user_context=member,
)
assert {grant["id"] for grant in visible} == {
owner_grant["id"],
member_grant["id"],
}
assert revoked_owner["status"] == "revoked"
assert revoked_member["status"] == "revoked"
def test_active_org_member_audit_limit_uses_complete_event_stream(vault) -> None:
owner = _context("owner-1", instance_role="owner")
member = _context("member-1")
with vault.begin() as conn:
_create_secret(conn, "OWNER_AUDIT", protection="protected")
_create_secret(conn, "MEMBER_AUDIT", protection="protected")
_set_policy(conn, "OWNER_AUDIT", access_level="private")
_set_policy(conn, "MEMBER_AUDIT", access_level="private", owner_user_id="member-1")
owner_request = vault_service.create_access_request(conn, "OWNER_AUDIT", user_context=owner)
owner_grant = _grant_from_request(conn, owner_request, user_context=owner)
vault_service.audit(conn, "member-event", secret_name="MEMBER_AUDIT")
vault_service.audit(
conn,
"owner-event",
request_id=owner_request["id"],
grant_id=owner_grant["id"],
delivery={"grant_id": owner_grant["id"]},
)
visible = vault_service.list_audit(conn, limit=1, user_context=member)
assert [row["event"] for row in visible] == ["owner-event"]
assert visible[0]["request_id"] == owner_request["id"]
assert visible[0]["grant_id"] == owner_grant["id"]
def test_deleted_secret_audit_is_visible_to_active_org_members_without_exposing_tombstone(vault) -> None:
owner = _context("member-1", instance_role="owner")
admin = _context("admin-1", role="admin", instance_role="owner")
member = _context("member-2")
guest = _external_guest_context()
with vault.begin() as conn:
_create_secret(conn, "DELETED_AUDIT", protection="protected")
_set_policy(conn, "DELETED_AUDIT", access_level="private", owner_user_id="member-1")
vault_service.audit(conn, "before-delete", secret_name="DELETED_AUDIT")
vault_service.delete_secret(conn, "DELETED_AUDIT", user_context=admin)
owner_rows = vault_service.list_audit(conn, secret_name="DELETED_AUDIT", user_context=owner)
admin_rows = vault_service.list_audit(conn, secret_name="DELETED_AUDIT", user_context=admin)
member_rows = vault_service.list_audit(conn, secret_name="DELETED_AUDIT", user_context=member)
guest_rows = vault_service.list_audit(conn, secret_name="DELETED_AUDIT", user_context=guest)
expected_events = {"before-delete", "deleted"}
assert expected_events <= {row["event"] for row in owner_rows}
assert expected_events <= {row["event"] for row in admin_rows}
assert expected_events <= {row["event"] for row in member_rows}
assert guest_rows == []
assert vault_service._AUDIT_ACCESS_SNAPSHOT_KEY not in json.dumps(owner_rows)
assert vault_service._AUDIT_ACCESS_SNAPSHOT_KEY not in json.dumps(admin_rows)
assert vault_service._AUDIT_ACCESS_SNAPSHOT_KEY not in json.dumps(member_rows)
def test_acl_filtered_audit_uses_bounded_keyset_batches_until_limit_is_visible(vault, monkeypatch) -> None:
member = _context("member-1", is_remote=False)
monkeypatch.setattr(vault_service, "_REMOTE_AUDIT_MIN_BATCH_SIZE", 2)
monkeypatch.setattr(vault_service, "_REMOTE_AUDIT_MAX_BATCH_SIZE", 2)
with vault.begin() as conn:
_create_secret(conn, "BATCH_VISIBLE")
_create_secret(conn, "BATCH_HIDDEN")
_set_policy(conn, "BATCH_VISIBLE", access_level="public")
_set_policy(conn, "BATCH_HIDDEN", access_level="private")
vault_service.audit(conn, "batch-visible", secret_name="BATCH_VISIBLE")
for index in range(5):
vault_service.audit(
conn,
f"batch-hidden-{index}",
secret_name="BATCH_HIDDEN",
)
visible = vault_service.list_audit(conn, limit=1, user_context=member)
assert [row["event"] for row in visible] == ["batch-visible"]
assert vault_service._AUDIT_ACCESS_SNAPSHOT_KEY not in json.dumps(visible)
def test_vault_api_allows_active_org_member_full_grant_and_audit_access(vault, monkeypatch) -> None:
owner = _context("owner-1", instance_role="owner")
member = _context("member-1")
with vault.begin() as conn:
_create_secret(conn, "API_OWNER", protection="protected")
_create_secret(conn, "API_MEMBER", protection="protected")
_set_policy(conn, "API_OWNER", access_level="private")
_set_policy(conn, "API_MEMBER", access_level="private", owner_user_id="member-1")
owner_request = vault_service.create_access_request(conn, "API_OWNER", user_context=owner)
member_request = vault_service.create_access_request(conn, "API_MEMBER", user_context=member)
owner_grant = _grant_from_request(conn, owner_request, user_context=owner)
member_grant = _grant_from_request(conn, member_request, user_context=member)
vault_service.audit(conn, "api-member-visible", secret_name="API_MEMBER")
releases: list[list[dict[str, str]]] = []
monkeypatch.setattr(api, "_vault_engine", lambda: vault)
monkeypatch.setattr(api, "resolve_resource_access_context", lambda: member)
monkeypatch.setattr(
api,
"release_vault_agent_scopes",
lambda scopes, *, reason: releases.append([dict(scope) for scope in scopes]),
)
grants = api.get_vault_grants()["grants"]
audit_rows = api.get_vault_audit()["events"]
revoked = api.revoke_vault_grant(owner_grant["id"])
with vault.connect() as conn:
owner_status = conn.execute(
select(vault_grants.c.status).where(vault_grants.c.id == owner_grant["id"])
).scalar_one()
assert {grant["id"] for grant in grants} == {
owner_grant["id"],
member_grant["id"],
}
assert "api-member-visible" in {row["event"] for row in audit_rows}
assert owner_grant["id"] in json.dumps(audit_rows)
assert revoked["grant"]["status"] == "revoked"
assert owner_status == "revoked"
assert releases == [[{"grant_id": owner_grant["id"]}]]
@pytest.mark.parametrize(
"selector",
[
{"env": ["PRIVATE_SELECTOR"]},
{"tags": ["deploy"]},
{"skills": ["release"]},
],
)
def test_active_org_member_resolves_private_secret_cli_selectors(vault, selector: dict) -> None:
with vault.begin() as conn:
_create_secret(conn, "PRIVATE_SELECTOR", tags=["deploy", "skill:release"])
_set_policy(conn, "PRIVATE_SELECTOR", access_level="private")
expanded = vault_service.expand_value_delivery_selector(
conn,
user_context=_context("member-1"),
**selector,
)
assert list(conn.execute(select(vault_requests)).mappings()) == []
assert list(conn.execute(select(vault_grants)).mappings()) == []
assert expanded["secrets"] == [
{
"name": "PRIVATE_SELECTOR",
"field": "value",
"record": "PRIVATE_SELECTOR",
"env": "PRIVATE_SELECTOR",
"kind": "static",
"protection": "standard",
}
]
def test_remote_created_secret_registers_private_organization_policy(vault) -> None:
creator = _context("member-1", instance_role="owner")
with vault.begin() as conn:
_create_secret(conn, "REMOTE_CREATED", user_context=creator)
policy = resource_access_service.get_resource_policy(
"vault_secret",
_secret_id(conn, "REMOTE_CREATED"),
connection=conn,
)
assert policy is not None
assert policy["organization_id"] == "org-1"
assert policy["owner_user_id"] == "member-1"
assert policy["access_level"] == "private"
def test_vault_secret_removal_deletes_resource_policy_and_groups(vault) -> None:
with vault.begin() as conn:
_create_secret(conn, "REMOVED_SECRET")
resource_id = _set_policy(
conn,
"REMOVED_SECRET",
access_level="scope",
group_ids=["group-engineering"],
)
vault_service.delete_secret(
conn,
"REMOVED_SECRET",
user_context=_context("owner-1", instance_role="owner"),
)
policies = conn.execute(
select(resource_access_policies).where(
resource_access_policies.c.resource_kind == "vault_secret",
resource_access_policies.c.resource_id == resource_id,
)
).all()
groups = conn.execute(
select(resource_access_groups).where(
resource_access_groups.c.resource_kind == "vault_secret",
resource_access_groups.c.resource_id == resource_id,
)
).all()
assert policies == []
assert groups == []
def test_active_org_admin_can_manage_public_vault_secret(vault) -> None:
with vault.begin() as conn:
_create_secret(conn, "PUBLIC_MANAGEMENT")
_set_policy(conn, "PUBLIC_MANAGEMENT", access_level="public")
# Reads stay open to every active Organization member.
assert vault_service.get_secret_meta(
conn,
"PUBLIC_MANAGEMENT",
user_context=_context("member-1"),
)["name"] == "PUBLIC_MANAGEMENT"
# Instance Editor cannot manage secrets, regardless of Organization role.
with pytest.raises(vault_service.VaultSecretAccessError):
vault_service.update_secret_metadata(
conn,
"PUBLIC_MANAGEMENT",
description="member update",
user_context=_context("member-1"),
)
updated = vault_service.update_secret_metadata(
conn,
"PUBLIC_MANAGEMENT",
description="admin update",
user_context=_context("admin-1", role="admin", instance_role="owner"),
)
vault_service.delete_secret(
conn,
"PUBLIC_MANAGEMENT",
user_context=_context("admin-1", role="admin", instance_role="owner"),
)
stored = conn.execute(
select(vault_secrets).where(vault_secrets.c.name == "PUBLIC_MANAGEMENT")
).first()
assert updated["description"] == "admin update"
assert stored is None
def test_active_org_member_can_create_vault_secret_but_external_guest_cannot(vault) -> None:
guest = _external_guest_context()
with vault.begin() as conn:
_create_secret(
conn,
"MEMBER_CREATED",
user_context=_context("member-1"),
)
with pytest.raises(vault_service.VaultSecretAccessError):
_create_secret(conn, "GUEST_CREATED", user_context=guest)
assert conn.execute(
select(vault_secrets).where(vault_secrets.c.name == "MEMBER_CREATED")
).first() is not None
assert conn.execute(select(vault_secrets).where(vault_secrets.c.name == "GUEST_CREATED")).first() is None
@pytest.mark.parametrize(
("initial_level", "initial_groups", "updated_level", "updated_groups"),
[
("public", None, "scope", ["group-engineering"]),
("scope", ["group-engineering", "group-sales"], "scope", ["group-engineering"]),
("private", None, "scope", ["group-sales"]),
],
)
def test_narrowed_vault_policy_revokes_active_grants(
vault,
monkeypatch,
initial_level: str,
initial_groups: list[str] | None,
updated_level: str,
updated_groups: list[str],
) -> None:
owner = _context("owner-1", instance_role="owner")
with vault.begin() as conn:
_create_secret(conn, "NARROWED_KEY", protection="protected")
resource_id = _set_policy(
conn,
"NARROWED_KEY",
access_level=initial_level,
group_ids=initial_groups,
)
request = vault_service.create_access_request(conn, "NARROWED_KEY", user_context=owner)
grant = _grant_from_request(conn, request, user_context=owner)
monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: vault)
monkeypatch.setattr(
remote_access,
"publish_resource_index",
lambda *_args, **_kwargs: {"organization_id": "org-1", "resources": []},
)
monkeypatch.setattr(
remote_access,
"pull_resource_acl_intents",
lambda *_args, **_kwargs: {
"organization_id": "org-1",
"intents": [
{
"resource_kind": "vault_secret",
"resource_id": resource_id,
"revision": 2,
"access_level": updated_level,
"group_ids": updated_groups,
}
],
},
)
monkeypatch.setattr(remote_access, "acknowledge_resource_acl_intent", lambda *_args, **_kwargs: {})
releases: list[dict] = []
monkeypatch.setattr(
remote_access.api,
"release_vault_agent_scopes",
lambda scopes, *, reason: releases.append({"scopes": scopes, "reason": reason}),
)
result = remote_access._sync_one_organization(None, organization_id="org-1", resources=[])
assert result["applied"] == 1
with vault.connect() as conn:
status = conn.execute(select(vault_grants.c.status).where(vault_grants.c.id == grant["id"])).scalar_one()
assert status == "revoked"
assert releases == [{"scopes": [{"grant_id": grant["id"]}], "reason": "resource-access-policy-narrowed"}]
def test_narrowed_vault_release_failure_stays_pending_until_retry_succeeds(vault, monkeypatch) -> None:
owner = _context("owner-1", instance_role="owner")
with vault.begin() as conn:
_create_secret(conn, "RETRY_RELEASE_KEY", protection="protected")
resource_id = _set_policy(conn, "RETRY_RELEASE_KEY", access_level="public")
request = vault_service.create_access_request(conn, "RETRY_RELEASE_KEY", user_context=owner)
grant = _grant_from_request(conn, request, user_context=owner)
intent = {
"resource_kind": "vault_secret",
"resource_id": resource_id,
"revision": 2,
"access_level": "private",
"group_ids": [],
}
monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: vault)
monkeypatch.setattr(
remote_access,
"publish_resource_index",
lambda *_args, **_kwargs: {"organization_id": "org-1", "resources": []},
)
monkeypatch.setattr(
remote_access,
"pull_resource_acl_intents",
lambda *_args, **_kwargs: {"organization_id": "org-1", "intents": [intent]},
)
acknowledgements: list[dict] = []
monkeypatch.setattr(
remote_access,
"acknowledge_resource_acl_intent",
lambda *_args, **kwargs: acknowledgements.append(kwargs),
)
releases: list[list[dict[str, str]]] = []
def release(scopes, *, reason):
releases.append([dict(scope) for scope in scopes])
if len(releases) == 1:
raise RuntimeError("resident release failed")
monkeypatch.setattr(remote_access.api, "release_vault_agent_scopes", release)
first = remote_access._sync_one_organization(None, organization_id="org-1", resources=[])
pending_key = remote_access._pending_vault_release_key("org-1", resource_id, 2)
with vault.connect() as conn:
pending_after_failure = conn.execute(
select(state_meta.c.value_json).where(state_meta.c.key == pending_key)
).scalar_one_or_none()
second = remote_access._sync_one_organization(None, organization_id="org-1", resources=[])
with vault.connect() as conn:
pending_after_success = conn.execute(
select(state_meta.c.value_json).where(state_meta.c.key == pending_key)
).scalar_one_or_none()
assert first["ok"] is False
assert first["applied"] == 1
assert first["acknowledged"] == 0
assert first["ack_errors"] == 1
assert pending_after_failure is not None
assert second["ok"] is True
assert second["acknowledged"] == 1
assert pending_after_success is None
assert releases == [[{"grant_id": grant["id"]}], [{"grant_id": grant["id"]}]]
assert acknowledgements == [
{
"resource_kind": "vault_secret",
"resource_id": resource_id,
"revision": 2,
"outcome": "applied",
}
]
@pytest.mark.parametrize("role", ["owner", "member", "editor", "viewer"])
def test_secret_management_follows_instance_manager_capability(vault, role):
context = _context("manager", instance_role=role)
with vault.begin() as conn:
_create_secret(conn, "MANAGED_KEY")
operations = (
lambda: vault_service.update_secret_tags(conn, "MANAGED_KEY", ["test"], user_context=context),
lambda: vault_service.update_secret_metadata(conn, "MANAGED_KEY", description="managed", user_context=context),
lambda: vault_service.update_secret_field(conn, "MANAGED_KEY", "username", _sealed("user"), record="MANAGED_KEY.username", user_context=context),
lambda: vault_service.update_secret_field(conn, "MANAGED_KEY", "value", _sealed("default"), record="MANAGED_KEY", user_context=context),
lambda: vault_service.update_secret_metadata(conn, "MANAGED_KEY", default_field="password", user_context=context),
lambda: vault_service.remove_secret_field(conn, "MANAGED_KEY", "username", user_context=context),
lambda: vault_service.update_secret_classification(conn, "MANAGED_KEY", protection="protected", user_context=context),
lambda: vault_service.store_pubkey_pin(conn, "MANAGED_KEY", {"fingerprint": "test-pin"}, user_context=context),
lambda: vault_service.rotate_secret(conn, "MANAGED_KEY", _sealed("rotated"), user_context=context),
lambda: vault_service.delete_secret(conn, "MANAGED_KEY", user_context=context),
)
for operation in operations:
if role in {"owner", "member"}:
operation()
else:
with pytest.raises(vault_service.VaultSecretAccessError):
operation()
if role in {"owner", "member"}:
with pytest.raises(vault_service.SecretNotFoundError):
vault_service.get_secret_meta(conn, "MANAGED_KEY")
else:
assert vault_service.get_secret_meta(conn, "MANAGED_KEY")["tags"] == []
@pytest.mark.parametrize("policy", ["missing", "foreign"])
@pytest.mark.parametrize("role", ["owner", "member", "editor", "viewer"])
def test_direct_secret_operations_preserve_protected_approval_and_lower_role_acl(vault, policy, role):
context = _context("manager", instance_role=role, is_remote=False)
with vault.begin() as conn:
_create_secret(conn, "DIRECT_PRIVATE", protection="protected")
resource_id = _secret_id(conn, "DIRECT_PRIVATE")
conn.execute(resource_access_policies.delete().where(resource_access_policies.c.resource_id == resource_id))
if policy == "foreign":
resource_access_service.ensure_resource_policy(
conn, resource_kind="vault_secret", resource_id=resource_id,
organization_id="foreign-org", owner_user_id="foreign-user",
access_level="private", group_ids=[], policy_revision=1,
last_applied_control_plane_revision=1,
)
before = [dict(row) for row in conn.execute(select(resource_access_policies)).mappings()]
if role in {"owner", "member"}:
vault_service.update_secret_metadata(conn, "DIRECT_PRIVATE", description="managed", user_context=context)
access = vault_service.resolve_secret_access(conn, "DIRECT_PRIVATE", session_id="ses-private", user_context=context)
assert access["status"] == "approval_required"
assert access["request"]["status"] == "pending"
assert access.get("envelope") is None
assert access["request"]["card"]["value"] is None
else:
with pytest.raises(vault_service.VaultSecretAccessError):
vault_service.resolve_secret_access(conn, "DIRECT_PRIVATE", session_id="ses-private", user_context=context)
assert [dict(row) for row in conn.execute(select(resource_access_policies)).mappings()] == before