logarchiver/internal/index/query_test.go

package index

import (
	"regexp"
	"strings"
	"testing"
	"time"
)

func TestSubjectToRegex(t *testing.T) {
	cases := []struct {
		glob    string
		match   []string
		nomatch []string
	}{
		{
			glob:    "logs.vm.*",
			match:   []string{"logs.vm.db-1", "logs.vm.web"},
			nomatch: []string{"logs.vm", "logs.vm.db.1", "logs.k8s.x"},
		},
		{
			glob:    "logs.k8s.vault.>",
			match:   []string{"logs.k8s.vault.audit", "logs.k8s.vault.a.b", "logs.k8s.vault"},
			nomatch: []string{"logs.k8s.shop.web", "logs.vm.x"},
		},
		{
			glob:    "logs.vm.db-1",
			match:   []string{"logs.vm.db-1"},
			nomatch: []string{"logs.vm.db-2", "logs.vm.db-1.x"},
		},
	}
	for _, c := range cases {
		re := regexp.MustCompile(subjectToRegex(c.glob))
		for _, s := range c.match {
			if !re.MatchString(s) {
				t.Errorf("%q -> %q should match %q", c.glob, re.String(), s)
			}
		}
		for _, s := range c.nomatch {
			if re.MatchString(s) {
				t.Errorf("%q -> %q should NOT match %q", c.glob, re.String(), s)
			}
		}
	}
}

func TestBuildSearchSQLFull(t *testing.T) {
	from := time.Date(2026, 7, 26, 0, 0, 0, 0, time.UTC)
	to := time.Date(2026, 7, 27, 0, 0, 0, 0, time.UTC)
	sql, args := buildSearchSQL("logs", "archive_index", SearchQuery{
		Subject: "logs.k8s.vault.>",
		Host:    "node-1",
		From:    from,
		To:      to,
		Limit:   50,
	})
	if !strings.Contains(sql, "FROM logs.archive_index") {
		t.Errorf("missing table: %s", sql)
	}
	for _, want := range []string{"match(subject, ?)", "has(hosts, ?)", "max_ts >= ?", "min_ts <= ?", "ORDER BY min_ts", "LIMIT ?"} {
		if !strings.Contains(sql, want) {
			t.Errorf("sql missing %q: %s", want, sql)
		}
	}
	if len(args) != 5 {
		t.Fatalf("args = %d, want 5: %v", len(args), args)
	}
	if args[1] != "node-1" {
		t.Errorf("host arg = %v", args[1])
	}
	if args[4] != 50 {
		t.Errorf("limit arg = %v", args[4])
	}
}

func TestBuildSearchSQLEmpty(t *testing.T) {
	sql, args := buildSearchSQL("logs", "archive_index", SearchQuery{})
	if strings.Contains(sql, "WHERE") {
		t.Errorf("empty query should have no WHERE: %s", sql)
	}
	if len(args) != 0 {
		t.Errorf("args = %v, want none", args)
	}
}

func TestBuildSearchSQLHostGlob(t *testing.T) {
	sql, args := buildSearchSQL("logs", "archive_index", SearchQuery{Host: "db-*"})
	if !strings.Contains(sql, "arrayExists(h -> match(h, ?), hosts)") {
		t.Errorf("host glob should use arrayExists/match: %s", sql)
	}
	if len(args) != 1 {
		t.Fatalf("args = %v", args)
	}
	re := regexp.MustCompile(args[0].(string))
	if !re.MatchString("db-1") || re.MatchString("web-1") {
		t.Errorf("host glob regex wrong: %q", args[0])
	}
}

func TestDDLContainsKeyColumns(t *testing.T) {
	ddl := CreateTableSQL("logs", "archive_index")
	for _, col := range []string{"object_key", "subject", "hosts", "min_ts", "max_ts", "event_count", "key_fingerprint", "bloom_filter"} {
		if !strings.Contains(ddl, col) {
			t.Errorf("DDL missing %q", col)
		}
	}
	if !strings.Contains(ddl, "IF NOT EXISTS") {
		t.Errorf("DDL should be idempotent")
	}
}