eval_v_text_test.go

package vuego_test

import (
	"bytes"
	"testing"
	"testing/fstest"

	"github.com/stretchr/testify/require"

	"github.com/titpetric/vuego"
	"github.com/titpetric/vuego/diff"
)

func TestVue_EvalVText(t *testing.T) {
	tests := []struct {
		name     string
		template string
		data     map[string]any
		expected string
	}{
		{
			name:     "simple v-text",
			template: "<div v-text=\"text\"></div>",
			data:     map[string]any{"text": "plain text"},
			expected: "<div>plain text</div>",
		},
		{
			name:     "v-text escapes HTML",
			template: "<div v-text=\"text\"></div>",
			data:     map[string]any{"text": "<span>inner</span>"},
			expected: "<div>&lt;span&gt;inner&lt;/span&gt;</div>",
		},
		{
			name:     "v-text with empty string",
			template: "<div v-text=\"text\">original</div>",
			data:     map[string]any{"text": ""},
			expected: "<div></div>",
		},
		{
			name:     "v-text missing variable",
			template: "<div v-text=\"missing\">fallback</div>",
			data:     map[string]any{},
			expected: "<div>fallback</div>",
		},
		{
			name:     "v-text replaces children",
			template: "<div v-text=\"text\"><p>original</p></div>",
			data:     map[string]any{"text": "replaced"},
			expected: "<div>replaced</div>",
		},
		{
			name:     "v-text with special characters",
			template: "<div v-text=\"text\"></div>",
			data:     map[string]any{"text": "a & b < c > d"},
			expected: "<div>a &amp; b &lt; c &gt; d</div>",
		},
		{
			name:     "v-text with quotes",
			template: "<div v-text=\"text\"></div>",
			data:     map[string]any{"text": `"quoted" value`},
			expected: "<div>&quot;quoted&quot; value</div>",
		},
		{
			name:     "v-text same as interpolation",
			template: "<span v-text=\"msg\"></span>",
			data:     map[string]any{"msg": "hello"},
			expected: "<span>hello</span>",
		},
		{
			name:     "v-text preserves interpolation syntax in variable value",
			template: "<code v-text=\"code\"></code>",
			data:     map[string]any{"code": `echo "${{ version }}"`},
			expected: `<code>echo &quot;${{ version }}&quot;</code>`,
		},
		{
			name:     "v-text does not re-interpolate variable contents",
			template: "<div v-text=\"content\"></div>",
			data:     map[string]any{"content": "{{ name }}", "name": "Alice"},
			expected: "<div>{{ name }}</div>",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			template := []byte(tc.template)
			fs := fstest.MapFS{
				"test.vuego": &fstest.MapFile{Data: template},
			}
			vue := vuego.NewVue(fs)

			var buf bytes.Buffer
			err := vue.RenderFragment(t.Context(), &buf, "test.vuego", tc.data)
			require.NoError(t, err)
			diff.EqualHTML(t, []byte(tc.expected), buf.Bytes(), nil, nil)
		})
	}
}

func TestVue_EvalVText_PreservesWhitespace(t *testing.T) {
	// Test that v-text content preserves its original whitespace without re-indenting
	tests := []struct {
		name     string
		template string
		data     map[string]any
		expected string // exact expected output (not normalized)
	}{
		{
			name:     "v-text preserves newlines in text",
			template: "<div v-text=\"text\"></div>",
			data:     map[string]any{"text": "line1\nline2"},
			expected: "<div>line1\nline2</div>\n",
		},
		{
			name:     "v-text escapes HTML with newlines",
			template: "<div v-text=\"text\"></div>",
			data: map[string]any{
				"text": "<span>\n  content\n</span>",
			},
			// v-text content is escaped and output as-is without re-indenting
			expected: "<div>&lt;span&gt;\n  content\n&lt;/span&gt;</div>\n",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			template := []byte(tc.template)
			fs := fstest.MapFS{
				"test.vuego": &fstest.MapFile{Data: template},
			}
			vue := vuego.NewVue(fs)

			var buf bytes.Buffer
			err := vue.RenderFragment(t.Context(), &buf, "test.vuego", tc.data)
			require.NoError(t, err)
			// Compare exact output to verify whitespace is preserved
			require.Equal(t, tc.expected, buf.String())
		})
	}
}

