hyperguild/internal/skills/brain/handlers_test.go

// internal/skills/brain/handlers_test.go
package brain_test

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/mathiasbq/supervisor/internal/skills/brain"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestHandle_BrainQuery_CallsIngestServer(t *testing.T) {
	called := false
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		assert.Equal(t, "/query", r.URL.Path)
		called = true
		_ = json.NewEncoder(w).Encode(map[string]any{
			"results": []map[string]any{
				{"path": "wiki/concepts/tdd.md", "title": "TDD", "excerpt": "Test-driven development.", "score": 3},
			},
		})
	}))
	defer srv.Close()

	s := brain.New(brain.Config{IngestBaseURL: srv.URL})
	args, _ := json.Marshal(map[string]string{"query": "test driven development"})
	out, err := s.Handle(context.Background(), "brain_query", args)
	require.NoError(t, err)
	assert.True(t, called)

	var result map[string]any
	require.NoError(t, json.Unmarshal(out, &result))
	results := result["results"].([]any)
	assert.Len(t, results, 1)
}

func TestHandle_BrainWrite_CallsIngestServer(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		assert.Equal(t, "/write", r.URL.Path)
		var body map[string]string
		require.NoError(t, json.NewDecoder(r.Body).Decode(&body))
		assert.Equal(t, "concept", body["type"])
		assert.Equal(t, "# Test\n\nSome learning.", body["content"])
		_ = json.NewEncoder(w).Encode(map[string]string{"path": "raw/test.md"})
	}))
	defer srv.Close()

	s := brain.New(brain.Config{IngestBaseURL: srv.URL})
	args, _ := json.Marshal(map[string]string{"content": "# Test\n\nSome learning.", "type": "concept"})
	out, err := s.Handle(context.Background(), "brain_write", args)
	require.NoError(t, err)
	var result map[string]string
	require.NoError(t, json.Unmarshal(out, &result))
	assert.Equal(t, "raw/test.md", result["path"])
}

func TestHandle_UnknownTool_ReturnsError(t *testing.T) {
	s := brain.New(brain.Config{IngestBaseURL: "http://localhost:3300"})
	_, err := s.Handle(context.Background(), "brain_unknown", nil)
	assert.Error(t, err)
}

func TestIngest_RoutesToIngestPath(t *testing.T) {
	var capturedPath string
	var capturedBody map[string]any
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		capturedPath = r.URL.Path
		require.NoError(t, json.NewDecoder(r.Body).Decode(&capturedBody))
		_ = json.NewEncoder(w).Encode(map[string]any{"pages": []string{"wiki/foo.md"}})
	}))
	defer srv.Close()

	s := brain.New(brain.Config{IngestSvcURL: srv.URL})
	args, _ := json.Marshal(map[string]any{"path": "/tmp/some-file.md"})
	out, err := s.Handle(context.Background(), "brain_ingest", args)
	require.NoError(t, err)

	assert.Equal(t, "/ingest-path", capturedPath)
	assert.Equal(t, "/tmp/some-file.md", capturedBody["path"])

	var result map[string]any
	require.NoError(t, json.Unmarshal(out, &result))
	pages := result["pages"].([]any)
	assert.Len(t, pages, 1)
}

func TestIngest_RoutesToIngest(t *testing.T) {
	var capturedPath string
	var capturedBody map[string]any
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		capturedPath = r.URL.Path
		require.NoError(t, json.NewDecoder(r.Body).Decode(&capturedBody))
		_ = json.NewEncoder(w).Encode(map[string]any{"pages": []string{"wiki/bar.md"}})
	}))
	defer srv.Close()

	s := brain.New(brain.Config{IngestSvcURL: srv.URL})
	args, _ := json.Marshal(map[string]any{"content": "some content", "source": "my-source.md"})
	out, err := s.Handle(context.Background(), "brain_ingest", args)
	require.NoError(t, err)

	assert.Equal(t, "/ingest", capturedPath)
	assert.Equal(t, "some content", capturedBody["content"])
	assert.Equal(t, "my-source.md", capturedBody["source"])

	var result map[string]any
	require.NoError(t, json.Unmarshal(out, &result))
	pages := result["pages"].([]any)
	assert.Len(t, pages, 1)
}

func TestIngest_MissingRequiredFields(t *testing.T) {
	s := brain.New(brain.Config{IngestSvcURL: "http://localhost:3300"})
	args, _ := json.Marshal(map[string]any{})
	_, err := s.Handle(context.Background(), "brain_ingest", args)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "either content+source or path is required")
}