-
@@ -63,9 +63,11 @@
请选择左侧的数据表，或点击 + 新建数据表
@@ -127,7 +129,7 @@ import {
SettingOutlined,
} from '@ant-design/icons-vue'
import { useBitableStore } from '@/stores/bitable'
-import type { IBitableField } from '@/api/bitable'
+import type { IBitableField, ViewType } from '@/api/bitable'
import TableViewList from '@/components/bitable/TableViewList.vue'
import BitableGrid from '@/components/bitable/BitableGrid.vue'
import TableCreateModal from '@/components/bitable/TableCreateModal.vue'
@@ -143,6 +145,9 @@ const store = useBitableStore()
const createModalOpen = ref(false)
const fieldPanelOpen = ref(false)
const viewConfigOpen = ref(false)
+// U4: createView POST in-flight flag — disables the "新建视图" button + shows
+// a spinner to prevent duplicate submits.
+const viewCreating = ref(false)
const fileId = computed(() => (route.params.fileId as string) ?? '')
const tableId = computed(() => (route.params.tableId as string) ?? '')
@@ -225,8 +230,16 @@ function handleSwitchView(viewId: string): void {
store.switchView(viewId)
}
-async function handleCreateView(): Promise {
- // ponytail: simple prompt for view name; full create modal is overkill for v1
+// U6: delete the active view. The ViewSwitcher's a-popconfirm already asked
+// for confirmation; the store handles the 409 last-view case with a warning.
+async function handleDeleteView(viewId: string): Promise {
+ await store.deleteView(viewId)
+}
+
+async function handleCreateView(viewType: ViewType = 'grid'): Promise {
+ // ponytail: simple prompt for view name; full create modal is overkill for v1.
+ // viewType comes from the ViewSwitcher dropdown (U4) — defaults to 'grid'
+ // for backward compatibility with any direct caller.
let name = ''
AModal.confirm({
title: '新建视图',
@@ -239,7 +252,12 @@ async function handleCreateView(): Promise {
}),
onOk: async () => {
if (!name.trim()) return
- await store.createView(name.trim(), 'grid')
+ viewCreating.value = true
+ try {
+ await store.createView(name.trim(), viewType)
+ } finally {
+ viewCreating.value = false
+ }
},
})
}
@@ -280,40 +298,40 @@ async function handleDeleteField(field: IBitableField): Promise {
height: 100vh;
width: 100vw;
overflow: hidden;
- background: var(--bg-primary, #fff);
+ background: var(--bitable-color-bg);
}
.bitable-file-detail-view__topbar {
display: flex;
align-items: center;
justify-content: space-between;
- padding: 8px 16px;
- border-bottom: 1px solid var(--border-color, #f0f0f0);
+ padding: var(--bitable-spacing-sm) var(--bitable-spacing-lg);
+ border-bottom: 1px solid var(--bitable-color-border);
flex-shrink: 0;
}
.bitable-file-detail-view__topbar-left {
display: flex;
align-items: center;
- gap: 8px;
+ gap: var(--bitable-spacing-sm);
}
.bitable-file-detail-view__topbar-right {
display: flex;
align-items: center;
- gap: 8px;
+ gap: var(--bitable-spacing-sm);
}
.bitable-file-detail-view__icon {
font-size: 20px;
- color: var(--color-primary, #1a1a1a);
+ color: var(--bitable-color-primary);
display: inline-flex;
align-items: center;
}
.bitable-file-detail-view__title {
font-weight: 600;
- font-size: 16px;
+ font-size: var(--bitable-font-lg);
}
.bitable-file-detail-view__body {
@@ -342,28 +360,28 @@ async function handleDeleteField(field: IBitableField): Promise {
align-items: center;
justify-content: center;
height: 100%;
- gap: 16px;
- color: var(--text-placeholder, #bfbfbf);
+ gap: var(--bitable-spacing-lg);
+ color: var(--bitable-color-text-placeholder);
}
.bitable-file-detail-view__grid-header {
display: flex;
align-items: baseline;
- gap: 12px;
- padding: 12px 16px;
- border-bottom: 1px solid var(--border-color, #f0f0f0);
+ gap: var(--bitable-spacing-md);
+ padding: var(--bitable-spacing-md) var(--bitable-spacing-lg);
+ border-bottom: 1px solid var(--bitable-color-border);
flex-shrink: 0;
}
.bitable-file-detail-view__table-name {
margin: 0;
- font-size: 16px;
+ font-size: var(--bitable-font-lg);
font-weight: 600;
}
.bitable-file-detail-view__field-count {
- font-size: 12px;
- color: var(--text-secondary, #8c8c8c);
+ font-size: var(--bitable-font-xs);
+ color: var(--bitable-color-text-secondary);
}
.bitable-file-detail-view__grid-container {
@@ -375,8 +393,8 @@ async function handleDeleteField(field: IBitableField): Promise {
.bitable-file-detail-view__load-more {
display: flex;
justify-content: center;
- padding: 8px;
- border-top: 1px solid var(--border-color, #f0f0f0);
+ padding: var(--bitable-spacing-sm);
+ border-top: 1px solid var(--bitable-color-border);
flex-shrink: 0;
}
diff --git a/src/agentkit/server/frontend/src/views/BitableFileListView.vue b/src/agentkit/server/frontend/src/views/BitableFileListView.vue
index 55bfd10..8151fe6 100644
--- a/src/agentkit/server/frontend/src/views/BitableFileListView.vue
+++ b/src/agentkit/server/frontend/src/views/BitableFileListView.vue
@@ -189,16 +189,16 @@ function handleDelete(file: IBitableFile): void {
height: 100vh;
width: 100vw;
overflow: hidden;
- background: var(--bg-secondary, #fafafa);
+ background: var(--bitable-color-bg-secondary);
}
.bitable-file-list-view__topbar {
display: flex;
align-items: center;
justify-content: space-between;
- padding: 8px 16px;
- background: var(--bg-primary, #fff);
- border-bottom: 1px solid var(--border-color, #f0f0f0);
+ padding: var(--bitable-spacing-sm) var(--bitable-spacing-lg);
+ background: var(--bitable-color-bg);
+ border-bottom: 1px solid var(--bitable-color-border);
flex-shrink: 0;
}
@@ -248,7 +248,7 @@ function handleDelete(file: IBitableFile): void {
}
.bitable-file-list-view__option-icon {
- font-size: 16px;
- color: var(--color-primary, #1a1a1a);
+ font-size: var(--bitable-font-lg);
+ color: var(--bitable-color-primary);
}
diff --git a/src/agentkit/server/routes/bitable.py b/src/agentkit/server/routes/bitable.py
index d2d8b2c..63072af 100644
--- a/src/agentkit/server/routes/bitable.py
+++ b/src/agentkit/server/routes/bitable.py
@@ -28,7 +28,12 @@ from fastapi.responses import FileResponse
from pydantic import BaseModel, Field
from agentkit.bitable.models import FieldOwner, FieldType, ViewType
-from agentkit.bitable.service import BitableService, FieldDependencyError
+from agentkit.bitable.service import (
+ BitableService,
+ FieldDependencyError,
+ LastViewDeletionError,
+)
+from agentkit.bitable.view_config import ViewConfigValidationError, validate_view_config
from agentkit.server.auth.dependencies import get_current_user
logger = logging.getLogger(__name__)
@@ -668,6 +673,16 @@ async def update_view(
if existing is None:
raise HTTPException(status_code=404, detail="View not found")
await _check_table_ownership(service, existing.table_id, user)
+ # U5: validate group_by / conditional_formatting sub-keys before persisting.
+ # Other config keys (filters / sort / hidden_fields) pass through unchanged.
+ if body.config is not None:
+ try:
+ validate_view_config(body.config)
+ except ViewConfigValidationError as exc:
+ raise HTTPException(
+ status_code=422,
+ detail={"message": str(exc), "errors": exc.errors},
+ ) from exc
kwargs = body.model_dump(exclude_none=True)
view = await service.update_view(view_id, **kwargs)
if view is None:
@@ -675,6 +690,33 @@ async def update_view(
return {"success": True, "view": view.model_dump(mode="json")}
+@router.delete("/views/{view_id}", status_code=204)
+async def delete_view(
+ view_id: str,
+ request: Request,
+ user: dict = Depends(require_bitable_auth),
+) -> None:
+ """Delete a view (U6).
+
+ 404-before-403: ownership is checked via ``_check_table_ownership`` so a
+ non-owner gets 404 (not 403) — never disclosing existence. Last-view
+ protection returns 409 Conflict. X-Internal-Token bypasses ownership
+ (KTD11) via ``require_bitable_auth``.
+ """
+ service = _get_service(request)
+ existing = await service.get_view(view_id)
+ if existing is None:
+ raise HTTPException(status_code=404, detail="View not found")
+ await _check_table_ownership(service, existing.table_id, user)
+ try:
+ deleted = await service.delete_view(view_id)
+ except LastViewDeletionError as e:
+ raise HTTPException(status_code=409, detail=str(e)) from e
+ if not deleted:
+ raise HTTPException(status_code=404, detail="View not found")
+ return None
+
+
# ---------------------------------------------------------------------------
# File upload / download (U6: attachment & image fields)
# ---------------------------------------------------------------------------
diff --git a/src/agentkit/server/static/index.html b/src/agentkit/server/static/index.html
index c9a7f66..bbbad35 100644
--- a/src/agentkit/server/static/index.html
+++ b/src/agentkit/server/static/index.html
@@ -5,8 +5,8 @@
Fischer AgentKit
-
-
+
+
diff --git a/src/agentkit/tools/bitable_tool.py b/src/agentkit/tools/bitable_tool.py
index 86250ac..6365155 100644
--- a/src/agentkit/tools/bitable_tool.py
+++ b/src/agentkit/tools/bitable_tool.py
@@ -5,7 +5,8 @@ Implements KTD5 (REST API boundary even when co-deployed) and KTD11
the bitable REST API; it never imports BitableService directly.
Actions: create_table, import_excel, import_database, collect_api,
- upsert_records, query_records.
+ upsert_records, query_records, create_view, update_view,
+ update_field, delete_view.
Batch chunking: upsert and import operations send at most ``BATCH_SIZE``
records per HTTP request. On partial failure, the result includes
@@ -45,7 +46,8 @@ class BitableTool(Tool):
"Create and manage bitable (multi-dimensional spreadsheet) tables, "
"ingest data from Excel files, databases, or API responses, and "
"query records. Actions: create_table, import_excel, "
- "import_database, collect_api, upsert_records, query_records."
+ "import_database, collect_api, upsert_records, query_records, "
+ "create_view, update_view, update_field, delete_view."
),
input_schema={
"type": "object",
@@ -59,6 +61,10 @@ class BitableTool(Tool):
"collect_api",
"upsert_records",
"query_records",
+ "create_view",
+ "update_view",
+ "update_field",
+ "delete_view",
],
"description": "Bitable operation to perform.",
},
@@ -89,7 +95,7 @@ class BitableTool(Tool):
},
"table_id": {
"type": "string",
- "description": "Target bitable table ID (collect_api, upsert_records, query_records).",
+ "description": "Target bitable table ID (collect_api, upsert_records, query_records, create_view).",
},
"records": {
"type": "array",
@@ -115,6 +121,31 @@ class BitableTool(Tool):
"type": "integer",
"description": "Max records to return (query_records).",
},
+ "view_id": {
+ "type": "string",
+ "description": "View ID (update_view, delete_view).",
+ },
+ "view_type": {
+ "type": "string",
+ "enum": ["grid", "kanban", "gantt", "gallery", "form"],
+ "description": "View type (create_view). Defaults to grid.",
+ },
+ "field_id": {
+ "type": "string",
+ "description": "Field ID (update_field).",
+ },
+ "name": {
+ "type": "string",
+ "description": "Name for a view or field (create_view, update_view, update_field).",
+ },
+ "type": {
+ "type": "string",
+ "description": "Field type for update_field (e.g. text, number, date).",
+ },
+ "config": {
+ "type": "object",
+ "description": "View/field config dict (create_view, update_view, update_field).",
+ },
},
"required": ["action"],
},
@@ -148,6 +179,10 @@ class BitableTool(Tool):
"collect_api": self._collect_api,
"upsert_records": self._upsert_records,
"query_records": self._query_records,
+ "create_view": self._create_view,
+ "update_view": self._update_view,
+ "update_field": self._update_field,
+ "delete_view": self._delete_view,
}
handler = handlers.get(action)
if handler is None:
@@ -483,3 +518,68 @@ class BitableTool(Tool):
"records": data["records"],
"next_cursor": data.get("next_cursor"),
}
+
+ # ------------------------------------------------------------------
+ # View & field CRUD (U6: agent parity with REST endpoints)
+ # ------------------------------------------------------------------
+
+ async def _create_view(self, **kwargs) -> dict[str, object]:
+ table_id = kwargs.get("table_id")
+ name = kwargs.get("name")
+ if not table_id:
+ return {"success": False, "error": "Missing required field: table_id"}
+ if not name:
+ return {"success": False, "error": "Missing required field: name"}
+ view_type = kwargs.get("view_type") or "grid"
+ config = kwargs.get("config") or {}
+ client = await self._get_client()
+ resp = await client.post(
+ f"/tables/{table_id}/views",
+ json={"name": name, "view_type": view_type, "config": config},
+ )
+ resp.raise_for_status()
+ return {"success": True, "view": resp.json()["view"]}
+
+ async def _update_view(self, **kwargs) -> dict[str, object]:
+ view_id = kwargs.get("view_id")
+ if not view_id:
+ return {"success": False, "error": "Missing required field: view_id"}
+ payload: dict[str, object] = {}
+ if kwargs.get("name") is not None:
+ payload["name"] = kwargs["name"]
+ if kwargs.get("config") is not None:
+ payload["config"] = kwargs["config"]
+ client = await self._get_client()
+ resp = await client.patch(f"/views/{view_id}", json=payload)
+ resp.raise_for_status()
+ return {"success": True, "view": resp.json()["view"]}
+
+ async def _update_field(self, **kwargs) -> dict[str, object]:
+ field_id = kwargs.get("field_id")
+ if not field_id:
+ return {"success": False, "error": "Missing required field: field_id"}
+ payload: dict[str, object] = {}
+ if kwargs.get("name") is not None:
+ payload["name"] = kwargs["name"]
+ # ponytail: PATCH /fields/{id} is backed by UpdateFieldRequest which
+ # currently accepts only name + config. `type` is forwarded as
+ # `field_type` so the tool is forward-compatible once the request
+ # model adds it; today it is silently ignored by Pydantic (extra=ignore).
+ if kwargs.get("type") is not None:
+ payload["field_type"] = kwargs["type"]
+ if kwargs.get("config") is not None:
+ payload["config"] = kwargs["config"]
+ client = await self._get_client()
+ resp = await client.patch(f"/fields/{field_id}", json=payload)
+ resp.raise_for_status()
+ return {"success": True, "field": resp.json()["field"]}
+
+ async def _delete_view(self, **kwargs) -> dict[str, object]:
+ view_id = kwargs.get("view_id")
+ if not view_id:
+ return {"success": False, "error": "Missing required field: view_id"}
+ client = await self._get_client()
+ resp = await client.delete(f"/views/{view_id}")
+ resp.raise_for_status()
+ # 204 No Content has an empty body; report a stable success shape.
+ return {"success": True, "deleted": True}
diff --git a/tests/unit/bitable/test_bitable_tool.py b/tests/unit/bitable/test_bitable_tool.py
index b8b20b4..1f885fd 100644
--- a/tests/unit/bitable/test_bitable_tool.py
+++ b/tests/unit/bitable/test_bitable_tool.py
@@ -483,3 +483,236 @@ def test_transform_records_missing_keys() -> None:
field_mapping={"a": "fld_a"}, # b is not mapped
)
assert result == [{"fld_a": 1}]
+
+
+# ---------------------------------------------------------------------------
+# U6: View & field CRUD actions (create_view, update_view, update_field,
+# delete_view) — agent parity with the REST API.
+# ---------------------------------------------------------------------------
+
+
+def test_action_enum_has_10_actions() -> None:
+ """input_schema.action.enum lists all 10 actions (6 original + 4 new)."""
+ tool = BitableTool(base_url="http://test/api/v1/bitable")
+ actions = tool.input_schema["properties"]["action"]["enum"]
+ assert len(actions) == 10
+ for new_action in ("create_view", "update_view", "update_field", "delete_view"):
+ assert new_action in actions
+
+
+def test_execute_handlers_dict_has_10_actions() -> None:
+ """execute() handlers dict contains all 10 action keys (KTD10)."""
+ import re
+
+ src = open(
+ "src/agentkit/tools/bitable_tool.py",
+ encoding="utf-8",
+ ).read()
+ handlers_match = re.search(r"handlers\s*=\s*\{([^}]*)\}", src, re.DOTALL)
+ handler_keys = re.findall(r'"([a-z_]+)":\s*self\._', handlers_match.group(1))
+ assert len(handler_keys) == 10
+ for new_action in ("create_view", "update_view", "update_field", "delete_view"):
+ assert new_action in handler_keys
+
+
+async def test_create_view_action(tool: BitableTool) -> None:
+ """create_view action POSTs /tables/{id}/views with name + view_type + config."""
+ result = await tool.execute(action="create_table", table_name="VC")
+ table_id = result["table"]["id"]
+
+ resp = await tool.execute(
+ action="create_view",
+ table_id=table_id,
+ name="Kanban Plan",
+ view_type="kanban",
+ config={"group_by": [{"field_id": "fld_x", "direction": "asc"}]},
+ )
+ assert resp["success"] is True
+ assert resp["view"]["name"] == "Kanban Plan"
+ assert resp["view"]["view_type"] == "kanban"
+
+
+async def test_create_view_defaults_to_grid(tool: BitableTool) -> None:
+ """create_view without view_type defaults to grid."""
+ result = await tool.execute(action="create_table", table_name="VG")
+ table_id = result["table"]["id"]
+ resp = await tool.execute(action="create_view", table_id=table_id, name="Default")
+ assert resp["success"] is True
+ assert resp["view"]["view_type"] == "grid"
+
+
+async def test_create_view_missing_table_id(tool: BitableTool) -> None:
+ """Missing table_id → error."""
+ resp = await tool.execute(action="create_view", name="x")
+ assert resp["success"] is False
+ assert "table_id" in resp["error"]
+
+
+async def test_update_view_action(tool: BitableTool) -> None:
+ """update_view action PATCHes /views/{id} with name + config."""
+ result = await tool.execute(action="create_table", table_name="VU")
+ table_id = result["table"]["id"]
+ view_id = (
+ await tool.execute(action="create_view", table_id=table_id, name="Old")
+ )["view"]["id"]
+
+ resp = await tool.execute(
+ action="update_view",
+ view_id=view_id,
+ name="Renamed",
+ config={"group_by": [{"field_id": "fld_a", "direction": "asc"}]},
+ )
+ assert resp["success"] is True
+ assert resp["view"]["name"] == "Renamed"
+
+
+async def test_update_view_missing_view_id(tool: BitableTool) -> None:
+ """Missing view_id → error."""
+ resp = await tool.execute(action="update_view", name="x")
+ assert resp["success"] is False
+ assert "view_id" in resp["error"]
+
+
+async def test_update_field_action(tool: BitableTool) -> None:
+ """update_field action PATCHes /fields/{id} (equivalent to REST PATCH /fields)."""
+ result = await tool.execute(action="create_table", table_name="FU")
+ table_id = result["table"]["id"]
+ client = await tool._get_client()
+ field_id = (
+ await client.post(
+ f"/tables/{table_id}/fields",
+ json={"name": "col", "field_type": "text", "owner": "user"},
+ )
+ ).json()["field"]["id"]
+
+ resp = await tool.execute(
+ action="update_field",
+ field_id=field_id,
+ name="renamed_col",
+ config={"description": "updated"},
+ )
+ assert resp["success"] is True
+ assert resp["field"]["name"] == "renamed_col"
+
+
+async def test_update_field_missing_field_id(tool: BitableTool) -> None:
+ """Missing field_id → error."""
+ resp = await tool.execute(action="update_field", name="x")
+ assert resp["success"] is False
+ assert "field_id" in resp["error"]
+
+
+async def test_delete_view_action(tool: BitableTool) -> None:
+ """delete_view action DELETEs /views/{id}; last-view protection applies."""
+ result = await tool.execute(action="create_table", table_name="VD")
+ table_id = result["table"]["id"]
+ v1 = (await tool.execute(action="create_view", table_id=table_id, name="v1"))["view"]["id"]
+ await tool.execute(action="create_view", table_id=table_id, name="v2")
+
+ resp = await tool.execute(action="delete_view", view_id=v1)
+ assert resp["success"] is True
+ assert resp["deleted"] is True
+
+
+async def test_delete_view_action_409_on_last_view(tool: BitableTool) -> None:
+ """delete_view on the last view → HTTP 409 surfaced as error."""
+ result = await tool.execute(action="create_table", table_name="VL")
+ table_id = result["table"]["id"]
+ only = (await tool.execute(action="create_view", table_id=table_id, name="only"))["view"]["id"]
+
+ resp = await tool.execute(action="delete_view", view_id=only)
+ assert resp["success"] is False
+ assert "409" in resp["error"]
+
+
+async def test_delete_view_missing_view_id(tool: BitableTool) -> None:
+ """Missing view_id → error."""
+ resp = await tool.execute(action="delete_view")
+ assert resp["success"] is False
+ assert "view_id" in resp["error"]
+
+
+async def test_create_view_with_r3_r4_config(tool: BitableTool) -> None:
+ """create_view forwards group_by + conditional_formatting config (R3/R4 parity)."""
+ result = await tool.execute(action="create_table", table_name="R34")
+ table_id = result["table"]["id"]
+ client = await tool._get_client()
+ # Create a field so group_by can reference a real field id.
+ fid = (
+ await client.post(
+ f"/tables/{table_id}/fields",
+ json={"name": "status", "field_type": "select", "owner": "user"},
+ )
+ ).json()["field"]["id"]
+
+ resp = await tool.execute(
+ action="create_view",
+ table_id=table_id,
+ name="GroupedView",
+ config={
+ "group_by": [{"field_id": fid, "direction": "asc"}],
+ "conditional_formatting": [
+ {
+ "field_id": fid,
+ "operator": "equals",
+ "value": "done",
+ "color_key": "green",
+ }
+ ],
+ },
+ )
+ assert resp["success"] is True
+ cfg = resp["view"]["config"]
+ assert len(cfg["group_by"]) == 1
+ assert cfg["group_by"][0]["field_id"] == fid
+ assert cfg["conditional_formatting"][0]["color_key"] == "green"
+
+
+# ---------------------------------------------------------------------------
+# X-Internal-Token transparent passthrough on the 4 new actions (KTD11)
+# ---------------------------------------------------------------------------
+
+
+async def test_new_actions_internal_token_passthrough(
+ tool_real_auth: BitableTool,
+) -> None:
+ """X-Internal-Token bypasses ownership for all 4 new actions (KTD11)."""
+ # create_table (existing action) — establishes an admin-owned table.
+ result = await tool_real_auth.execute(action="create_table", table_name="TokenT")
+ table_id = result["table"]["id"]
+
+ # create_view via the new action.
+ v = await tool_real_auth.execute(
+ action="create_view", table_id=table_id, name="tv1"
+ )
+ assert v["success"] is True
+ view_id = v["view"]["id"]
+
+ # update_view via the new action.
+ uv = await tool_real_auth.execute(action="update_view", view_id=view_id, name="tv1-renamed")
+ assert uv["success"] is True
+
+ # update_field: create a field first via the tool's HTTP client, then update.
+ client = await tool_real_auth._get_client()
+ fid = (
+ await client.post(
+ f"/tables/{table_id}/fields",
+ json={"name": "c", "field_type": "text", "owner": "user"},
+ )
+ ).json()["field"]["id"]
+ uf = await tool_real_auth.execute(action="update_field", field_id=fid, name="c2")
+ assert uf["success"] is True
+
+ # delete_view: add a second view so last-view protection doesn't block.
+ await tool_real_auth.execute(action="create_view", table_id=table_id, name="tv2")
+ dv = await tool_real_auth.execute(action="delete_view", view_id=view_id)
+ assert dv["success"] is True
+
+
+async def test_delete_view_internal_token_404_when_missing(
+ tool_real_auth: BitableTool,
+) -> None:
+ """X-Internal-Token calling delete_view on a non-existent view → 404 (no silent success)."""
+ resp = await tool_real_auth.execute(action="delete_view", view_id="no-such-view")
+ assert resp["success"] is False
+ assert "404" in resp["error"]
diff --git a/tests/unit/bitable/test_conditional_formatting.py b/tests/unit/bitable/test_conditional_formatting.py
new file mode 100644
index 0000000..7e8664b
--- /dev/null
+++ b/tests/unit/bitable/test_conditional_formatting.py
@@ -0,0 +1,420 @@
+"""Tests for bitable view config conditional formatting validation (U5 / R4).
+
+Covers all 7 operators + 8 color keys. Layered like test_grouping.py:
+1. Pure Pydantic validation (no DB) — always runs
+2. Route-level 422 via fake service (no DB) — always runs
+3. Round-trip via real PG service — skipped if PG unavailable
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+import pytest
+from fastapi import FastAPI
+from httpx import ASGITransport
+from pydantic import ValidationError
+
+from agentkit.bitable.models import View, ViewType
+from agentkit.bitable.view_config import (
+ ColorKey,
+ ConditionalFormatRule,
+ ConditionalOperator,
+ ViewConfigSchema,
+ ViewConfigValidationError,
+ validate_view_config,
+)
+from agentkit.server.routes import bitable as bitable_routes
+from agentkit.server.routes.bitable import require_bitable_auth
+
+TEST_USER_ID = "test-user-id"
+
+# Exhaustive lists — kept in sync with the Literal definitions in view_config.py.
+ALL_OPERATORS: list[ConditionalOperator] = [
+ "equals",
+ "not-equals",
+ "contains",
+ "is-empty",
+ "greater-than",
+ "less-than",
+ "between",
+]
+ALL_COLOR_KEYS: list[ColorKey] = [
+ "red",
+ "orange",
+ "yellow",
+ "green",
+ "blue",
+ "purple",
+ "gray",
+ "neutral",
+]
+
+
+def _rule(
+ *,
+ field_id: str = "f1",
+ operator: ConditionalOperator = "equals",
+ value: str = "v",
+ color_key: ColorKey = "red",
+ bold: bool = True,
+ enabled: bool = True,
+) -> dict[str, object]:
+ return {
+ "field_id": field_id,
+ "operator": operator,
+ "value": value,
+ "color_key": color_key,
+ "bold": bold,
+ "enabled": enabled,
+ }
+
+
+# ---------------------------------------------------------------------------
+# 1. Pure Pydantic validation — always runs
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("op", ALL_OPERATORS)
+def test_validate_accepts_each_operator(op: ConditionalOperator) -> None:
+ """All 7 operators accepted (spec test scenario 8)."""
+ config = {"conditional_formatting": [_rule(operator=op)]}
+ validate_view_config(config) # no raise
+
+
+@pytest.mark.parametrize("color", ALL_COLOR_KEYS)
+def test_validate_accepts_each_color_key(color: ColorKey) -> None:
+ """All 8 color keys accepted."""
+ config = {"conditional_formatting": [_rule(color_key=color)]}
+ validate_view_config(config) # no raise
+
+
+def test_validate_rejects_invalid_operator() -> None:
+ """Operator not in the 7-key whitelist is rejected."""
+ config = {"conditional_formatting": [_rule(operator="starts-with")]} # type: ignore[dict-item]
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_rejects_invalid_color_key() -> None:
+ """color_key not in the 8-color whitelist is rejected."""
+ config = {"conditional_formatting": [_rule(color_key="pink")]} # type: ignore[dict-item]
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_rejects_missing_field_id() -> None:
+ """field_id is required."""
+ rule = _rule()
+ del rule["field_id"]
+ config = {"conditional_formatting": [rule]}
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_rejects_missing_operator() -> None:
+ """operator is required."""
+ rule = _rule()
+ del rule["operator"]
+ config = {"conditional_formatting": [rule]}
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_rejects_missing_color_key() -> None:
+ """color_key is required."""
+ rule = _rule()
+ del rule["color_key"]
+ config = {"conditional_formatting": [rule]}
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_value_defaults_to_empty_string() -> None:
+ """value is optional, defaults to '' (UI sends '' for is-empty)."""
+ rule = _rule()
+ del rule["value"]
+ parsed = ConditionalFormatRule.model_validate(rule)
+ assert parsed.value == ""
+
+
+def test_validate_bold_defaults_to_true() -> None:
+ """bold defaults to True (WCAG 1.4.1 — color alone is not enough)."""
+ rule = _rule()
+ del rule["bold"]
+ parsed = ConditionalFormatRule.model_validate(rule)
+ assert parsed.bold is True
+
+
+def test_validate_enabled_defaults_to_true() -> None:
+ """enabled defaults to True."""
+ rule = _rule()
+ del rule["enabled"]
+ parsed = ConditionalFormatRule.model_validate(rule)
+ assert parsed.enabled is True
+
+
+def test_validate_rejects_extra_keys_in_rule() -> None:
+ """extra='forbid' on ConditionalFormatRule — unknown keys rejected."""
+ rule = _rule()
+ rule["extra_key"] = "oops"
+ config = {"conditional_formatting": [rule]}
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_accepts_empty_conditional_formatting_list() -> None:
+ """Empty rule list is valid (no rules = no coloring)."""
+ validate_view_config({"conditional_formatting": []})
+
+
+def test_validate_accepts_multiple_rules() -> None:
+ """Multiple rules accepted (first-match-wins is enforced client-side)."""
+ config = {
+ "conditional_formatting": [
+ _rule(field_id="f1", operator="equals", value="a", color_key="red"),
+ _rule(field_id="f2", operator="greater-than", value="10", color_key="green"),
+ _rule(field_id="f3", operator="is-empty", color_key="gray"),
+ ]
+ }
+ validate_view_config(config) # no raise
+
+
+def test_validate_ignores_non_u5_keys_with_cf_present() -> None:
+ """filters / sort / hidden_fields pass through when cf is also present."""
+ config = {
+ "filters": [{"field_id": "f1", "op": "weird-op"}],
+ "hidden_fields": ["f2"],
+ "conditional_formatting": [_rule()],
+ }
+ validate_view_config(config) # no raise
+
+
+def test_schema_round_trips_conditional_formatting() -> None:
+ """ViewConfigSchema round-trips a CF config without loss."""
+ raw = {
+ "group_by": [],
+ "conditional_formatting": [
+ {
+ "field_id": "f1",
+ "operator": "between",
+ "value": "10,20",
+ "color_key": "blue",
+ "bold": False,
+ "enabled": True,
+ }
+ ],
+ }
+ schema = ViewConfigSchema.model_validate(raw)
+ assert len(schema.conditional_formatting) == 1
+ rule = schema.conditional_formatting[0]
+ assert rule.operator == "between"
+ assert rule.color_key == "blue"
+ assert rule.bold is False
+ dumped = schema.model_dump()
+ assert dumped["conditional_formatting"][0]["value"] == "10,20"
+
+
+def test_rule_model_rejects_invalid_operator_directly() -> None:
+ """ConditionalFormatRule rejects invalid operator at construction."""
+ with pytest.raises(ValidationError):
+ ConditionalFormatRule(
+ field_id="f1",
+ operator="starts-with", # type: ignore[arg-type]
+ value="v",
+ color_key="red",
+ )
+
+
+def test_rule_model_rejects_invalid_color_key_directly() -> None:
+ """ConditionalFormatRule rejects invalid color_key at construction."""
+ with pytest.raises(ValidationError):
+ ConditionalFormatRule(
+ field_id="f1",
+ operator="equals",
+ value="v",
+ color_key="pink", # type: ignore[arg-type]
+ )
+
+
+def test_constants_match_spec() -> None:
+ """7 operators + 8 color keys (spec invariant)."""
+ assert len(ALL_OPERATORS) == 7
+ assert len(ALL_COLOR_KEYS) == 8
+
+
+# ---------------------------------------------------------------------------
+# 2. Route-level 422 — uses a fake service (no DB)
+# ---------------------------------------------------------------------------
+
+
+def _make_fake_view(view_id: str = "v1", table_id: str = "t1") -> View:
+ return View(
+ id=view_id,
+ table_id=table_id,
+ name="Test View",
+ view_type=ViewType.grid,
+ config={},
+ )
+
+
+class _FakeService:
+ """Minimal service stub — same shape as test_grouping.py's stub."""
+
+ def __init__(self, *, existing_view: View | None = None) -> None:
+ self._existing = existing_view
+
+ async def get_view(self, view_id: str) -> View | None:
+ if self._existing is None or self._existing.id != view_id:
+ return None
+ return self._existing
+
+ async def get_table(self, table_id: str) -> Any:
+ class _T:
+ owner_user_id = TEST_USER_ID
+
+ return _T()
+
+ async def update_view(self, view_id: str, **kwargs: object) -> View | None:
+ if self._existing is None:
+ return None
+ config = kwargs.get("config")
+ if isinstance(config, dict):
+ self._existing = self._existing.model_copy(update={"config": config})
+ return self._existing
+
+
+@pytest.fixture
+def fake_service_app() -> FastAPI:
+ app = FastAPI()
+ app.state.bitable_service = _FakeService(existing_view=_make_fake_view())
+ app.include_router(bitable_routes.router, prefix="/api/v1")
+ app.dependency_overrides[require_bitable_auth] = lambda: {
+ "user_id": TEST_USER_ID,
+ "username": "testuser",
+ "role": "member",
+ }
+ return app
+
+
+@pytest.fixture
+async def fake_client(fake_service_app: FastAPI) -> httpx.AsyncClient:
+ transport = ASGITransport(app=fake_service_app)
+ async with httpx.AsyncClient(transport=transport, base_url="http://test") as c:
+ yield c
+
+
+async def test_patch_view_with_valid_cf_returns_200(
+ fake_client: httpx.AsyncClient,
+) -> None:
+ """Valid conditional_formatting is accepted and persisted."""
+ config = {
+ "conditional_formatting": [
+ {
+ "field_id": "f1",
+ "operator": "equals",
+ "value": "done",
+ "color_key": "green",
+ }
+ ]
+ }
+ resp = await fake_client.patch(
+ "/api/v1/bitable/views/v1",
+ json={"config": config},
+ )
+ assert resp.status_code == 200, resp.text
+ body = resp.json()
+ assert body["view"]["config"]["conditional_formatting"] == config["conditional_formatting"]
+
+
+async def test_patch_view_with_invalid_operator_returns_422(
+ fake_client: httpx.AsyncClient,
+) -> None:
+ """Invalid operator returns 422."""
+ resp = await fake_client.patch(
+ "/api/v1/bitable/views/v1",
+ json={
+ "config": {
+ "conditional_formatting": [
+ {"field_id": "f1", "operator": "starts-with", "value": "x", "color_key": "red"}
+ ]
+ }
+ },
+ )
+ assert resp.status_code == 422
+
+
+async def test_patch_view_with_invalid_color_key_returns_422(
+ fake_client: httpx.AsyncClient,
+) -> None:
+ """Invalid color_key returns 422."""
+ resp = await fake_client.patch(
+ "/api/v1/bitable/views/v1",
+ json={
+ "config": {
+ "conditional_formatting": [
+ {"field_id": "f1", "operator": "equals", "value": "x", "color_key": "pink"}
+ ]
+ }
+ },
+ )
+ assert resp.status_code == 422
+
+
+async def test_patch_view_with_missing_field_id_returns_422(
+ fake_client: httpx.AsyncClient,
+) -> None:
+ """Missing field_id in a CF rule returns 422."""
+ resp = await fake_client.patch(
+ "/api/v1/bitable/views/v1",
+ json={
+ "config": {
+ "conditional_formatting": [{"operator": "equals", "value": "x", "color_key": "red"}]
+ }
+ },
+ )
+ assert resp.status_code == 422
+
+
+# ---------------------------------------------------------------------------
+# 3. Round-trip via real PG — skipped if PG unavailable
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.postgres
+async def test_round_trip_conditional_formatting_via_real_service(bitable_service) -> None:
+ """PATCH config with conditional_formatting → GET view returns same."""
+ from agentkit.bitable.service import BitableService
+
+ assert isinstance(bitable_service, BitableService)
+ table = await bitable_service.create_table(name="U5 CF Round-Trip")
+ view = await bitable_service.create_view(table.id, name="V1")
+
+ cf_rules = [
+ {
+ "field_id": "f1",
+ "operator": "equals",
+ "value": "done",
+ "color_key": "green",
+ "bold": True,
+ "enabled": True,
+ },
+ {
+ "field_id": "f2",
+ "operator": "between",
+ "value": "10,20",
+ "color_key": "blue",
+ "bold": False,
+ "enabled": False,
+ },
+ ]
+ config = {"conditional_formatting": cf_rules}
+ validate_view_config(config)
+ updated = await bitable_service.update_view(view.id, config=config)
+ assert updated is not None
+ assert updated.config.get("conditional_formatting") == cf_rules
+
+ fetched = await bitable_service.get_view(view.id)
+ assert fetched is not None
+ assert fetched.config.get("conditional_formatting") == cf_rules
diff --git a/tests/unit/bitable/test_grouping.py b/tests/unit/bitable/test_grouping.py
new file mode 100644
index 0000000..77e3dd4
--- /dev/null
+++ b/tests/unit/bitable/test_grouping.py
@@ -0,0 +1,319 @@
+"""Tests for bitable view config grouping validation (U5 / R4).
+
+Layered tests:
+1. Pure Pydantic validation via ``validate_view_config`` (no DB needed — always runs)
+2. Route-level 422 via a mocked BitableService (no DB needed — always runs)
+3. Round-trip via real PG service (skipped if PG unavailable)
+
+The validator lives in ``agentkit.bitable.view_config`` and is called from
+the PATCH /views route before ``service.update_view`` is invoked.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+import pytest
+from fastapi import FastAPI
+from httpx import ASGITransport
+from pydantic import ValidationError
+
+from agentkit.bitable.models import View, ViewType
+from agentkit.bitable.view_config import (
+ MAX_GROUP_BY_FIELDS,
+ GroupByItem,
+ ViewConfigSchema,
+ ViewConfigValidationError,
+ validate_view_config,
+)
+from agentkit.server.routes import bitable as bitable_routes
+from agentkit.server.routes.bitable import require_bitable_auth
+
+TEST_USER_ID = "test-user-id"
+
+
+# ---------------------------------------------------------------------------
+# 1. Pure Pydantic validation — always runs (no DB)
+# ---------------------------------------------------------------------------
+
+
+def _gb(field_id: str, direction: str = "asc") -> dict[str, str]:
+ return {"field_id": field_id, "direction": direction}
+
+
+def test_validate_accepts_empty_config() -> None:
+ """Empty / None config is valid (no group_by to check)."""
+ validate_view_config(None)
+ validate_view_config({})
+ validate_view_config({"filters": []}) # non-U5 keys ignored
+
+
+def test_validate_accepts_one_to_three_group_by_fields() -> None:
+ """Spec: max 3 levels. 1, 2, 3 all accepted."""
+ for n in (1, 2, 3):
+ config = {"group_by": [_gb(f"f{i}") for i in range(n)]}
+ validate_view_config(config) # no raise
+
+
+def test_validate_rejects_more_than_three_group_by_fields() -> None:
+ """group_by with >3 fields raises ValidationError (422 at the route)."""
+ config = {"group_by": [_gb(f"f{i}") for i in range(MAX_GROUP_BY_FIELDS + 1)]}
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_rejects_invalid_direction() -> None:
+ """direction must be 'asc' or 'desc' (Literal)."""
+ config = {"group_by": [_gb("f1", "sideways")]}
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_rejects_missing_field_id() -> None:
+ """field_id is required."""
+ config = {"group_by": [{"direction": "asc"}]}
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_rejects_empty_field_id() -> None:
+ """field_id must be non-empty (min_length=1)."""
+ config = {"group_by": [_gb("")]}
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_rejects_extra_keys_in_group_by_item() -> None:
+ """extra='forbid' on GroupByItem — unknown keys rejected."""
+ config = {"group_by": [{"field_id": "f1", "direction": "asc", "color": "red"}]}
+ with pytest.raises(ViewConfigValidationError):
+ validate_view_config(config)
+
+
+def test_validate_defaults_direction_to_asc() -> None:
+ """direction is optional, defaults to 'asc'."""
+ item = GroupByItem(field_id="f1")
+ assert item.direction == "asc"
+
+
+def test_validate_passes_through_non_u5_keys() -> None:
+ """filters / sort / hidden_fields are NOT validated here — pass through."""
+ config = {
+ "filters": [{"field_id": "f1", "op": "weird-op", "value": None}],
+ "sort": {"field": "f1", "order": "asc"},
+ "hidden_fields": ["f2"],
+ "group_by": [_gb("f1")],
+ }
+ validate_view_config(config) # no raise — non-U5 keys ignored
+
+
+def test_schema_max_length_constant() -> None:
+ """MAX_GROUP_BY_FIELDS is 3 (matches spec / Feishu / Twenty UX)."""
+ assert MAX_GROUP_BY_FIELDS == 3
+
+
+def test_schema_round_trips_through_model() -> None:
+ """ViewConfigSchema.model_validate round-trips a valid config."""
+ raw = {
+ "group_by": [{"field_id": "f1", "direction": "asc"}],
+ "conditional_formatting": [],
+ }
+ schema = ViewConfigSchema.model_validate(raw)
+ assert len(schema.group_by) == 1
+ assert schema.group_by[0].field_id == "f1"
+ dumped = schema.model_dump()
+ assert dumped["group_by"][0]["direction"] == "asc"
+
+
+def test_validation_error_carries_structured_errors() -> None:
+ """ViewConfigValidationError.errors is the Pydantic error list (for 422 body)."""
+ config = {"group_by": [_gb("")]}
+ with pytest.raises(ViewConfigValidationError) as exc_info:
+ validate_view_config(config)
+ assert isinstance(exc_info.value.errors, list)
+ assert len(exc_info.value.errors) > 0
+
+
+def test_validation_error_is_value_error_subclass() -> None:
+ """Subclasses ValueError so existing handlers pick it up."""
+ config = {"group_by": [_gb("")]}
+ with pytest.raises(ValueError):
+ validate_view_config(config)
+
+
+# ---------------------------------------------------------------------------
+# 2. Route-level 422 — uses a fake service (no DB needed)
+# ---------------------------------------------------------------------------
+
+
+def _make_fake_view(view_id: str = "v1", table_id: str = "t1") -> View:
+ return View(
+ id=view_id,
+ table_id=table_id,
+ name="Test View",
+ view_type=ViewType.grid,
+ config={},
+ )
+
+
+class _FakeService:
+ """Minimal service stub for route-level tests.
+
+ Only implements the methods the PATCH /views route touches:
+ ``get_view`` (existence + ownership check) and ``update_view``.
+ """
+
+ def __init__(self, *, existing_view: View | None = None) -> None:
+ self._existing = existing_view
+ self.updated_config: dict[str, object] | None = None
+ self.update_called = False
+
+ async def get_view(self, view_id: str) -> View | None:
+ if self._existing is None or self._existing.id != view_id:
+ return None
+ return self._existing
+
+ async def get_table(self, table_id: str) -> Any:
+ # Ownership check passes — return a table owned by the test user.
+ class _T:
+ owner_user_id = TEST_USER_ID
+
+ return _T()
+
+ async def update_view(self, view_id: str, **kwargs: object) -> View | None:
+ self.update_called = True
+ self.updated_config = kwargs.get("config") # type: ignore[assignment]
+ if self._existing is None:
+ return None
+ config = kwargs.get("config")
+ if isinstance(config, dict):
+ self._existing = self._existing.model_copy(update={"config": config})
+ return self._existing
+
+
+@pytest.fixture
+def fake_service_app() -> FastAPI:
+ """App with a fake service on state — bypasses PG entirely."""
+ app = FastAPI()
+ app.state.bitable_service = _FakeService(existing_view=_make_fake_view())
+ app.include_router(bitable_routes.router, prefix="/api/v1")
+ app.dependency_overrides[require_bitable_auth] = lambda: {
+ "user_id": TEST_USER_ID,
+ "username": "testuser",
+ "role": "member",
+ }
+ return app
+
+
+@pytest.fixture
+async def fake_client(fake_service_app: FastAPI) -> httpx.AsyncClient:
+ transport = ASGITransport(app=fake_service_app)
+ async with httpx.AsyncClient(transport=transport, base_url="http://test") as c:
+ yield c
+
+
+async def test_patch_view_with_valid_group_by_returns_200(
+ fake_client: httpx.AsyncClient,
+) -> None:
+ """Valid group_by is accepted and persisted (round-trip at the route layer)."""
+ config = {"group_by": [{"field_id": "f1", "direction": "asc"}]}
+ resp = await fake_client.patch(
+ "/api/v1/bitable/views/v1",
+ json={"config": config},
+ )
+ assert resp.status_code == 200, resp.text
+ body = resp.json()
+ assert body["success"] is True
+ assert body["view"]["config"]["group_by"] == config["group_by"]
+
+
+async def test_patch_view_with_too_many_group_by_returns_422(
+ fake_client: httpx.AsyncClient,
+) -> None:
+ """group_by with >3 fields returns 422 (not 500)."""
+ config = {"group_by": [{"field_id": f"f{i}"} for i in range(4)]}
+ resp = await fake_client.patch(
+ "/api/v1/bitable/views/v1",
+ json={"config": config},
+ )
+ assert resp.status_code == 422
+ body = resp.json()
+ assert "errors" in body["detail"]
+
+
+async def test_patch_view_with_invalid_direction_returns_422(
+ fake_client: httpx.AsyncClient,
+) -> None:
+ """Invalid direction value returns 422."""
+ resp = await fake_client.patch(
+ "/api/v1/bitable/views/v1",
+ json={"config": {"group_by": [{"field_id": "f1", "direction": "sideways"}]}},
+ )
+ assert resp.status_code == 422
+
+
+async def test_patch_view_with_non_u5_config_returns_200(
+ fake_client: httpx.AsyncClient,
+) -> None:
+ """Non-U5 config keys (filters / sort / hidden_fields) pass through unchanged."""
+ resp = await fake_client.patch(
+ "/api/v1/bitable/views/v1",
+ json={"config": {"hidden_fields": ["f1", "f2"]}},
+ )
+ assert resp.status_code == 200, resp.text
+
+
+# ---------------------------------------------------------------------------
+# 3. Round-trip via real PG — skipped if PG unavailable
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.postgres
+async def test_round_trip_group_by_via_real_service(bitable_service) -> None:
+ """PATCH config with group_by → GET view returns same group_by.
+
+ Requires PostgreSQL. Verifies the config dict survives the JSONB
+ round-trip and the route-layer validation does not strip fields.
+ """
+ from agentkit.bitable.service import BitableService
+
+ assert isinstance(bitable_service, BitableService)
+ table = await bitable_service.create_table(name="U5 Round-Trip")
+ view = await bitable_service.create_view(table.id, name="V1")
+
+ config = {
+ "group_by": [
+ {"field_id": "f1", "direction": "asc"},
+ {"field_id": "f2", "direction": "desc"},
+ ],
+ }
+ # Validator accepts the config (no exception).
+ validate_view_config(config)
+ # Service persists it as-is.
+ updated = await bitable_service.update_view(view.id, config=config)
+ assert updated is not None
+ assert updated.config.get("group_by") == config["group_by"]
+
+ # GET view returns the same group_by.
+ fetched = await bitable_service.get_view(view.id)
+ assert fetched is not None
+ assert fetched.config.get("group_by") == config["group_by"]
+
+
+# ---------------------------------------------------------------------------
+# Direct schema construction (covers Literal type errors at the model layer)
+# ---------------------------------------------------------------------------
+
+
+def test_group_by_item_rejects_invalid_direction_via_model() -> None:
+ """Constructing GroupByItem with an invalid direction raises ValidationError."""
+ with pytest.raises(ValidationError):
+ GroupByItem(field_id="f1", direction="sideways") # type: ignore[arg-type]
+
+
+def test_view_config_schema_max_length_enforced() -> None:
+ """ViewConfigSchema.group_by max_length=3 enforced at the model level."""
+ too_many = [{"field_id": f"f{i}"} for i in range(MAX_GROUP_BY_FIELDS + 1)]
+ with pytest.raises(ValidationError):
+ ViewConfigSchema.model_validate({"group_by": too_many})
diff --git a/tests/unit/bitable/test_routes.py b/tests/unit/bitable/test_routes.py
index 8b4e09d..84cd239 100644
--- a/tests/unit/bitable/test_routes.py
+++ b/tests/unit/bitable/test_routes.py
@@ -53,6 +53,23 @@ def unauth_app(bitable_service: BitableService) -> FastAPI:
return app
+INTERNAL_TOKEN = "internal-token-routes-abc"
+
+
+@pytest.fixture
+def internal_app(bitable_service: BitableService) -> FastAPI:
+ """App with X-Internal-Token configured and NO auth override.
+
+ Exercises the real ``require_bitable_auth`` path: the internal token
+ yields a synthetic admin user that bypasses ownership (KTD11).
+ """
+ app = FastAPI()
+ app.state.bitable_service = bitable_service
+ app.state.bitable_internal_token = INTERNAL_TOKEN
+ app.include_router(bitable_routes.router, prefix="/api/v1")
+ return app
+
+
@pytest.fixture
def no_service_app() -> FastAPI:
"""App without bitable_service on state — simulates uninitialized subsystem."""
@@ -77,6 +94,18 @@ async def unauth_client(unauth_app: FastAPI) -> httpx.AsyncClient:
yield c
+@pytest.fixture
+async def internal_client(internal_app: FastAPI) -> httpx.AsyncClient:
+ """Client that sends X-Internal-Token (real auth path, no override)."""
+ transport = ASGITransport(app=internal_app)
+ async with httpx.AsyncClient(
+ transport=transport,
+ base_url="http://test",
+ headers={"X-Internal-Token": INTERNAL_TOKEN},
+ ) as c:
+ yield c
+
+
@pytest.fixture
async def no_service_client(no_service_app: FastAPI) -> httpx.AsyncClient:
transport = ASGITransport(app=no_service_app)
@@ -497,6 +526,86 @@ async def test_update_view(client: httpx.AsyncClient) -> None:
assert resp.json()["view"]["name"] == "New"
+# ---------------------------------------------------------------------------
+# DELETE /views/{view_id} (U6)
+# ---------------------------------------------------------------------------
+
+
+async def test_delete_view_success(client: httpx.AsyncClient) -> None:
+ """DELETE an existing view with >=2 views → 204 No Content."""
+ table_id = (await client.post("/api/v1/bitable/tables", json={"name": "T"})).json()["table"][
+ "id"
+ ]
+ # Create 2 views so the last-view protection does not trigger.
+ v1 = (
+ await client.post(f"/api/v1/bitable/tables/{table_id}/views", json={"name": "v1"})
+ ).json()["view"]["id"]
+ await client.post(f"/api/v1/bitable/tables/{table_id}/views", json={"name": "v2"})
+ resp = await client.delete(f"/api/v1/bitable/views/{v1}")
+ assert resp.status_code == 204
+ assert resp.content == b""
+ # Confirm it's gone.
+ views = (await client.get(f"/api/v1/bitable/tables/{table_id}/views")).json()["views"]
+ assert all(v["id"] != v1 for v in views)
+
+
+async def test_delete_view_404_when_missing(client: httpx.AsyncClient) -> None:
+ """DELETE a non-existent view → 404."""
+ resp = await client.delete("/api/v1/bitable/views/nonexistent-view-id")
+ assert resp.status_code == 404
+
+
+async def test_delete_view_404_when_not_owner(
+ client: httpx.AsyncClient, bitable_service: BitableService
+) -> None:
+ """DELETE a view on a table owned by another user → 404 (not 403).
+
+ Pattern 4 (IDOR): existence is never disclosed to a non-owner.
+ """
+ # Table owned by a different user.
+ other_table = await bitable_service.create_table(name="Other", owner_user_id="other-user")
+ view = await bitable_service.create_view(other_table.id, name="v")
+ resp = await client.delete(f"/api/v1/bitable/views/{view.id}")
+ assert resp.status_code == 404
+
+
+async def test_delete_view_409_when_last_view(client: httpx.AsyncClient) -> None:
+ """DELETE the last remaining view of a table → 409 Conflict."""
+ table_id = (await client.post("/api/v1/bitable/tables", json={"name": "T"})).json()["table"][
+ "id"
+ ]
+ only_view = (
+ await client.post(f"/api/v1/bitable/tables/{table_id}/views", json={"name": "only"})
+ ).json()["view"]["id"]
+ resp = await client.delete(f"/api/v1/bitable/views/{only_view}")
+ assert resp.status_code == 409
+ # The view is still present.
+ views = (await client.get(f"/api/v1/bitable/tables/{table_id}/views")).json()["views"]
+ assert len(views) == 1
+
+
+async def test_delete_view_internal_token_passthrough(internal_client: httpx.AsyncClient) -> None:
+ """X-Internal-Token bypasses ownership: DELETE succeeds on another user's table."""
+ # Create a table as the internal admin user; ownership is bypassed.
+ table_id = (
+ await internal_client.post("/api/v1/bitable/tables", json={"name": "InternalT"})
+ ).json()["table"]["id"]
+ v1 = (
+ await internal_client.post(f"/api/v1/bitable/tables/{table_id}/views", json={"name": "v1"})
+ ).json()["view"]["id"]
+ await internal_client.post(f"/api/v1/bitable/tables/{table_id}/views", json={"name": "v2"})
+ resp = await internal_client.delete(f"/api/v1/bitable/views/{v1}")
+ assert resp.status_code == 204
+
+
+async def test_delete_view_internal_token_404_when_missing(
+ internal_client: httpx.AsyncClient,
+) -> None:
+ """X-Internal-Token still gets 404 for a non-existent view (no silent success)."""
+ resp = await internal_client.delete("/api/v1/bitable/views/does-not-exist")
+ assert resp.status_code == 404
+
+
# ---------------------------------------------------------------------------
# Formula validation (U5b)
# ---------------------------------------------------------------------------