func TestVue_EvalVText_WithFiltersAndFunctions(t *testing.T) {
	// Test v-text with pipe filters and complex expressions
	tests := []struct {
		name     string
		template string
		data     map[string]any
		expected string
	}{
		{
			name:     "v-text with upper filter",
			template: "<span v-text=\"name | upper\"></span>",
			data:     map[string]any{"name": "hello world"},
			expected: "<span>HELLO WORLD</span>",
		},
		{
			name:     "v-text with multiple filters",
			template: "<span v-text=\"text | trim | upper\"></span>",
			data:     map[string]any{"text": "  hello world  "},
			expected: "<span>HELLO WORLD</span>",
		},
		{
			name:     "v-text with default filter",
			template: "<span v-text=\"missing | default('placeholder')\"></span>",
			data:     map[string]any{},
			expected: "<span>placeholder</span>",
		},
		{
			name:     "v-text with function call",
			template: "<span v-text=\"len(items)\"></span>",
			data:     map[string]any{"items": []int{1, 2, 3}},
			expected: "<span>3</span>",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			template := []byte(tc.template)
			fs := fstest.MapFS{
				"test.vuego": &fstest.MapFile{Data: template},
			}
			vue := vuego.NewVue(fs)

			var buf bytes.Buffer
			err := vue.RenderFragment(t.Context(), &buf, "test.vuego", tc.data)
			require.NoError(t, err)
			diff.EqualHTML(t, []byte(tc.expected), buf.Bytes(), nil, nil)
		})
	}
}

func TestVue_EvalVText_WithComplexVariables(t *testing.T) {
	// Test v-text with nested property access and variables
	tests := []struct {
		name     string
		template string
		data     map[string]any
		expected string
	}{
		{
			name:     "v-text with nested property access",
			template: "<span v-text=\"user.profile.name\"></span>",
			data: map[string]any{
				"user": map[string]any{
					"profile": map[string]any{
						"name": "Alice",
					},
				},
			},
			expected: "<span>Alice</span>",
		},
		{
			name:     "v-text with array index",
			template: "<span v-text=\"items.0\"></span>",
			data: map[string]any{
				"items": []string{"first", "second", "third"},
			},
			expected: "<span>first</span>",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			template := []byte(tc.template)
			fs := fstest.MapFS{
				"test.vuego": &fstest.MapFile{Data: template},
			}
			vue := vuego.NewVue(fs)

			var buf bytes.Buffer
			err := vue.RenderFragment(t.Context(), &buf, "test.vuego", tc.data)
			require.NoError(t, err)
			diff.EqualHTML(t, []byte(tc.expected), buf.Bytes(), nil, nil)
		})
	}
}

func TestVue_EvalVText_HTMLEscaping(t *testing.T) {
	// Test various HTML content that needs escaping
	tests := []struct {
		name     string
		template string
		data     map[string]any
		expected string
	}{
		{
			name:     "v-text with mixed entities",
			template: "<div v-text=\"text\"></div>",
			data:     map[string]any{"text": "a < b && c > d"},
			expected: "<div>a &lt; b &amp;&amp; c &gt; d</div>",
		},
		{
			name:     "v-text with single quotes",
			template: "<div v-text=\"text\"></div>",
			data:     map[string]any{"text": `it's a test`},
			expected: "<div>it&#39;s a test</div>",
		},
		{
			name:     "v-text with script injection attempt",
			template: "<div v-text=\"text\"></div>",
			data:     map[string]any{"text": `"><script>alert('xss')</script>`},
			expected: "<div>&quot;&gt;&lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;</div>",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			template := []byte(tc.template)
			fs := fstest.MapFS{
				"test.vuego": &fstest.MapFile{Data: template},
			}
			vue := vuego.NewVue(fs)

			var buf bytes.Buffer
			err := vue.RenderFragment(t.Context(), &buf, "test.vuego", tc.data)
			require.NoError(t, err)
			diff.EqualHTML(t, []byte(tc.expected), buf.Bytes(), nil, nil)
		})
	}
}