mathiasandClaude Sonnet 5.5
27b1579b80
- in a wing, an ingest that writes no source page is an error: the note goes to
raw/failed with the warnings in log.md instead of leaving the inbox as
'processed' (model returned [], only invalid types, only clashing entities)
- the wing's source path is deterministic, so Resolve no longer redirects a
source onto another note's page because the model gave both the same title
('Home'); that overwrote the hash and the text
- a batch tie between concept and entity prefers the page already on disk, so
its update is not lost; the wing's own source page keeps its slug even when a
foreign page shares it
- brain_pending lists an unreadable (over-cap) note with the reason instead of
dropping it; the client filter's 4 KiB match-span limit is documented
Each has a test that fails without it (mutation-checked).
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
211 lines
8.2 KiB
Go
211 lines
8.2 KiB
Go
package api
|
|
|
|
import (
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// brain_pending lists a top-level note and a parked note of the same name as two
|
|
// entries with the same filename. Acting on "a.md" must not silently pick one.
|
|
func TestPromoteNote_ANameInBothQueuesNeedsTheQueueToBeNamed(t *testing.T) {
|
|
dir := t.TempDir()
|
|
writeRaw(t, dir, "a.md", "---\ncreated_at: 2026-10-20T08:00:00Z\n---\nTop-level body.\n")
|
|
writeParked(t, dir, "a.md", parkedNote)
|
|
|
|
_, err := PromoteNote(dir, PromoteOptions{Filename: "a.md", Wing: "homelab", Hall: "facts"})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "both")
|
|
assert.Contains(t, err.Error(), "queue")
|
|
_, statErr := os.Stat(filepath.Join(dir, "wiki/homelab/facts/a.md"))
|
|
assert.ErrorIs(t, statErr, os.ErrNotExist, "nothing was promoted")
|
|
|
|
rel, err := PromoteNote(dir, PromoteOptions{Filename: "a.md", Wing: "homelab", Hall: "facts", Queue: QueueNeedsReview})
|
|
require.NoError(t, err)
|
|
got, _ := os.ReadFile(filepath.Join(dir, rel))
|
|
assert.Contains(t, string(got), "Body of the parked note.")
|
|
_, statErr = os.Stat(filepath.Join(dir, "raw", "a.md"))
|
|
assert.NoError(t, statErr, "the top-level note of the same name is untouched")
|
|
}
|
|
|
|
func TestPromoteNote_QueueInboxSelectsTheTopLevelNote(t *testing.T) {
|
|
dir := t.TempDir()
|
|
writeRaw(t, dir, "a.md", "---\ncreated_at: 2026-10-20T08:00:00Z\n---\nTop-level body.\n")
|
|
writeParked(t, dir, "a.md", parkedNote)
|
|
|
|
rel, err := PromoteNote(dir, PromoteOptions{Filename: "a.md", Wing: "homelab", Hall: "facts", Queue: QueueInbox})
|
|
require.NoError(t, err)
|
|
got, _ := os.ReadFile(filepath.Join(dir, rel))
|
|
assert.Contains(t, string(got), "Top-level body.")
|
|
_, statErr := os.Stat(filepath.Join(dir, "raw", "needs-review", "a.md"))
|
|
assert.NoError(t, statErr, "the parked note is untouched")
|
|
}
|
|
|
|
func TestPromoteNote_ANamedQueueThatDoesNotHoldTheNoteIsAnError(t *testing.T) {
|
|
dir := t.TempDir()
|
|
writeRaw(t, dir, "a.md", "top")
|
|
_, err := PromoteNote(dir, PromoteOptions{Filename: "a.md", Wing: "homelab", Hall: "facts", Queue: QueueNeedsReview})
|
|
assert.Error(t, err)
|
|
_, err = PromoteNote(dir, PromoteOptions{Filename: "a.md", Wing: "homelab", Hall: "facts", Queue: "elsewhere"})
|
|
assert.Error(t, err, "an unknown queue name is refused")
|
|
}
|
|
|
|
func TestRejectNote_ANameInBothQueuesNeedsTheQueueToBeNamed(t *testing.T) {
|
|
dir := t.TempDir()
|
|
writeRaw(t, dir, "a.md", "top")
|
|
writeParked(t, dir, "a.md", parkedNote)
|
|
|
|
_, err := RejectNote(dir, RejectOptions{Filename: "a.md"})
|
|
require.Error(t, err)
|
|
_, err = RejectNote(dir, RejectOptions{Filename: "a.md", Queue: QueueNeedsReview})
|
|
require.NoError(t, err)
|
|
_, statErr := os.Stat(filepath.Join(dir, "raw", "a.md"))
|
|
assert.NoError(t, statErr, "the top-level note is untouched")
|
|
}
|
|
|
|
func TestPromoteNote_NeverIntoARetiredLayoutName(t *testing.T) {
|
|
for _, w := range []string{"sources", "concepts", "entities", "wiki"} {
|
|
t.Run(w, func(t *testing.T) {
|
|
dir := t.TempDir()
|
|
writeRaw(t, dir, "a.md", "top")
|
|
_, err := PromoteNote(dir, PromoteOptions{Filename: "a.md", Wing: w, Hall: "facts"})
|
|
assert.Error(t, err)
|
|
_, statErr := os.Stat(filepath.Join(dir, "wiki", w))
|
|
assert.ErrorIs(t, statErr, os.ErrNotExist)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestListPending_LabelsEveryEntryWithItsQueue(t *testing.T) {
|
|
dir := t.TempDir()
|
|
writeRaw(t, dir, "fresh.md", "---\ncreated_at: 2026-10-20T08:00:00Z\n---\nx\n")
|
|
writeParked(t, dir, "p.md", parkedNote)
|
|
got, err := ListPending(dir)
|
|
require.NoError(t, err)
|
|
require.Len(t, got, 2)
|
|
queues := map[string]string{}
|
|
for _, n := range got {
|
|
queues[n.Filename] = n.Queue
|
|
}
|
|
assert.Equal(t, QueueInbox, queues["fresh.md"])
|
|
assert.Equal(t, QueueNeedsReview, queues["p.md"])
|
|
}
|
|
|
|
// Parked notes that are not markdown (a pdf, a txt) were invisible: the only
|
|
// trace was a log.md line.
|
|
func TestListPending_ShowsParkedNonMarkdownFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw", "needs-review"), 0o755))
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "needs-review", "paper.pdf"), []byte("%PDF-1.4 binary"), 0o644))
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "needs-review", "plain.txt"), []byte("some text"), 0o644))
|
|
|
|
got, err := ListPending(dir)
|
|
require.NoError(t, err)
|
|
names := map[string]PendingNote{}
|
|
for _, n := range got {
|
|
names[n.Filename] = n
|
|
}
|
|
require.Contains(t, names, "paper.pdf")
|
|
require.Contains(t, names, "plain.txt")
|
|
assert.Equal(t, QueueNeedsReview, names["paper.pdf"].Queue)
|
|
assert.Contains(t, names["paper.pdf"].Excerpt, "proposal", "points the reader at where the proposal is")
|
|
}
|
|
|
|
func TestPromoteNote_OnlyMarkdownCanBePromoted(t *testing.T) {
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw", "needs-review"), 0o755))
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "needs-review", "paper.pdf"), []byte("%PDF binary"), 0o644))
|
|
_, err := PromoteNote(dir, PromoteOptions{Filename: "paper.pdf", Wing: "homelab", Hall: "facts"})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "markdown")
|
|
_, statErr := os.Stat(filepath.Join(dir, "raw", "needs-review", "paper.pdf"))
|
|
assert.NoError(t, statErr, "refused, untouched")
|
|
}
|
|
|
|
// brain.Sanitise normalises case, trailing dots and separators; the reserved-name
|
|
// check must look at the normalised name or "Sources" and "sources." walk past it.
|
|
func TestPromoteNote_ReservedWingNamesAreRefusedInEveryDisguise(t *testing.T) {
|
|
for _, w := range []string{"Sources", "sources.", "SOURCES ", "Entities/", "concepts\\", " wiki "} {
|
|
t.Run(w, func(t *testing.T) {
|
|
dir := t.TempDir()
|
|
writeRaw(t, dir, "a.md", "top")
|
|
_, err := PromoteNote(dir, PromoteOptions{Filename: "a.md", Wing: w, Hall: "facts"})
|
|
assert.Error(t, err)
|
|
_, statErr := os.Stat(filepath.Join(dir, "raw", "a.md"))
|
|
assert.NoError(t, statErr, "refused, untouched")
|
|
})
|
|
}
|
|
}
|
|
|
|
// Reject moves the bytes; it must not prepend frontmatter to a pdf or txt.
|
|
func TestRejectNote_AParkedNonMarkdownFileIsMovedUntouched(t *testing.T) {
|
|
dir := t.TempDir()
|
|
pdf := "%PDF-1.4\r\n\x00\xff binary \r\n"
|
|
require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw", "needs-review"), 0o755))
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "needs-review", "paper.pdf"), []byte(pdf), 0o644))
|
|
|
|
rel, err := RejectNote(dir, RejectOptions{Filename: "paper.pdf", Reason: "not relevant"})
|
|
require.NoError(t, err)
|
|
got, err := os.ReadFile(filepath.Join(dir, rel))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, pdf, string(got), "byte for byte")
|
|
_, statErr := os.Stat(filepath.Join(dir, "raw", "needs-review", "paper.pdf"))
|
|
assert.ErrorIs(t, statErr, os.ErrNotExist)
|
|
}
|
|
|
|
func TestReadRawNote_IsBoundedByTheCap(t *testing.T) {
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "big.md"), []byte(strings.Repeat("x", 200)), 0o644))
|
|
root, err := os.OpenRoot(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = root.Close() }()
|
|
prev := maxRawNoteBytes
|
|
maxRawNoteBytes = 100
|
|
t.Cleanup(func() { maxRawNoteBytes = prev })
|
|
|
|
_, _, err = readRawNote(root, "big.md")
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "exceeds")
|
|
}
|
|
|
|
type endless struct{ n int64 }
|
|
|
|
func (e *endless) Read(p []byte) (int, error) {
|
|
if e.n > 8<<20 { // a regression fails the test instead of exhausting memory
|
|
return 0, errors.New("endless reader drained")
|
|
}
|
|
e.n += int64(len(p))
|
|
return len(p), nil
|
|
}
|
|
|
|
func TestReadCapped_StopsAtTheCap(t *testing.T) {
|
|
e := &endless{}
|
|
_, err := readCapped(e, 1000)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "exceeds")
|
|
assert.LessOrEqual(t, e.n, int64(1000+1+32*1024), "pulled far more than the cap: %d", e.n)
|
|
}
|
|
|
|
// An .md over the read cap used to vanish from the listing (readRawNote failed
|
|
// and the entry was skipped). It must stay visible, with the reason.
|
|
func TestListPending_AnUnreadableNoteIsListedWithTheReason(t *testing.T) {
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw"), 0o755))
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "huge.md"), []byte(strings.Repeat("x", 200)), 0o644))
|
|
prev := maxRawNoteBytes
|
|
maxRawNoteBytes = 100
|
|
t.Cleanup(func() { maxRawNoteBytes = prev })
|
|
|
|
got, err := ListPending(dir)
|
|
require.NoError(t, err)
|
|
require.Len(t, got, 1)
|
|
assert.Equal(t, "huge.md", got[0].Filename)
|
|
assert.Contains(t, got[0].Excerpt, "cannot be read")
|
|
assert.Contains(t, got[0].Excerpt, "exceeds")
|
|
}
|