hyperguild/ingestion/internal/brainfs/brainfs_test.go

package brainfs

import (
	"errors"
	"io"
	"os"
	"path/filepath"
	"syscall"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// The handle check is what stops a FIFO swapped in after the Lstat. A FIFO
// with no writer reads EOF at once, so a race test could not see the check
// missing; here a writer holds the FIFO open, as any local process can, and
// readOpened must refuse it promptly (PR #161 review).
func TestReadOpenedRefusesAFIFOHeldOpenByAWriter(t *testing.T) {
	dir := t.TempDir()
	fifo := filepath.Join(dir, "p.md")
	require.NoError(t, syscall.Mkfifo(fifo, 0o644))
	w, err := os.OpenFile(fifo, os.O_RDWR, 0)
	require.NoError(t, err)
	defer func() { _ = w.Close() }()

	b, err := Open(dir)
	require.NoError(t, err)
	defer func() { _ = b.Close() }()

	done := make(chan error, 1)
	go func() { _, err := b.readOpened("p.md"); done <- err }()
	select {
	case err := <-done:
		assert.True(t, errors.Is(err, ErrNotRegular), "got %v", err)
	case <-time.After(2 * time.Second):
		t.Fatal("readOpened blocked on a FIFO with a writer")
	}
}

func TestReadRegularRefusesSymlinksAndReadsRegularFiles(t *testing.T) {
	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "ok.md"), []byte("ok"), 0o644))
	outside := filepath.Join(t.TempDir(), "s.md")
	require.NoError(t, os.WriteFile(outside, []byte("secret"), 0o644))
	require.NoError(t, os.Symlink(outside, filepath.Join(dir, "link.md")))
	b, err := Open(dir)
	require.NoError(t, err)
	defer func() { _ = b.Close() }()
	got, err := b.ReadRegular("ok.md")
	require.NoError(t, err)
	assert.Equal(t, "ok", string(got))
	_, err = b.ReadRegular("link.md")
	assert.True(t, errors.Is(err, ErrNotRegular), "got %v", err)
	_, err = b.ReadRegular("../" + filepath.Base(outside))
	assert.Error(t, err)
}

func TestRelAcceptsPathsInsideAndRefusesEscapes(t *testing.T) {
	dir := t.TempDir()
	b, err := Open(dir)
	require.NoError(t, err)
	defer func() { _ = b.Close() }()
	for in, want := range map[string]string{
		filepath.Join(dir, "wiki", "x.md"): "wiki/x.md",
		filepath.Join(dir, "..foo", "x"):   "..foo/x",
		dir:                                ".",
	} {
		got, err := b.Rel(in)
		require.NoError(t, err, in)
		assert.Equal(t, want, got, in)
	}
	for _, bad := range []string{filepath.Join(dir, "..", "x"), dir + "-evil/x", "/etc/passwd", filepath.Join(dir, "wiki", "..", "..", "x")} {
		_, err := b.Rel(bad)
		assert.Error(t, err, bad)
	}
}

func TestWalkRegularYieldsOnlyRegularFiles(t *testing.T) {
	dir := t.TempDir()
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "a"), 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "a", "n.md"), []byte("n"), 0o644))
	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(dir, "a", "dirlink")))
	require.NoError(t, os.Symlink(filepath.Join(dir, "a", "n.md"), filepath.Join(dir, "a", "filelink.md")))
	require.NoError(t, syscall.Mkfifo(filepath.Join(dir, "a", "p.md"), 0o644))
	b, err := Open(dir)
	require.NoError(t, err)
	defer func() { _ = b.Close() }()
	var got []string
	require.NoError(t, b.WalkRegular(".", func(rel string) error { got = append(got, rel); return nil }, nil))
	assert.Equal(t, []string{"a/n.md"}, got)
}

func TestReadRegularMaxRefusesAFileOverTheLimit(t *testing.T) {
	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "big.md"), make([]byte, 100), 0o644))
	b, err := Open(dir)
	require.NoError(t, err)
	defer func() { _ = b.Close() }()
	_, err = b.ReadRegularMax("big.md", 99)
	assert.True(t, errors.Is(err, ErrTooLarge), "got %v", err)
	got, err := b.ReadRegularMax("big.md", 100)
	require.NoError(t, err)
	assert.Len(t, got, 100)
}

func TestReadRegularMaxRefusesAndStopsReadingAFileThatGrowsPastTheLimit(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "grow.md")
	require.NoError(t, os.WriteFile(p, make([]byte, 10), 0o644))
	consumed := &countingReader{}
	wrapAfterStat = func(r io.Reader) io.Reader {
		f, err := os.OpenFile(p, os.O_WRONLY|os.O_APPEND, 0)
		require.NoError(t, err)
		_, err = f.Write(make([]byte, 1000))
		require.NoError(t, err)
		require.NoError(t, f.Close())
		consumed.r = r
		return consumed
	}
	t.Cleanup(func() { wrapAfterStat = nil })
	b, err := Open(dir)
	require.NoError(t, err)
	defer func() { _ = b.Close() }()
	got, err := b.ReadRegularMax("grow.md", 100)
	assert.True(t, errors.Is(err, ErrTooLarge), "got %v", err)
	assert.Nil(t, got)
	assert.LessOrEqual(t, consumed.n, 101, "read past max+1 bytes")
}

type countingReader struct {
	r io.Reader
	n int
}

func (c *countingReader) Read(p []byte) (int, error) {
	n, err := c.r.Read(p)
	c.n += n
	return n, err
}