page_source_test.go

package xlog

import (
	"context"
	"html/template"
	"testing"
	"time"

	"github.com/emad-elsaid/xlog/markdown/ast"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// mockPageSource implements PageSource for testing.
type mockPageSource struct {
	pages    map[string]Page
	eachFunc func(context.Context, func(Page))
}

func (m *mockPageSource) Page(name string) Page {
	if m.pages == nil {
		return nil
	}
	return m.pages[name]
}

func (m *mockPageSource) Each(ctx context.Context, fn func(Page)) {
	if m.eachFunc != nil {
		m.eachFunc(ctx, fn)
	}
}

// mockPage implements Page for testing.
type mockPage struct {
	name   string
	exists bool
}

func (m *mockPage) Name() string            { return m.name }
func (m *mockPage) Exists() bool            { return m.exists }
func (m *mockPage) FileName() string        { return m.name + ".md" }
func (m *mockPage) Content() Markdown       { return "" }
func (m *mockPage) Render() template.HTML   { return "" }
func (m *mockPage) Delete() bool            { return false }
func (m *mockPage) Write(Markdown) bool     { return false }
func (m *mockPage) ModTime() time.Time      { return time.Time{} }
func (m *mockPage) AST() ([]byte, ast.Node) { return nil, nil }

func TestNewPage(t *testing.T) {
	// Save original sources and restore after test
	originalSources := sources
	defer func() { sources = originalSources }()

	tests := []struct {
		name           string
		pageName       string
		setupSources   func()
		expectedExists bool
		expectedName   string
	}{
		{
			name:     "page exists in first source",
			pageName: "test-page",
			setupSources: func() {
				sources = []PageSource{
					&mockPageSource{
						pages: map[string]Page{
							"test-page": &mockPage{name: "test-page", exists: true},
						},
					},
				}
			},
			expectedExists: true,
			expectedName:   "test-page",
		},
		{
			name:     "page exists in second source",
			pageName: "second-page",
			setupSources: func() {
				sources = []PageSource{
					&mockPageSource{
						pages: map[string]Page{
							"other-page": &mockPage{name: "other-page", exists: true},
						},
					},
					&mockPageSource{
						pages: map[string]Page{
							"second-page": &mockPage{name: "second-page", exists: true},
						},
					},
				}
			},
			expectedExists: true,
			expectedName:   "second-page",
		},
		{
			name:     "page doesn't exist in any source",
			pageName: "missing-page",
			setupSources: func() {
				sources = []PageSource{
					&mockPageSource{
						pages: map[string]Page{
							"other-page": &mockPage{name: "other-page", exists: true},
						},
					},
				}
			},
			expectedExists: false,
		},
		{
			name:     "page exists but not marked as existing",
			pageName: "non-existing-page",
			setupSources: func() {
				sources = []PageSource{
					&mockPageSource{
						pages: map[string]Page{
							"non-existing-page": &mockPage{name: "non-existing-page", exists: false},
						},
					},
				}
			},
			expectedExists: false,
		},
		{
			name:     "empty sources list",
			pageName: "any-page",
			setupSources: func() {
				sources = []PageSource{}
			},
			expectedExists: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.setupSources()

			page := NewPage(tt.pageName)

			if tt.expectedExists {
				require.NotNil(t, page, "Expected page to exist")
				assert.True(t, page.Exists(), "Expected page.Exists() to return true")
				assert.Equal(t, tt.expectedName, page.Name(), "Page name mismatch")
			} else if page != nil {
				assert.False(t, page.Exists(), "Expected page.Exists() to return false")
			}
		})
	}
}

func TestRegisterPageSource(t *testing.T) {
	// Save original sources and restore after test
	originalSources := sources
	defer func() { sources = originalSources }()

	// Reset sources to a known state
	sources = []PageSource{
		&mockPageSource{
			pages: map[string]Page{
				"existing": &mockPage{name: "existing", exists: true},
			},
		},
	}
	initialLen := len(sources)

	// Register a new page source
	newSource := &mockPageSource{
		pages: map[string]Page{
			"new-page": &mockPage{name: "new-page", exists: true},
		},
	}
	RegisterPageSource(newSource)

	// Verify the source was added
	assert.Equal(t, initialLen+1, len(sources), "Source count should increase by 1")

	// Verify new source is prepended (checked first)
	page := NewPage("new-page")
	require.NotNil(t, page, "Should find page from newly registered source")
	assert.True(t, page.Exists())
	assert.Equal(t, "new-page", page.Name())

	// Verify old sources still work
	page = NewPage("existing")
	require.NotNil(t, page, "Should still find page from original source")
	assert.True(t, page.Exists())
	assert.Equal(t, "existing", page.Name())
}

