diff --git a/app/bot/routers/commit.py b/app/bot/routers/commit.py
index 7864a17..866f8ee 100644
--- a/app/bot/routers/commit.py
+++ b/app/bot/routers/commit.py
@@ -1,20 +1,39 @@
-"""«📝 Коммит»: browsing the uploads repo tree with buttons (SPEC C-1…C-4). Changes and push — #26, #9."""
+"""«📝 Коммит»: browse the uploads repo tree and collect changes into a draft (SPEC C-1…C-16). Push — #9."""
+import base64
import html
+import io
import logging
+from dataclasses import dataclass
from enum import StrEnum
from typing import Any
-from aiogram import F, Router
+from aiogram import Bot, F, Router
from aiogram.enums import ParseMode
from aiogram.filters.callback_data import CallbackData
from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
from aiogram.types import BufferedInputFile, CallbackQuery, InlineKeyboardMarkup, Message
from aiogram.utils.keyboard import InlineKeyboardBuilder
from app.bot.menu import Nav, NavAction
+from app.db.models import ChangeOp, User
+from app.repo.drafts import DraftFull, DraftService, DraftView
from app.repo.git import Entry, GitError, UploadsRepo
-from app.texts import Texts
+from app.repo.publisher import Publisher, PushResult, PushStatus
+from app.repo.validate import (
+ MAX_FILE_BYTES,
+ ValidationError,
+ check_content,
+ check_message,
+ check_name,
+ diff_stat,
+ is_protected,
+ join,
+ python_syntax,
+ strip_fence,
+)
+from app.texts import CommitTexts, Texts
log = logging.getLogger(__name__)
@@ -32,6 +51,14 @@ class Act(StrEnum):
DELETE = "d"
NEW_FILE = "f"
NEW_DIR = "n"
+ DRAFT = "dr"
+ UNSTAGE = "x"
+ FORCE = "y"
+ FIX = "z"
+ MESSAGE = "m"
+ PUSH = "ps"
+ PUSH_GO = "pg"
+ PUSH_FORCE = "pf"
class CommitCb(CallbackData, prefix="c"):
@@ -40,6 +67,35 @@ class CommitCb(CallbackData, prefix="c"):
i: int = 0
+class Flow(StatesGroup):
+ file_name = State()
+ dir_name = State()
+ content = State()
+ syntax = State()
+ message = State()
+
+
+class Mark(StrEnum):
+ NONE = ""
+ NEW = "new"
+ MODIFIED = "mod"
+ DELETED = "del"
+
+
+@dataclass(frozen=True)
+class Row:
+ """A line of the directory screen: a repo entry with the draft laid over it."""
+
+ path: str
+ kind: str
+ size: int
+ mark: Mark
+
+ @property
+ def name(self) -> str:
+ return self.path.rsplit("/", 1)[-1]
+
+
def human_size(n: int) -> str:
size = float(n)
for unit in ("Б", "КБ", "МБ"):
@@ -53,26 +109,61 @@ def parent(path: str) -> str:
return path.rsplit("/", 1)[0] if "/" in path else ""
-def render_dir(texts: Texts, path: str, entries: list[Entry], page: int) -> tuple[str, InlineKeyboardMarkup]:
+def overlay(path: str, entries: list[Entry], draft: DraftView | None, virtual_dirs: list[str]) -> list[Row]:
+ """Repo listing + what the draft adds, changes or deletes in this directory."""
+ changes = {c.path: c for c in draft.changes} if draft else {}
+ rows: dict[str, Row] = {}
+ for e in entries:
+ change = changes.get(e.path)
+ mark, size = Mark.NONE, e.size
+ if change is not None:
+ mark = Mark.DELETED if change.op is ChangeOp.DELETE else Mark.MODIFIED
+ if change.content is not None:
+ size = len(change.content) # show the size the file will have after the push
+ rows[e.path] = Row(e.path, e.kind, size, mark)
+ prefix = f"{path}/" if path else ""
+ for change in changes.values():
+ if change.op is not ChangeOp.ADD or not change.path.startswith(prefix):
+ continue
+ rest = change.path[len(prefix) :]
+ if "/" in rest: # a file deeper down: show its top folder here
+ sub = prefix + rest.split("/", 1)[0]
+ rows.setdefault(sub, Row(sub, "dir", 0, Mark.NEW))
+ else:
+ rows[change.path] = Row(change.path, "file", len(change.content or b""), Mark.NEW)
+ for vd in virtual_dirs:
+ if parent(vd) == path:
+ rows.setdefault(vd, Row(vd, "dir", 0, Mark.NEW))
+ return sorted(rows.values(), key=lambda r: (r.kind != "dir", r.name.lower()))
+
+
+def mark_prefix(t: CommitTexts, mark: Mark) -> str:
+ return {Mark.NONE: "", Mark.NEW: t.mark_new, Mark.MODIFIED: t.mark_modified, Mark.DELETED: t.mark_deleted}[mark]
+
+
+def render_dir(
+ texts: Texts, path: str, rows: list[Row], page: int, draft_count: int
+) -> tuple[str, InlineKeyboardMarkup]:
t = texts.commit
- pages = max(1, -(-len(entries) // PAGE_SIZE))
+ pages = max(1, -(-len(rows) // PAGE_SIZE))
page = min(max(page, 0), pages - 1)
lines = [t.title.format(path=path)]
- if not entries:
+ if not rows:
lines.append(t.empty)
elif pages > 1:
lines.append(t.page.format(page=page + 1, pages=pages))
kb = InlineKeyboardBuilder()
start = page * PAGE_SIZE
- for index, e in enumerate(entries[start : start + PAGE_SIZE], start=start):
- label = (
- t.dir_button.format(name=e.name)
- if e.kind == "dir"
- else t.file_button.format(name=e.name, size=human_size(e.size))
+ shown = rows[start : start + PAGE_SIZE]
+ for index, r in enumerate(shown, start=start):
+ base = (
+ t.dir_button.format(name=r.name)
+ if r.kind == "dir"
+ else t.file_button.format(name=r.name, size=human_size(r.size))
)
- kb.button(text=label, callback_data=CommitCb(a=Act.OPEN, i=index))
- sizes = [1] * min(PAGE_SIZE, max(0, len(entries) - start))
+ kb.button(text=mark_prefix(t, r.mark) + base, callback_data=CommitCb(a=Act.OPEN, i=index))
+ sizes = [1] * len(shown)
paging: list[tuple[str, CommitCb]] = []
if page > 0:
@@ -87,6 +178,9 @@ def render_dir(texts: Texts, path: str, entries: list[Entry], page: int) -> tupl
kb.button(text=t.new_file, callback_data=CommitCb(a=Act.NEW_FILE))
kb.button(text=t.new_dir, callback_data=CommitCb(a=Act.NEW_DIR))
sizes.append(2)
+ if draft_count:
+ kb.button(text=t.draft_button.format(count=draft_count), callback_data=CommitCb(a=Act.DRAFT))
+ sizes.append(1)
if path:
kb.button(text=t.up, callback_data=CommitCb(a=Act.UP))
sizes.append(1)
@@ -108,80 +202,106 @@ def file_keyboard(texts: Texts) -> InlineKeyboardMarkup:
return kb.as_markup()
-def build_router(texts: Texts, repo: UploadsRepo) -> Router:
+def to_dir_keyboard(texts: Texts) -> InlineKeyboardMarkup:
+ kb = InlineKeyboardBuilder()
+ kb.button(text=texts.commit.to_dir, callback_data=CommitCb(a=Act.TO_DIR))
+ return kb.as_markup()
+
+
+def build_router(
+ texts: Texts, repo: UploadsRepo, drafts: DraftService, publisher: Publisher, commit_url_template: str = ""
+) -> Router:
router = Router(name="commit")
t = texts.commit
- async def show_dir(message: Message, state: FSMContext, path: str, page: int, *, edit: bool) -> None:
- entries = await repo.list_dir(path)
+ async def dir_screen(state: FSMContext, user_id: int, path: str, page: int) -> tuple[str, InlineKeyboardMarkup]:
+ data = await state.get_data()
+ virtual: list[str] = data.get("commit_virtual", [])
+ draft = await drafts.get(user_id)
+ try:
+ entries = await repo.list_dir(path)
+ except GitError:
+ # a folder that exists only in the draft (or a virtual one) has nothing in the repo yet
+ if path not in virtual and not (draft and any(c.path.startswith(f"{path}/") for c in draft.changes)):
+ raise
+ entries = []
+ rows = overlay(path, entries, draft, virtual)
await state.update_data(
commit_path=path,
commit_page=page,
- commit_entries=[[e.path, e.kind, e.size] for e in entries],
+ commit_rows=[[r.path, r.kind, r.size, r.mark.value] for r in rows],
commit_file=None,
)
- text, kb = render_dir(texts, path, entries, page)
- if edit:
- await message.edit_text(text, reply_markup=kb)
+ return render_dir(texts, path, rows, page, len(draft.changes) if draft else 0)
+
+ async def draft_screen(state: FSMContext, user_id: int) -> tuple[str, InlineKeyboardMarkup]:
+ draft = await drafts.get(user_id)
+ changes = draft.changes if draft else []
+ await state.update_data(commit_draft=[c.path for c in changes])
+ kb = InlineKeyboardBuilder()
+ if not changes:
+ text = t.draft_empty
else:
- await message.answer(text, reply_markup=kb)
+ ops = {ChangeOp.ADD: t.op_add, ChangeOp.MODIFY: t.op_modify, ChangeOp.DELETE: t.op_delete}
+ lines = [t.draft_title.format(count=len(changes)), ""]
+ lines += [f"{ops[c.op]} /{c.path}" for c in changes]
+ message = draft.message if draft else None
+ lines += ["", t.message_current.format(message=message) if message else t.message_missing]
+ text = "\n".join(lines)
+ for i, c in enumerate(changes):
+ kb.button(
+ text=t.unstage.format(name=c.path.rsplit("/", 1)[-1]), callback_data=CommitCb(a=Act.UNSTAGE, i=i)
+ )
+ if changes:
+ kb.button(text=t.message_button, callback_data=CommitCb(a=Act.MESSAGE))
+ if draft and draft.message:
+ kb.button(text=t.push_button, callback_data=CommitCb(a=Act.PUSH))
+ kb.button(text=t.to_dir, callback_data=CommitCb(a=Act.TO_DIR))
+ kb.adjust(1)
+ return text, kb.as_markup()
- @router.message(F.text == texts.menu.commit)
- async def open_commit(message: Message, state: FSMContext) -> None:
- await state.clear()
- try:
- await repo.refresh()
- await show_dir(message, state, "", 0, edit=False)
- except GitError:
- log.exception("uploads repo unavailable")
- await message.answer(t.unavailable)
+ def summary(draft: DraftView) -> str:
+ ops = {ChangeOp.ADD: t.op_add, ChangeOp.MODIFY: t.op_modify, ChangeOp.DELETE: t.op_delete}
+ return "\n".join(f"{ops[c.op]} /{c.path}" for c in draft.changes)
- @router.callback_query(CommitCb.filter())
- async def on_action(query: CallbackQuery, callback_data: CommitCb, state: FSMContext) -> None:
- if not isinstance(query.message, Message):
- await query.answer()
+ async def do_push(msg: Message, state: FSMContext, member: User, *, overwrite: bool) -> None:
+ draft = await drafts.get(member.tg_id)
+ if draft is None or not draft.changes or not draft.message:
+ text, kb = await draft_screen(state, member.tg_id)
+ await msg.edit_text(text, reply_markup=kb)
return
- msg = query.message
- data: dict[str, Any] = await state.get_data()
- path: str = data.get("commit_path", "")
- entries: list[list[Any]] = data.get("commit_entries", [])
- try:
- match callback_data.a:
- case Act.OPEN:
- if not 0 <= callback_data.i < len(entries):
- await query.answer() # stale button from an older screen
- return
- target, kind, size = entries[callback_data.i]
- if kind == "dir":
- await repo.refresh()
- await show_dir(msg, state, target, 0, edit=True)
- else:
- await state.update_data(commit_file=target)
- await msg.edit_text(await file_card(target, size), reply_markup=file_keyboard(texts))
- case Act.UP:
- await show_dir(msg, state, parent(path), 0, edit=True)
- case Act.PAGE:
- await state.update_data(commit_page=callback_data.i)
- real = [Entry(p, k, s) for p, k, s in entries]
- text, kb = render_dir(texts, path, real, callback_data.i)
- await msg.edit_text(text, reply_markup=kb)
- case Act.TO_DIR:
- await show_dir(msg, state, path, data.get("commit_page", 0), edit=True)
- case Act.VIEW:
- file_path = data.get("commit_file")
- if file_path:
- await send_file(msg, file_path)
- case Act.REPLACE | Act.DELETE | Act.NEW_FILE | Act.NEW_DIR:
- await query.answer(t.soon, show_alert=True)
- return
- except GitError:
- log.exception("uploads repo unavailable")
- await query.answer(t.unavailable, show_alert=True)
- return
- await query.answer()
+ await msg.edit_text(t.pushing)
+ result: PushResult = await publisher.push(member, draft, draft.message, overwrite=overwrite)
+ match result.status:
+ case PushStatus.OK:
+ assert result.sha is not None
+ first_line = draft.message.splitlines()[0]
+ lines = [t.pushed.format(sha=result.sha[:7], message=first_line)]
+ if commit_url_template:
+ lines.append(commit_url_template.format(sha=result.sha))
+ lines.append(t.ci_pending)
+ await msg.edit_text("\n".join(lines))
+ await publisher.record(member, result, draft.message, draft, msg.chat.id, msg.message_id)
+ await drafts.clear(member.tg_id)
+ await state.update_data(commit_virtual=[])
+ case PushStatus.CONFLICT:
+ builder = InlineKeyboardBuilder()
+ builder.button(text=t.overwrite, callback_data=CommitCb(a=Act.PUSH_FORCE))
+ builder.button(text=texts.menu.cancel, callback_data=CommitCb(a=Act.DRAFT))
+ paths = "\n".join(f"/{p}" for p in result.conflicts)
+ await msg.edit_text(t.conflict.format(paths=paths), reply_markup=builder.as_markup())
+ case PushStatus.EMPTY:
+ await drafts.clear(member.tg_id)
+ await msg.edit_text(t.push_empty)
+ case PushStatus.LIMIT:
+ await msg.edit_text(t.push_limit, reply_markup=to_dir_keyboard(texts))
+ case PushStatus.FAILED:
+ await msg.edit_text(t.push_failed, reply_markup=to_dir_keyboard(texts))
- async def file_card(path: str, size: int) -> str:
+ async def file_card(user_id: int, path: str, size: int, mark: Mark) -> str:
card = t.file_card.format(path=path, size=human_size(size))
+ if mark is Mark.NEW:
+ return f"{card}\n{t.in_draft_new}"
info = await repo.last_commit(path)
tail = (
t.last_commit.format(
@@ -190,11 +310,21 @@ def build_router(texts: Texts, repo: UploadsRepo) -> Router:
if info
else t.no_commits
)
- return f"{card}\n{tail}"
+ note = {Mark.MODIFIED: f"\n{t.in_draft_modified}", Mark.DELETED: f"\n{t.in_draft_deleted}"}.get(mark, "")
+ return f"{card}\n{tail}{note}"
- async def send_file(msg: Message, path: str) -> None:
- content = await repo.read(path)
- name = path.rsplit("/", 1)[-1]
+ async def current_content(user_id: int, path: str) -> bytes | None:
+ """What the member sees as the file now: the draft version if there is one."""
+ draft = await drafts.get(user_id)
+ change = draft.change_for(path) if draft else None
+ if change is not None:
+ return change.content # None for a deleted file
+ return await repo.read(path)
+
+ async def send_file(msg: Message, user_id: int, path: str) -> None:
+ content = await current_content(user_id, path)
+ if content is None:
+ return
try:
text = content.decode("utf-8")
except UnicodeDecodeError:
@@ -202,6 +332,253 @@ def build_router(texts: Texts, repo: UploadsRepo) -> Router:
if text is not None and "\0" not in text and len(text) <= INLINE_VIEW_LIMIT:
await msg.answer(f"/{html.escape(path)}\n{html.escape(text)}", parse_mode=ParseMode.HTML)
else:
- await msg.answer_document(BufferedInputFile(content, name), caption=t.sent_as_file)
+ await msg.answer_document(BufferedInputFile(content, path.rsplit("/", 1)[-1]), caption=t.sent_as_file)
+
+ async def stage(message: Message, state: FSMContext, member: User, path: str, op: ChangeOp, content: bytes) -> None:
+ old = await current_content(member.tg_id, path) if op is ChangeOp.MODIFY else None
+ try:
+ await drafts.put(member.tg_id, await repo.head(), path, op, content)
+ except DraftFull:
+ await message.answer(t.draft_full)
+ return
+ if op is ChangeOp.ADD:
+ note = t.added.format(path=path)
+ else:
+ added, removed = diff_stat((old or b"").decode("utf-8", errors="replace"), content.decode("utf-8"))
+ note = t.modified.format(path=path, added=added, removed=removed)
+ data = await state.get_data()
+ # a virtual folder becomes real as soon as a file lands in it
+ virtual = [v for v in data.get("commit_virtual", []) if not path.startswith(f"{v}/")]
+ await state.set_state(None)
+ await state.update_data(commit_virtual=virtual, commit_pending=None)
+ text, kb = await dir_screen(state, member.tg_id, data.get("commit_path", ""), 0)
+ await message.answer(f"{note}\n\n{text}", reply_markup=kb)
+
+ # ---- entry point -------------------------------------------------------------------------------------------
+
+ @router.message(F.text == texts.menu.commit)
+ async def open_commit(message: Message, state: FSMContext, member: User) -> None:
+ await state.clear()
+ try:
+ await repo.refresh()
+ text, kb = await dir_screen(state, member.tg_id, "", 0)
+ except GitError:
+ log.exception("uploads repo unavailable")
+ await message.answer(t.unavailable)
+ return
+ await message.answer(text, reply_markup=kb)
+
+ # ---- buttons -----------------------------------------------------------------------------------------------
+
+ @router.callback_query(CommitCb.filter())
+ async def on_action(query: CallbackQuery, callback_data: CommitCb, state: FSMContext, member: User) -> None:
+ if not isinstance(query.message, Message):
+ await query.answer()
+ return
+ msg = query.message
+ data: dict[str, Any] = await state.get_data()
+ path: str = data.get("commit_path", "")
+ rows: list[list[Any]] = data.get("commit_rows", [])
+ uid = member.tg_id
+ try:
+ match callback_data.a:
+ case Act.OPEN:
+ if not 0 <= callback_data.i < len(rows):
+ await query.answer() # stale button from an older screen
+ return
+ target, kind, size, mark = rows[callback_data.i]
+ if kind == "dir":
+ await repo.refresh()
+ text, kb = await dir_screen(state, uid, target, 0)
+ await msg.edit_text(text, reply_markup=kb)
+ else:
+ await state.update_data(commit_file=target)
+ await msg.edit_text(
+ await file_card(uid, target, size, Mark(mark)), reply_markup=file_keyboard(texts)
+ )
+ case Act.UP:
+ text, kb = await dir_screen(state, uid, parent(path), 0)
+ await msg.edit_text(text, reply_markup=kb)
+ case Act.PAGE:
+ real = [Row(p, k, s, Mark(m)) for p, k, s, m in rows]
+ draft = await drafts.get(uid)
+ await state.update_data(commit_page=callback_data.i)
+ text, kb = render_dir(texts, path, real, callback_data.i, len(draft.changes) if draft else 0)
+ await msg.edit_text(text, reply_markup=kb)
+ case Act.TO_DIR:
+ await state.set_state(None)
+ text, kb = await dir_screen(state, uid, path, data.get("commit_page", 0))
+ await msg.edit_text(text, reply_markup=kb)
+ case Act.VIEW:
+ if data.get("commit_file"):
+ await send_file(msg, uid, data["commit_file"])
+ case Act.NEW_FILE:
+ await state.set_state(Flow.file_name)
+ await msg.edit_text(t.ask_file_name.format(dir=path), reply_markup=to_dir_keyboard(texts))
+ case Act.NEW_DIR:
+ await state.set_state(Flow.dir_name)
+ await msg.edit_text(t.ask_dir_name.format(dir=path), reply_markup=to_dir_keyboard(texts))
+ case Act.REPLACE:
+ target = data.get("commit_file")
+ if not target:
+ await query.answer()
+ return
+ if is_protected(target):
+ await query.answer(t.protected, show_alert=True)
+ return
+ await state.set_state(Flow.content)
+ await state.update_data(commit_target=target, commit_op=ChangeOp.MODIFY.value)
+ await msg.edit_text(t.ask_content.format(path=target), reply_markup=to_dir_keyboard(texts))
+ case Act.DELETE:
+ target = data.get("commit_file")
+ if not target:
+ await query.answer()
+ return
+ if is_protected(target):
+ await query.answer(t.protected, show_alert=True)
+ return
+ await drafts.put(uid, await repo.head(), target, ChangeOp.DELETE, None)
+ text, kb = await dir_screen(state, uid, path, data.get("commit_page", 0))
+ await msg.edit_text(f"{t.deleted.format(path=target)}\n\n{text}", reply_markup=kb)
+ case Act.DRAFT:
+ text, kb = await draft_screen(state, uid)
+ await msg.edit_text(text, reply_markup=kb)
+ case Act.UNSTAGE:
+ paths: list[str] = data.get("commit_draft", [])
+ if 0 <= callback_data.i < len(paths):
+ await drafts.drop(uid, paths[callback_data.i])
+ text, kb = await draft_screen(state, uid)
+ await msg.edit_text(text, reply_markup=kb)
+ case Act.FORCE:
+ pending = data.get("commit_pending")
+ if pending is None or await state.get_state() != Flow.syntax.state:
+ await query.answer()
+ return
+ await query.answer()
+ await stage(
+ msg,
+ state,
+ member,
+ data["commit_target"],
+ ChangeOp(data["commit_op"]),
+ base64.b64decode(pending),
+ )
+ return
+ case Act.MESSAGE:
+ await state.set_state(Flow.message)
+ await msg.edit_text(t.ask_message, reply_markup=to_dir_keyboard(texts))
+ case Act.PUSH:
+ draft = await drafts.get(uid)
+ if draft is None or not draft.changes or not draft.message:
+ await query.answer()
+ return
+ builder = InlineKeyboardBuilder()
+ builder.button(text=t.push_go, callback_data=CommitCb(a=Act.PUSH_GO))
+ builder.button(text=texts.menu.back, callback_data=CommitCb(a=Act.DRAFT))
+ confirm = t.push_confirm.format(summary=summary(draft), message=draft.message)
+ await msg.edit_text(confirm, reply_markup=builder.as_markup())
+ case Act.PUSH_GO | Act.PUSH_FORCE:
+ await query.answer()
+ await do_push(msg, state, member, overwrite=callback_data.a is Act.PUSH_FORCE)
+ return
+ case Act.FIX:
+ await state.set_state(Flow.content)
+ await state.update_data(commit_pending=None)
+ await msg.edit_text(
+ t.ask_content.format(path=data.get("commit_target", "")), reply_markup=to_dir_keyboard(texts)
+ )
+ except GitError:
+ log.exception("uploads repo unavailable")
+ await query.answer(t.unavailable, show_alert=True)
+ return
+ except DraftFull:
+ await query.answer(t.draft_full, show_alert=True)
+ return
+ await query.answer()
+
+ # ---- text input --------------------------------------------------------------------------------------------
+
+ @router.message(Flow.file_name, F.text)
+ async def got_file_name(message: Message, state: FSMContext, member: User) -> None:
+ data = await state.get_data()
+ directory = data.get("commit_path", "")
+ try:
+ name = check_name(message.text or "")
+ except ValidationError:
+ await message.answer(t.bad_name)
+ return
+ path = join(directory, name)
+ if is_protected(path):
+ await message.answer(t.protected)
+ return
+ taken = {row[0] for row in data.get("commit_rows", [])}
+ if path in taken:
+ await message.answer(t.exists)
+ return
+ await state.set_state(Flow.content)
+ await state.update_data(commit_target=path, commit_op=ChangeOp.ADD.value)
+ await message.answer(t.ask_content.format(path=path), reply_markup=to_dir_keyboard(texts))
+
+ @router.message(Flow.dir_name, F.text)
+ async def got_dir_name(message: Message, state: FSMContext, member: User) -> None:
+ data = await state.get_data()
+ directory = data.get("commit_path", "")
+ try:
+ name = check_name(message.text or "")
+ except ValidationError:
+ await message.answer(t.bad_name)
+ return
+ path = join(directory, name)
+ if is_protected(path + "/x"):
+ await message.answer(t.protected)
+ return
+ if path in {row[0] for row in data.get("commit_rows", [])}:
+ await message.answer(t.exists)
+ return
+ await state.set_state(None)
+ await state.update_data(commit_virtual=[*data.get("commit_virtual", []), path])
+ text, kb = await dir_screen(state, member.tg_id, path, 0)
+ await message.answer(text, reply_markup=kb)
+
+ @router.message(Flow.message, F.text)
+ async def got_message(message: Message, state: FSMContext, member: User) -> None:
+ try:
+ text = check_message(message.text or "")
+ except ValidationError:
+ await message.answer(t.bad_message)
+ return
+ await drafts.set_message(member.tg_id, text)
+ await state.set_state(None)
+ screen, kb = await draft_screen(state, member.tg_id)
+ await message.answer(screen, reply_markup=kb)
+
+ @router.message(Flow.content, F.text | F.document)
+ async def got_content(message: Message, state: FSMContext, member: User, bot: Bot) -> None:
+ data = await state.get_data()
+ target: str = data["commit_target"]
+ if message.document is not None:
+ if (message.document.file_size or 0) > MAX_FILE_BYTES:
+ await message.answer(t.too_big)
+ return
+ buf = io.BytesIO()
+ await bot.download(message.document, destination=buf)
+ raw = buf.getvalue()
+ else:
+ raw = strip_fence(message.text or "").encode("utf-8")
+ try:
+ text = check_content(raw)
+ except ValidationError as e:
+ await message.answer({"too_big": t.too_big, "binary": t.binary, "encoding": t.encoding}[str(e)])
+ return
+ issue = python_syntax(target, text)
+ if issue is not None:
+ await state.set_state(Flow.syntax)
+ await state.update_data(commit_pending=base64.b64encode(raw).decode())
+ kb = InlineKeyboardBuilder()
+ kb.button(text=t.fix, callback_data=CommitCb(a=Act.FIX))
+ kb.button(text=t.force, callback_data=CommitCb(a=Act.FORCE))
+ await message.answer(t.syntax.format(line=issue.line, message=issue.message), reply_markup=kb.as_markup())
+ return
+ await stage(message, state, member, target, ChangeOp(data["commit_op"]), raw)
return router
diff --git a/app/config.py b/app/config.py
index 0f0fe45..689f438 100644
--- a/app/config.py
+++ b/app/config.py
@@ -74,6 +74,8 @@ class GitSettings(BaseSettings):
# container user (uid 10001 vs the owner's 0600). Written to a private temp file at startup.
ssh_key_b64: SecretStr | None = None
branch: str = "main"
+ # Web link to a commit in the uploads repo, e.g. https://sourcecraft.dev/{repo}/commit/{sha}; empty — no link
+ commit_url_template: str = ""
clone_dir: Path = Path("data/uploads")
# Browsing re-fetches at most this often; a push always fetches first (#9)
fetch_interval: float = Field(default=10.0, ge=0)
diff --git a/app/main.py b/app/main.py
index 1be8a8e..789e390 100644
--- a/app/main.py
+++ b/app/main.py
@@ -17,20 +17,26 @@ from app.db.migrate import upgrade
from app.db.session import SessionMaker, make_engine, make_sessionmaker
from app.health import heartbeat
from app.logs_setup import setup_logging
+from app.repo.drafts import DraftService
from app.repo.git import UploadsRepo
+from app.repo.publisher import Publisher
from app.texts import Texts, load_texts
log = logging.getLogger("tgit")
-def build_dispatcher(texts: Texts, sessions: SessionMaker, access: AccessService, repo: UploadsRepo) -> Dispatcher:
+def build_dispatcher(
+ texts: Texts, sessions: SessionMaker, access: AccessService, repo: UploadsRepo, commit_url_template: str = ""
+) -> Dispatcher:
dp = Dispatcher(storage=make_storage(sessions))
gate = AccessMiddleware(access, texts)
# Outer middleware: runs before filters, so nothing — not even a stale button — reaches a handler unchecked.
dp.message.outer_middleware(gate)
dp.callback_query.outer_middleware(gate)
dp.include_router(members.build_router(texts, access))
- dp.include_router(commit.build_router(texts, repo))
+ dp.include_router(
+ commit.build_router(texts, repo, DraftService(sessions), Publisher(repo, sessions), commit_url_template)
+ )
dp.include_router(common.build_router(texts, access))
return dp
@@ -42,7 +48,7 @@ async def run(settings: Settings) -> None:
sessions = make_sessionmaker(engine)
access = AccessService(sessions, settings.access)
await access.bootstrap_admins()
- dp = build_dispatcher(texts, sessions, access, UploadsRepo(settings.git))
+ dp = build_dispatcher(texts, sessions, access, UploadsRepo(settings.git), settings.git.commit_url_template)
rt = settings.runtime
background = [
asyncio.create_task(heartbeat(rt.heartbeat_file, rt.heartbeat_interval)),
diff --git a/app/repo/drafts.py b/app/repo/drafts.py
new file mode 100644
index 0000000..81ca43e
--- /dev/null
+++ b/app/repo/drafts.py
@@ -0,0 +1,107 @@
+"""A member's draft: pending add/modify/delete changes until Push (SPEC C-14, C-15). One draft per member."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+
+from sqlalchemy import delete, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.db.models import ChangeOp, Draft, DraftChange, utcnow
+from app.db.session import SessionMaker
+
+MAX_CHANGES = 50
+
+
+class DraftFull(Exception):
+ pass
+
+
+@dataclass(frozen=True)
+class Change:
+ path: str
+ op: ChangeOp
+ content: bytes | None
+
+
+@dataclass(frozen=True)
+class DraftView:
+ base_sha: str
+ message: str | None
+ changes: list[Change]
+
+ def change_for(self, path: str) -> Change | None:
+ return next((c for c in self.changes if c.path == path), None)
+
+
+class DraftService:
+ def __init__(
+ self, sessions: SessionMaker, ttl: timedelta = timedelta(hours=24), clock: Callable[[], datetime] = utcnow
+ ):
+ self._sessions = sessions
+ self._ttl = ttl
+ self._clock = clock
+
+ async def get(self, user_id: int) -> DraftView | None:
+ async with self._sessions() as s:
+ draft = await self._load(s, user_id)
+ if draft is None:
+ return None
+ return DraftView(
+ base_sha=draft.base_sha,
+ message=draft.message,
+ changes=[Change(c.path, c.op, c.content) for c in draft.changes],
+ )
+
+ async def put(self, user_id: int, base_sha: str, path: str, op: ChangeOp, content: bytes | None) -> None:
+ """Record a change. Deleting a file that only exists in the draft just drops it from the draft."""
+ async with self._sessions.begin() as s:
+ draft = await self._load(s, user_id)
+ if draft is None:
+ draft = Draft(
+ user_id=user_id, base_sha=base_sha, created_at=self._clock(), expires_at=self._clock() + self._ttl
+ )
+ s.add(draft)
+ existing = next((c for c in draft.changes if c.path == path), None)
+ if existing is not None:
+ if op is ChangeOp.DELETE and existing.op is ChangeOp.ADD:
+ draft.changes.remove(existing)
+ return
+ # editing a file added in this draft keeps it an "add"
+ existing.op = ChangeOp.ADD if existing.op is ChangeOp.ADD and op is ChangeOp.MODIFY else op
+ existing.content = content
+ else:
+ if len(draft.changes) >= MAX_CHANGES:
+ raise DraftFull
+ draft.changes.append(DraftChange(path=path, op=op, content=content))
+ draft.expires_at = self._clock() + self._ttl
+
+ async def drop(self, user_id: int, path: str) -> None:
+ async with self._sessions.begin() as s:
+ draft = await self._load(s, user_id)
+ if draft is None:
+ return
+ draft.changes = [c for c in draft.changes if c.path != path]
+
+ async def set_message(self, user_id: int, message: str) -> None:
+ async with self._sessions.begin() as s:
+ draft = await self._load(s, user_id)
+ if draft is not None:
+ draft.message = message
+
+ async def clear(self, user_id: int) -> None:
+ async with self._sessions.begin() as s:
+ await s.execute(delete(Draft).where(Draft.user_id == user_id))
+
+ async def _load(self, s: AsyncSession, user_id: int) -> Draft | None:
+ draft = await s.scalar(select(Draft).where(Draft.user_id == user_id).options(selectinload(Draft.changes)))
+ if draft is not None and _aware(draft.expires_at) <= self._clock():
+ await s.delete(draft)
+ await s.flush()
+ return None
+ return draft
+
+
+def _aware(value: datetime) -> datetime:
+ return value if value.tzinfo is not None else value.replace(tzinfo=UTC)
diff --git a/app/repo/git.py b/app/repo/git.py
index 38de956..f1bfeb9 100644
--- a/app/repo/git.py
+++ b/app/repo/git.py
@@ -52,6 +52,10 @@ class UploadsRepo:
self._fetched_at: float | None = None
self._key_path = self._materialize_key()
+ @property
+ def branch(self) -> str:
+ return self._s.branch
+
@property
def ref(self) -> str:
return f"origin/{self._s.branch}"
diff --git a/app/repo/publisher.py b/app/repo/publisher.py
new file mode 100644
index 0000000..08dcfc5
--- /dev/null
+++ b/app/repo/publisher.py
@@ -0,0 +1,171 @@
+"""Turns a member's draft into one commit on the uploads repo's main branch (SPEC C-20…C-25, ARCHITECTURE §2.3).
+
+Pushes are serialized with a lock: two members pushing at once never fight over the shared working tree.
+"""
+
+import asyncio
+import logging
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import StrEnum
+from pathlib import Path
+
+from sqlalchemy import func, select
+
+from app.db.models import ChangeOp, Push, User, utcnow
+from app.db.session import SessionMaker
+from app.repo.drafts import DraftView
+from app.repo.git import GitError, UploadsRepo
+
+log = logging.getLogger(__name__)
+
+BOT_NAME = "tgit-bot"
+BOT_EMAIL = "tgit-bot@users.noreply.tgit"
+PUSHES_PER_HOUR = 20
+PUSH_ATTEMPTS = 3
+
+
+class PushStatus(StrEnum):
+ OK = "ok"
+ CONFLICT = "conflict" # someone changed the same files in main since the draft began
+ EMPTY = "empty" # the draft matches main already
+ LIMIT = "limit"
+ FAILED = "failed"
+
+
+@dataclass(frozen=True)
+class PushResult:
+ status: PushStatus
+ sha: str | None = None
+ conflicts: list[str] = field(default_factory=list)
+
+
+class Publisher:
+ def __init__(
+ self,
+ repo: UploadsRepo,
+ sessions: SessionMaker,
+ clock: Callable[[], datetime] = utcnow,
+ before_push: Callable[[], Awaitable[None]] | None = None, # test hook: simulate a concurrent push
+ ) -> None:
+ self._repo = repo
+ self._sessions = sessions
+ self._clock = clock
+ self._before_push = before_push
+ self._lock = asyncio.Lock()
+
+ async def push(self, member: User, draft: DraftView, message: str, *, overwrite: bool = False) -> PushResult:
+ if await self._pushes_last_hour(member.tg_id) >= PUSHES_PER_HOUR:
+ return PushResult(PushStatus.LIMIT)
+ async with self._lock:
+ try:
+ return await self._push(member, draft, message, overwrite)
+ except GitError:
+ log.exception("push failed")
+ await self._reset()
+ return PushResult(PushStatus.FAILED)
+
+ async def record(
+ self, member: User, result: PushResult, message: str, draft: DraftView, chat_id: int, message_id: int
+ ) -> None:
+ assert result.sha is not None
+ async with self._sessions.begin() as s:
+ s.add(
+ Push(
+ user_id=member.tg_id,
+ sha=result.sha,
+ message=message,
+ paths=[c.path for c in draft.changes],
+ chat_id=chat_id,
+ message_id=message_id,
+ created_at=self._clock(),
+ )
+ )
+
+ async def _push(self, member: User, draft: DraftView, message: str, overwrite: bool) -> PushResult:
+ repo = self._repo
+ await repo.refresh(force=True)
+ if not overwrite:
+ conflicts = await self._conflicts(draft)
+ if conflicts:
+ return PushResult(PushStatus.CONFLICT, conflicts=conflicts)
+
+ await self._reset()
+ self._apply(draft)
+ await repo.git("add", "-A")
+ try:
+ await repo.git("diff", "--cached", "--quiet")
+ return PushResult(PushStatus.EMPTY) # exit 0: nothing staged
+ except GitError:
+ pass # exit 1: there are changes
+
+ handle = f"@{member.username}" if member.username else member.full_name
+ full_message = f"{message.strip()}\n\nTelegram-User: {handle} ({member.tg_id})"
+ await repo.git(
+ "-c", f"user.name={BOT_NAME}", "-c", f"user.email={BOT_EMAIL}", "commit", "-q", "-m", full_message
+ )
+
+ branch = repo.branch
+ for attempt in range(1, PUSH_ATTEMPTS + 1):
+ if self._before_push is not None:
+ await self._before_push()
+ try:
+ await repo.git("push", "-q", "origin", f"HEAD:{branch}")
+ break
+ except GitError:
+ if attempt == PUSH_ATTEMPTS:
+ raise
+ log.info("push rejected, rebasing (attempt %d)", attempt)
+ await repo.git("fetch", "-q", "origin")
+ try:
+ await repo.git(
+ "-c", f"user.name={BOT_NAME}", "-c", f"user.email={BOT_EMAIL}", "rebase", "-q", repo.ref
+ )
+ except GitError:
+ await repo.git("rebase", "--abort")
+ return PushResult(PushStatus.CONFLICT, conflicts=await self._conflicts(draft))
+ sha = (await repo.git("rev-parse", "HEAD")).decode().strip()
+ return PushResult(PushStatus.OK, sha=sha)
+
+ async def _conflicts(self, draft: DraftView) -> list[str]:
+ try:
+ out = await self._repo.git("diff", "--name-only", draft.base_sha, self._repo.ref)
+ except GitError:
+ return [c.path for c in draft.changes] # base unknown (e.g. history rewritten): be safe
+ changed = set(out.decode().splitlines())
+ return [c.path for c in draft.changes if c.path in changed]
+
+ async def _reset(self) -> None:
+ repo = self._repo
+ await repo.git("checkout", "-q", "-B", repo.branch, repo.ref)
+ await repo.git("reset", "-q", "--hard", repo.ref)
+ await repo.git("clean", "-q", "-fdx")
+
+ def _apply(self, draft: DraftView) -> None:
+ root = self._repo.path.resolve()
+ for change in draft.changes:
+ target = (root / change.path).resolve()
+ if root not in target.parents: # validated earlier; this is the last line of defence
+ raise GitError(f"path escapes the repo: {change.path}")
+ if change.op is ChangeOp.DELETE:
+ target.unlink(missing_ok=True)
+ _prune_empty_dirs(target.parent, root)
+ else:
+ target.parent.mkdir(parents=True, exist_ok=True)
+ target.write_bytes(change.content or b"")
+
+ async def _pushes_last_hour(self, user_id: int) -> int:
+ async with self._sessions() as s:
+ count = await s.scalar(
+ select(func.count())
+ .select_from(Push)
+ .where(Push.user_id == user_id, Push.created_at > self._clock() - timedelta(hours=1))
+ )
+ return count or 0
+
+
+def _prune_empty_dirs(directory: Path, root: Path) -> None:
+ while directory != root and directory.is_dir() and not any(directory.iterdir()):
+ directory.rmdir()
+ directory = directory.parent
diff --git a/app/repo/validate.py b/app/repo/validate.py
new file mode 100644
index 0000000..9c28f28
--- /dev/null
+++ b/app/repo/validate.py
@@ -0,0 +1,83 @@
+"""Checks for names and file contents before anything goes into a draft (SPEC C-10, C-12, C-16). No code runs here."""
+
+import ast
+import difflib
+import re
+from dataclasses import dataclass
+
+MAX_FILE_BYTES = 100 * 1024
+NAME = re.compile(r"^[A-Za-z0-9._-]{1,100}$")
+# Bot users can't touch the CI of the uploads repo or its helper scripts (SPEC C-16, ADR-014)
+PROTECTED_PREFIXES = (".sourcecraft/", ".tgit/", ".git/")
+PROTECTED_FILES = {"ruff.toml"}
+_FENCE = re.compile(r"^\s*```[\w+-]*[ \t]*\n(.*?)\n?```\s*$", re.DOTALL)
+
+
+class ValidationError(ValueError):
+ pass
+
+
+@dataclass(frozen=True)
+class SyntaxIssue:
+ line: int
+ message: str
+
+
+def check_name(name: str) -> str:
+ name = name.strip()
+ if not NAME.match(name) or name in {".", ".."}:
+ raise ValidationError("name")
+ return name
+
+
+def is_protected(path: str) -> bool:
+ return path in PROTECTED_FILES or any(path.startswith(p) or path + "/" == p for p in PROTECTED_PREFIXES)
+
+
+def join(directory: str, name: str) -> str:
+ return f"{directory}/{name}" if directory else name
+
+
+def strip_fence(text: str) -> str:
+ """Code pasted as a Telegram message often comes wrapped in ``` — keep only what's inside."""
+ match = _FENCE.match(text)
+ return match.group(1) if match else text
+
+
+def check_content(data: bytes) -> str:
+ """Size, encoding, NUL bytes. Returns the decoded text."""
+ if len(data) > MAX_FILE_BYTES:
+ raise ValidationError("too_big")
+ if b"\0" in data:
+ raise ValidationError("binary")
+ try:
+ return data.decode("utf-8")
+ except UnicodeDecodeError:
+ raise ValidationError("encoding") from None
+
+
+def python_syntax(path: str, text: str) -> SyntaxIssue | None:
+ if not path.endswith(".py"):
+ return None
+ try:
+ ast.parse(text, filename=path)
+ except SyntaxError as e:
+ return SyntaxIssue(line=e.lineno or 0, message=e.msg)
+ return None
+
+
+def diff_stat(old: str, new: str) -> tuple[int, int]:
+ added = removed = 0
+ for line in difflib.ndiff(old.splitlines(), new.splitlines()):
+ if line.startswith("+ "):
+ added += 1
+ elif line.startswith("- "):
+ removed += 1
+ return added, removed
+
+
+def check_message(message: str) -> str:
+ message = message.strip()
+ if not 1 <= len(message) <= 200 or len(message.splitlines()[0]) > 72:
+ raise ValidationError("message")
+ return message
diff --git a/app/texts.py b/app/texts.py
index e1c0724..803e65a 100644
--- a/app/texts.py
+++ b/app/texts.py
@@ -75,6 +75,51 @@ class CommitTexts(_Strict):
soon: str
unavailable: str
sent_as_file: str
+ ask_file_name: str
+ ask_dir_name: str
+ bad_name: str
+ exists: str
+ protected: str
+ ask_content: str
+ too_big: str
+ binary: str
+ encoding: str
+ syntax: str
+ fix: str
+ force: str
+ added: str
+ modified: str
+ deleted: str
+ draft_button: str
+ draft_title: str
+ draft_empty: str
+ unstage: str
+ draft_full: str
+ in_draft_new: str
+ in_draft_modified: str
+ in_draft_deleted: str
+ mark_new: str
+ mark_modified: str
+ mark_deleted: str
+ op_add: str
+ op_modify: str
+ op_delete: str
+ message_button: str
+ message_current: str
+ message_missing: str
+ ask_message: str
+ bad_message: str
+ push_button: str
+ push_confirm: str
+ push_go: str
+ pushing: str
+ pushed: str
+ ci_pending: str
+ conflict: str
+ overwrite: str
+ push_empty: str
+ push_limit: str
+ push_failed: str
class Texts(_Strict):
diff --git a/config/texts.yaml b/config/texts.yaml
index 9ff6a6b..7df9dd1 100644
--- a/config/texts.yaml
+++ b/config/texts.yaml
@@ -78,3 +78,57 @@ commit:
soon: "Будет в следующей версии."
unavailable: "Репозиторий загрузок недоступен, попробуйте через минуту."
sent_as_file: "Файл большой или бинарный — отправил документом."
+ ask_file_name: "Имя нового файла в /{dir} (латиница, цифры, «.», «_», «-»):"
+ ask_dir_name: "Имя новой папки в /{dir}:"
+ bad_name: "Недопустимое имя: латиница, цифры, «.», «_», «-», до 100 символов. Пришлите другое."
+ exists: "Такое имя уже есть в этой папке. Пришлите другое."
+ protected: "Это служебный путь репозитория — из бота его менять нельзя."
+ ask_content: "Пришлите содержимое /{path} — текстом сообщения или файлом (до 100 КБ)."
+ too_big: "Больше 100 КБ — не принимаю."
+ binary: "Похоже на бинарный файл — принимаю только текст."
+ encoding: "Файл не в кодировке UTF-8."
+ syntax: "⚠️ Синтаксическая ошибка, строка {line}: {message}"
+ fix: "✏️ Исправить"
+ force: "Всё равно добавить"
+ added: "🆕 /{path} — добавлен в черновик."
+ modified: "✏️ /{path} — в черновике: +{added} −{removed}."
+ deleted: "🗑 /{path} — в черновике на удаление."
+ draft_button: "🧾 Черновик · {count}"
+ draft_title: "🧾 Черновик · изменений: {count}"
+ draft_empty: "Черновик пуст."
+ unstage: "↩️ убрать {name}"
+ draft_full: "В черновике уже 50 изменений — запушьте или уберите лишнее."
+ in_draft_new: "В черновике: новый файл."
+ in_draft_modified: "В черновике: изменён."
+ in_draft_deleted: "В черновике: удалён."
+ mark_new: "🆕 "
+ mark_modified: "✏️ "
+ mark_deleted: "🗑 "
+ op_add: "A"
+ op_modify: "M"
+ op_delete: "D"
+ message_button: "💬 Сообщение коммита"
+ message_current: "💬 {message}"
+ message_missing: "💬 Сообщение коммита не задано."
+ ask_message: "Сообщение коммита: до 200 символов, первая строка — до 72."
+ bad_message: "Сообщение: 1–200 символов, первая строка — до 72. Пришлите другое."
+ push_button: "🚀 Push"
+ push_confirm: |-
+ Запушить в main?
+
+ {summary}
+
+ 💬 {message}
+ push_go: "✅ Запушить"
+ pushing: "⏳ Пушу…"
+ pushed: "✅ Запушено: {sha} — {message}"
+ ci_pending: "⏳ CI…"
+ conflict: |-
+ ⚠️ Пока вы готовили черновик, в main изменились те же файлы:
+ {paths}
+
+ Перезаписать их вашей версией?
+ overwrite: "Перезаписать"
+ push_empty: "В main уже всё так же — коммитить нечего. Черновик очищен."
+ push_limit: "Лимит — 20 пушей в час. Попробуйте позже."
+ push_failed: "Не удалось запушить: репозиторий недоступен. Черновик сохранён — попробуйте позже."
diff --git a/pyproject.toml b/pyproject.toml
index dee183b..dd0ca9b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -42,6 +42,8 @@ extend-exclude = [".claude", "docs"]
[tool.ruff.lint]
select = ["E", "F", "I", "B", "UP", "SIM", "ASYNC", "RUF"]
+# Russian UI texts, commit messages and comments are normal here, not homoglyph attacks
+ignore = ["RUF001", "RUF002", "RUF003"]
[tool.mypy]
python_version = "3.12"
diff --git a/tests/bot/test_commit.py b/tests/bot/test_commit.py
index 43f8096..0e04cc4 100644
--- a/tests/bot/test_commit.py
+++ b/tests/bot/test_commit.py
@@ -87,13 +87,11 @@ async def test_pagination(tg: TgClient, texts: Texts) -> None:
assert labels(second.reply_markup)[0].startswith("📄 f20.txt") and texts.commit.prev in labels(second.reply_markup)
-async def test_unfinished_actions_and_stale_buttons(tg: TgClient, texts: Texts) -> None:
+async def test_stale_button_is_ignored(tg: TgClient, texts: Texts) -> None:
await tg.send(ADMIN, texts.menu.commit)
- await tg.press(ADMIN, cb(Act.NEW_FILE))
await tg.press(ADMIN, cb(Act.OPEN, 99))
- soon, stale = tg.session.sent(AnswerCallbackQuery)
- assert soon.text == texts.commit.soon and soon.show_alert
+ [stale] = tg.session.sent(AnswerCallbackQuery)
assert stale.text is None
assert tg.session.sent(EditMessageText) == []
diff --git a/tests/bot/test_commit_edit.py b/tests/bot/test_commit_edit.py
new file mode 100644
index 0000000..47601f1
--- /dev/null
+++ b/tests/bot/test_commit_edit.py
@@ -0,0 +1,162 @@
+import pytest
+from aiogram.methods import AnswerCallbackQuery, EditMessageText, SendMessage
+from aiogram.types import InlineKeyboardMarkup
+
+from app.access.service import AccessService
+from app.bot.routers.commit import Act, CommitCb
+from app.db.session import SessionMaker
+from app.main import build_dispatcher
+from app.repo.git import UploadsRepo
+from app.texts import Texts
+from tests.conftest import ADMIN
+from tests.fakes import TgClient
+
+
+@pytest.fixture
+def tg(texts: Texts, sessions: SessionMaker, access: AccessService, repo: UploadsRepo) -> TgClient:
+ return TgClient(build_dispatcher(texts, sessions, access, repo))
+
+
+def cb(action: Act, i: int = 0) -> str:
+ return CommitCb(a=action, i=i).pack()
+
+
+def labels(markup: object) -> list[str]:
+ assert isinstance(markup, InlineKeyboardMarkup)
+ return [b.text for row in markup.inline_keyboard for b in row]
+
+
+def last_text(tg: TgClient) -> SendMessage:
+ return tg.session.sent(SendMessage)[-1]
+
+
+async def to_hello(tg: TgClient, texts: Texts) -> None:
+ await tg.send(ADMIN, texts.menu.commit)
+ await tg.press(ADMIN, cb(Act.OPEN, 2)) # services
+ await tg.press(ADMIN, cb(Act.OPEN, 0)) # services/hello
+
+
+async def test_new_file_from_fenced_text(tg: TgClient, texts: Texts) -> None:
+ await to_hello(tg, texts)
+ await tg.press(ADMIN, cb(Act.NEW_FILE))
+ await tg.send(ADMIN, "utils.py")
+ await tg.send(ADMIN, "```python\ndef add(a, b):\n return a + b\n```")
+
+ reply = last_text(tg)
+ assert reply.text.startswith(texts.commit.added.format(path="services/hello/utils.py"))
+ got = labels(reply.reply_markup)
+ assert "🆕 📄 utils.py · 31 Б" in got # fence stripped, no trailing newline
+ assert texts.commit.draft_button.format(count=1) in got
+
+ await tg.press(ADMIN, cb(Act.OPEN, 1)) # utils.py (main.py is 0)
+ await tg.press(ADMIN, cb(Act.VIEW))
+ view = last_text(tg)
+ assert "def add(a, b):" in view.text and "```" not in view.text
+
+
+async def test_replace_with_document_shows_diff(tg: TgClient, texts: Texts) -> None:
+ await to_hello(tg, texts)
+ await tg.press(ADMIN, cb(Act.OPEN, 0)) # main.py
+ await tg.press(ADMIN, cb(Act.REPLACE))
+ await tg.send_document(ADMIN, "main.py", b"print('hello')\nprint('bye')\n")
+
+ reply = last_text(tg)
+ assert reply.text.startswith(texts.commit.modified.format(path="services/hello/main.py", added=1, removed=0))
+ assert "✏️ 📄 main.py · 28 Б" in labels(reply.reply_markup)
+
+
+async def test_delete_marks_and_draft_lists(tg: TgClient, texts: Texts) -> None:
+ await tg.send(ADMIN, texts.menu.commit)
+ await tg.press(ADMIN, cb(Act.OPEN, 3)) # README.md
+ await tg.press(ADMIN, cb(Act.DELETE))
+ deleted = tg.session.sent(EditMessageText)[-1]
+ assert deleted.text.startswith(texts.commit.deleted.format(path="README.md"))
+ assert "🗑 📄 README.md · 10 Б" in labels(deleted.reply_markup)
+
+ await tg.press(ADMIN, cb(Act.DRAFT))
+ draft = tg.session.sent(EditMessageText)[-1]
+ assert "D /README.md" in draft.text
+
+ await tg.press(ADMIN, cb(Act.UNSTAGE, 0))
+ assert tg.session.sent(EditMessageText)[-1].text == texts.commit.draft_empty
+
+
+async def test_syntax_error_force_or_fix(tg: TgClient, texts: Texts) -> None:
+ await to_hello(tg, texts)
+ await tg.press(ADMIN, cb(Act.NEW_FILE))
+ await tg.send(ADMIN, "bad.py")
+ await tg.send(ADMIN, "def f(:\n pass")
+
+ warn = last_text(tg)
+ assert warn.text.startswith("⚠️") and "1" in warn.text
+ assert labels(warn.reply_markup) == [texts.commit.fix, texts.commit.force]
+
+ await tg.press(ADMIN, cb(Act.FIX))
+ assert tg.session.sent(EditMessageText)[-1].text == texts.commit.ask_content.format(path="services/hello/bad.py")
+ await tg.send(ADMIN, "def f(:\n pass")
+ await tg.press(ADMIN, cb(Act.FORCE))
+ assert last_text(tg).text.startswith(texts.commit.added.format(path="services/hello/bad.py"))
+
+
+async def test_virtual_folder_becomes_real_with_a_file(tg: TgClient, texts: Texts) -> None:
+ await tg.send(ADMIN, texts.menu.commit)
+ await tg.press(ADMIN, cb(Act.OPEN, 2)) # services
+ await tg.press(ADMIN, cb(Act.NEW_DIR))
+ await tg.send(ADMIN, "api")
+ inside = last_text(tg)
+ assert inside.text == f"{texts.commit.title.format(path='services/api')}\n{texts.commit.empty}"
+
+ await tg.press(ADMIN, cb(Act.NEW_FILE))
+ await tg.send(ADMIN, "main.py")
+ await tg.send(ADMIN, "print('api')")
+ await tg.press(ADMIN, cb(Act.UP))
+
+ services = tg.session.sent(EditMessageText)[-1]
+ assert "🆕 📁 api" in labels(services.reply_markup)
+
+
+async def test_names_rejected(tg: TgClient, texts: Texts) -> None:
+ await tg.send(ADMIN, texts.menu.commit)
+ await tg.press(ADMIN, cb(Act.NEW_FILE))
+ for bad in ["../etc", "README.md", "ruff.toml"]:
+ await tg.send(ADMIN, bad)
+
+ assert [m.text for m in tg.session.sent(SendMessage)][-3:] == [
+ texts.commit.bad_name,
+ texts.commit.exists,
+ texts.commit.protected,
+ ]
+
+
+async def test_binary_document_rejected(tg: TgClient, texts: Texts) -> None:
+ await to_hello(tg, texts)
+ await tg.press(ADMIN, cb(Act.NEW_FILE))
+ await tg.send(ADMIN, "img.png")
+ await tg.send_document(ADMIN, "img.png", b"\x89PNG\x00\x00")
+
+ assert last_text(tg).text == texts.commit.binary
+
+
+async def test_draft_survives_a_restart(
+ texts: Texts, sessions: SessionMaker, access: AccessService, repo: UploadsRepo
+) -> None:
+ first = TgClient(build_dispatcher(texts, sessions, access, repo))
+ await first.send(ADMIN, texts.menu.commit)
+ await first.press(ADMIN, cb(Act.OPEN, 3))
+ await first.press(ADMIN, cb(Act.DELETE))
+
+ second = TgClient(build_dispatcher(texts, sessions, access, repo)) # same DB, new bot process
+ await second.send(ADMIN, texts.menu.commit)
+ assert texts.commit.draft_button.format(count=1) in labels(second.session.sent(SendMessage)[-1].reply_markup)
+
+
+async def test_protected_file_cannot_be_replaced(tg: TgClient, texts: Texts, repo: UploadsRepo) -> None:
+ await tg.send(ADMIN, texts.menu.commit)
+ # fake a card for a protected path via FSM: open README then rewrite the selection
+ await tg.press(ADMIN, cb(Act.OPEN, 3))
+ state = tg.dp.fsm.get_context(tg.bot, chat_id=ADMIN, user_id=ADMIN)
+ await state.update_data(commit_file=".sourcecraft/ci.yaml")
+ await tg.press(ADMIN, cb(Act.REPLACE))
+
+ answer = tg.session.sent(AnswerCallbackQuery)[-1]
+ assert answer.text == texts.commit.protected and answer.show_alert
diff --git a/tests/bot/test_commit_push.py b/tests/bot/test_commit_push.py
new file mode 100644
index 0000000..158e7bc
--- /dev/null
+++ b/tests/bot/test_commit_push.py
@@ -0,0 +1,65 @@
+from pathlib import Path
+
+import pytest
+from aiogram.methods import EditMessageText, SendMessage
+from aiogram.types import InlineKeyboardMarkup
+
+from app.access.service import AccessService
+from app.bot.routers.commit import Act, CommitCb
+from app.db.session import SessionMaker
+from app.main import build_dispatcher
+from app.repo.git import UploadsRepo
+from app.texts import Texts
+from tests.conftest import ADMIN, git
+from tests.fakes import TgClient
+
+
+@pytest.fixture
+def tg(texts: Texts, sessions: SessionMaker, access: AccessService, repo: UploadsRepo) -> TgClient:
+ return TgClient(build_dispatcher(texts, sessions, access, repo, "https://example.test/commit/{sha}"))
+
+
+def cb(action: Act, i: int = 0) -> str:
+ return CommitCb(a=action, i=i).pack()
+
+
+def labels(markup: object) -> list[str]:
+ assert isinstance(markup, InlineKeyboardMarkup)
+ return [b.text for row in markup.inline_keyboard for b in row]
+
+
+async def test_message_then_push_lands_in_remote(tg: TgClient, texts: Texts, remote: Path, tmp_path: Path) -> None:
+ t = texts.commit
+ await tg.send(ADMIN, texts.menu.commit)
+ await tg.press(ADMIN, cb(Act.NEW_FILE))
+ await tg.send(ADMIN, "notes.txt")
+ await tg.send(ADMIN, "привет из телеграма")
+ await tg.press(ADMIN, cb(Act.DRAFT))
+ draft = tg.session.sent(EditMessageText)[-1]
+ assert t.message_missing in draft.text and t.push_button not in labels(draft.reply_markup)
+
+ await tg.press(ADMIN, cb(Act.MESSAGE))
+ await tg.send(ADMIN, "x" * 80) # first line too long
+ assert tg.session.sent(SendMessage)[-1].text == t.bad_message
+ await tg.send(ADMIN, "docs: заметки")
+ with_message = tg.session.sent(SendMessage)[-1]
+ assert t.message_current.format(message="docs: заметки") in with_message.text
+ assert t.push_button in labels(with_message.reply_markup)
+
+ await tg.press(ADMIN, cb(Act.PUSH))
+ assert tg.session.sent(EditMessageText)[-1].text.startswith("Запушить в main?")
+ await tg.press(ADMIN, cb(Act.PUSH_GO))
+
+ pushing, done = tg.session.sent(EditMessageText)[-2:]
+ assert pushing.text == t.pushing
+ assert done.text.startswith("✅ Запушено: ") and "docs: заметки" in done.text
+ assert "https://example.test/commit/" in done.text and done.text.endswith(t.ci_pending)
+
+ clone = tmp_path / "verify"
+ git(tmp_path, "clone", "-q", str(remote), str(clone))
+ assert (clone / "notes.txt").read_text(encoding="utf-8") == "привет из телеграма"
+
+ # the draft is gone after a push
+ tg.session.requests.clear()
+ await tg.send(ADMIN, texts.menu.commit)
+ assert not any(label.startswith("🧾") for label in labels(tg.session.sent(SendMessage)[-1].reply_markup))
diff --git a/tests/fakes.py b/tests/fakes.py
index f03867d..a563e04 100644
--- a/tests/fakes.py
+++ b/tests/fakes.py
@@ -7,9 +7,9 @@ from typing import Any
from aiogram import Bot, Dispatcher
from aiogram.client.session.base import BaseSession
-from aiogram.methods import EditMessageText, GetMe, SendMessage, SendPhoto, TelegramMethod
+from aiogram.methods import EditMessageText, GetFile, GetMe, SendMessage, SendPhoto, TelegramMethod
from aiogram.methods.base import TelegramType
-from aiogram.types import Chat, Message, Update, User
+from aiogram.types import Chat, File, Message, Update, User
BOT_TOKEN = "42:TEST-TOKEN"
@@ -19,6 +19,7 @@ class FakeSession(BaseSession):
super().__init__()
self.requests: list[TelegramMethod[Any]] = []
self._ids = count(1000)
+ self.files: dict[str, bytes] = {} # file_id -> content, for documents users "upload"
async def make_request(
self,
@@ -27,6 +28,10 @@ class FakeSession(BaseSession):
timeout: int | None = None, # noqa: ASYNC109 - signature fixed by aiogram BaseSession
) -> TelegramType:
self.requests.append(method)
+ if isinstance(method, GetFile):
+ return File( # type: ignore[return-value]
+ file_id=method.file_id, file_unique_id=method.file_id, file_path=f"documents/{method.file_id}"
+ )
if isinstance(method, GetMe):
return User(id=42, is_bot=True, first_name="tgit", username="tgit_test_bot") # type: ignore[return-value]
if isinstance(method, SendPhoto):
@@ -54,9 +59,9 @@ class FakeSession(BaseSession):
timeout: int = 30, # noqa: ASYNC109 - signature fixed by aiogram BaseSession
chunk_size: int = 65536,
raise_for_status: bool = True,
- ) -> AsyncGenerator[bytes, None]: # pragma: no cover - not used
- raise NotImplementedError
- yield b""
+ ) -> AsyncGenerator[bytes, None]:
+ file_id = url.rsplit("/", 1)[-1]
+ yield self.files[file_id]
async def close(self) -> None:
pass
@@ -92,6 +97,18 @@ class TgClient:
message["entities"] = [{"type": "bot_command", "offset": 0, "length": len(cmd)}]
await self._feed({"message": message})
+ async def send_document(self, tg_id: int, name: str, content: bytes) -> None:
+ file_id = f"doc{next(self._message_ids)}"
+ self.session.files[file_id] = content
+ message = {
+ "message_id": next(self._message_ids),
+ "date": int(datetime.now(UTC).timestamp()),
+ "chat": {"id": tg_id, "type": "private"},
+ "from": self.user(tg_id),
+ "document": {"file_id": file_id, "file_unique_id": file_id, "file_name": name, "file_size": len(content)},
+ }
+ await self._feed({"message": message})
+
async def press(self, tg_id: int, data: str, message_text: str = "section") -> None:
callback = {
"id": str(next(self._update_ids)),
diff --git a/tests/repo/test_drafts.py b/tests/repo/test_drafts.py
new file mode 100644
index 0000000..5802d4f
--- /dev/null
+++ b/tests/repo/test_drafts.py
@@ -0,0 +1,72 @@
+from datetime import UTC, datetime, timedelta
+
+import pytest
+
+from app.db.models import ChangeOp, User
+from app.db.session import SessionMaker
+from app.repo.drafts import MAX_CHANGES, DraftFull, DraftService
+
+UID = 7
+SHA = "a" * 40
+
+
+class Clock:
+ now = datetime(2026, 10, 15, tzinfo=UTC)
+
+ def __call__(self) -> datetime:
+ return self.now
+
+
+@pytest.fixture
+async def svc(sessions: SessionMaker) -> DraftService:
+ async with sessions.begin() as s:
+ s.add(User(tg_id=UID, full_name="u"))
+ return DraftService(sessions, clock=Clock())
+
+
+async def test_put_get_and_order(svc: DraftService) -> None:
+ await svc.put(UID, SHA, "b.py", ChangeOp.ADD, b"b")
+ await svc.put(UID, "other-sha", "a.py", ChangeOp.MODIFY, b"a")
+
+ draft = await svc.get(UID)
+ assert draft is not None and draft.base_sha == SHA # base fixed when the draft started
+ assert [(c.path, c.op) for c in draft.changes] == [("b.py", ChangeOp.ADD), ("a.py", ChangeOp.MODIFY)]
+
+
+async def test_editing_a_new_file_keeps_it_added_and_deleting_it_drops_it(svc: DraftService) -> None:
+ await svc.put(UID, SHA, "n.py", ChangeOp.ADD, b"1")
+ await svc.put(UID, SHA, "n.py", ChangeOp.MODIFY, b"2")
+ draft = await svc.get(UID)
+ assert draft is not None and draft.changes[0].op is ChangeOp.ADD and draft.changes[0].content == b"2"
+
+ await svc.put(UID, SHA, "n.py", ChangeOp.DELETE, None)
+ draft = await svc.get(UID)
+ assert draft is not None and draft.changes == []
+
+
+async def test_drop_message_clear(svc: DraftService) -> None:
+ await svc.put(UID, SHA, "a.py", ChangeOp.ADD, b"1")
+ await svc.put(UID, SHA, "b.py", ChangeOp.DELETE, None)
+ await svc.drop(UID, "a.py")
+ await svc.set_message(UID, "feat: x")
+
+ draft = await svc.get(UID)
+ assert draft is not None and [c.path for c in draft.changes] == ["b.py"] and draft.message == "feat: x"
+ await svc.clear(UID)
+ assert await svc.get(UID) is None
+
+
+async def test_expired_draft_is_gone(svc: DraftService) -> None:
+ await svc.put(UID, SHA, "a.py", ChangeOp.ADD, b"1")
+ Clock.now += timedelta(hours=25)
+ try:
+ assert await svc.get(UID) is None
+ finally:
+ Clock.now -= timedelta(hours=25)
+
+
+async def test_draft_size_limit(svc: DraftService) -> None:
+ for i in range(MAX_CHANGES):
+ await svc.put(UID, SHA, f"f{i}.py", ChangeOp.ADD, b"")
+ with pytest.raises(DraftFull):
+ await svc.put(UID, SHA, "one-more.py", ChangeOp.ADD, b"")
diff --git a/tests/repo/test_publisher.py b/tests/repo/test_publisher.py
new file mode 100644
index 0000000..bdf7e08
--- /dev/null
+++ b/tests/repo/test_publisher.py
@@ -0,0 +1,143 @@
+from datetime import timedelta
+from pathlib import Path
+
+import pytest
+from sqlalchemy import select
+
+from app.access.service import AccessService
+from app.db.models import ChangeOp, Push, User, utcnow
+from app.db.session import SessionMaker
+from app.repo.drafts import Change, DraftView
+from app.repo.git import UploadsRepo
+from app.repo.publisher import PUSHES_PER_HOUR, Publisher, PushStatus
+from tests.conftest import ADMIN, git
+
+
+@pytest.fixture
+async def member(access: AccessService) -> User:
+ user = await access.get_member(ADMIN)
+ assert user is not None
+ return user
+
+
+def remote_log(remote: Path, tmp_path: Path, name: str = "check") -> tuple[Path, str]:
+ clone = tmp_path / name
+ git(tmp_path, "clone", "-q", str(remote), str(clone))
+ return clone, git(clone, "log", "-1", "--format=%an <%ae>%n%B")
+
+
+def foreign_commit(remote: Path, tmp_path: Path, path: str, text: str, name: str) -> None:
+ other = tmp_path / name
+ git(tmp_path, "clone", "-q", str(remote), str(other))
+ target = other / path
+ target.parent.mkdir(parents=True, exist_ok=True)
+ target.write_text(text, encoding="utf-8")
+ git(other, "add", "-A")
+ git(other, "commit", "-q", "-m", f"foreign {path}")
+ git(other, "push", "-q", "origin", "main")
+
+
+async def draft_on(repo: UploadsRepo, *changes: Change) -> DraftView:
+ await repo.refresh(force=True)
+ return DraftView(base_sha=await repo.head(), message=None, changes=list(changes))
+
+
+async def test_push_applies_changes_with_trailer(
+ repo: UploadsRepo, sessions: SessionMaker, member: User, remote: Path, tmp_path: Path
+) -> None:
+ draft = await draft_on(
+ repo,
+ Change("services/hello/utils.py", ChangeOp.ADD, b"X = 1\n"),
+ Change("services/hello/main.py", ChangeOp.MODIFY, b"print('v2')\n"),
+ Change("docs/logo.bin", ChangeOp.DELETE, None),
+ Change("docs/мои заметки.md", ChangeOp.DELETE, None),
+ )
+ publisher = Publisher(repo, sessions)
+
+ result = await publisher.push(member, draft, "feat: v2\n\nподробности")
+
+ assert result.status is PushStatus.OK and result.sha is not None
+ clone, log = remote_log(remote, tmp_path)
+ assert log.startswith("tgit-bot \nfeat: v2\n\nподробности\n\nTelegram-User: ")
+ assert f"({ADMIN})" in log
+ assert (clone / "services/hello/utils.py").read_text() == "X = 1\n"
+ assert (clone / "services/hello/main.py").read_text() == "print('v2')\n"
+ assert not (clone / "docs").exists() # both files gone → the folder is gone too
+ assert git(clone, "rev-parse", "HEAD").strip() == result.sha
+
+
+async def test_nothing_to_commit(repo: UploadsRepo, sessions: SessionMaker, member: User) -> None:
+ draft = await draft_on(repo, Change("README.md", ChangeOp.MODIFY, b"# uploads\n"))
+
+ assert (await Publisher(repo, sessions).push(member, draft, "noop")).status is PushStatus.EMPTY
+
+
+async def test_conflict_then_overwrite(
+ repo: UploadsRepo, sessions: SessionMaker, member: User, remote: Path, tmp_path: Path
+) -> None:
+ draft = await draft_on(repo, Change("README.md", ChangeOp.MODIFY, b"mine\n"))
+ foreign_commit(remote, tmp_path, "README.md", "theirs\n", "other")
+ publisher = Publisher(repo, sessions)
+
+ conflict = await publisher.push(member, draft, "edit readme")
+ assert conflict.status is PushStatus.CONFLICT and conflict.conflicts == ["README.md"]
+
+ forced = await publisher.push(member, draft, "edit readme", overwrite=True)
+ assert forced.status is PushStatus.OK
+ clone, _ = remote_log(remote, tmp_path)
+ assert (clone / "README.md").read_text() == "mine\n"
+
+
+async def test_unrelated_change_in_main_is_not_a_conflict(
+ repo: UploadsRepo, sessions: SessionMaker, member: User, remote: Path, tmp_path: Path
+) -> None:
+ draft = await draft_on(repo, Change("a.txt", ChangeOp.ADD, b"a"))
+ foreign_commit(remote, tmp_path, "b.txt", "b", "other")
+
+ assert (await Publisher(repo, sessions).push(member, draft, "add a")).status is PushStatus.OK
+ clone, _ = remote_log(remote, tmp_path)
+ assert (clone / "a.txt").exists() and (clone / "b.txt").exists()
+
+
+async def test_rejected_push_is_rebased(
+ repo: UploadsRepo, sessions: SessionMaker, member: User, remote: Path, tmp_path: Path
+) -> None:
+ raced = False
+
+ async def someone_pushes_first() -> None:
+ nonlocal raced
+ if not raced:
+ raced = True
+ foreign_commit(remote, tmp_path, "race.txt", "r", "racer")
+
+ draft = await draft_on(repo, Change("mine.txt", ChangeOp.ADD, b"m"))
+ result = await Publisher(repo, sessions, before_push=someone_pushes_first).push(member, draft, "add mine")
+
+ assert result.status is PushStatus.OK and raced
+ clone, log = remote_log(remote, tmp_path)
+ assert "add mine" in log and (clone / "race.txt").exists() and (clone / "mine.txt").exists()
+
+
+async def test_path_escape_is_refused(repo: UploadsRepo, sessions: SessionMaker, member: User, tmp_path: Path) -> None:
+ draft = await draft_on(repo, Change("../evil.txt", ChangeOp.ADD, b"x"))
+
+ assert (await Publisher(repo, sessions).push(member, draft, "evil")).status is PushStatus.FAILED
+ assert not (tmp_path / "evil.txt").exists()
+
+
+async def test_rate_limit_and_record(repo: UploadsRepo, sessions: SessionMaker, member: User) -> None:
+ publisher = Publisher(repo, sessions)
+ draft = await draft_on(repo, Change("x.txt", ChangeOp.ADD, b"x"))
+ result = await publisher.push(member, draft, "x")
+ await publisher.record(member, result, "x", draft, chat_id=ADMIN, message_id=77)
+
+ async with sessions() as s:
+ push = await s.scalar(select(Push))
+ assert push is not None and push.sha == result.sha and push.paths == ["x.txt"] and push.message_id == 77
+ for i in range(PUSHES_PER_HOUR):
+ s.add(
+ Push(user_id=ADMIN, sha=f"{i:040d}", message="m", chat_id=1, created_at=utcnow() - timedelta(minutes=1))
+ )
+ await s.commit()
+
+ assert (await publisher.push(member, draft, "y")).status is PushStatus.LIMIT
diff --git a/tests/repo/test_validate.py b/tests/repo/test_validate.py
new file mode 100644
index 0000000..5c48fdb
--- /dev/null
+++ b/tests/repo/test_validate.py
@@ -0,0 +1,74 @@
+import pytest
+
+from app.repo.validate import (
+ ValidationError,
+ check_content,
+ check_name,
+ diff_stat,
+ is_protected,
+ join,
+ python_syntax,
+ strip_fence,
+)
+
+
+@pytest.mark.parametrize("name", ["main.py", "a-b_c.1", ".gitignore", "X" * 100])
+def test_good_names(name: str) -> None:
+ assert check_name(f" {name} ") == name
+
+
+@pytest.mark.parametrize("name", ["", ".", "..", "a/b", "привет.py", "a b", "X" * 101, "a;rm"])
+def test_bad_names(name: str) -> None:
+ with pytest.raises(ValidationError):
+ check_name(name)
+
+
+@pytest.mark.parametrize(
+ ("path", "protected"),
+ [
+ (".sourcecraft/ci.yaml", True),
+ (".tgit/x.py", True),
+ ("ruff.toml", True),
+ (".sourcecraft", True),
+ ("services/a/ruff.toml", False),
+ ("README.md", False),
+ ("services/a/main.py", False),
+ ],
+)
+def test_protected_paths(path: str, protected: bool) -> None:
+ assert is_protected(path) is protected
+
+
+def test_join() -> None:
+ assert join("", "a.py") == "a.py" and join("s/x", "a.py") == "s/x/a.py"
+
+
+@pytest.mark.parametrize(
+ ("text", "expected"),
+ [
+ ("```python\nprint(1)\n```", "print(1)"),
+ ("```\na\nb\n```", "a\nb"),
+ ("print(1)", "print(1)"),
+ ("x ``` y", "x ``` y"),
+ ],
+)
+def test_strip_fence(text: str, expected: str) -> None:
+ assert strip_fence(text) == expected
+
+
+def test_content_checks() -> None:
+ assert check_content("привет".encode()) == "привет"
+ for data, reason in [(b"a\0b", "binary"), (b"\xff\xfe", "encoding"), (b"x" * (100 * 1024 + 1), "too_big")]:
+ with pytest.raises(ValidationError, match=reason):
+ check_content(data)
+
+
+def test_python_syntax_only_for_py() -> None:
+ issue = python_syntax("a.py", "def f(:\n pass\n")
+ assert issue is not None and issue.line == 1
+ assert python_syntax("a.py", "x = 1\n") is None
+ assert python_syntax("a.txt", "def f(:") is None
+
+
+def test_diff_stat() -> None:
+ assert diff_stat("a\nb\nc", "a\nB\nc\nd") == (2, 1)