qparser_test.go

package qparser

import (
	"errors"
	"testing"
	"time"
)

// TestIsQuery tests the IsQuery function
func TestIsQuery(t *testing.T) {
	tests := []struct {
		input    string
		expected bool
	}{
		{"title:hello", true},
		{"title:hello world", true},
		{"plain text", false},
		{"", false},
		{"title:", true},
		{"just text without colon", false},
	}

	for _, test := range tests {
		result := IsQuery(test.input)
		if result != test.expected {
			t.Errorf("IsQuery(%q) = %v, expected %v", test.input, result, test.expected)
		}
	}
}

// TestUnmarshal_BasicExample tests the basic example from README
func TestUnmarshal_BasicExample(t *testing.T) {
	type SearchFilter struct {
		Keyword string    `query:"keyword,default"`
		Title   string    `query:"title"`
		Limit   int       `query:"limit"`
		Tags    []string  `query:"tags"`
		Before  time.Time `query:"before,format=2006-01-02"`
	}

	q := `hello world title:foobar limit:42 tags:admin,editor,guest before:2024-12-31`

	var filter SearchFilter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	if filter.Keyword != "hello world" {
		t.Errorf("Keyword = %q, expected %q", filter.Keyword, "hello world")
	}

	if filter.Title != "foobar" {
		t.Errorf("Title = %q, expected %q", filter.Title, "foobar")
	}

	if filter.Limit != 42 {
		t.Errorf("Limit = %d, expected %d", filter.Limit, 42)
	}

	expectedTags := []string{"admin", "editor", "guest"}
	if len(filter.Tags) != len(expectedTags) {
		t.Errorf("Tags length = %d, expected %d", len(filter.Tags), len(expectedTags))
	}
	for i, tag := range filter.Tags {
		if i >= len(expectedTags) || tag != expectedTags[i] {
			t.Errorf("Tags[%d] = %q, expected %q", i, tag, expectedTags[i])
		}
	}

	expectedTime := time.Date(2024, 12, 31, 0, 0, 0, 0, time.UTC)
	if !filter.Before.Equal(expectedTime) {
		t.Errorf("Before = %v, expected %v", filter.Before, expectedTime)
	}
}

// TestUnmarshal_BasicParsing tests basic parsing
func TestUnmarshal_BasicParsing(t *testing.T) {
	type Filter struct {
		Title    string `query:"title"`
		Author   string `query:"author"`
		Category string `query:"category"`
	}

	q := `title:hello author:world category:"science fiction"`

	var filter Filter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	if filter.Title != "hello" {
		t.Errorf("Title = %q, expected %q", filter.Title, "hello")
	}

	if filter.Author != "world" {
		t.Errorf("Author = %q, expected %q", filter.Author, "world")
	}

	if filter.Category != "science fiction" {
		t.Errorf("Category = %q, expected %q", filter.Category, "science fiction")
	}
}

// TestUnmarshal_FallbackParsing tests fallback parsing
func TestUnmarshal_FallbackParsing(t *testing.T) {
	type Filter struct {
		Query string `query:"query,default"`
		Type  string `query:"type"`
	}

	q := `search for golang tutorials`

	var filter Filter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	if filter.Query != "search for golang tutorials" {
		t.Errorf("Query = %q, expected %q", filter.Query, "search for golang tutorials")
	}

	if filter.Type != "" {
		t.Errorf("Type = %q, expected empty string", filter.Type)
	}
}

// TestUnmarshal_EnhancedFallbackParsing tests enhanced fallback parsing
func TestUnmarshal_EnhancedFallbackParsing(t *testing.T) {
	type Filter struct {
		Keyword  string `query:"keyword,default"`
		Category string `query:"category"`
	}

	q := `hello world category:books foo bar emotion:happy`

	var filter Filter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	expectedKeyword := "hello world foo bar emotion:happy"
	if filter.Keyword != expectedKeyword {
		t.Errorf("Keyword = %q, expected %q", filter.Keyword, expectedKeyword)
	}

	if filter.Category != "books" {
		t.Errorf("Category = %q, expected %q", filter.Category, "books")
	}
}