func TestRegisterPageSourcePriority(t *testing.T) {
	// Save original sources and restore after test
	originalSources := sources
	defer func() { sources = originalSources }()

	// Create two sources with the same page name
	sources = []PageSource{
		&mockPageSource{
			pages: map[string]Page{
				"conflict": &mockPage{name: "conflict-old", exists: true},
			},
		},
	}

	// Register a new source with the same page name
	newSource := &mockPageSource{
		pages: map[string]Page{
			"conflict": &mockPage{name: "conflict-new", exists: true},
		},
	}
	RegisterPageSource(newSource)

	// The newly registered source should take priority
	page := NewPage("conflict")
	require.NotNil(t, page)
	assert.Equal(t, "conflict-new", page.Name(), "Newly registered source should take priority")
}

func TestPageSourceIntegration(t *testing.T) {
	// This test verifies that markdownFS can be used as a PageSource
	// We use the current directory which should have some .md files

	// Save original sources and restore after test
	originalSources := sources
	defer func() { sources = originalSources }()

	// Create a markdownFS for current directory
	sources = []PageSource{
		newMarkdownFS("."),
	}

	// Test that NewPage returns a non-nil page even for non-existent pages
	// This is how the actual implementation works
	page := NewPage("nonexistent-test-page-12345")
	require.NotNil(t, page, "NewPage should always return a page object")
	assert.Equal(t, "nonexistent-test-page-12345", page.Name())

	// Since the page doesn't exist, Exists() should return false
	assert.False(t, page.Exists(), "Page should not exist")
}

// TestNewPageNeverReturnsNil verifies the critical safety guarantee that NewPage
// never returns nil, preventing panic vulnerabilities in handlers that use page names
// from user input (e.g., PathValue, FormValue).
func TestNewPageNeverReturnsNil(t *testing.T) {
	// Save original sources and restore after test
	originalSources := sources
	defer func() { sources = originalSources }()

	tests := []struct {
		name         string
		setupSources func()
		pageName     string
	}{
		{
			name: "empty sources list",
			setupSources: func() {
				sources = []PageSource{}
			},
			pageName: "any-page",
		},
		{
			name: "source returns nil for page",
			setupSources: func() {
				sources = []PageSource{
					&mockPageSource{pages: nil}, // Returns nil
				}
			},
			pageName: "missing-page",
		},
		{
			name: "source returns non-existing page",
			setupSources: func() {
				sources = []PageSource{
					&mockPageSource{
						pages: map[string]Page{
							"other": &mockPage{name: "other", exists: true},
						},
					},
				}
			},
			pageName: "missing-page",
		},
		{
			name: "empty page name",
			setupSources: func() {
				sources = []PageSource{
					&mockPageSource{pages: map[string]Page{}},
				}
			},
			pageName: "",
		},
		{
			name: "special characters in page name",
			setupSources: func() {
				sources = []PageSource{
					&mockPageSource{pages: map[string]Page{}},
				}
			},
			pageName: "../../../etc/passwd",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.setupSources()

			// The critical assertion: NewPage must NEVER return nil
			page := NewPage(tt.pageName)
			require.NotNil(t, page, "NewPage must never return nil to prevent panics in handlers")

			// The page should have the correct name
			assert.Equal(t, tt.pageName, page.Name())

			// It's acceptable for Exists() to return false for non-existent pages
			// We just need the page object itself to be non-nil
		})
	}
}

// TestNewPageSafeForHandlers demonstrates the vulnerability this fix prevents.
// Handlers that call NewPage with user-supplied input must not panic.
func TestNewPageSafeForHandlers(t *testing.T) {
	// Save original sources and restore after test
	originalSources := sources
	defer func() { sources = originalSources }()

	// Simulate handler scenario with no matching pages
	sources = []PageSource{
		&mockPageSource{pages: map[string]Page{}},
	}

	// This simulates: page := xlog.NewPage(r.PathValue("page"))
	userSuppliedName := "non-existent-page"
	page := NewPage(userSuppliedName)

	// Critical: this must not panic
	require.NotNil(t, page, "NewPage must return non-nil to prevent panic in handlers")

	// Handler code like `slog.Info("Editing page", "name", page)` should work
	// Even though the page doesn't exist
	assert.NotPanics(t, func() {
		_ = page.Name()
		_ = page.Exists()
		_ = page.FileName()
	}, "Basic page operations must not panic even for non-existent pages")
}