parser_test.go

package scaf_test

import (
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/rlch/scaf"
)

func TestParse(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		input    string
		expected *scaf.Suite
	}{
		{
			name: "basic query and test",
			input: `
				fn GetUser() ` + "`MATCH (u:User) RETURN u`" + `
				GetUser {
					test "finds user" {
						$id: 1
						u.name: "alice"
					}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{
					{Name: "GetUser", Body: "MATCH (u:User) RETURN u"},
				},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "GetUser",
						Items: []*scaf.TestOrGroup{
							{
								Test: &scaf.Test{
									Name: "finds user",
									Statements: []*scaf.Statement{
										scaf.NewStatement("$id", &scaf.Value{Number: ptr(1.0)}),
										scaf.NewStatement("u.name", &scaf.Value{Str: ptr("alice")}),
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "global setup",
			input: `
				fn Q() ` + "`Q`" + `
				setup ` + "`CREATE (:User)`" + `
				Q {
					test "t" {}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Setup:     &scaf.SetupClause{Inline: ptr("CREATE (:User)")},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "Q",
						Items:        []*scaf.TestOrGroup{{Test: &scaf.Test{Name: "t"}}},
					},
				},
			},
		},
		{
			name: "scope setup",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup ` + "`SCOPE SETUP`" + `
					test "t" {}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "Q",
						Setup:        &scaf.SetupClause{Inline: ptr("SCOPE SETUP")},
						Items:        []*scaf.TestOrGroup{{Test: &scaf.Test{Name: "t"}}},
					},
				},
			},
		},
		{
			name: "test setup",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						setup ` + "`TEST SETUP`" + `
					}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "Q",
						Items: []*scaf.TestOrGroup{
							{Test: &scaf.Test{Name: "t", Setup: &scaf.SetupClause{Inline: ptr("TEST SETUP")}}},
						},
					},
				},
			},
		},
		{
			name: "group with tests",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					group "users" {
						test "a" { $x: 1 }
						test "b" { $y: 2 }
					}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "Q",
						Items: []*scaf.TestOrGroup{
							{
								Group: &scaf.Group{
									Name: "users",
									Items: []*scaf.TestOrGroup{
										{
											Test: &scaf.Test{
												Name:       "a",
												Statements: []*scaf.Statement{scaf.NewStatement("$x", &scaf.Value{Number: ptr(1.0)})},
											},
										},
										{
											Test: &scaf.Test{
												Name:       "b",
												Statements: []*scaf.Statement{scaf.NewStatement("$y", &scaf.Value{Number: ptr(2.0)})},
											},
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "nested groups",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					group "level1" {
						group "level2" {
							test "deep" {}
						}
					}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "Q",
						Items: []*scaf.TestOrGroup{
							{
								Group: &scaf.Group{
									Name: "level1",
									Items: []*scaf.TestOrGroup{
										{
											Group: &scaf.Group{
												Name:  "level2",
												Items: []*scaf.TestOrGroup{{Test: &scaf.Test{Name: "deep"}}},
											},
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "assertion block",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert ` + "`MATCH (n) RETURN count(n) as c`" + ` {
							(c == 1)
						}
					}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "Q",
						Items: []*scaf.TestOrGroup{
							{
								Test: &scaf.Test{
									Name: "t",
									Asserts: []*scaf.Assert{
										{
											Query: &scaf.AssertQuery{
												Inline: ptr("MATCH (n) RETURN count(n) as c"),
											},
											Conditions: makeConditions(&scaf.Expr{ExprTokens: []*scaf.ExprToken{
												{Ident: ptr("c")},
												{Op: ptr("==")},
												{Number: ptr("1")},
											}}),
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "assert with field ref param",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert OtherQuery($id: u.id) {
							(count > 0)
						}
					}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "Q",
						Items: []*scaf.TestOrGroup{
							{
								Test: &scaf.Test{
									Name: "t",
									Asserts: []*scaf.Assert{
										{
											Query: &scaf.AssertQuery{
												QueryName: ptr("OtherQuery"),
												Params: []*scaf.SetupParam{
													{Name: "$id", Value: &scaf.ParamValue{FieldRef: &scaf.DottedIdent{Parts: []string{"u", "id"}}}},
												},
											},
											Conditions: makeConditions(&scaf.Expr{ExprTokens: []*scaf.ExprToken{
												{Ident: ptr("count")},
												{Op: ptr(">")},
												{Number: ptr("0")},
											}}),
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "multiple queries and scopes",
			input: `
				fn A() ` + "`A`" + `
				fn B() ` + "`B`" + `
				A { test "a" {} }
				B { test "b" {} }
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{
					{Name: "A", Body: "A"},
					{Name: "B", Body: "B"},
				},
				Scopes: []*scaf.QueryScope{
					{FunctionName: "A", Items: []*scaf.TestOrGroup{{Test: &scaf.Test{Name: "a"}}}},
					{FunctionName: "B", Items: []*scaf.TestOrGroup{{Test: &scaf.Test{Name: "b"}}}},
				},
			},
		},
		{
			name: "global teardown",
			input: `
				fn Q() ` + "`Q`" + `
				setup ` + "`CREATE (:User)`" + `
				teardown ` + "`MATCH (u:User) DELETE u`" + `
				Q { test "t" {} }
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Setup:     &scaf.SetupClause{Inline: ptr("CREATE (:User)")},
				Teardown:  ptr("MATCH (u:User) DELETE u"),
				Scopes: []*scaf.QueryScope{
					{FunctionName: "Q", Items: []*scaf.TestOrGroup{{Test: &scaf.Test{Name: "t"}}}},
				},
			},
		},
		{
			name: "scope teardown",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup ` + "`SCOPE SETUP`" + `
					teardown ` + "`SCOPE TEARDOWN`" + `
					test "t" {}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "Q",
						Setup:        &scaf.SetupClause{Inline: ptr("SCOPE SETUP")},
						Teardown:     ptr("SCOPE TEARDOWN"),
						Items:        []*scaf.TestOrGroup{{Test: &scaf.Test{Name: "t"}}},
					},
				},
			},
		},
		{
			name: "group teardown",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					group "g" {
						setup ` + "`GROUP SETUP`" + `
						teardown ` + "`GROUP TEARDOWN`" + `
						test "t" {}
					}
				}
			`,
			expected: &scaf.Suite{
				Functions: []*scaf.Query{{Name: "Q", Body: "Q"}},
				Scopes: []*scaf.QueryScope{
					{
						FunctionName: "Q",
						Items: []*scaf.TestOrGroup{
							{
								Group: &scaf.Group{
									Name:     "g",
									Setup:    &scaf.SetupClause{Inline: ptr("GROUP SETUP")},
									Teardown: ptr("GROUP TEARDOWN"),
									Items:    []*scaf.TestOrGroup{{Test: &scaf.Test{Name: "t"}}},
								},
							},
						},
					},
				},
			},
		},
	}

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

			result, err := scaf.Parse([]byte(tt.input))
			if err != nil {
				t.Fatalf("Parse() error: %v", err)
			}

			if diff := cmp.Diff(tt.expected, result, cmpIgnoreAST); diff != "" {
				t.Errorf("Parse() mismatch (-want +got):\n%s", diff)
			}
		})
	}
}

func TestParseImports(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		input    string
		expected []*scaf.Import
	}{
		{
			name: "simple import",
			input: `
				import "../../setup/db"
				fn Q() ` + "`Q`" + `
			`,
			expected: []*scaf.Import{
				{Path: "../../setup/db"},
			},
		},
		{
			name: "import with alias",
			input: `
				import fixtures "../shared/fixtures"
				fn Q() ` + "`Q`" + `
			`,
			expected: []*scaf.Import{
				{Alias: ptr("fixtures"), Path: "../shared/fixtures"},
			},
		},
		{
			name: "multiple imports",
			input: `
				import "../../setup/db"
				import fixtures "../shared/fixtures"
				import utils "./utils"
				fn Q() ` + "`Q`" + `
			`,
			expected: []*scaf.Import{
				{Path: "../../setup/db"},
				{Alias: ptr("fixtures"), Path: "../shared/fixtures"},
				{Alias: ptr("utils"), Path: "./utils"},
			},
		},
	}

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

			result, err := scaf.Parse([]byte(tt.input))
			if err != nil {
				t.Fatalf("Parse() error: %v", err)
			}

			if diff := cmp.Diff(tt.expected, result.Imports, cmpIgnoreAST); diff != "" {
				t.Errorf("Parse() imports mismatch (-want +got):\n%s", diff)
			}
		})
	}
}

func TestParseSetupCall(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		input    string
		expected *scaf.SetupClause
	}{
		{
			name: "setup call with module",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup fixtures.SetupDB()
					test "t" {}
				}
			`,
			expected: &scaf.SetupClause{
				Call: &scaf.SetupCall{
					Module: "fixtures",
					Query:  "SetupDB",
				},
			},
		},
		{
			name: "setup call with params",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup fixtures.CreatePosts($n: 10, $title: "Post")
					test "t" {}
				}
			`,
			expected: &scaf.SetupClause{
				Call: &scaf.SetupCall{
					Module: "fixtures",
					Query:  "CreatePosts",
					Params: []*scaf.SetupParam{
						{Name: "$n", Value: &scaf.ParamValue{Literal: &scaf.Value{Number: ptr(10.0)}}},
						{Name: "$title", Value: &scaf.ParamValue{Literal: &scaf.Value{Str: ptr("Post")}}},
					},
				},
			},
		},
		{
			name: "setup module reference",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup fixtures
					test "t" {}
				}
			`,
			expected: &scaf.SetupClause{
				Module: ptr("fixtures"),
			},
		},
		{
			name: "setup block with single inline",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup { ` + "`CREATE (:User)`" + ` }
					test "t" {}
				}
			`,
			expected: &scaf.SetupClause{
				Block: []*scaf.SetupItem{
					{Inline: ptr("CREATE (:User)")},
				},
			},
		},
		{
			name: "setup block with single module",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup { fixtures }
					test "t" {}
				}
			`,
			expected: &scaf.SetupClause{
				Block: []*scaf.SetupItem{
					{Module: ptr("fixtures")},
				},
			},
		},
		{
			name: "setup block with single call",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup { fixtures.SetupUsers() }
					test "t" {}
				}
			`,
			expected: &scaf.SetupClause{
				Block: []*scaf.SetupItem{
					{Call: &scaf.SetupCall{Module: "fixtures", Query: "SetupUsers"}},
				},
			},
		},
		{
			name: "setup block with multiple items",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup {
						` + "`CREATE (:User)`" + `
						fixtures
						fixtures.CreatePosts($n: 10)
					}
					test "t" {}
				}
			`,
			expected: &scaf.SetupClause{
				Block: []*scaf.SetupItem{
					{Inline: ptr("CREATE (:User)")},
					{Module: ptr("fixtures")},
					{Call: &scaf.SetupCall{
						Module: "fixtures",
						Query:  "CreatePosts",
						Params: []*scaf.SetupParam{
							{Name: "$n", Value: &scaf.ParamValue{Literal: &scaf.Value{Number: ptr(10.0)}}},
						},
					}},
				},
			},
		},
	}

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

			result, err := scaf.Parse([]byte(tt.input))
			if err != nil {
				t.Fatalf("Parse() error: %v", err)
			}

			gotSetup := result.Scopes[0].Setup
			if diff := cmp.Diff(tt.expected, gotSetup, cmpIgnoreAST); diff != "" {
				t.Errorf("Parse() setup mismatch (-want +got):\n%s", diff)
			}
		})
	}
}

func TestParseValues(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		input    string
		expected *scaf.Value
	}{
		{name: "string", input: `"hello"`, expected: &scaf.Value{Str: ptr("hello")}},
		{name: "int", input: `42`, expected: &scaf.Value{Number: ptr(42.0)}},
		{name: "float", input: `3.14`, expected: &scaf.Value{Number: ptr(3.14)}},
		{name: "true", input: `true`, expected: &scaf.Value{Boolean: boolPtr(true)}},
		{name: "false", input: `false`, expected: &scaf.Value{Boolean: boolPtr(false)}},
		{name: "null", input: `null`, expected: &scaf.Value{Null: true}},
		{
			name:     "empty list",
			input:    `[]`,
			expected: &scaf.Value{List: &scaf.List{Values: nil}},
		},
		{
			name:  "list",
			input: `[1, "two"]`,
			expected: &scaf.Value{List: &scaf.List{Values: []*scaf.Value{
				{Number: ptr(1.0)},
				{Str: ptr("two")},
			}}},
		},
		{
			name:     "empty map",
			input:    `{}`,
			expected: &scaf.Value{Map: &scaf.Map{Entries: nil}},
		},
		{
			name:  "map",
			input: `{a: 1, b: "two"}`,
			expected: &scaf.Value{Map: &scaf.Map{Entries: []*scaf.MapEntry{
				{Key: "a", Value: &scaf.Value{Number: ptr(1.0)}},
				{Key: "b", Value: &scaf.Value{Str: ptr("two")}},
			}}},
		},
		{
			name:  "nested",
			input: `{arr: [1, {x: true}]}`,
			expected: &scaf.Value{Map: &scaf.Map{Entries: []*scaf.MapEntry{
				{Key: "arr", Value: &scaf.Value{List: &scaf.List{Values: []*scaf.Value{
					{Number: ptr(1.0)},
					{Map: &scaf.Map{Entries: []*scaf.MapEntry{{Key: "x", Value: &scaf.Value{Boolean: boolPtr(true)}}}}},
				}}}},
			}}},
		},
	}

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

			src := `fn Q() ` + "`Q`" + ` Q { test "t" { v: ` + tt.input + ` } }`

			result, err := scaf.Parse([]byte(src))
			if err != nil {
				t.Fatalf("Parse() error: %v", err)
			}

			gotValue := result.Scopes[0].Items[0].Test.Statements[0].Value
			if gotValue == nil {
				t.Fatal("Value is nil")
			}
			if diff := cmp.Diff(tt.expected, gotValue.Literal, cmpIgnoreAST); diff != "" {
				t.Errorf("Value mismatch (-want +got):\n%s", diff)
			}
		})
	}
}

func TestParseFnParams(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name           string
		input          string
		expectedParams []*scaf.FnParam
		expectedGoType []string
	}{
		{
			name:           "no params",
			input:          `fn GetUser() ` + "`Q`",
			expectedParams: nil,
			expectedGoType: nil,
		},
		{
			name:  "single simple param",
			input: `fn GetUser(id: string) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "id", Type: &scaf.TypeExpr{Simple: ptr("string")}},
			},
			expectedGoType: []string{"string"},
		},
		{
			name:  "multiple params",
			input: `fn CreateUser(name: string, age: int) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "name", Type: &scaf.TypeExpr{Simple: ptr("string")}},
				{Name: "age", Type: &scaf.TypeExpr{Simple: ptr("int")}},
			},
			expectedGoType: []string{"string", "int"},
		},
		{
			name:  "nullable type",
			input: `fn GetUser(id: string, name: string?) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "id", Type: &scaf.TypeExpr{Simple: ptr("string")}},
				{Name: "name", Type: &scaf.TypeExpr{Simple: ptr("string"), Nullable: true}},
			},
			expectedGoType: []string{"string", "*string"},
		},
		{
			name:  "array type",
			input: `fn GetUsers(ids: [string]) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "ids", Type: &scaf.TypeExpr{Array: &scaf.TypeExpr{Simple: ptr("string")}}},
			},
			expectedGoType: []string{"[]string"},
		},
		{
			name:  "map type",
			input: `fn CreateData(data: {string: int}) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "data", Type: &scaf.TypeExpr{Map: &scaf.MapTypeExpr{
					Key:   &scaf.TypeExpr{Simple: ptr("string")},
					Value: &scaf.TypeExpr{Simple: ptr("int")},
				}}},
			},
			expectedGoType: []string{"map[string]int"},
		},
		{
			name:  "nested map with array",
			input: `fn CreateData(data: {string: [int]}) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "data", Type: &scaf.TypeExpr{Map: &scaf.MapTypeExpr{
					Key:   &scaf.TypeExpr{Simple: ptr("string")},
					Value: &scaf.TypeExpr{Array: &scaf.TypeExpr{Simple: ptr("int")}},
				}}},
			},
			expectedGoType: []string{"map[string][]int"},
		},
		{
			name:  "nullable array",
			input: `fn GetIds(ids: [int]?) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "ids", Type: &scaf.TypeExpr{
					Array:    &scaf.TypeExpr{Simple: ptr("int")},
					Nullable: true,
				}},
			},
			expectedGoType: []string{"*[]int"},
		},
		{
			name:  "untyped param",
			input: `fn GetUser(id) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "id", Type: nil},
			},
			expectedGoType: []string{"any"},
		},
		{
			name:  "mixed typed and untyped params",
			input: `fn CreateUser(id, name: string, data) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "id", Type: nil},
				{Name: "name", Type: &scaf.TypeExpr{Simple: ptr("string")}},
				{Name: "data", Type: nil},
			},
			expectedGoType: []string{"any", "string", "any"},
		},
		{
			name:  "multiple untyped params",
			input: `fn Query(a, b, c) ` + "`Q`",
			expectedParams: []*scaf.FnParam{
				{Name: "a", Type: nil},
				{Name: "b", Type: nil},
				{Name: "c", Type: nil},
			},
			expectedGoType: []string{"any", "any", "any"},
		},
	}

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

			result, err := scaf.Parse([]byte(tt.input))
			if err != nil {
				t.Fatalf("Parse() error: %v", err)
			}

			if len(result.Functions) != 1 {
				t.Fatalf("Expected 1 function, got %d", len(result.Functions))
			}

			fn := result.Functions[0]
			if len(fn.Params) != len(tt.expectedParams) {
				t.Fatalf("Expected %d params, got %d", len(tt.expectedParams), len(fn.Params))
			}

			for i, expected := range tt.expectedParams {
				got := fn.Params[i]
				if got.Name != expected.Name {
					t.Errorf("Param %d: name = %q, want %q", i, got.Name, expected.Name)
				}
				goType := got.Type.ToGoType()
				if goType != tt.expectedGoType[i] {
					t.Errorf("Param %d: ToGoType() = %q, want %q", i, goType, tt.expectedGoType[i])
				}
			}
		})
	}
}

func TestValueToGo(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		value    *scaf.Value
		expected any
	}{
		{name: "string", value: &scaf.Value{Str: ptr("hello")}, expected: "hello"},
		{name: "number", value: &scaf.Value{Number: ptr(42.0)}, expected: 42.0},
		{name: "bool", value: &scaf.Value{Boolean: boolPtr(true)}, expected: true},
		{name: "null", value: &scaf.Value{Null: true}, expected: nil},
		{name: "empty value", value: &scaf.Value{}, expected: nil},
		{
			name: "list",
			value: &scaf.Value{List: &scaf.List{Values: []*scaf.Value{
				{Number: ptr(1.0)},
				{Str: ptr("two")},
			}}},
			expected: []any{1.0, "two"},
		},
		{
			name: "map",
			value: &scaf.Value{Map: &scaf.Map{Entries: []*scaf.MapEntry{
				{Key: "a", Value: &scaf.Value{Number: ptr(1.0)}},
			}}},
			expected: map[string]any{"a": 1.0},
		},
	}

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

			got := tt.value.ToGo()
			if diff := cmp.Diff(tt.expected, got); diff != "" {
				t.Errorf("ToGo() mismatch (-want +got):\n%s", diff)
			}
		})
	}
}

func TestParseComments(t *testing.T) {
	// Not parallel - trivia state requires serialized access
	src := `
		// This is a comment
		fn Q() ` + "`Q`" + `
		// Another comment
		Q {
			// Test comment
			test "t" {
				// Input comment
				$id: 1
			}
		}
	`

	result, err := scaf.Parse([]byte(src))
	if err != nil {
		t.Fatalf("Parse() error: %v", err)
	}

	// Verify function doc comment
	if len(result.Functions) == 0 {
		t.Fatal("Expected at least one function")
	}
	if diff := cmp.Diff([]string{"// This is a comment"}, result.Functions[0].LeadingComments); diff != "" {
		t.Errorf("Function.LeadingComments mismatch (-want +got):\n%s", diff)
	}

	// Verify scope doc comment
	if len(result.Scopes) == 0 {
		t.Fatal("Expected at least one scope")
	}
	if diff := cmp.Diff([]string{"// Another comment"}, result.Scopes[0].LeadingComments); diff != "" {
		t.Errorf("Scope.LeadingComments mismatch (-want +got):\n%s", diff)
	}

	// Verify test doc comment
	if len(result.Scopes[0].Items) == 0 || result.Scopes[0].Items[0].Test == nil {
		t.Fatal("Expected at least one test")
	}
	test := result.Scopes[0].Items[0].Test
	if diff := cmp.Diff([]string{"// Test comment"}, test.LeadingComments); diff != "" {
		t.Errorf("Test.LeadingComments mismatch (-want +got):\n%s", diff)
	}

	// Verify statement doc comment (new feature)
	if len(test.Statements) == 0 {
		t.Fatal("Expected at least one statement")
	}
	if diff := cmp.Diff([]string{"// Input comment"}, test.Statements[0].LeadingComments); diff != "" {
		t.Errorf("Statement.LeadingComments mismatch (-want +got):\n%s", diff)
	}
}

func TestValueString(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		value    *scaf.Value
		expected string
	}{
		{name: "null", value: &scaf.Value{Null: true}, expected: "null"},
		{name: "string", value: &scaf.Value{Str: ptr("hello")}, expected: `"hello"`},
		{name: "number", value: &scaf.Value{Number: ptr(42.0)}, expected: "42"},
		{name: "float", value: &scaf.Value{Number: ptr(3.14)}, expected: "3.14"},
		{name: "bool true", value: &scaf.Value{Boolean: boolPtr(true)}, expected: "true"},
		{name: "bool false", value: &scaf.Value{Boolean: boolPtr(false)}, expected: "false"},
		{name: "empty list", value: &scaf.Value{List: &scaf.List{}}, expected: "[]"},
		{
			name: "list",
			value: &scaf.Value{List: &scaf.List{Values: []*scaf.Value{
				{Number: ptr(1.0)},
				{Str: ptr("two")},
			}}},
			expected: `[1, "two"]`,
		},
		{name: "empty map", value: &scaf.Value{Map: &scaf.Map{}}, expected: "{}"},
		{
			name: "map",
			value: &scaf.Value{Map: &scaf.Map{Entries: []*scaf.MapEntry{
				{Key: "a", Value: &scaf.Value{Number: ptr(1.0)}},
				{Key: "b", Value: &scaf.Value{Str: ptr("two")}},
			}}},
			expected: `{a: 1, b: "two"}`,
		},
		{name: "nil value", value: &scaf.Value{}, expected: "nil"},
	}

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

			got := tt.value.String()
			if got != tt.expected {
				t.Errorf("String() = %q, want %q", got, tt.expected)
			}
		})
	}
}

func TestParseExprAssert(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		input    string
		expected []string // expected expression strings
	}{
		{
			name: "simple comparison",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert { (u.age > 18) }
					}
				}
			`,
			expected: []string{"u.age > 18"},
		},
		{
			name: "expression with function call",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert { (u.createdAt - now() < duration("24h")) }
					}
				}
			`,
			expected: []string{`u.createdAt - now() < duration("24h")`},
		},
		{
			name: "complex expression",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert { (len(u.posts) > 0 && u.verified == true) }
					}
				}
			`,
			expected: []string{"len(u.posts) > 0 && u.verified == true"},
		},
		{
			name: "multiple expressions",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert { (x > 0) (y < 10) (z == 5) }
					}
				}
			`,
			expected: []string{"x > 0", "y < 10", "z == 5"},
		},
	}

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

			result, err := scaf.Parse([]byte(tt.input))
			if err != nil {
				t.Fatalf("Parse() error: %v", err)
			}

			test := result.Scopes[0].Items[0].Test
			if len(test.Asserts) == 0 {
				t.Fatal("Expected at least one assert")
			}

			assert := test.Asserts[0]
			if assert.Query != nil {
				t.Fatal("Expected standalone assert (no query)")
			}

			if len(assert.Conditions) != len(tt.expected) {
				t.Fatalf("Conditions count = %d, want %d", len(assert.Conditions), len(tt.expected))
			}

			for i, cond := range assert.Conditions {
				gotExpr := cond.String()
				if gotExpr != tt.expected[i] {
					t.Errorf("Condition[%d] = %q, want %q", i, gotExpr, tt.expected[i])
				}
			}
		})
	}
}

func TestParseShorthandAssert(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		input    string
		expected string // expected expression string
	}{
		{
			name: "simple shorthand assert",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert (u.age >= 18)
					}
				}
			`,
			expected: "u.age >= 18",
		},
		{
			name: "shorthand with function call",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert (len(items) > 0)
					}
				}
			`,
			expected: "len(items) > 0",
		},
		{
			name: "shorthand with complex expression",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert (x > 0 && y < 10)
					}
				}
			`,
			expected: "x > 0 && y < 10",
		},
		{
			name: "shorthand with member access",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert (user.profile.name == "Alice")
					}
				}
			`,
			expected: `user.profile.name == "Alice"`,
		},
		{
			name: "shorthand with nested parens",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert ((x + y) * 2 > 10)
					}
				}
			`,
			expected: "(x + y) * 2 > 10",
		},
		{
			name: "multiple shorthand asserts",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert (x > 0)
						assert (y < 10)
						assert (z == 5)
					}
				}
			`,
			expected: "x > 0", // First assert
		},
	}

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

			result, err := scaf.Parse([]byte(tt.input))
			if err != nil {
				t.Fatalf("Parse() error: %v", err)
			}

			test := result.Scopes[0].Items[0].Test
			if len(test.Asserts) == 0 {
				t.Fatal("Expected at least one assert")
			}

			assert := test.Asserts[0]

			// Should be shorthand form
			if !assert.IsShorthand() {
				t.Fatal("Expected shorthand assert form")
			}

			if assert.Shorthand == nil {
				t.Fatal("Expected Shorthand to be non-nil")
			}

			gotExpr := assert.Shorthand.String()
			if gotExpr != tt.expected {
				t.Errorf("Shorthand.String() = %q, want %q", gotExpr, tt.expected)
			}

			// AllConditions should return the shorthand as a single condition
			allConds := assert.AllConditions()
			if len(allConds) != 1 {
				t.Errorf("AllConditions() count = %d, want 1", len(allConds))
			}
		})
	}
}

func TestParseQueryAssert(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name           string
		input          string
		expectedInline *string
		expectedQuery  *string
		expectedParams int
		expectedConds  int
	}{
		{
			name: "inline query with conditions",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert ` + "`MATCH (n) RETURN count(n) as cnt`" + ` {
							(cnt > 0)
							(cnt < 100)
						}
					}
				}
			`,
			expectedInline: ptr("MATCH (n) RETURN count(n) as cnt"),
			expectedConds:  2,
		},
		{
			name: "named query without params",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert CheckCount() {
							(c == 1)
						}
					}
				}
			`,
			expectedQuery:  ptr("CheckCount"),
			expectedParams: 0,
			expectedConds:  1,
		},
		{
			name: "named query with params",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert CreatePost($title: "test", $authorId: 1) {
							(p.title == "test")
						}
					}
				}
			`,
			expectedQuery:  ptr("CreatePost"),
			expectedParams: 2,
			expectedConds:  1,
		},
	}

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

			result, err := scaf.Parse([]byte(tt.input))
			if err != nil {
				t.Fatalf("Parse() error: %v", err)
			}

			test := result.Scopes[0].Items[0].Test
			if len(test.Asserts) == 0 {
				t.Fatal("Expected at least one assert")
			}

			assert := test.Asserts[0]
			if assert.Query == nil {
				t.Fatal("Expected QueryAssert")
			}

			qa := assert.Query
			if tt.expectedInline != nil {
				if qa.Inline == nil || *qa.Inline != *tt.expectedInline {
					t.Errorf("Inline = %v, want %v", qa.Inline, *tt.expectedInline)
				}
			}

			if tt.expectedQuery != nil {
				if qa.QueryName == nil || *qa.QueryName != *tt.expectedQuery {
					t.Errorf("QueryName = %v, want %v", qa.QueryName, *tt.expectedQuery)
				}
			}

			if len(qa.Params) != tt.expectedParams {
				t.Errorf("Params count = %d, want %d", len(qa.Params), tt.expectedParams)
			}

			if len(assert.Conditions) != tt.expectedConds {
				t.Errorf("Conditions count = %d, want %d", len(assert.Conditions), tt.expectedConds)
			}
		})
	}
}