// TestUnmarshal_NumericParsing tests numeric parsing
func TestUnmarshal_NumericParsing(t *testing.T) {
	type Filter struct {
		Price    float64 `query:"price"`
		Discount float32 `query:"discount"`
		Quantity uint32  `query:"qty"`
		MinAge   int8    `query:"min_age"`
		MaxSize  uint64  `query:"max_size"`
	}

	q := `price:10.10 discount:0.10 qty:100 min_age:10 max_size:100000`

	var filter Filter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	if filter.Price != 10.10 {
		t.Errorf("Price = %f, expected %f", filter.Price, 10.10)
	}

	if filter.Discount != 0.10 {
		t.Errorf("Discount = %f, expected %f", filter.Discount, 0.10)
	}

	if filter.Quantity != 100 {
		t.Errorf("Quantity = %d, expected %d", filter.Quantity, 100)
	}

	if filter.MinAge != 10 {
		t.Errorf("MinAge = %d, expected %d", filter.MinAge, 10)
	}

	if filter.MaxSize != 100000 {
		t.Errorf("MaxSize = %d, expected %d", filter.MaxSize, 100000)
	}
}

// TestUnmarshal_SliceParsing tests slice parsing
func TestUnmarshal_SliceParsing(t *testing.T) {
	type Filter struct {
		Tags    []string  `query:"tags"`
		Scores  []int     `query:"scores"`
		Weights []float64 `query:"weights"`
	}

	q := `tags:foo,bar scores:10,20,30 weights:0.1,0.2,0.3`

	var filter Filter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	expectedTags := []string{"foo", "bar"}
	if len(filter.Tags) != len(expectedTags) {
		t.Errorf("Tags length = %d, expected %d", len(filter.Tags), len(expectedTags))
	}
	for i, tag := range filter.Tags {
		if i >= len(expectedTags) || tag != expectedTags[i] {
			t.Errorf("Tags[%d] = %q, expected %q", i, tag, expectedTags[i])
		}
	}

	expectedScores := []int{10, 20, 30}
	if len(filter.Scores) != len(expectedScores) {
		t.Errorf("Scores length = %d, expected %d", len(filter.Scores), len(expectedScores))
	}
	for i, score := range filter.Scores {
		if i >= len(expectedScores) || score != expectedScores[i] {
			t.Errorf("Scores[%d] = %d, expected %d", i, score, expectedScores[i])
		}
	}

	expectedWeights := []float64{0.1, 0.2, 0.3}
	if len(filter.Weights) != len(expectedWeights) {
		t.Errorf("Weights length = %d, expected %d", len(filter.Weights), len(expectedWeights))
	}
	for i, weight := range filter.Weights {
		if i >= len(expectedWeights) || weight != expectedWeights[i] {
			t.Errorf("Weights[%d] = %f, expected %f", i, weight, expectedWeights[i])
		}
	}
}

// TestUnmarshal_SliceWithSpaces tests slice parsing with spaces
func TestUnmarshal_SliceWithSpaces(t *testing.T) {
	type Filter struct {
		Tags []string `query:"tags"`
	}

	q := `tags:"hello world,golang,web dev"`

	var filter Filter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	expectedTags := []string{"hello world", "golang", "web dev"}
	if len(filter.Tags) != len(expectedTags) {
		t.Errorf("Tags length = %d, expected %d", len(filter.Tags), len(expectedTags))
	}
	for i, tag := range filter.Tags {
		if i >= len(expectedTags) || tag != expectedTags[i] {
			t.Errorf("Tags[%d] = %q, expected %q", i, tag, expectedTags[i])
		}
	}
}

// TestUnmarshal_TimeParsing tests time parsing
func TestUnmarshal_TimeParsing(t *testing.T) {
	type Filter struct {
		StartedAt   time.Time `query:"started_at"`
		EndedAt     time.Time `query:"ended_at,format=01/02/2006"`
		PublishDate time.Time `query:"publish_date,format=2006 2006-01 2006-01-02"`
	}

	q := `started_at:2025-12-30 ended_at:12/30/2025 publish_date:2025`

	var filter Filter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	expectedStartedAt := time.Date(2025, 12, 30, 0, 0, 0, 0, time.UTC)
	if !filter.StartedAt.Equal(expectedStartedAt) {
		t.Errorf("StartedAt = %v, expected %v", filter.StartedAt, expectedStartedAt)
	}

	expectedEndedAt := time.Date(2025, 12, 30, 0, 0, 0, 0, time.UTC)
	if !filter.EndedAt.Equal(expectedEndedAt) {
		t.Errorf("EndedAt = %v, expected %v", filter.EndedAt, expectedEndedAt)
	}

	expectedPublishDate := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
	if !filter.PublishDate.Equal(expectedPublishDate) {
		t.Errorf("PublishDate = %v, expected %v", filter.PublishDate, expectedPublishDate)
	}
}

