hyperguild/ingestion/internal/api/promote_queue_test.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)
}