// TODO: TestParseComputedField - ComputedFields feature removed temporarily
// Will be re-added with proper syntax disambiguation (e.g., "mock u { field: expr }")

func TestParseWithRecovery(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name        string
		input       string
		expectError bool
		checkAST    func(t *testing.T, suite *scaf.Suite)
	}{
		{
			name: "valid input with recovery enabled",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						$id: 1
					}
				}
			`,
			expectError: false,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				if len(suite.Scopes) != 1 {
					t.Errorf("Expected 1 scope, got %d", len(suite.Scopes))
				}
				if len(suite.Scopes[0].Items) != 1 {
					t.Errorf("Expected 1 item, got %d", len(suite.Scopes[0].Items))
				}
			},
		},
		// Note: Recovery only works for parse errors, not lexer errors.
		// Unterminated strings cause lexer errors before parsing begins.
		// Test cases below use syntactically invalid (but lexically valid) input.
		{
			name: "incomplete setup - missing close paren",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup Func(
					test "t" {}
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				// Should still have partial AST
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				if len(suite.Functions) != 1 {
					t.Errorf("Expected 1 query, got %d", len(suite.Functions))
				}
				if len(suite.Scopes) != 1 {
					t.Errorf("Expected 1 scope, got %d", len(suite.Scopes))
				}
			},
		},
		{
			name: "incomplete test - missing closing brace",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "unclosed" {
						$id: 1
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				// Should still have partial AST
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				if len(suite.Functions) != 1 {
					t.Errorf("Expected 1 query, got %d", len(suite.Functions))
				}
			},
		},
		{
			name: "multiple scopes with error in second",
			input: `
				fn Q1() ` + "`Q1`" + `
				fn Q2() ` + "`Q2`" + `
				Q1 {
					test "valid" {}
				}
				Q2 {
					setup Func(
					test "after error" {}
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				if len(suite.Functions) != 2 {
					t.Errorf("Expected 2 queries, got %d", len(suite.Functions))
				}
				// Both scopes should be present
				if len(suite.Scopes) != 2 {
					t.Errorf("Expected 2 scopes, got %d", len(suite.Scopes))
				}
			},
		},
		{
			name: "extra token after setup",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup ` + "`Q`" + ` extra
					test "t" {}
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				if len(suite.Functions) != 1 {
					t.Errorf("Expected 1 query, got %d", len(suite.Functions))
				}
			},
		},
		// Empty setup recovery - previously caused panic when recovery found sync token
		// immediately without consuming any tokens. Fixed by checking result.progressed.
		{
			name: "empty setup before closing brace",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				// Recovery should gracefully handle this without panic
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
			},
		},
		{
			name: "empty setup before test keyword",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup
					test "t" {}
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				// Recovery should gracefully handle this without panic
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				// The test after setup should still be parsed
				if len(suite.Scopes) != 1 {
					t.Fatalf("Expected 1 scope, got %d", len(suite.Scopes))
				}
				// We expect the test to be parsed after recovery skips the invalid setup
				scope := suite.Scopes[0]
				if len(scope.Items) < 1 {
					t.Error("Expected at least 1 item in scope after recovery")
				}
			},
		},
		// Test recovery for incomplete test constructs
		// NOTE: Recovery only works when there's partial content to consume.
		// When just "test" keyword with no name, recovery cannot make progress.
		{
			name: "test missing name and brace",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				// Recovery can't progress when there's no content after the keyword
				// because it can't consume any tokens. The partial AST will exist
				// but may not contain the test item.
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
			},
		},
		{
			name: "test missing closing brace with content",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "incomplete" {
						$id: 1
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				// The scope should parse with recovery finding the closing brace
				if len(suite.Scopes) != 1 {
					t.Errorf("Expected 1 scope, got %d", len(suite.Scopes))
				}
			},
		},
		{
			name: "test followed by another test (recovery stops at keyword)",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "first" {
					test "second" {}
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				// When test "first" { has no closing brace and is immediately followed by
				// another test keyword, recovery finds the sync token immediately without
				// consuming tokens. Since no progress is made, recovery returns nil/nil,
				// causing the entire scope to fail. This is correct behavior - we can't
				// return a value without progress (would cause infinite loops in disjunction).
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				// The query should still be present
				if len(suite.Functions) != 1 {
					t.Errorf("Expected 1 query, got %d", len(suite.Functions))
				}
			},
		},
		// Group recovery tests
		// NOTE: Recovery only works when there's partial content to consume.
		{
			name: "group missing name",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					group
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				// Recovery can't progress when there's no content after the keyword
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
			},
		},
		{
			name: "group missing closing brace",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					group "incomplete" {
						test "inner" {}
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				// Should have partial AST
				if len(suite.Functions) != 1 {
					t.Errorf("Expected 1 query, got %d", len(suite.Functions))
				}
			},
		},
		// Assert recovery tests
		// NOTE: Recovery only works when there's partial content to consume.
		{
			name: "assert missing brace",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert
					}
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				// Recovery can't progress when there's no content after the keyword
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
			},
		},
		{
			name: "assert with query missing closing brace",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert QueryName() {
					}
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				// Should have partial AST
				if len(suite.Functions) != 1 {
					t.Errorf("Expected 1 query, got %d", len(suite.Functions))
				}
			},
		},
		{
			name: "assert with inline query missing close",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert ` + "`SELECT 1`" + ` {
					}
				}
			`,
			expectError: true,
			checkAST: func(t *testing.T, suite *scaf.Suite) {
				if suite == nil {
					t.Fatal("Expected partial AST, got nil")
				}
				if len(suite.Functions) != 1 {
					t.Errorf("Expected 1 query, got %d", len(suite.Functions))
				}
			},
		},
	}

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

			suite, err := scaf.ParseWithRecovery([]byte(tt.input), true)

			if tt.expectError && err == nil {
				t.Error("Expected error, got nil")
			}
			if !tt.expectError && err != nil {
				t.Errorf("Unexpected error: %v", err)
			}

			if tt.checkAST != nil {
				tt.checkAST(t, suite)
			}
		})
	}
}

func TestIsComplete(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name    string
		input   string
		checkFn func(t *testing.T, suite *scaf.Suite)
	}{
		{
			name: "complete test has Close",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {}
				}
			`,
			checkFn: func(t *testing.T, suite *scaf.Suite) {
				test := suite.Scopes[0].Items[0].Test
				if test == nil {
					t.Fatal("Expected test, got nil")
				}
				if !test.IsComplete() {
					t.Error("Expected test.IsComplete() = true")
				}
				if test.Close != "}" {
					t.Errorf("Expected test.Close = '}', got %q", test.Close)
				}
			},
		},
		{
			name: "complete group has Close",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					group "g" {
						test "t" {}
					}
				}
			`,
			checkFn: func(t *testing.T, suite *scaf.Suite) {
				group := suite.Scopes[0].Items[0].Group
				if group == nil {
					t.Fatal("Expected group, got nil")
				}
				if !group.IsComplete() {
					t.Error("Expected group.IsComplete() = true")
				}
				if group.Close != "}" {
					t.Errorf("Expected group.Close = '}', got %q", group.Close)
				}
			},
		},
		{
			name: "complete assert has Close",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {
						assert { (true) }
					}
				}
			`,
			checkFn: func(t *testing.T, suite *scaf.Suite) {
				test := suite.Scopes[0].Items[0].Test
				if len(test.Asserts) != 1 {
					t.Fatalf("Expected 1 assert, got %d", len(test.Asserts))
				}
				assert := test.Asserts[0]
				if !assert.IsComplete() {
					t.Error("Expected assert.IsComplete() = true")
				}
				if assert.Close != "}" {
					t.Errorf("Expected assert.Close = '}', got %q", assert.Close)
				}
			},
		},
		{
			name: "complete QueryScope has Close",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					test "t" {}
				}
			`,
			checkFn: func(t *testing.T, suite *scaf.Suite) {
				scope := suite.Scopes[0]
				if !scope.IsComplete() {
					t.Error("Expected scope.IsComplete() = true")
				}
				if scope.Close != "}" {
					t.Errorf("Expected scope.Close = '}', got %q", scope.Close)
				}
			},
		},
		{
			name: "complete SetupClause with inline",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup ` + "`CREATE (:N)`" + `
					test "t" {}
				}
			`,
			checkFn: func(t *testing.T, suite *scaf.Suite) {
				setup := suite.Scopes[0].Setup
				if setup == nil {
					t.Fatal("Expected setup, got nil")
				}
				if !setup.IsComplete() {
					t.Error("Expected setup.IsComplete() = true")
				}
			},
		},
		{
			name: "complete SetupCall",
			input: `
				fn Q() ` + "`Q`" + `
				Q {
					setup fixtures.Func()
					test "t" {}
				}
			`,
			checkFn: func(t *testing.T, suite *scaf.Suite) {
				setup := suite.Scopes[0].Setup
				if setup == nil || setup.Call == nil {
					t.Fatal("Expected setup call")
				}
				if !setup.Call.IsComplete() {
					t.Error("Expected setup.Call.IsComplete() = true")
				}
				if setup.Call.Query != "Func" {
					t.Errorf("Expected setup.Call.Query = 'Func', got %q", setup.Call.Query)
				}
				if setup.Call.Module != "fixtures" {
					t.Errorf("Expected setup.Call.Module = 'fixtures', got %q", setup.Call.Module)
				}
			},
		},
	}

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

			suite, err := scaf.Parse([]byte(tt.input))
			if err != nil {
				t.Fatalf("Parse error: %v", err)
			}

			tt.checkFn(t, suite)
		})
	}
}