// TestUnmarshal_BooleanParsing tests boolean parsing
func TestUnmarshal_BooleanParsing(t *testing.T) {
	type Filter struct {
		IsActive   bool  `query:"is_active"`
		IsRequired *bool `query:"is_required"`
	}

	q := `is_active:true`

	var filter Filter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	if !filter.IsActive {
		t.Errorf("IsActive = %v, expected %v", filter.IsActive, true)
	}

	if filter.IsRequired != nil {
		t.Errorf("IsRequired = %v, expected nil", *filter.IsRequired)
	}
}

// TestUnmarshal_PointerTypes tests pointer types
func TestUnmarshal_PointerTypes(t *testing.T) {
	type Filter struct {
		Title  *string `query:"title"`
		Count  *int    `query:"count"`
		Active *bool   `query:"active"`
	}

	q := `title:hello count:42 active:true`

	var filter Filter
	err := Unmarshal(q, &filter)
	if err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	if filter.Title == nil || *filter.Title != "hello" {
		t.Errorf("Title = %v, expected %q", filter.Title, "hello")
	}

	if filter.Count == nil || *filter.Count != 42 {
		t.Errorf("Count = %v, expected %d", filter.Count, 42)
	}

	if filter.Active == nil || !*filter.Active {
		t.Errorf("Active = %v, expected %v", filter.Active, true)
	}
}

// TestUnmarshalStrict_InvalidValue tests UnmarshalStrict handling of invalid values
func TestUnmarshalStrict_InvalidValue(t *testing.T) {
	type Filter struct {
		Count int `query:"count"`
	}

	q := `count:invalid`

	var filter Filter
	err := UnmarshalStrict(q, &filter)

	if err == nil {
		t.Fatal("UnmarshalStrict should return error for invalid value")
	}

	if !errors.Is(err, ErrInvalidValue) {
		t.Errorf("Expected ErrInvalidValue, got %v", err)
	}

	// Ensure field is set to zero value
	if filter.Count != 0 {
		t.Errorf("Count = %d, expected 0 (zero value)", filter.Count)
	}
}

// TestUnmarshalStrict_UnknownField tests UnmarshalStrict handling of unknown fields
func TestUnmarshalStrict_UnknownField(t *testing.T) {
	type Filter struct {
		Title   string `query:"title"`
		Keyword string `query:"keyword,default"`
	}

	q := `title:hello unknown:value extra text`

	var filter Filter
	err := UnmarshalStrict(q, &filter)

	if err == nil {
		t.Fatal("UnmarshalStrict should return error for unknown field")
	}

	if !errors.Is(err, ErrUnknownField) {
		t.Errorf("Expected ErrUnknownField, got %v", err)
	}

	// Ensure known fields parse correctly
	if filter.Title != "hello" {
		t.Errorf("Title = %q, expected %q", filter.Title, "hello")
	}

	// Ensure unknown fields and extra text are added to default field
	expectedKeyword := "unknown:value extra text"
	if filter.Keyword != expectedKeyword {
		t.Errorf("Keyword = %q, expected %q", filter.Keyword, expectedKeyword)
	}
}

// TestUnmarshal_NormalBehavior tests Unmarshal normal behavior (no errors returned)
func TestUnmarshal_NormalBehavior(t *testing.T) {
	type Filter struct {
		Count   int    `query:"count"`
		Title   string `query:"title"`
		Keyword string `query:"keyword,default"`
	}

	q := `title:hello count:invalid unknown:value extra text`

	var filter Filter
	err := Unmarshal(q, &filter)

	if err != nil {
		t.Fatalf("Unmarshal should not return error: %v", err)
	}

	// Ensure known fields parse correctly
	if filter.Title != "hello" {
		t.Errorf("Title = %q, expected %q", filter.Title, "hello")
	}

	// Ensure invalid values are set to zero value
	if filter.Count != 0 {
		t.Errorf("Count = %d, expected 0 (zero value)", filter.Count)
	}

	// Ensure unknown fields and extra text are added to default field
	expectedKeyword := "unknown:value extra text"
	if filter.Keyword != expectedKeyword {
		t.Errorf("Keyword = %q, expected %q", filter.Keyword, expectedKeyword)
	}
}