Hi,
-{inviter_name} invited you to join {target} on MyDevTools.
- -This link is valid for 14 days.
- """ - - -async def send_invitation_email( - *, - to: str, - token: str, - inviter_name: str, - org_name: str, - workspace_name: str | None, -) -> None: - invite_url = _build_invite_url(token) - settings = get_settings() - if not settings.RESEND_API_KEY: - log.info( - "DEV email: would send to=%s token=%s url=%s org=%s workspace=%s", - to, token, invite_url, org_name, workspace_name, - ) - return - - import resend - - resend.api_key = settings.RESEND_API_KEY - html = _render_html( - inviter_name=inviter_name, - org_name=org_name, - workspace_name=workspace_name, - invite_url=invite_url, - ) - target = f"{org_name}" + (f" / {workspace_name}" if workspace_name else "") - - # resend.Emails.send is sync, so wrap it with asyncio.to_thread - await asyncio.to_thread( - resend.Emails.send, - { - "from": settings.INVITATION_FROM_EMAIL, - "to": [to], - "subject": f"You're invited to {target} on MyDevTools", - "html": html, - }, - ) diff --git a/apps/backend/app/core/indexes.py b/apps/backend/app/core/indexes.py index 1917a156..a42a711e 100644 --- a/apps/backend/app/core/indexes.py +++ b/apps/backend/app/core/indexes.py @@ -25,11 +25,8 @@ USER_PREFERENCES, USERS, WEBAUTHN_CHALLENGES, - ORGANIZATIONS, - ORG_MEMBERSHIPS, WORKSPACES, WORKSPACE_MEMBERSHIPS, - INVITATIONS, ) from app.core.config import get_settings @@ -77,14 +74,9 @@ async def ensure_indexes() -> None: await db_manager.create_index(AUDIT_LOG, [("uid", 1), ("ts", -1)]) await db_manager.create_index(AUDIT_LOG, [("uid", 1), ("module", 1), ("ts", -1)]) await db_manager.create_index(AUDIT_LOG, "expireAt", expire_after_seconds=0) - await db_manager.create_index(ORGANIZATIONS, [("slug", 1)], unique=True) - await db_manager.create_index( - ORG_MEMBERSHIPS, [("org_id", 1), ("uid", 1)], unique=True - ) - await db_manager.create_index(ORG_MEMBERSHIPS, [("uid", 1)]) await db_manager.create_index( WORKSPACES, - [("org_id", 1), ("owner_uid", 1), ("is_personal", 1)], + [("owner_uid", 1), ("is_personal", 1)], ) await db_manager.create_index( WORKSPACE_MEMBERSHIPS, @@ -92,7 +84,3 @@ async def ensure_indexes() -> None: unique=True, ) await db_manager.create_index(WORKSPACE_MEMBERSHIPS, [("uid", 1)]) - await db_manager.create_index(INVITATIONS, [("token", 1)], unique=True) - await db_manager.create_index(INVITATIONS, [("invited_email", 1), ("status", 1)]) - await db_manager.create_index(INVITATIONS, [("org_id", 1), ("status", 1)]) - await db_manager.create_index(INVITATIONS, [("expires_at", 1), ("status", 1)]) diff --git a/apps/backend/app/main.py b/apps/backend/app/main.py index 7703281b..9c24cee5 100644 --- a/apps/backend/app/main.py +++ b/apps/backend/app/main.py @@ -25,21 +25,12 @@ async def lifespan(_app: FastAPI): except Exception as exc: logging.getLogger(__name__).warning("Index creation failed: %s", exc) - try: - from app.api.routes.workspaces.seed import ensure_system_org - await ensure_system_org() - except Exception as exc: - logging.getLogger(__name__).warning("System org seed failed: %s", exc) - from app.core.redis_client import open_redis, close_redis await open_redis() from app.api.routes.url_shortener.click_queue import flush_loop, close_flush_client click_flush_task = asyncio.create_task(flush_loop()) - from app.api.routes.workspaces.sweeper import sweeper_loop - sweeper_task = asyncio.create_task(sweeper_loop()) - try: yield finally: @@ -48,11 +39,6 @@ async def lifespan(_app: FastAPI): await click_flush_task except asyncio.CancelledError: pass - sweeper_task.cancel() - try: - await sweeper_task - except asyncio.CancelledError: - pass await close_flush_client() await close_redis() diff --git a/apps/backend/app/utils/collection_name.py b/apps/backend/app/utils/collection_name.py index ccd2e649..64a6ee9a 100644 --- a/apps/backend/app/utils/collection_name.py +++ b/apps/backend/app/utils/collection_name.py @@ -27,9 +27,6 @@ URL_CLICK_EVENTS = "url_click_events" AUDIT_LOG = "audit_log" WEBAUTHN_CHALLENGES = "webauthn_challenges" -ORGANIZATIONS = "organizations" -ORG_MEMBERSHIPS = "org_memberships" WORKSPACES = "workspaces" WORKSPACE_MEMBERSHIPS = "workspace_memberships" -INVITATIONS = "invitations" COUNTERS = "counters" diff --git a/apps/backend/tests/api/routes/api_client/test_collections_delta.py b/apps/backend/tests/api/routes/api_client/test_collections_delta.py index 2b042288..513eb3f8 100644 --- a/apps/backend/tests/api/routes/api_client/test_collections_delta.py +++ b/apps/backend/tests/api/routes/api_client/test_collections_delta.py @@ -28,7 +28,6 @@ BASE_COLLECTION: dict[str, Any] = { "_id": COLLECTION_OID, "created_by": OWNER_UID, - "org_id": "org-test", "workspace_id": "ws-owner", "owner_uid": OWNER_UID, "name": "My Collection", @@ -56,10 +55,9 @@ } -def _make_ctx(uid: str, ws_id: str = "ws-owner", org_id: str = "org-test") -> WorkspaceContext: +def _make_ctx(uid: str, ws_id: str = "ws-owner") -> WorkspaceContext: return WorkspaceContext( uid=uid, - org_id=org_id, workspace_id=ws_id, ws_role="admin", is_personal=True, diff --git a/apps/backend/tests/api/routes/webhook_tester/__init__.py b/apps/backend/tests/api/routes/webhook_tester/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/apps/backend/tests/api/routes/webhook_tester/test_webhook_tester.py b/apps/backend/tests/api/routes/webhook_tester/test_webhook_tester.py new file mode 100644 index 00000000..4437d351 --- /dev/null +++ b/apps/backend/tests/api/routes/webhook_tester/test_webhook_tester.py @@ -0,0 +1,200 @@ +"""Webhook Tester route tests. + +The router is not yet wired into app.api.router (the coordinator adds the +include line), so we mount it on the app here. REDIS_URL is unset in tests, +so the service's in-memory fallback store is exercised. +""" +from datetime import datetime, timedelta, timezone + +import pytest +from fastapi.testclient import TestClient + +from app.api.routes.webhook_tester import services as svc +from app.api.routes.webhook_tester.api import router as webhook_tester_router +from app.main import app + +if not any(getattr(r, "path", "").startswith("/api/v1/webhook-tester") for r in app.routes): + app.include_router(webhook_tester_router, prefix="/api/v1") + +client = TestClient(app) + +BASE = "/api/v1/webhook-tester" + + +@pytest.fixture(autouse=True) +def clean_store(): + svc._memory_bins.clear() + yield + svc._memory_bins.clear() + + +def _create_bin() -> dict: + res = client.post(f"{BASE}/bins") + assert res.status_code == 200 + return res.json() + + +def test_create_bin_shape_and_ttl() -> None: + data = _create_bin() + assert set(data) == {"bin_id", "created_at", "expires_at"} + assert 8 <= len(data["bin_id"]) <= 16 + created = datetime.fromisoformat(data["created_at"]) + expires = datetime.fromisoformat(data["expires_at"]) + assert expires - created == timedelta(hours=24) + + +def test_bin_ids_are_unique() -> None: + ids = {_create_bin()["bin_id"] for _ in range(5)} + assert len(ids) == 5 + + +def test_receive_records_request_details() -> None: + bin_id = _create_bin()["bin_id"] + res = client.post( + f"{BASE}/in/{bin_id}?foo=bar&foo=baz&x=1", + json={"hello": "world"}, + headers={"x-custom": "abc"}, + ) + assert res.status_code == 200 + assert res.json() == {"ok": True} + + listed = client.get(f"{BASE}/bins/{bin_id}/requests") + assert listed.status_code == 200 + body = listed.json() + assert body["bin_id"] == bin_id + assert body["count"] == 1 + req = body["requests"][0] + assert req["method"] == "POST" + assert req["path"] == "" + assert req["query"] == {"foo": "bar,baz", "x": "1"} + assert req["headers"]["x-custom"] == "abc" + assert req["body"] == '{"hello":"world"}' + assert req["body_encoding"] == "text" + assert req["body_truncated"] is False + assert req["content_type"] == "application/json" + assert req["size"] == len('{"hello":"world"}') + assert req["id"] + assert req["received_at"] + + +def test_receive_captures_path_suffix() -> None: + bin_id = _create_bin()["bin_id"] + res = client.put(f"{BASE}/in/{bin_id}/github/push/events", content=b"payload") + assert res.status_code == 200 + req = client.get(f"{BASE}/bins/{bin_id}/requests").json()["requests"][0] + assert req["method"] == "PUT" + assert req["path"] == "github/push/events" + assert req["body"] == "payload" + + +@pytest.mark.parametrize("method", ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]) +def test_receive_accepts_all_methods(method: str) -> None: + bin_id = _create_bin()["bin_id"] + res = client.request(method, f"{BASE}/in/{bin_id}") + assert res.status_code == 200 + reqs = client.get(f"{BASE}/bins/{bin_id}/requests").json()["requests"] + assert [r["method"] for r in reqs] == [method] + + +def test_receive_unknown_bin_404() -> None: + assert client.post(f"{BASE}/in/does-not-exist").status_code == 404 + + +def test_list_unknown_bin_404() -> None: + assert client.get(f"{BASE}/bins/does-not-exist/requests").status_code == 404 + + +def test_clear_unknown_bin_404() -> None: + assert client.delete(f"{BASE}/bins/does-not-exist/requests").status_code == 404 + + +def test_expired_bin_rejected() -> None: + bin_id = _create_bin()["bin_id"] + past = (datetime.now(timezone.utc) - timedelta(seconds=1)).isoformat() + svc._memory_bins[bin_id]["expires_at"] = past + assert client.post(f"{BASE}/in/{bin_id}").status_code == 404 + assert client.get(f"{BASE}/bins/{bin_id}/requests").status_code == 404 + + +def test_newest_first_and_capped_at_100() -> None: + bin_id = _create_bin()["bin_id"] + for i in range(105): + client.post(f"{BASE}/in/{bin_id}", content=f"n{i}".encode()) + body = client.get(f"{BASE}/bins/{bin_id}/requests").json() + assert body["count"] == 100 + assert body["requests"][0]["body"] == "n104" + assert body["requests"][-1]["body"] == "n5" # oldest 5 dropped + + +def test_after_cursor_by_request_id() -> None: + bin_id = _create_bin()["bin_id"] + for i in range(3): + client.post(f"{BASE}/in/{bin_id}", content=f"n{i}".encode()) + all_reqs = client.get(f"{BASE}/bins/{bin_id}/requests").json()["requests"] + cursor = all_reqs[1]["id"] # the middle (n1) + newer = client.get(f"{BASE}/bins/{bin_id}/requests", params={"after": cursor}).json() + assert newer["count"] == 1 + assert newer["requests"][0]["body"] == "n2" + + +def test_after_cursor_by_timestamp() -> None: + bin_id = _create_bin()["bin_id"] + client.post(f"{BASE}/in/{bin_id}", content=b"old") + old = client.get(f"{BASE}/bins/{bin_id}/requests").json()["requests"][0] + client.post(f"{BASE}/in/{bin_id}", content=b"new") + newer = client.get( + f"{BASE}/bins/{bin_id}/requests", params={"after": old["received_at"]} + ).json()["requests"] + assert [r["body"] for r in newer] == ["new"] + + +def test_after_unknown_cursor_returns_everything() -> None: + bin_id = _create_bin()["bin_id"] + client.post(f"{BASE}/in/{bin_id}", content=b"a") + body = client.get(f"{BASE}/bins/{bin_id}/requests", params={"after": "bogus"}).json() + assert body["count"] == 1 + + +def test_binary_body_is_base64() -> None: + bin_id = _create_bin()["bin_id"] + client.post(f"{BASE}/in/{bin_id}", content=b"\xff\xfe\x00binary") + req = client.get(f"{BASE}/bins/{bin_id}/requests").json()["requests"][0] + assert req["body_encoding"] == "base64" + import base64 + + assert base64.b64decode(req["body"]) == b"\xff\xfe\x00binary" + + +def test_large_body_truncated_at_64kb() -> None: + bin_id = _create_bin()["bin_id"] + client.post(f"{BASE}/in/{bin_id}", content=b"a" * (svc.MAX_BODY_BYTES + 500)) + req = client.get(f"{BASE}/bins/{bin_id}/requests").json()["requests"][0] + assert req["body_truncated"] is True + assert len(req["body"]) == svc.MAX_BODY_BYTES + assert req["size"] == svc.MAX_BODY_BYTES + 500 + + +def test_clear_requests() -> None: + bin_id = _create_bin()["bin_id"] + client.post(f"{BASE}/in/{bin_id}", content=b"x") + res = client.delete(f"{BASE}/bins/{bin_id}/requests") + assert res.status_code == 204 + body = client.get(f"{BASE}/bins/{bin_id}/requests").json() + assert body["count"] == 0 + # Bin itself still alive after clearing + assert client.post(f"{BASE}/in/{bin_id}", content=b"y").status_code == 200 + + +def test_source_ip_prefers_x_forwarded_for() -> None: + bin_id = _create_bin()["bin_id"] + client.post(f"{BASE}/in/{bin_id}", headers={"x-forwarded-for": "203.0.113.7, 10.0.0.1"}) + req = client.get(f"{BASE}/bins/{bin_id}/requests").json()["requests"][0] + assert req["source_ip"] == "203.0.113.7" + + +def test_endpoints_do_not_require_auth() -> None: + # No cookies / Authorization header anywhere in this file — reaching 200s + # above already proves it, but assert explicitly for the receive endpoint. + bin_id = _create_bin()["bin_id"] + res = client.post(f"{BASE}/in/{bin_id}", json={"ping": 1}) + assert res.status_code == 200 diff --git a/apps/backend/tests/api/routes/whois/__init__.py b/apps/backend/tests/api/routes/whois/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/apps/backend/tests/api/routes/whois/test_whois_lookup.py b/apps/backend/tests/api/routes/whois/test_whois_lookup.py new file mode 100644 index 00000000..c8c695d7 --- /dev/null +++ b/apps/backend/tests/api/routes/whois/test_whois_lookup.py @@ -0,0 +1,294 @@ +import asyncio + +import httpx +import pytest +from fastapi import HTTPException + +from app.api.routes.whois import services as svc + +RDAP_DOMAIN = { + "objectClassName": "domain", + "ldhName": "EXAMPLE.COM", + "status": ["client delete prohibited", "client transfer prohibited"], + "events": [ + {"eventAction": "registration", "eventDate": "1995-08-14T04:00:00Z"}, + {"eventAction": "expiration", "eventDate": "2026-08-13T04:00:00Z"}, + {"eventAction": "last changed", "eventDate": "2025-08-14T07:01:44Z"}, + {"eventAction": "last update of RDAP database", "eventDate": "2026-01-01T00:00:00Z"}, + ], + "entities": [ + { + "objectClassName": "entity", + "handle": "376", + "roles": ["registrar"], + "vcardArray": [ + "vcard", + [ + ["version", {}, "text", "4.0"], + ["fn", {}, "text", "RESERVED-Internet Assigned Numbers Authority"], + ], + ], + "entities": [ + { + "objectClassName": "entity", + "handle": "ABUSE-1", + "roles": ["abuse"], + "vcardArray": ["vcard", [["version", {}, "text", "4.0"], ["fn", {}, "text", "Abuse Desk"]]], + } + ], + }, + { + "objectClassName": "entity", + "roles": ["registrant"], + "vcardArray": [ + "vcard", + [ + ["version", {}, "text", "4.0"], + ["fn", {}, "text", "REDACTED FOR PRIVACY"], + ["org", {}, "text", "Example Org"], + ], + ], + }, + ], + "nameservers": [ + {"ldhName": "A.IANA-SERVERS.NET."}, + {"ldhName": "B.IANA-SERVERS.NET"}, + {"ldhName": "a.iana-servers.net"}, + ], +} + +RDAP_IP = { + "objectClassName": "ip network", + "handle": "NET-8-8-8-0-1", + "name": "LVLT-GOGL-8-8-8", + "startAddress": "8.8.8.0", + "endAddress": "8.8.8.255", + "status": ["active"], + "events": [ + {"eventAction": "registration", "eventDate": "2014-03-14T00:00:00Z"}, + {"eventAction": "last changed", "eventDate": "2014-03-14T00:00:00Z"}, + ], + "entities": [ + { + "objectClassName": "entity", + "handle": "GOGL", + "roles": ["registrant"], + "vcardArray": ["vcard", [["version", {}, "text", "4.0"], ["fn", {}, "text", "Google LLC"]]], + } + ], +} + + +# --------------------------------------------------------------------------- +# sanitize_target +# --------------------------------------------------------------------------- + +def test_sanitize_target_plain_domain(): + assert svc.sanitize_target("example.com") == ("example.com", "domain") + + +def test_sanitize_target_strips_scheme_path_and_case(): + assert svc.sanitize_target("https://Example.COM/path?q=1#frag") == ("example.com", "domain") + + +def test_sanitize_target_strips_trailing_dot_and_port(): + assert svc.sanitize_target("example.com.") == ("example.com", "domain") + assert svc.sanitize_target("example.com:8080") == ("example.com", "domain") + + +def test_sanitize_target_ipv4(): + assert svc.sanitize_target("8.8.8.8") == ("8.8.8.8", "ip") + + +def test_sanitize_target_ipv6(): + assert svc.sanitize_target("2001:4860:4860::8888") == ("2001:4860:4860::8888", "ip") + assert svc.sanitize_target("[2001:4860:4860::8888]") == ("2001:4860:4860::8888", "ip") + + +@pytest.mark.parametrize("bad", ["", " ", "not a domain", "no-tld", "-bad-.com", "a" * 300 + ".com"]) +def test_sanitize_target_rejects_invalid(bad): + with pytest.raises(HTTPException) as exc: + svc.sanitize_target(bad) + assert exc.value.status_code == 400 + + +# --------------------------------------------------------------------------- +# lookup_whois normalization (fetch mocked) +# --------------------------------------------------------------------------- + +def test_lookup_whois_normalizes_domain(monkeypatch): + async def fake_fetch(*, kind, target): + assert kind == "domain" + assert target == "example.com" + return RDAP_DOMAIN + + monkeypatch.setattr(svc, "fetch_rdap", fake_fetch) + out = asyncio.run(svc.lookup_whois("https://Example.com/whatever")) + + assert out.target == "example.com" + assert out.type == "domain" + assert out.registrar == "RESERVED-Internet Assigned Numbers Authority" + assert out.status == ["client delete prohibited", "client transfer prohibited"] + assert out.created == "1995-08-14T04:00:00Z" + assert out.updated == "2025-08-14T07:01:44Z" + assert out.expires == "2026-08-13T04:00:00Z" + # lowercased, trailing dot stripped, deduped + assert out.nameservers == ["a.iana-servers.net", "b.iana-servers.net"] + assert out.raw == RDAP_DOMAIN + + +def test_lookup_whois_contacts_include_nested_and_redacted(monkeypatch): + async def fake_fetch(*, kind, target): + return RDAP_DOMAIN + + monkeypatch.setattr(svc, "fetch_rdap", fake_fetch) + out = asyncio.run(svc.lookup_whois("example.com")) + + by_role = {tuple(c.roles): c for c in out.contacts} + registrar = by_role[("registrar",)] + assert registrar.name == "RESERVED-Internet Assigned Numbers Authority" + assert registrar.handle == "376" + + registrant = by_role[("registrant",)] + assert registrant.name == "REDACTED FOR PRIVACY" # kept as the registry exposed it + assert registrant.organization == "Example Org" + + abuse = by_role[("abuse",)] # nested inside the registrar entity + assert abuse.name == "Abuse Desk" + assert abuse.handle == "ABUSE-1" + + +def test_lookup_whois_ip(monkeypatch): + async def fake_fetch(*, kind, target): + assert kind == "ip" + assert target == "8.8.8.8" + return RDAP_IP + + monkeypatch.setattr(svc, "fetch_rdap", fake_fetch) + out = asyncio.run(svc.lookup_whois("8.8.8.8")) + + assert out.type == "ip" + assert out.registrar == "LVLT-GOGL-8-8-8" # falls back to network name + assert out.created == "2014-03-14T00:00:00Z" + assert out.nameservers == [] + assert any(c.name == "Google LLC" for c in out.contacts) + + +def test_lookup_whois_unknown_domain_returns_404(monkeypatch): + async def fake_fetch(*, kind, target): + return None + + monkeypatch.setattr(svc, "fetch_rdap", fake_fetch) + with pytest.raises(HTTPException) as exc: + asyncio.run(svc.lookup_whois("definitely-not-registered-zzz.com")) + assert exc.value.status_code == 404 + + +def test_lookup_whois_invalid_target_short_circuits(monkeypatch): + called = False + + async def fake_fetch(*, kind, target): + nonlocal called + called = True + return RDAP_DOMAIN + + monkeypatch.setattr(svc, "fetch_rdap", fake_fetch) + with pytest.raises(HTTPException) as exc: + asyncio.run(svc.lookup_whois("!!not valid!!")) + assert exc.value.status_code == 400 + assert called is False + + +# --------------------------------------------------------------------------- +# fetch_rdap (httpx mocked) +# --------------------------------------------------------------------------- + +class _FakeResponse: + def __init__(self, status_code=200, json_data=None): + self.status_code = status_code + self._json = json_data + + def json(self): + if self._json is None: + raise ValueError("no json") + return self._json + + +class _FakeAsyncClient: + init_kwargs = None + last_url = None + response = None + error = None + + def __init__(self, **kwargs): + _FakeAsyncClient.init_kwargs = kwargs + + async def __aenter__(self): + return self + + async def __aexit__(self, *exc): + return False + + async def get(self, url, **kwargs): + _FakeAsyncClient.last_url = url + if _FakeAsyncClient.error is not None: + raise _FakeAsyncClient.error + return _FakeAsyncClient.response + + +@pytest.fixture +def fake_http(monkeypatch): + _FakeAsyncClient.init_kwargs = None + _FakeAsyncClient.last_url = None + _FakeAsyncClient.response = None + _FakeAsyncClient.error = None + monkeypatch.setattr(svc.httpx, "AsyncClient", _FakeAsyncClient) + return _FakeAsyncClient + + +def test_fetch_rdap_domain_url_and_redirects(fake_http): + fake_http.response = _FakeResponse(200, RDAP_DOMAIN) + out = asyncio.run(svc.fetch_rdap(kind="domain", target="example.com")) + assert out == RDAP_DOMAIN + assert fake_http.last_url == "https://rdap.org/domain/example.com" + assert fake_http.init_kwargs.get("follow_redirects") is True + + +def test_fetch_rdap_ip_url(fake_http): + fake_http.response = _FakeResponse(200, RDAP_IP) + out = asyncio.run(svc.fetch_rdap(kind="ip", target="8.8.8.8")) + assert out == RDAP_IP + assert fake_http.last_url == "https://rdap.org/ip/8.8.8.8" + + +def test_fetch_rdap_404_returns_none(fake_http): + fake_http.response = _FakeResponse(404) + assert asyncio.run(svc.fetch_rdap(kind="domain", target="nope.example")) is None + + +def test_fetch_rdap_upstream_error_maps_to_502(fake_http): + fake_http.response = _FakeResponse(500) + with pytest.raises(HTTPException) as exc: + asyncio.run(svc.fetch_rdap(kind="domain", target="example.com")) + assert exc.value.status_code == 502 + + +def test_fetch_rdap_rate_limit_maps_to_503(fake_http): + fake_http.response = _FakeResponse(429) + with pytest.raises(HTTPException) as exc: + asyncio.run(svc.fetch_rdap(kind="domain", target="example.com")) + assert exc.value.status_code == 503 + + +def test_fetch_rdap_network_error_maps_to_502(fake_http): + fake_http.error = httpx.ConnectError("boom") + with pytest.raises(HTTPException) as exc: + asyncio.run(svc.fetch_rdap(kind="domain", target="example.com")) + assert exc.value.status_code == 502 + + +def test_fetch_rdap_invalid_json_maps_to_502(fake_http): + fake_http.response = _FakeResponse(200, None) + with pytest.raises(HTTPException) as exc: + asyncio.run(svc.fetch_rdap(kind="domain", target="example.com")) + assert exc.value.status_code == 502 diff --git a/apps/backend/tests/conftest.py b/apps/backend/tests/conftest.py index 9e303a1b..104437e6 100644 --- a/apps/backend/tests/conftest.py +++ b/apps/backend/tests/conftest.py @@ -18,7 +18,6 @@ os.environ.setdefault("WEBAUTHN_ORIGINS", "http://localhost:3000") os.environ.setdefault("WEBAUTHN_CHALLENGE_TTL_SECONDS", "300") -from app.api.routes.workspaces.seed import ensure_system_org from app.api.routes.workspaces.services import ensure_user_workspace_setup from app.database import db_manager from app.utils.collection_name import ( @@ -35,8 +34,6 @@ NOSQL_CONNECTIONS, NOSQL_QUERY_HISTORY, NOTES, - ORGANIZATIONS, - ORG_MEMBERSHIPS, PASSWORD_ENTRIES, PASSWORD_VAULTS, PROJECTS, @@ -50,7 +47,6 @@ WORKSPACE_MEMBERSHIPS, URL_LINKS, URL_CLICK_EVENTS, - INVITATIONS, ) pytest_plugins = ("pytest_asyncio",) @@ -59,7 +55,7 @@ @pytest.fixture async def clean_db(): """Drop workspace-related collections and USERS before and after test.""" - collections = [API_CLIENT_COLLECTIONS, API_CLIENT_ENVIRONMENTS, API_CLIENT_HISTORY, API_CLIENT_WORKSPACES, API_KEY_VAULT_ENTRIES, ORGANIZATIONS, ORG_MEMBERSHIPS, WORKSPACES, WORKSPACE_MEMBERSHIPS, USERS, PASSWORD_ENTRIES, PASSWORD_VAULTS, NOTES, USER_PREFERENCES, BOOKMARKS, BOOKMARK_FOLDERS, TASKS, PROJECTS, ENV_MANAGER_ENTRIES, CODE_SNIPPETS, NOSQL_CONNECTIONS, NOSQL_QUERY_HISTORY, SQL_CONNECTIONS, S3_CONNECTIONS, REDIS_CONNECTIONS, URL_LINKS, URL_CLICK_EVENTS, JSON_FORMATTER_DOCUMENTS, INVITATIONS] + collections = [API_CLIENT_COLLECTIONS, API_CLIENT_ENVIRONMENTS, API_CLIENT_HISTORY, API_CLIENT_WORKSPACES, API_KEY_VAULT_ENTRIES, WORKSPACES, WORKSPACE_MEMBERSHIPS, USERS, PASSWORD_ENTRIES, PASSWORD_VAULTS, NOTES, USER_PREFERENCES, BOOKMARKS, BOOKMARK_FOLDERS, TASKS, PROJECTS, ENV_MANAGER_ENTRIES, CODE_SNIPPETS, NOSQL_CONNECTIONS, NOSQL_QUERY_HISTORY, SQL_CONNECTIONS, S3_CONNECTIONS, REDIS_CONNECTIONS, URL_LINKS, URL_CLICK_EVENTS, JSON_FORMATTER_DOCUMENTS] # Clean before test for coll in collections: @@ -166,12 +162,6 @@ async def seed_legacy_user_data(): yield -@pytest.fixture -async def system_org_id(): - """Idempotently create the system org and return its id.""" - return await ensure_system_org() - - @pytest.fixture def personal_ws_for(): """Return an async callable that creates (idempotently) a Personal workspace diff --git a/apps/backend/tests/test_api_client_workspace_isolation.py b/apps/backend/tests/test_api_client_workspace_isolation.py index a7d3105a..ca4685ce 100644 --- a/apps/backend/tests/test_api_client_workspace_isolation.py +++ b/apps/backend/tests/test_api_client_workspace_isolation.py @@ -15,10 +15,9 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( uid=uid, - org_id=org_id, workspace_id=ws_id, ws_role="admin", is_personal=True, @@ -28,15 +27,14 @@ def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: @pytest.mark.asyncio async def test_api_client_collections_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """Collections created by u1 must not appear in u2's list.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await api_client_svc.create_collection(ctx_u1, ApiClientCollectionCreate(name="u1-collection")) @@ -49,32 +47,30 @@ async def test_api_client_collections_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_cannot_read_api_client_collections( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """u2 forging u1's workspace_id still cannot see u1's collections due to owner_uid.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await api_client_svc.create_collection(ctx_u1, ApiClientCollectionCreate(name="secret-collection")) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 claims u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 claims u1's workspace_id cols = await api_client_svc.list_collections(ctx=forged_ctx) assert cols == [] # owner_uid filter prevents cross-user bleed @pytest.mark.asyncio async def test_api_client_environments_and_history_isolated( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """Environments and history created by u1 must not appear for u2.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await api_client_svc.create_environment(ctx_u1, ApiClientEnvironmentCreate(name="prod")) await api_client_svc.create_history( diff --git a/apps/backend/tests/test_api_key_vault_workspace_isolation.py b/apps/backend/tests/test_api_key_vault_workspace_isolation.py index b6470095..017807e1 100644 --- a/apps/backend/tests/test_api_key_vault_workspace_isolation.py +++ b/apps/backend/tests/test_api_key_vault_workspace_isolation.py @@ -4,23 +4,22 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( - uid=uid, org_id=org_id, workspace_id=ws_id, ws_role="admin", + uid=uid, workspace_id=ws_id, ws_role="admin", is_personal=True, owner_uid=uid, ) @pytest.mark.asyncio async def test_api_key_vault_entries_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await vault_svc.create_entry(ctx_u1, ApiKeyEntryCreate(encryptedData="enc-u1", iv="iv-u1")) @@ -33,15 +32,14 @@ async def test_api_key_vault_entries_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_api_key_vault_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await vault_svc.create_entry(ctx_u1, ApiKeyEntryCreate(encryptedData="enc-u1", iv="iv-u1")) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 forges u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 forges u1's workspace_id entries = await vault_svc.list_entries(forged_ctx) assert entries == [] # owner_uid filter saves us diff --git a/apps/backend/tests/test_audit_middleware.py b/apps/backend/tests/test_audit_middleware.py index 71415eee..fadbd61d 100644 --- a/apps/backend/tests/test_audit_middleware.py +++ b/apps/backend/tests/test_audit_middleware.py @@ -101,7 +101,7 @@ async def fake_insert_one(collection_name, data): monkeypatch.setattr("app.api.routes.bookmarks.services.db_manager.insert_one", fake_insert_one) _bm_ctx = WorkspaceContext( - uid="uid1", org_id="org1", workspace_id="ws1", ws_role="admin", + uid="uid1", workspace_id="ws1", ws_role="admin", is_personal=True, owner_uid="uid1", ) diff --git a/apps/backend/tests/test_backfill.py b/apps/backend/tests/test_backfill.py index e1a13a06..41e54505 100644 --- a/apps/backend/tests/test_backfill.py +++ b/apps/backend/tests/test_backfill.py @@ -1,26 +1,22 @@ import pytest from app.api.routes.auth import users_repo -from app.api.routes.workspaces.backfill import BACKFILL_COLLECTIONS, run_user_backfill -from app.api.routes.workspaces.seed import ensure_system_org +from app.api.routes.workspaces.backfill import run_user_backfill from app.database import db_manager from app.utils.collection_name import PASSWORD_ENTRIES, NOTES, USER_PREFERENCES @pytest.mark.asyncio async def test_backfill_stamps_legacy_rows(clean_db, seed_legacy_user_data): - org_id = await ensure_system_org() # seed_legacy_user_data inserts a few rows in PASSWORD_ENTRIES + NOTES # for created_by="u1" with no workspace_id ws_id = "ws-1" - await run_user_backfill("u1", ws_id, org_id) + await run_user_backfill("u1", ws_id) for entry in await db_manager.find(PASSWORD_ENTRIES, {"created_by": "u1"}, limit=100): - assert entry["org_id"] == org_id assert entry["workspace_id"] == ws_id for note in await db_manager.find(NOTES, {"created_by": "u1"}, limit=100): - assert note["org_id"] == org_id assert note["workspace_id"] == ws_id assert await users_repo.get_migrated_at("u1") is not None @@ -28,25 +24,23 @@ async def test_backfill_stamps_legacy_rows(clean_db, seed_legacy_user_data): @pytest.mark.asyncio async def test_backfill_is_idempotent(clean_db, seed_legacy_user_data): - org_id = await ensure_system_org() ws_id = "ws-1" - await run_user_backfill("u1", ws_id, org_id) + await run_user_backfill("u1", ws_id) migrated_first = await users_repo.get_migrated_at("u1") - await run_user_backfill("u1", ws_id, org_id) + await run_user_backfill("u1", ws_id) migrated_second = await users_repo.get_migrated_at("u1") assert migrated_first == migrated_second @pytest.mark.asyncio async def test_backfill_rewrites_pinned_tools(clean_db): - org_id = await ensure_system_org() ws_id = "ws-1" await db_manager.insert_one( USER_PREFERENCES, {"_id": "u1", "uid": "u1", "toolFavorites": ["/app/passwords", "/app/notes"]}, ) - await run_user_backfill("u1", ws_id, org_id) + await run_user_backfill("u1", ws_id) pref = await db_manager.find_one(USER_PREFERENCES, {"_id": "u1"}) assert pref["pinnedToolsByWorkspace"] == {ws_id: ["/app/passwords", "/app/notes"]} diff --git a/apps/backend/tests/test_bookmarks_workspace_isolation.py b/apps/backend/tests/test_bookmarks_workspace_isolation.py index b96cf227..5437cf4a 100644 --- a/apps/backend/tests/test_bookmarks_workspace_isolation.py +++ b/apps/backend/tests/test_bookmarks_workspace_isolation.py @@ -4,23 +4,22 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( - uid=uid, org_id=org_id, workspace_id=ws_id, ws_role="admin", + uid=uid, workspace_id=ws_id, ws_role="admin", is_personal=True, owner_uid=uid, ) @pytest.mark.asyncio async def test_bookmarks_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await bm_svc.create_bookmark(ctx_u1, BookmarkCreate(title="u1 bookmark", url="https://u1.example")) @@ -33,30 +32,28 @@ async def test_bookmarks_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_bookmark_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await bm_svc.create_bookmark(ctx_u1, BookmarkCreate(title="u1 secret", url="https://u1.example")) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 forges u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 forges u1's workspace_id bookmarks = await bm_svc.list_bookmarks(ctx=forged_ctx) assert bookmarks == [] # owner_uid filter saves us @pytest.mark.asyncio async def test_folders_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await bm_svc.create_folder(ctx_u1, BookmarkFolderCreate(name="u1 folder")) diff --git a/apps/backend/tests/test_code_snippets_workspace_isolation.py b/apps/backend/tests/test_code_snippets_workspace_isolation.py index b1d26c9d..989138d6 100644 --- a/apps/backend/tests/test_code_snippets_workspace_isolation.py +++ b/apps/backend/tests/test_code_snippets_workspace_isolation.py @@ -4,23 +4,22 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( - uid=uid, org_id=org_id, workspace_id=ws_id, ws_role="admin", + uid=uid, workspace_id=ws_id, ws_role="admin", is_personal=True, owner_uid=uid, ) @pytest.mark.asyncio async def test_code_snippets_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await snippet_svc.create_code_snippet(ctx_u1, CodeSnippetCreate(title="snippet-u1", code="code-u1")) @@ -33,15 +32,14 @@ async def test_code_snippets_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_code_snippets_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await snippet_svc.create_code_snippet(ctx_u1, CodeSnippetCreate(title="snippet-u1", code="code-u1")) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 forges u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 forges u1's workspace_id snippets = await snippet_svc.list_code_snippets(forged_ctx) assert snippets == [] # owner_uid filter saves us diff --git a/apps/backend/tests/test_dek_wrap.py b/apps/backend/tests/test_dek_wrap.py deleted file mode 100644 index a31dec65..00000000 --- a/apps/backend/tests/test_dek_wrap.py +++ /dev/null @@ -1,64 +0,0 @@ -import pytest -from httpx import AsyncClient - - -@pytest.mark.asyncio -async def test_get_dek_wrap_returns_null_initially(authed_client: AsyncClient, personal_ws_id: str): - res = await authed_client.get(f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/dek-wrap") - assert res.status_code == 200 - body = res.json() - assert body["wrappedDek"] is None - assert body["wrappedDekVersion"] == 0 - - -@pytest.mark.asyncio -async def test_post_then_get_wrap_roundtrip(authed_client: AsyncClient, personal_ws_id: str): - # The authed_client uid is "test-uid" (from conftest), and "test-uid" is the - # sole member of the personal workspace with ws_role="admin", so it can - # wrap for itself. - payload = { - "target_uid": "test-uid", - "wrapped": {"encrypted": "enc", "iv": "iv", "senderPublicKey": "pk"}, - } - res = await authed_client.post( - f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/dek-wrap", json=payload, - ) - assert res.status_code == 204 - - get_res = await authed_client.get( - f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/dek-wrap", - ) - assert get_res.status_code == 200 - body = get_res.json() - assert body["wrappedDek"]["encrypted"] == "enc" - assert body["wrappedDek"]["iv"] == "iv" - assert body["wrappedDek"]["senderPublicKey"] == "pk" - assert body["wrappedDekVersion"] == 1 - - -@pytest.mark.asyncio -async def test_post_wrap_bumps_version_on_second_write(authed_client: AsyncClient, personal_ws_id: str): - payload = { - "target_uid": "test-uid", - "wrapped": {"encrypted": "enc1", "iv": "iv1", "senderPublicKey": "pk1"}, - } - res = await authed_client.post( - f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/dek-wrap", json=payload, - ) - assert res.status_code == 204 - - payload2 = { - "target_uid": "test-uid", - "wrapped": {"encrypted": "enc2", "iv": "iv2", "senderPublicKey": "pk2"}, - } - res2 = await authed_client.post( - f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/dek-wrap", json=payload2, - ) - assert res2.status_code == 204 - - get_res = await authed_client.get( - f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/dek-wrap", - ) - body = get_res.json() - assert body["wrappedDek"]["encrypted"] == "enc2" - assert body["wrappedDekVersion"] == 2 diff --git a/apps/backend/tests/test_email.py b/apps/backend/tests/test_email.py deleted file mode 100644 index 2f66c9ea..00000000 --- a/apps/backend/tests/test_email.py +++ /dev/null @@ -1,18 +0,0 @@ -import logging -import pytest -from app.core.email import send_invitation_email - - -@pytest.mark.asyncio -async def test_dev_mode_logs_when_key_missing(monkeypatch, caplog): - monkeypatch.delenv("RESEND_API_KEY", raising=False) - caplog.set_level(logging.INFO) - await send_invitation_email( - to="alice@example.com", - token="tok-1", - inviter_name="Bob", - org_name="Acme", - workspace_name="Prod", - ) - assert any("alice@example.com" in r.message for r in caplog.records) - assert any("tok-1" in r.message for r in caplog.records) diff --git a/apps/backend/tests/test_environment_manager_workspace_isolation.py b/apps/backend/tests/test_environment_manager_workspace_isolation.py index 69584a91..f4973f3d 100644 --- a/apps/backend/tests/test_environment_manager_workspace_isolation.py +++ b/apps/backend/tests/test_environment_manager_workspace_isolation.py @@ -4,23 +4,22 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( - uid=uid, org_id=org_id, workspace_id=ws_id, ws_role="admin", + uid=uid, workspace_id=ws_id, ws_role="admin", is_personal=True, owner_uid=uid, ) @pytest.mark.asyncio async def test_env_entries_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await env_svc.create_entry(ctx_u1, EnvSetEntryCreate(encryptedData="enc-u1", iv="iv-u1")) @@ -33,15 +32,14 @@ async def test_env_entries_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_env_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await env_svc.create_entry(ctx_u1, EnvSetEntryCreate(encryptedData="enc-u1", iv="iv-u1")) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 forges u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 forges u1's workspace_id entries = await env_svc.list_entries(forged_ctx) assert entries == [] # owner_uid filter saves us diff --git a/apps/backend/tests/test_invitations.py b/apps/backend/tests/test_invitations.py deleted file mode 100644 index d81342bf..00000000 --- a/apps/backend/tests/test_invitations.py +++ /dev/null @@ -1,84 +0,0 @@ -import pytest -from httpx import AsyncClient -from app.utils.collection_name import INVITATIONS -from app.api.routes.workspaces.invitations_repo import ( - create_invitation, find_invitation_by_token, -) - - -@pytest.mark.asyncio -async def test_invitations_constant_exported(): - assert INVITATIONS == "invitations" - - -@pytest.mark.asyncio -async def test_create_and_find_invitation_roundtrip(clean_db): - inv_id = await create_invitation({ - "_id": "inv-1", - "org_id": "org-1", - "workspace_id": None, - "invited_email": "test@example.com", - "invited_uid": None, - "invited_role_org": "member", - "invited_role_ws": None, - "token": "tok-abc", - "status": "pending", - "invited_by": "u1", - "created_at": 1000, - "expires_at": 2000, - }) - assert inv_id == "inv-1" - doc = await find_invitation_by_token("tok-abc") - assert doc is not None - assert doc["status"] == "pending" - - -@pytest.fixture -async def authed_client_other_uid(clean_db) -> AsyncClient: - """Authenticated HTTP client for a second test user (uid=other-uid).""" - from app.api.routes.auth.services import get_current_uid - from app.api.routes.workspaces.services import ensure_user_workspace_setup - from app.main import app - - other_uid = "other-uid" - - def override_get_current_uid(): - return other_uid - - app.dependency_overrides[get_current_uid] = override_get_current_uid - - await ensure_user_workspace_setup(other_uid) - - async with AsyncClient( - transport=__import__("httpx").ASGITransport(app=app), - base_url="http://test", - ) as client: - yield client - - app.dependency_overrides.clear() - - -@pytest.mark.asyncio -async def test_invite_to_org_sends_email_and_creates_pending(authed_client, caplog): - import logging - caplog.set_level(logging.INFO) - org_id = (await authed_client.post( - "/api/v1/workspaces-api/orgs", json={"name": "InvOrg"} - )).json()["id"] - res = await authed_client.post( - f"/api/v1/workspaces-api/orgs/{org_id}/members", - json={"email": "alice@example.com", "role": "member"}, - ) - assert res.status_code == 201 - body = res.json() - assert body["invited_email"] == "alice@example.com" - assert body["status"] == "pending" - # Dev-mode logger emits a line containing the recipient - assert any("alice@example.com" in r.message for r in caplog.records) - - -@pytest.mark.asyncio -async def test_accept_invitation_creates_membership(authed_client_other_uid): - # Setup: original user creates org + invite for the second user's email - # then second user accepts. Implement via a separate authed_client for uid=alice. - pass diff --git a/apps/backend/tests/test_json_formatter_workspace_isolation.py b/apps/backend/tests/test_json_formatter_workspace_isolation.py index 63d3c7cd..f486d55f 100644 --- a/apps/backend/tests/test_json_formatter_workspace_isolation.py +++ b/apps/backend/tests/test_json_formatter_workspace_isolation.py @@ -11,10 +11,9 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( uid=uid, - org_id=org_id, workspace_id=ws_id, ws_role="admin", is_personal=True, @@ -24,15 +23,14 @@ def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: @pytest.mark.asyncio async def test_json_formatter_documents_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """Documents created by u1 must not appear in u2's list.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) # u1 creates a document await jf_svc.create_document(ctx_u1, JsonFormatterDocumentCreate(title="test", pane="left", content="{}")) @@ -49,17 +47,16 @@ async def test_json_formatter_documents_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_cannot_read_json_formatter_documents( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """u2 forging u1's workspace_id still cannot see u1's documents due to owner_uid.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await jf_svc.create_document(ctx_u1, JsonFormatterDocumentCreate(title="secret", pane="left", content="{}")) # u2 forges u1's workspace_id - forged_ctx = _ctx("u2", ws_u1, org_id) + forged_ctx = _ctx("u2", ws_u1) docs = await jf_svc.list_documents(forged_ctx) assert docs == [] # owner_uid filter prevents cross-user bleed diff --git a/apps/backend/tests/test_member_publickeys.py b/apps/backend/tests/test_member_publickeys.py deleted file mode 100644 index 8de7c81a..00000000 --- a/apps/backend/tests/test_member_publickeys.py +++ /dev/null @@ -1,15 +0,0 @@ -import pytest -from httpx import AsyncClient - - -@pytest.mark.asyncio -async def test_list_member_publickeys_for_admin(authed_client: AsyncClient, personal_ws_id: str): - res = await authed_client.get( - f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/member-publickeys", - ) - assert res.status_code == 200 - members = res.json() - assert len(members) >= 1 - assert members[0]["uid"] == "test-uid" - # publicKey is None initially (keypair not generated) - assert members[0]["publicKey"] is None diff --git a/apps/backend/tests/test_members.py b/apps/backend/tests/test_members.py deleted file mode 100644 index d304bcfe..00000000 --- a/apps/backend/tests/test_members.py +++ /dev/null @@ -1,36 +0,0 @@ -import pytest -from httpx import AsyncClient - - -@pytest.mark.asyncio -async def test_list_org_members_after_create(authed_client: AsyncClient): - org_id = (await authed_client.post( - "/api/v1/workspaces-api/orgs", json={"name": "Acme"} - )).json()["id"] - res = await authed_client.get(f"/api/v1/workspaces-api/orgs/{org_id}/members") - assert res.status_code == 200 - members = res.json() - assert len(members) == 1 - assert members[0]["role"] == "owner" - - -@pytest.mark.asyncio -async def test_cannot_demote_sole_owner(authed_client: AsyncClient): - org_id = (await authed_client.post( - "/api/v1/workspaces-api/orgs", json={"name": "SoloOrg"} - )).json()["id"] - me_uid = "test-uid" # the authed_client fixture's uid - res = await authed_client.patch( - f"/api/v1/workspaces-api/orgs/{org_id}/members/{me_uid}", - json={"role": "member"}, - ) - assert res.status_code == 400 - assert "sole owner" in res.json()["detail"].lower() - - -@pytest.mark.asyncio -async def test_remove_org_member_cascades_to_workspaces(authed_client: AsyncClient): - # Multi-member tests need a second test uid — set up via fixtures. - # Verifies that removing a user from the org also drops their ws memberships. - # (Skip skeleton — implement once test fixtures support multi-user clients.) - pass diff --git a/apps/backend/tests/test_nosql_workspace_isolation.py b/apps/backend/tests/test_nosql_workspace_isolation.py index 0acd025d..ade00d4e 100644 --- a/apps/backend/tests/test_nosql_workspace_isolation.py +++ b/apps/backend/tests/test_nosql_workspace_isolation.py @@ -4,23 +4,22 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( - uid=uid, org_id=org_id, workspace_id=ws_id, ws_role="admin", + uid=uid, workspace_id=ws_id, ws_role="admin", is_personal=True, owner_uid=uid, ) @pytest.mark.asyncio async def test_nosql_connections_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await nosql_svc.create_connection(ctx_u1, ConnectionCreate(encryptedData="encrypted-u1", iv="iv-u1", name="conn-u1")) @@ -33,15 +32,14 @@ async def test_nosql_connections_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_nosql_connections_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await nosql_svc.create_connection(ctx_u1, ConnectionCreate(encryptedData="encrypted-u1", iv="iv-u1", name="conn-u1")) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 forges u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 forges u1's workspace_id connections = await nosql_svc.list_connections(forged_ctx) assert connections == [] # owner_uid filter saves us diff --git a/apps/backend/tests/test_notes_workspace_isolation.py b/apps/backend/tests/test_notes_workspace_isolation.py index 563dc486..55d8d651 100644 --- a/apps/backend/tests/test_notes_workspace_isolation.py +++ b/apps/backend/tests/test_notes_workspace_isolation.py @@ -4,23 +4,22 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( - uid=uid, org_id=org_id, workspace_id=ws_id, ws_role="admin", + uid=uid, workspace_id=ws_id, ws_role="admin", is_personal=True, owner_uid=uid, ) @pytest.mark.asyncio async def test_notes_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await note_svc.create_note(ctx_u1, NoteCreate(title="u1 note")) @@ -33,16 +32,15 @@ async def test_notes_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_note_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await note_svc.create_note(ctx_u1, NoteCreate(title="u1 secret note")) # u2 forges u1's workspace_id but has different uid -> owner_uid filter blocks them - forged_ctx = _ctx("u2", ws_u1, org_id) + forged_ctx = _ctx("u2", ws_u1) notes = await note_svc.list_notes(ctx=forged_ctx) assert notes == [] diff --git a/apps/backend/tests/test_orgs_crud.py b/apps/backend/tests/test_orgs_crud.py deleted file mode 100644 index 090277f9..00000000 --- a/apps/backend/tests/test_orgs_crud.py +++ /dev/null @@ -1,48 +0,0 @@ -import pytest -from httpx import AsyncClient - - -@pytest.mark.asyncio -async def test_create_org_grants_owner_role(authed_client: AsyncClient): - res = await authed_client.post( - "/api/v1/workspaces-api/orgs", - json={"name": "Acme Inc"}, - ) - assert res.status_code == 201 - body = res.json() - assert body["name"] == "Acme Inc" - assert body["slug"] == "acme-inc" - assert body["kind"] == "user" - assert body["org_role"] == "owner" - - -@pytest.mark.asyncio -async def test_rename_org_owner_only(authed_client: AsyncClient): - create = await authed_client.post( - "/api/v1/workspaces-api/orgs", json={"name": "Beta"} - ) - org_id = create.json()["id"] - res = await authed_client.patch( - f"/api/v1/workspaces-api/orgs/{org_id}", - json={"name": "Beta Renamed"}, - ) - assert res.status_code == 200 - assert res.json()["name"] == "Beta Renamed" - - -@pytest.mark.asyncio -async def test_delete_org_soft_deletes(authed_client: AsyncClient): - create = await authed_client.post( - "/api/v1/workspaces-api/orgs", json={"name": "Doomed"} - ) - org_id = create.json()["id"] - res = await authed_client.delete(f"/api/v1/workspaces-api/orgs/{org_id}") - assert res.status_code == 204 - after = await authed_client.get("/api/v1/workspaces-api/orgs") - assert all(o["id"] != org_id for o in after.json()) - - -@pytest.mark.asyncio -async def test_cannot_delete_system_org(authed_client: AsyncClient, system_org_id: str): - res = await authed_client.delete(f"/api/v1/workspaces-api/orgs/{system_org_id}") - assert res.status_code == 403 diff --git a/apps/backend/tests/test_pending_wraps.py b/apps/backend/tests/test_pending_wraps.py deleted file mode 100644 index 02df07a2..00000000 --- a/apps/backend/tests/test_pending_wraps.py +++ /dev/null @@ -1,40 +0,0 @@ -import pytest -from httpx import AsyncClient - - -@pytest.mark.asyncio -async def test_pending_wraps_empty_initially(authed_client: AsyncClient, personal_ws_id: str): - res = await authed_client.get( - f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/pending-wraps", - ) - assert res.status_code == 200 - # The sole member (test-uid) has wrappedDek=None initially, so they appear - # in the pending list. The personal workspace is bootstrapped with one - # membership doc but no wrappedDek set yet. - body = res.json() - assert isinstance(body, list) - # The bootstrapped member has no wrap yet, so they should appear. - uids = [item["uid"] for item in body] - assert "test-uid" in uids - - -@pytest.mark.asyncio -async def test_pending_wraps_disappears_after_wrap_posted(authed_client: AsyncClient, personal_ws_id: str): - # Post a wrap for the sole member (test-uid). - payload = { - "target_uid": "test-uid", - "wrapped": {"encrypted": "enc", "iv": "iv", "senderPublicKey": "pk"}, - } - post_res = await authed_client.post( - f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/dek-wrap", json=payload, - ) - assert post_res.status_code == 204 - - # Now pending-wraps should not include test-uid. - res = await authed_client.get( - f"/api/v1/workspaces-api/workspaces/{personal_ws_id}/pending-wraps", - ) - assert res.status_code == 200 - body = res.json() - uids = [item["uid"] for item in body] - assert "test-uid" not in uids diff --git a/apps/backend/tests/test_rbac_dependency.py b/apps/backend/tests/test_rbac_dependency.py index 215f5e7b..7f87df18 100644 --- a/apps/backend/tests/test_rbac_dependency.py +++ b/apps/backend/tests/test_rbac_dependency.py @@ -6,7 +6,7 @@ def _ctx(role: str, is_personal: bool = False) -> WorkspaceContext: return WorkspaceContext( - uid="u1", org_id="o1", workspace_id="w1", + uid="u1", workspace_id="w1", ws_role=role, is_personal=is_personal, owner_uid="u1" if is_personal else None, ) diff --git a/apps/backend/tests/test_redis_commander_workspace_isolation.py b/apps/backend/tests/test_redis_commander_workspace_isolation.py index 8618188f..fb71e02a 100644 --- a/apps/backend/tests/test_redis_commander_workspace_isolation.py +++ b/apps/backend/tests/test_redis_commander_workspace_isolation.py @@ -8,10 +8,9 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( uid=uid, - org_id=org_id, workspace_id=ws_id, ws_role="admin", is_personal=True, @@ -21,15 +20,14 @@ def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: @pytest.mark.asyncio async def test_redis_connections_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """Connections created by u1 must not appear in u2's list.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await redis_svc.create_connection( ctx_u1, RedisConnectionCreate(encryptedData="encrypted-u1", iv="iv-u1", name="conn-u1") @@ -44,18 +42,17 @@ async def test_redis_connections_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_redis_connections_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """u2 forging u1's workspace_id still cannot see u1's connections due to owner_uid.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await redis_svc.create_connection( ctx_u1, RedisConnectionCreate(encryptedData="encrypted-u1", iv="iv-u1", name="conn-u1") ) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 forges u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 forges u1's workspace_id connections = await redis_svc.list_connections(forged_ctx) assert connections == [] # owner_uid filter saves us diff --git a/apps/backend/tests/test_s3_drive_workspace_isolation.py b/apps/backend/tests/test_s3_drive_workspace_isolation.py index 5b7f6ec1..c7d4bb3a 100644 --- a/apps/backend/tests/test_s3_drive_workspace_isolation.py +++ b/apps/backend/tests/test_s3_drive_workspace_isolation.py @@ -8,10 +8,9 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( uid=uid, - org_id=org_id, workspace_id=ws_id, ws_role="admin", is_personal=True, @@ -21,15 +20,14 @@ def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: @pytest.mark.asyncio async def test_s3_drive_connections_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """Connections created by u1 must not appear in u2's list.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await s3_drive_svc.create_connection( ctx_u1, S3ConnectionCreate(encryptedData="encrypted-u1", iv="iv-u1", name="conn-u1", provider="aws") @@ -44,18 +42,17 @@ async def test_s3_drive_connections_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_s3_drive_connections_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """u2 forging u1's workspace_id still cannot see u1's connections due to owner_uid.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await s3_drive_svc.create_connection( ctx_u1, S3ConnectionCreate(encryptedData="encrypted-u1", iv="iv-u1", name="conn-u1", provider="aws") ) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 forges u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 forges u1's workspace_id connections = await s3_drive_svc.list_connections(forged_ctx) assert connections == [] # owner_uid filter saves us diff --git a/apps/backend/tests/test_sql_client_workspace_isolation.py b/apps/backend/tests/test_sql_client_workspace_isolation.py index c680980c..f4055697 100644 --- a/apps/backend/tests/test_sql_client_workspace_isolation.py +++ b/apps/backend/tests/test_sql_client_workspace_isolation.py @@ -8,10 +8,9 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( uid=uid, - org_id=org_id, workspace_id=ws_id, ws_role="admin", is_personal=True, @@ -21,15 +20,14 @@ def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: @pytest.mark.asyncio async def test_sql_client_connections_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """Connections created by u1 must not appear in u2's list.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await sql_client_svc.create_connection( ctx_u1, SqlConnectionCreate(encryptedData="encrypted-u1", iv="iv-u1", name="conn-u1", type="postgresql") @@ -44,18 +42,17 @@ async def test_sql_client_connections_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_sql_client_connections_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """u2 forging u1's workspace_id still cannot see u1's connections due to owner_uid.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await sql_client_svc.create_connection( ctx_u1, SqlConnectionCreate(encryptedData="encrypted-u1", iv="iv-u1", name="conn-u1", type="postgresql") ) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 forges u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 forges u1's workspace_id connections = await sql_client_svc.list_connections(forged_ctx) assert connections == [] # owner_uid filter saves us diff --git a/apps/backend/tests/test_sweeper.py b/apps/backend/tests/test_sweeper.py deleted file mode 100644 index 266c8ad8..00000000 --- a/apps/backend/tests/test_sweeper.py +++ /dev/null @@ -1,39 +0,0 @@ -import pytest -from app.api.routes.workspaces.sweeper import ( - SOFT_DELETE_RETENTION_MS, run_sweeper_once, -) -from app.api.routes.workspaces.repo import upsert_org, set_org_deleted, find_org -from app.api.routes.workspaces.invitations_repo import create_invitation, find_invitation_by_token -from app.utils.utils import create_timestamp - - -@pytest.mark.asyncio -async def test_sweeper_hard_deletes_old_orgs(clean_db): - org_id = await upsert_org("Old", "old", "user", "u1") - old_ts = create_timestamp() - SOFT_DELETE_RETENTION_MS - 1000 - await set_org_deleted(org_id, old_ts) - - fresh_id = await upsert_org("Fresh", "fresh", "user", "u1") - await set_org_deleted(fresh_id, create_timestamp()) - - stats = await run_sweeper_once() - assert stats["orgs_hard_deleted"] == 1 - assert await find_org(org_id) is None - assert await find_org(fresh_id) is not None # still in grace - - -@pytest.mark.asyncio -async def test_sweeper_expires_old_invitations(clean_db): - old_ts = create_timestamp() - 1000 - await create_invitation({ - "_id": "inv-old", "org_id": "o1", "workspace_id": None, - "invited_email": "x@y.com", "invited_uid": None, - "invited_role_org": "member", "invited_role_ws": None, - "token": "tok-old", "status": "pending", - "invited_by": "u1", - "created_at": old_ts - 10000, "expires_at": old_ts, - }) - stats = await run_sweeper_once() - assert stats["invitations_expired"] == 1 - doc = await find_invitation_by_token("tok-old") - assert doc["status"] == "expired" diff --git a/apps/backend/tests/test_tasks_workspace_isolation.py b/apps/backend/tests/test_tasks_workspace_isolation.py index 6992eb87..ea29c2f4 100644 --- a/apps/backend/tests/test_tasks_workspace_isolation.py +++ b/apps/backend/tests/test_tasks_workspace_isolation.py @@ -4,32 +4,31 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( - uid=uid, org_id=org_id, workspace_id=ws_id, ws_role="admin", + uid=uid, workspace_id=ws_id, ws_role="admin", is_personal=True, owner_uid=uid, ) -def _shared_ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _shared_ctx(uid: str, ws_id: str) -> WorkspaceContext: """A shared (non-personal) workspace context — no owner_uid lock, so any member with a writer role can mutate any task in the workspace.""" return WorkspaceContext( - uid=uid, org_id=org_id, workspace_id=ws_id, ws_role="admin", + uid=uid, workspace_id=ws_id, ws_role="admin", is_personal=False, owner_uid=None, ) @pytest.mark.asyncio async def test_tasks_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await task_svc.create_task(ctx_u1, TaskCreate(text="u1 task")) @@ -42,14 +41,13 @@ async def test_tasks_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_projects_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await task_svc.create_project(ctx_u1, ProjectCreate(name="u1 project", color="#ff0000")) @@ -62,31 +60,29 @@ async def test_projects_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_task_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await task_svc.create_task(ctx_u1, TaskCreate(text="u1 secret task")) # u2 forges u1's workspace_id but has different uid → owner_uid filter blocks them - forged_ctx = _ctx("u2", ws_u1, org_id) + forged_ctx = _ctx("u2", ws_u1) result = await task_svc.list_tasks(ctx=forged_ctx) assert result.items == [] @pytest.mark.asyncio async def test_shared_workspace_member_can_edit_anothers_task( - clean_db, system_org_id, + clean_db, ): """Collaboration unlock: in a shared workspace, member B can edit / move / delete a task member A created (was blocked by the old created_by filter).""" - org_id = system_org_id ws = "ws-shared-1" - ctx_a = _shared_ctx("u1", ws, org_id) - ctx_b = _shared_ctx("u2", ws, org_id) + ctx_a = _shared_ctx("u1", ws) + ctx_b = _shared_ctx("u2", ws) created = await task_svc.create_task(ctx_a, TaskCreate(text="shared task")) @@ -114,22 +110,20 @@ async def test_shared_workspace_member_can_edit_anothers_task( @pytest.mark.asyncio async def test_shared_workspace_isolated_from_other_shared_workspace( - clean_db, system_org_id, + clean_db, ): """A shared workspace's tasks never leak into a different workspace.""" - org_id = system_org_id - ctx_a = _shared_ctx("u1", "ws-shared-A", org_id) - ctx_other = _shared_ctx("u1", "ws-shared-B", org_id) + ctx_a = _shared_ctx("u1", "ws-shared-A") + ctx_other = _shared_ctx("u1", "ws-shared-B") await task_svc.create_task(ctx_a, TaskCreate(text="A-only")) assert (await task_svc.list_tasks(ctx=ctx_other)).items == [] @pytest.mark.asyncio -async def test_assignee_filter(clean_db, system_org_id): +async def test_assignee_filter(clean_db): """list_tasks assignee filter supports me / unassigned / specific uid.""" - org_id = system_org_id - ctx = _shared_ctx("u1", "ws-assignee", org_id) + ctx = _shared_ctx("u1", "ws-assignee") await task_svc.create_task(ctx, TaskCreate(text="assigned to u2", assigneeUid="u2")) await task_svc.create_task(ctx, TaskCreate(text="unassigned")) diff --git a/apps/backend/tests/test_url_shortener_workspace_isolation.py b/apps/backend/tests/test_url_shortener_workspace_isolation.py index 1ef937d3..cbcd18b0 100644 --- a/apps/backend/tests/test_url_shortener_workspace_isolation.py +++ b/apps/backend/tests/test_url_shortener_workspace_isolation.py @@ -12,10 +12,9 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( uid=uid, - org_id=org_id, workspace_id=ws_id, ws_role="admin", is_personal=True, @@ -25,15 +24,14 @@ def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: @pytest.mark.asyncio async def test_url_shortener_links_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """Links created by u1 must not appear in u2's list.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) # u1 creates a link await url_svc.create_link(ctx_u1, ShortLinkCreate(original_url="https://example.com")) @@ -50,31 +48,29 @@ async def test_url_shortener_links_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_cannot_read_url_shortener_links( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): """u2 forging u1's workspace_id still cannot see u1's links due to owner_uid.""" - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) await url_svc.create_link(ctx_u1, ShortLinkCreate(original_url="https://secret.com")) # u2 forges u1's workspace_id - forged_ctx = _ctx("u2", ws_u1, org_id) + forged_ctx = _ctx("u2", ws_u1) links = await url_svc.list_my_short_urls(ctx=forged_ctx) assert links == [] # owner_uid filter prevents cross-user bleed @pytest.mark.asyncio async def test_click_events_inherit_link_workspace_stamps( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - """Click events must inherit the link's org_id, workspace_id, owner_uid stamps.""" - org_id = system_org_id + """Click events must inherit the link's workspace_id, owner_uid stamps.""" ws_u1 = await personal_ws_for("u1") - ctx_u1 = _ctx("u1", ws_u1, org_id) + ctx_u1 = _ctx("u1", ws_u1) # u1 creates a link link = await url_svc.create_link(ctx_u1, ShortLinkCreate(original_url="https://example.com")) @@ -90,7 +86,6 @@ async def test_click_events_inherit_link_workspace_stamps( # Verify the link has the correct stamps link_doc = await db_manager.find_one(COLLECTION, {"_id": code}) assert link_doc is not None - assert link_doc["org_id"] == org_id assert link_doc["workspace_id"] == ws_u1 assert link_doc["owner_uid"] == "u1" @@ -98,6 +93,5 @@ async def test_click_events_inherit_link_workspace_stamps( click_events = await db_manager.find(CLICKS_COLLECTION, {"code": code}, limit=10) assert len(click_events) > 0 for event in click_events: - assert event.get("org_id") == org_id assert event.get("workspace_id") == ws_u1 assert event.get("owner_uid") == "u1" diff --git a/apps/backend/tests/test_workspace_crud_b.py b/apps/backend/tests/test_workspace_crud_b.py deleted file mode 100644 index e247f257..00000000 --- a/apps/backend/tests/test_workspace_crud_b.py +++ /dev/null @@ -1,64 +0,0 @@ -import pytest -from httpx import AsyncClient - - -@pytest.mark.asyncio -async def test_create_shared_workspace(authed_client: AsyncClient): - org_create = await authed_client.post( - "/api/v1/workspaces-api/orgs", json={"name": "Acme"} - ) - org_id = org_create.json()["id"] - res = await authed_client.post( - f"/api/v1/workspaces-api/orgs/{org_id}/workspaces", - json={"name": "Production"}, - ) - assert res.status_code == 201 - body = res.json() - assert body["name"] == "Production" - assert body["is_personal"] is False - assert body["kind"] == "shared" - assert body["ws_role"] == "admin" # cascade from org owner - - -@pytest.mark.asyncio -async def test_personal_workspace_cannot_be_deleted( - authed_client: AsyncClient, personal_ws_id: str, -): - res = await authed_client.delete(f"/api/v1/workspaces-api/workspaces/{personal_ws_id}") - assert res.status_code == 403 - - -@pytest.mark.asyncio -async def test_delete_shared_workspace(authed_client: AsyncClient): - org_create = await authed_client.post( - "/api/v1/workspaces-api/orgs", json={"name": "DoomedOrg"} - ) - org_id = org_create.json()["id"] - ws_create = await authed_client.post( - f"/api/v1/workspaces-api/orgs/{org_id}/workspaces", - json={"name": "Doomed"}, - ) - ws_id = ws_create.json()["id"] - res = await authed_client.delete(f"/api/v1/workspaces-api/workspaces/{ws_id}") - assert res.status_code == 204 - listing = await authed_client.get("/api/v1/workspaces-api/workspaces") - assert all(w["id"] != ws_id for w in listing.json()) - - -@pytest.mark.asyncio -async def test_rename_workspace(authed_client: AsyncClient): - org_create = await authed_client.post( - "/api/v1/workspaces-api/orgs", json={"name": "RenameOrg"} - ) - org_id = org_create.json()["id"] - ws_create = await authed_client.post( - f"/api/v1/workspaces-api/orgs/{org_id}/workspaces", - json={"name": "First"}, - ) - ws_id = ws_create.json()["id"] - res = await authed_client.patch( - f"/api/v1/workspaces-api/workspaces/{ws_id}", - json={"name": "Second"}, - ) - assert res.status_code == 200 - assert res.json()["name"] == "Second" diff --git a/apps/backend/tests/test_workspace_ctx.py b/apps/backend/tests/test_workspace_ctx.py index 55dc5332..951e744b 100644 --- a/apps/backend/tests/test_workspace_ctx.py +++ b/apps/backend/tests/test_workspace_ctx.py @@ -8,8 +8,6 @@ get_workspace_ctx, ) from app.api.routes.workspaces.repo import ( - upsert_org, - upsert_org_membership, upsert_personal_workspace, upsert_ws_membership, ) @@ -17,10 +15,8 @@ @pytest.mark.asyncio async def test_get_workspace_ctx_rejects_non_member(make_request, clean_db): - org_id = await upsert_org("Acme", "acme", "user", "owner-uid") - await upsert_org_membership(org_id, "owner-uid", "owner") - ws_id = await upsert_personal_workspace(org_id, "owner-uid") - await upsert_ws_membership(ws_id, org_id, "owner-uid", "admin") + ws_id = await upsert_personal_workspace("owner-uid") + await upsert_ws_membership(ws_id, "owner-uid", "admin") req = make_request(cookies={"active_workspace": ws_id}) with pytest.raises(HTTPException) as exc: @@ -30,10 +26,8 @@ async def test_get_workspace_ctx_rejects_non_member(make_request, clean_db): @pytest.mark.asyncio async def test_default_personal_ws_id_returns_personal_ws(clean_db): - org_id = await upsert_org("MyDevTools Cloud", "mydevtools-cloud", "system", None) - await upsert_org_membership(org_id, "u1", "member") - ws_id = await upsert_personal_workspace(org_id, "u1") - await upsert_ws_membership(ws_id, org_id, "u1", "admin") + ws_id = await upsert_personal_workspace("u1") + await upsert_ws_membership(ws_id, "u1", "admin") assert await default_personal_ws_id("u1") == ws_id @@ -41,7 +35,6 @@ async def test_default_personal_ws_id_returns_personal_ws(clean_db): def test_apply_workspace_filter_personal_adds_owner_uid(): ctx = WorkspaceContext( uid="u1", - org_id="o1", workspace_id="w1", ws_role="admin", is_personal=True, @@ -50,7 +43,6 @@ def test_apply_workspace_filter_personal_adds_owner_uid(): out = apply_workspace_filter(ctx, {"foo": "bar"}) assert out == { "foo": "bar", - "org_id": "o1", "workspace_id": "w1", "owner_uid": "u1", } @@ -59,7 +51,6 @@ def test_apply_workspace_filter_personal_adds_owner_uid(): def test_apply_legacy_or_filter_bounds_by_user_field(): ctx = WorkspaceContext( uid="u1", - org_id="o1", workspace_id="w1", ws_role="admin", is_personal=True, @@ -67,7 +58,7 @@ def test_apply_legacy_or_filter_bounds_by_user_field(): ) out = apply_legacy_or_filter(ctx, {"foo": "bar"}, user_field="created_by") assert out["$or"] == [ - {"org_id": "o1", "workspace_id": "w1", "owner_uid": "u1"}, + {"workspace_id": "w1", "owner_uid": "u1"}, {"workspace_id": {"$exists": False}, "created_by": "u1"}, ] assert out["foo"] == "bar" @@ -76,7 +67,6 @@ def test_apply_legacy_or_filter_bounds_by_user_field(): def test_apply_legacy_or_filter_preserves_caller_or(): ctx = WorkspaceContext( uid="u1", - org_id="o1", workspace_id="w1", ws_role="admin", is_personal=True, @@ -88,21 +78,15 @@ def test_apply_legacy_or_filter_preserves_caller_or(): assert "$and" in out assert out["$and"][0] == base assert out["$and"][1]["$or"] == [ - {"org_id": "o1", "workspace_id": "w1", "owner_uid": "u1"}, + {"workspace_id": "w1", "owner_uid": "u1"}, {"workspace_id": {"$exists": False}, "created_by": "u1"}, ] @pytest.mark.asyncio -async def test_org_owner_gets_implicit_workspace_admin(clean_db, make_request): - org_id = await upsert_org("Acme", "acme", "user", "owner-uid") - await upsert_org_membership(org_id, "owner-uid", "owner") - # Shared workspace (Personal for now, since shared CRUD lands in B5). - ws_id = await upsert_personal_workspace(org_id, "owner-uid") - # ONLY org membership exists. NO workspace membership for the owner. - # ws membership exists for someone else. - await upsert_org_membership(org_id, "member-uid", "member") - await upsert_ws_membership(ws_id, org_id, "member-uid", "admin") +async def test_admin_member_gets_workspace_ctx(clean_db, make_request): + ws_id = await upsert_personal_workspace("owner-uid") + await upsert_ws_membership(ws_id, "owner-uid", "admin") req = make_request(cookies={"active_workspace": ws_id}) ctx = await get_workspace_ctx(req, uid="owner-uid") @@ -111,12 +95,9 @@ async def test_org_owner_gets_implicit_workspace_admin(clean_db, make_request): @pytest.mark.asyncio -async def test_org_member_without_ws_membership_is_rejected(clean_db, make_request): - org_id = await upsert_org("Acme2", "acme2", "user", "owner-uid") - await upsert_org_membership(org_id, "owner-uid", "owner") - await upsert_org_membership(org_id, "plain-member", "member") - ws_id = await upsert_personal_workspace(org_id, "owner-uid") - await upsert_ws_membership(ws_id, org_id, "owner-uid", "admin") +async def test_non_member_without_ws_membership_is_rejected(clean_db, make_request): + ws_id = await upsert_personal_workspace("owner-uid") + await upsert_ws_membership(ws_id, "owner-uid", "admin") req = make_request(cookies={"active_workspace": ws_id}) with pytest.raises(HTTPException) as exc: diff --git a/apps/backend/tests/test_workspace_invariant.py b/apps/backend/tests/test_workspace_invariant.py index fce4a555..37d1a12b 100644 --- a/apps/backend/tests/test_workspace_invariant.py +++ b/apps/backend/tests/test_workspace_invariant.py @@ -4,23 +4,22 @@ from app.api.routes.workspaces.middleware import WorkspaceContext -def _ctx(uid: str, ws_id: str, org_id: str) -> WorkspaceContext: +def _ctx(uid: str, ws_id: str) -> WorkspaceContext: return WorkspaceContext( - uid=uid, org_id=org_id, workspace_id=ws_id, ws_role="admin", + uid=uid, workspace_id=ws_id, ws_role="admin", is_personal=True, owner_uid=uid, ) @pytest.mark.asyncio async def test_password_entries_are_isolated_across_personal_workspaces( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") ws_u2 = await personal_ws_for("u2") - ctx_u1 = _ctx("u1", ws_u1, org_id) - ctx_u2 = _ctx("u2", ws_u2, org_id) + ctx_u1 = _ctx("u1", ws_u1) + ctx_u2 = _ctx("u2", ws_u2) await pw_svc.create_entry( ctx_u1, PasswordEntryCreate(encryptedData="enc-u1", iv="iv-u1"), @@ -35,17 +34,16 @@ async def test_password_entries_are_isolated_across_personal_workspaces( @pytest.mark.asyncio async def test_forged_workspace_id_cannot_cross_user_data( - clean_db, system_org_id, personal_ws_for, + clean_db, personal_ws_for, ): - org_id = system_org_id ws_u1 = await personal_ws_for("u1") await personal_ws_for("u2") await pw_svc.create_entry( - _ctx("u1", ws_u1, org_id), + _ctx("u1", ws_u1), PasswordEntryCreate(encryptedData="enc-u1", iv="iv-u1"), ) - forged_ctx = _ctx("u2", ws_u1, org_id) # u2 forges u1's workspace_id + forged_ctx = _ctx("u2", ws_u1) # u2 forges u1's workspace_id entries = await pw_svc.list_entries(ctx=forged_ctx) assert entries == [] # owner_uid filter saves us diff --git a/apps/backend/tests/test_workspace_routes.py b/apps/backend/tests/test_workspace_routes.py index c70f7baf..1275534a 100644 --- a/apps/backend/tests/test_workspace_routes.py +++ b/apps/backend/tests/test_workspace_routes.py @@ -2,16 +2,6 @@ from httpx import AsyncClient -@pytest.mark.asyncio -async def test_list_orgs_returns_mydevtools_cloud(authed_client: AsyncClient): - res = await authed_client.get("/api/v1/workspaces-api/orgs") - assert res.status_code == 200 - orgs = res.json() - assert len(orgs) == 1 - assert orgs[0]["slug"] == "mydevtools-cloud" - assert orgs[0]["org_role"] == "member" - - @pytest.mark.asyncio async def test_list_workspaces_returns_personal(authed_client: AsyncClient): res = await authed_client.get("/api/v1/workspaces-api/workspaces") diff --git a/apps/backend/tests/test_workspace_setup.py b/apps/backend/tests/test_workspace_setup.py deleted file mode 100644 index 837ac1b0..00000000 --- a/apps/backend/tests/test_workspace_setup.py +++ /dev/null @@ -1,33 +0,0 @@ -import pytest -from app.api.routes.workspaces.repo import ( - find_org_membership, - find_ws_membership, - find_user_workspaces, -) -from app.api.routes.workspaces.seed import ensure_system_org -from app.api.routes.workspaces.services import ensure_user_workspace_setup - - -@pytest.mark.asyncio -async def test_first_call_creates_membership_and_personal_workspace(clean_db): - org_id = await ensure_system_org() - ws_id = await ensure_user_workspace_setup("u1") - - assert await find_org_membership(org_id, "u1") is not None - assert await find_ws_membership(ws_id, "u1") is not None - - workspaces = await find_user_workspaces("u1") - assert len(workspaces) == 1 - assert workspaces[0]["is_personal"] is True - assert workspaces[0]["owner_uid"] == "u1" - assert workspaces[0]["name"] == "Personal" - - -@pytest.mark.asyncio -async def test_second_call_is_no_op(clean_db, count_inserts): - await ensure_system_org() - await ensure_user_workspace_setup("u1") - before = count_inserts() - await ensure_user_workspace_setup("u1") - after = count_inserts() - assert after == before diff --git a/apps/backend/tests/test_workspaces_seed.py b/apps/backend/tests/test_workspaces_seed.py deleted file mode 100644 index 76b4c7a3..00000000 --- a/apps/backend/tests/test_workspaces_seed.py +++ /dev/null @@ -1,37 +0,0 @@ -import pytest -from app.api.routes.workspaces.seed import ( - SYSTEM_ORG_NAME, - SYSTEM_ORG_SLUG, - ensure_system_org, - get_system_org_id, -) -from app.database import db_manager -from app.utils.collection_name import ORGANIZATIONS - - -@pytest.mark.asyncio -async def test_ensure_system_org_creates_singleton(clean_db): - org_id_first = await ensure_system_org() - org_id_second = await ensure_system_org() - - assert org_id_first == org_id_second - - docs = await db_manager.find( - ORGANIZATIONS, {"slug": SYSTEM_ORG_SLUG}, limit=10 - ) - assert len(docs) == 1 - assert docs[0]["name"] == SYSTEM_ORG_NAME - assert docs[0]["kind"] == "system" - assert docs[0].get("owner_uid") is None - - -@pytest.mark.asyncio -async def test_get_system_org_id_returns_none_when_not_seeded(clean_db): - assert await get_system_org_id() is None - - -@pytest.mark.asyncio -async def test_get_system_org_id_returns_id_after_seed(clean_db): - seeded = await ensure_system_org() - fetched = await get_system_org_id() - assert fetched == seeded diff --git a/apps/desktop/src-tauri/src/router/workspaces.rs b/apps/desktop/src-tauri/src/router/workspaces.rs index b0a8e078..a719ba63 100644 --- a/apps/desktop/src-tauri/src/router/workspaces.rs +++ b/apps/desktop/src-tauri/src/router/workspaces.rs @@ -1,7 +1,7 @@ //! Local mirror of FastAPI `/api/v1/workspaces-api/*`. //! -//! Offline there is exactly one org and one personal workspace, synthesized to -//! match the shapes in apps/web/src/lib/workspace-api.ts. +//! Offline there is exactly one personal workspace, synthesized to match the +//! shapes in apps/web/src/lib/workspace-api.ts. use serde_json::json; @@ -9,23 +9,11 @@ use crate::error::Result; use crate::router::ApiResponse; use crate::state::AppState; -pub const LOCAL_ORG_ID: &str = "local-org"; pub const LOCAL_WORKSPACE_ID: &str = "local-personal"; -fn local_org() -> serde_json::Value { - json!({ - "id": LOCAL_ORG_ID, - "name": "This Mac", - "slug": "local", - "kind": "user", - "org_role": "owner", - }) -} - fn local_workspace() -> serde_json::Value { json!({ "id": LOCAL_WORKSPACE_ID, - "org_id": LOCAL_ORG_ID, "name": "Personal", "slug": "personal-local", "is_personal": true, @@ -37,7 +25,6 @@ fn local_workspace() -> serde_json::Value { pub fn handle(state: &AppState, method: &str, path: &str, body: Option<&str>) -> Result