beads/internal/query/query_test.go
Rome Thorstenson 0121718514
fix(query): lex digit-led identifier-shaped tokens as identifiers (#4403)
The query lexer unconditionally dispatched digit-led tokens to the
number/duration reader, which only accepts digits followed by an optional
single-character duration suffix. Identifier-shaped values like
"1-alpha" or "42d-sla" tripped the reader at the first non-digit /
non-suffix byte:

    $ bd query 'assignee=1-alpha'
    Error: parsing query: expected digit at position 11

Every caller that wanted to filter on such a value had to quote it or
fall back to a client-side filter, which is silly given that the
character set is already accepted in the identifier reader. The query
DSL otherwise treats identifiers and values uniformly (cf. existing
"identifier with hyphen" / "unquoted identifier with colon" coverage),
so it is the digit-led case that is the outlier.

Two changes in readNumberOrDuration:

  - The duration suffix only fires when the suffix character stands
    alone (no further identifier-continuation lookahead). "7d" → still
    a duration; "7day" → falls through to identifier.
  - After reading the digit run, if an unsigned token butts against
    more identifier characters, the lex restarts at the start position
    and re-reads the token as an identifier. Signed forms ("-3-foo")
    still error so arithmetic-shaped input doesn't silently become an
    identifier.

Five lexer cases added covering both directions: digit-led identifiers
parse cleanly, durations still survive when the suffix is terminal.
2026-07-05 11:15:15 -07:00

882 lines
26 KiB
Go

package query
import (
"testing"
"time"
"github.com/steveyegge/beads/internal/types"
)
func TestLexer(t *testing.T) {
tests := []struct {
name string
input string
expected []TokenType
values []string
}{
{
name: "simple equality",
input: "status=open",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"status", "=", "open", ""},
},
{
name: "not equals",
input: "status!=closed",
expected: []TokenType{TokenIdent, TokenNotEquals, TokenIdent, TokenEOF},
values: []string{"status", "!=", "closed", ""},
},
{
name: "greater than",
input: "priority>1",
expected: []TokenType{TokenIdent, TokenGreater, TokenNumber, TokenEOF},
values: []string{"priority", ">", "1", ""},
},
{
name: "less than or equal",
input: "priority<=3",
expected: []TokenType{TokenIdent, TokenLessEq, TokenNumber, TokenEOF},
values: []string{"priority", "<=", "3", ""},
},
{
name: "duration value",
input: "updated>7d",
expected: []TokenType{TokenIdent, TokenGreater, TokenDuration, TokenEOF},
values: []string{"updated", ">", "7d", ""},
},
{
name: "AND expression",
input: "status=open AND priority>1",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenAnd, TokenIdent, TokenGreater, TokenNumber, TokenEOF},
values: []string{"status", "=", "open", "AND", "priority", ">", "1", ""},
},
{
name: "OR expression",
input: "status=open OR status=blocked",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenOr, TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"status", "=", "open", "OR", "status", "=", "blocked", ""},
},
{
name: "NOT expression",
input: "NOT status=closed",
expected: []TokenType{TokenNot, TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"NOT", "status", "=", "closed", ""},
},
{
name: "parentheses",
input: "(status=open)",
expected: []TokenType{TokenLParen, TokenIdent, TokenEquals, TokenIdent, TokenRParen, TokenEOF},
values: []string{"(", "status", "=", "open", ")", ""},
},
{
name: "quoted string",
input: `title="hello world"`,
expected: []TokenType{TokenIdent, TokenEquals, TokenString, TokenEOF},
values: []string{"title", "=", "hello world", ""},
},
{
name: "compound expression with colon in label value",
input: "ephemeral=true AND label=gt:merge-request AND status=open",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenAnd, TokenIdent, TokenEquals, TokenIdent, TokenAnd, TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"ephemeral", "=", "true", "AND", "label", "=", "gt:merge-request", "AND", "status", "=", "open", ""},
},
{
name: "case insensitive keywords",
input: "status=open and priority>1 or type=bug",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenAnd, TokenIdent, TokenGreater, TokenNumber, TokenOr, TokenIdent, TokenEquals, TokenIdent, TokenEOF},
},
{
name: "negative number",
input: "priority>-1",
expected: []TokenType{TokenIdent, TokenGreater, TokenNumber, TokenEOF},
values: []string{"priority", ">", "-1", ""},
},
{
name: "identifier with hyphen",
input: "id=bd-abc123",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"id", "=", "bd-abc123", ""},
},
{
name: "identifier with underscore",
input: "mol_type=swarm",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"mol_type", "=", "swarm", ""},
},
{
name: "quoted string with colon",
input: `label="gt:merge-request"`,
expected: []TokenType{TokenIdent, TokenEquals, TokenString, TokenEOF},
values: []string{"label", "=", "gt:merge-request", ""},
},
{
name: "unquoted identifier with colon",
input: "label=gt:merge-request",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"label", "=", "gt:merge-request", ""},
},
{
name: "digit-led identifier on the value side",
input: "assignee=1-alpha",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"assignee", "=", "1-alpha", ""},
},
{
name: "digit-led identifier in a compound expression",
input: "assignee=2-bravo AND status=open",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenAnd, TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"assignee", "=", "2-bravo", "AND", "status", "=", "open", ""},
},
{
name: "digit-led identifier with duration-suffix prefix",
input: "label=7day-window",
expected: []TokenType{TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"label", "=", "7day-window", ""},
},
{
name: "duration still wins when the suffix stands alone",
input: "updated>30d",
expected: []TokenType{TokenIdent, TokenGreater, TokenDuration, TokenEOF},
values: []string{"updated", ">", "30d", ""},
},
{
name: "duration with trailing space stays a duration",
input: "updated>30d AND status=open",
expected: []TokenType{TokenIdent, TokenGreater, TokenDuration, TokenAnd, TokenIdent, TokenEquals, TokenIdent, TokenEOF},
values: []string{"updated", ">", "30d", "AND", "status", "=", "open", ""},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
lexer := NewLexer(tt.input)
tokens, err := lexer.Tokenize()
if err != nil {
t.Fatalf("Tokenize() error = %v", err)
}
if len(tokens) != len(tt.expected) {
t.Fatalf("got %d tokens, want %d", len(tokens), len(tt.expected))
}
for i, tok := range tokens {
if tok.Type != tt.expected[i] {
t.Errorf("token %d: got type %v, want %v", i, tok.Type, tt.expected[i])
}
if tt.values != nil && tok.Value != tt.values[i] {
t.Errorf("token %d: got value %q, want %q", i, tok.Value, tt.values[i])
}
}
})
}
}
func TestLexerErrors(t *testing.T) {
tests := []struct {
name string
input string
}{
{"unterminated string", `title="hello`},
{"invalid character", "status@open"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
lexer := NewLexer(tt.input)
_, err := lexer.Tokenize()
if err == nil {
t.Error("expected error, got nil")
}
})
}
}
func TestParser(t *testing.T) {
tests := []struct {
name string
input string
expected string
}{
{
name: "simple comparison",
input: "status=open",
expected: "status=open",
},
{
name: "AND expression",
input: "status=open AND priority>1",
expected: "(status=open AND priority>1)",
},
{
name: "OR expression",
input: "status=open OR status=blocked",
expected: "(status=open OR status=blocked)",
},
{
name: "NOT expression",
input: "NOT status=closed",
expected: "NOT status=closed",
},
{
name: "parentheses",
input: "(status=open OR status=blocked) AND priority<2",
expected: "((status=open OR status=blocked) AND priority<2)",
},
{
name: "chained AND",
input: "status=open AND priority>1 AND type=bug",
expected: "((status=open AND priority>1) AND type=bug)",
},
{
name: "AND has higher precedence than OR",
input: "status=open OR priority>1 AND type=bug",
expected: "(status=open OR (priority>1 AND type=bug))",
},
{
name: "NOT with parentheses",
input: "NOT (status=closed OR status=deferred)",
expected: "NOT (status=closed OR status=deferred)",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
node, err := Parse(tt.input)
if err != nil {
t.Fatalf("Parse() error = %v", err)
}
got := node.String()
if got != tt.expected {
t.Errorf("got %q, want %q", got, tt.expected)
}
})
}
}
func TestParserErrors(t *testing.T) {
tests := []struct {
name string
input string
}{
{"empty query", ""},
{"missing value", "status="},
{"missing operator", "status open"},
{"unclosed paren", "(status=open"},
{"extra paren", "status=open)"},
{"missing operand after AND", "status=open AND"},
{"invalid operator", "status~open"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := Parse(tt.input)
if err == nil {
t.Error("expected error, got nil")
}
})
}
}
func TestEvaluatorSimpleQueries(t *testing.T) {
now := time.Date(2025, 2, 4, 12, 0, 0, 0, time.UTC)
tests := []struct {
name string
query string
expectFilter func(*types.IssueFilter) bool
requiresPredicate bool
}{
{
name: "status equals",
query: "status=open",
expectFilter: func(f *types.IssueFilter) bool {
return f.Status != nil && *f.Status == types.StatusOpen
},
},
{
name: "status not equals",
query: "status!=closed",
expectFilter: func(f *types.IssueFilter) bool {
return len(f.ExcludeStatus) == 1 && f.ExcludeStatus[0] == types.StatusClosed
},
},
{
name: "priority equals",
query: "priority=2",
expectFilter: func(f *types.IssueFilter) bool {
return f.Priority != nil && *f.Priority == 2
},
},
{
name: "priority greater than",
query: "priority>1",
expectFilter: func(f *types.IssueFilter) bool {
return f.PriorityMin != nil && *f.PriorityMin == 2
},
},
{
name: "priority less than",
query: "priority<3",
expectFilter: func(f *types.IssueFilter) bool {
return f.PriorityMax != nil && *f.PriorityMax == 2
},
},
{
name: "type equals",
query: "type=bug",
expectFilter: func(f *types.IssueFilter) bool {
return f.IssueType != nil && *f.IssueType == types.TypeBug
},
},
{
name: "assignee equals",
query: "assignee=alice",
expectFilter: func(f *types.IssueFilter) bool {
return f.Assignee != nil && *f.Assignee == "alice"
},
},
{
name: "assignee none",
query: "assignee=none",
expectFilter: func(f *types.IssueFilter) bool {
return f.NoAssignee
},
},
{
name: "label equals",
query: "label=urgent",
expectFilter: func(f *types.IssueFilter) bool {
return len(f.Labels) == 1 && f.Labels[0] == "urgent"
},
},
{
name: "label with colon (quoted)",
query: `label="gt:merge-request"`,
expectFilter: func(f *types.IssueFilter) bool {
return len(f.Labels) == 1 && f.Labels[0] == "gt:merge-request"
},
},
{
name: "label with colon (unquoted)",
query: "label=gt:merge-request",
expectFilter: func(f *types.IssueFilter) bool {
return len(f.Labels) == 1 && f.Labels[0] == "gt:merge-request"
},
},
{
name: "label none",
query: "label=none",
expectFilter: func(f *types.IssueFilter) bool {
return f.NoLabels
},
},
{
name: "title contains",
query: "title=authentication",
expectFilter: func(f *types.IssueFilter) bool {
return f.TitleContains == "authentication"
},
},
{
name: "description empty",
query: "description=none",
expectFilter: func(f *types.IssueFilter) bool {
return f.EmptyDescription
},
},
{
name: "pinned equals true",
query: "pinned=true",
expectFilter: func(f *types.IssueFilter) bool {
return f.Pinned != nil && *f.Pinned == true
},
},
{
name: "updated greater than duration",
query: "updated>7d",
expectFilter: func(f *types.IssueFilter) bool {
// 7d ago from now
expected := now.AddDate(0, 0, -7)
return f.UpdatedAfter != nil && f.UpdatedAfter.Year() == expected.Year() &&
f.UpdatedAfter.Month() == expected.Month() && f.UpdatedAfter.Day() == expected.Day()
},
},
{
name: "created less than duration",
query: "created<30d",
expectFilter: func(f *types.IssueFilter) bool {
expected := now.AddDate(0, 0, -30)
return f.CreatedBefore != nil && f.CreatedBefore.Year() == expected.Year() &&
f.CreatedBefore.Month() == expected.Month() && f.CreatedBefore.Day() == expected.Day()
},
},
{
name: "AND expression",
query: "status=open AND priority>1",
expectFilter: func(f *types.IssueFilter) bool {
return f.Status != nil && *f.Status == types.StatusOpen &&
f.PriorityMin != nil && *f.PriorityMin == 2
},
},
{
name: "multiple labels AND",
query: "label=frontend AND label=urgent",
expectFilter: func(f *types.IssueFilter) bool {
return len(f.Labels) == 2 &&
(f.Labels[0] == "frontend" || f.Labels[0] == "urgent") &&
(f.Labels[1] == "frontend" || f.Labels[1] == "urgent")
},
},
{
name: "NOT status",
query: "NOT status=closed",
expectFilter: func(f *types.IssueFilter) bool {
return len(f.ExcludeStatus) == 1 && f.ExcludeStatus[0] == types.StatusClosed
},
},
{
name: "NOT type",
query: "NOT type=epic",
expectFilter: func(f *types.IssueFilter) bool {
return len(f.ExcludeTypes) == 1 && f.ExcludeTypes[0] == types.TypeEpic
},
},
{
name: "labels OR uses LabelsAny",
query: "label=frontend OR label=backend",
expectFilter: func(f *types.IssueFilter) bool {
return len(f.LabelsAny) == 2
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := EvaluateAt(tt.query, now)
if err != nil {
t.Fatalf("EvaluateAt() error = %v", err)
}
if tt.expectFilter != nil && !tt.expectFilter(&result.Filter) {
t.Errorf("filter check failed for %q", tt.query)
}
if result.RequiresPredicate != tt.requiresPredicate {
t.Errorf("RequiresPredicate = %v, want %v", result.RequiresPredicate, tt.requiresPredicate)
}
})
}
}
func TestEvaluatorComplexQueries(t *testing.T) {
now := time.Date(2025, 2, 4, 12, 0, 0, 0, time.UTC)
tests := []struct {
name string
query string
requiresPredicate bool
}{
{
name: "OR with different fields requires predicate",
query: "status=open OR priority>1",
requiresPredicate: true,
},
{
name: "nested OR requires predicate",
query: "(status=open OR status=blocked) AND priority<2",
requiresPredicate: true,
},
{
name: "NOT with complex expression requires predicate",
query: "NOT (status=closed AND type=bug)",
requiresPredicate: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := EvaluateAt(tt.query, now)
if err != nil {
t.Fatalf("EvaluateAt() error = %v", err)
}
if result.RequiresPredicate != tt.requiresPredicate {
t.Errorf("RequiresPredicate = %v, want %v", result.RequiresPredicate, tt.requiresPredicate)
}
if tt.requiresPredicate && result.Predicate == nil {
t.Error("expected Predicate to be set")
}
})
}
}
func TestPredicateEvaluation(t *testing.T) {
now := time.Date(2025, 2, 4, 12, 0, 0, 0, time.UTC)
openBug := &types.Issue{
ID: "bd-1",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeBug,
Labels: []string{"urgent", "frontend"},
CreatedAt: now.AddDate(0, 0, -5),
UpdatedAt: now.AddDate(0, 0, -1),
}
closedTask := &types.Issue{
ID: "bd-2",
Status: types.StatusClosed,
Priority: 2,
IssueType: types.TypeTask,
Labels: []string{"backend"},
CreatedAt: now.AddDate(0, 0, -30),
UpdatedAt: now.AddDate(0, 0, -10),
}
blockedFeature := &types.Issue{
ID: "bd-3",
Status: types.StatusBlocked,
Priority: 0,
IssueType: types.TypeFeature,
Labels: []string{},
CreatedAt: now.AddDate(0, 0, -2),
UpdatedAt: now,
}
tests := []struct {
name string
query string
issue *types.Issue
matches bool
}{
// Status tests
{"status=open matches open bug", "status=open", openBug, true},
{"status=open doesn't match closed task", "status=open", closedTask, false},
{"status!=closed matches open bug", "status!=closed", openBug, true},
{"status!=closed doesn't match closed task", "status!=closed", closedTask, false},
// Priority tests
{"priority>0 matches P1 bug", "priority>0", openBug, true},
{"priority>0 doesn't match P0 feature", "priority>0", blockedFeature, false},
{"priority<=1 matches P1 bug", "priority<=1", openBug, true},
{"priority<=1 doesn't match P2 task", "priority<=1", closedTask, false},
// Type tests
{"type=bug matches bug", "type=bug", openBug, true},
{"type=bug doesn't match task", "type=bug", closedTask, false},
// Label tests
{"label=urgent matches issue with urgent", "label=urgent", openBug, true},
{"label=urgent doesn't match issue without", "label=urgent", closedTask, false},
{"label=none matches unlabeled", "label=none", blockedFeature, true},
{"label=none doesn't match labeled", "label=none", openBug, false},
// OR tests
{"status=open OR status=blocked matches open", "status=open OR status=blocked", openBug, true},
{"status=open OR status=blocked matches blocked", "status=open OR status=blocked", blockedFeature, true},
{"status=open OR status=blocked doesn't match closed", "status=open OR status=blocked", closedTask, false},
// AND tests
{"status=open AND type=bug matches", "status=open AND type=bug", openBug, true},
{"status=open AND type=bug doesn't match blocked", "status=open AND type=bug", blockedFeature, false},
// NOT tests
{"NOT status=closed matches open", "NOT status=closed", openBug, true},
{"NOT status=closed doesn't match closed", "NOT status=closed", closedTask, false},
// Complex tests
{"(status=open OR status=blocked) AND priority<2 matches P1 open", "(status=open OR status=blocked) AND priority<2", openBug, true},
{"(status=open OR status=blocked) AND priority<2 matches P0 blocked", "(status=open OR status=blocked) AND priority<2", blockedFeature, true},
{"(status=open OR status=blocked) AND priority<2 doesn't match P2 closed", "(status=open OR status=blocked) AND priority<2", closedTask, false},
// Label OR tests
{"label=urgent OR label=backend matches urgent", "label=urgent OR label=backend", openBug, true},
{"label=urgent OR label=backend matches backend", "label=urgent OR label=backend", closedTask, true},
{"label=urgent OR label=backend doesn't match unlabeled", "label=urgent OR label=backend", blockedFeature, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := EvaluateAt(tt.query, now)
if err != nil {
t.Fatalf("EvaluateAt() error = %v", err)
}
// For simple queries, check filter
if !result.RequiresPredicate {
// Build predicate anyway for testing
eval := NewEvaluator(now)
node, _ := Parse(tt.query)
pred, err := eval.buildPredicate(node)
if err != nil {
t.Fatalf("buildPredicate() error = %v", err)
}
got := pred(tt.issue)
if got != tt.matches {
t.Errorf("predicate(%s) = %v, want %v", tt.issue.ID, got, tt.matches)
}
} else {
// Use the predicate from result
got := result.Predicate(tt.issue)
if got != tt.matches {
t.Errorf("predicate(%s) = %v, want %v", tt.issue.ID, got, tt.matches)
}
}
})
}
}
func TestEvaluatorErrors(t *testing.T) {
tests := []struct {
name string
query string
}{
{"invalid status", "status=invalid"},
{"invalid priority", "priority=abc"},
{"priority out of range", "priority=5"},
{"invalid boolean", "pinned=maybe"},
{"unknown field", "unknown=value"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := Evaluate(tt.query)
if err == nil {
t.Error("expected error, got nil")
}
})
}
}
func TestDurationParsing(t *testing.T) {
now := time.Date(2025, 2, 4, 12, 0, 0, 0, time.UTC)
eval := NewEvaluator(now)
tests := []struct {
duration string
expected time.Time
}{
{"7d", now.AddDate(0, 0, -7)},
{"24h", now.Add(-24 * time.Hour)},
{"2w", now.AddDate(0, 0, -14)},
{"1m", now.AddDate(0, -1, 0)},
{"1y", now.AddDate(-1, 0, 0)},
}
for _, tt := range tests {
t.Run(tt.duration, func(t *testing.T) {
got, err := eval.parseDurationAgo(tt.duration)
if err != nil {
t.Fatalf("parseDurationAgo() error = %v", err)
}
// Compare dates (ignore time precision)
if got.Year() != tt.expected.Year() || got.Month() != tt.expected.Month() || got.Day() != tt.expected.Day() {
t.Errorf("got %v, want %v", got, tt.expected)
}
})
}
}
func TestEvaluatorMetadataQueries(t *testing.T) {
now := time.Date(2025, 2, 4, 12, 0, 0, 0, time.UTC)
tests := []struct {
name string
query string
expectFilter func(*types.IssueFilter) bool
requiresPredicate bool
expectError bool
}{
{
name: "metadata.team=platform",
query: "metadata.team=platform",
expectFilter: func(f *types.IssueFilter) bool {
return f.MetadataFields != nil && f.MetadataFields["team"] == "platform"
},
},
{
name: "metadata.jira.sprint=Q1",
query: "metadata.jira.sprint=Q1",
expectFilter: func(f *types.IssueFilter) bool {
return f.MetadataFields != nil && f.MetadataFields["jira.sprint"] == "Q1"
},
},
{
name: "metadata combined with status",
query: "status=open AND metadata.team=platform",
expectFilter: func(f *types.IssueFilter) bool {
return f.Status != nil && *f.Status == types.StatusOpen &&
f.MetadataFields != nil && f.MetadataFields["team"] == "platform"
},
},
{
name: "metadata in OR triggers predicate",
query: "metadata.team=platform OR status=open",
requiresPredicate: true,
},
{
name: "metadata with unsupported operator",
query: "metadata.team>platform",
expectError: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := EvaluateAt(tt.query, now)
if tt.expectError {
if err == nil {
t.Fatalf("expected error for %q, got nil", tt.query)
}
return
}
if err != nil {
t.Fatalf("EvaluateAt(%q) error = %v", tt.query, err)
}
if tt.expectFilter != nil && !tt.expectFilter(&result.Filter) {
t.Errorf("filter check failed for %q, filter=%+v", tt.query, result.Filter)
}
if result.RequiresPredicate != tt.requiresPredicate {
t.Errorf("RequiresPredicate = %v, want %v for %q", result.RequiresPredicate, tt.requiresPredicate, tt.query)
}
})
}
}
func TestEvaluatorHasMetadataKeyQueries(t *testing.T) {
now := time.Date(2025, 2, 4, 12, 0, 0, 0, time.UTC)
tests := []struct {
name string
query string
expectFilter func(*types.IssueFilter) bool
requiresPredicate bool
expectError bool
}{
{
name: "has_metadata_key=team",
query: "has_metadata_key=team",
expectFilter: func(f *types.IssueFilter) bool {
return f.HasMetadataKey == "team"
},
},
{
name: "has_metadata_key combined with status",
query: "has_metadata_key=sprint AND status=open",
expectFilter: func(f *types.IssueFilter) bool {
return f.HasMetadataKey == "sprint" &&
f.Status != nil && *f.Status == types.StatusOpen
},
},
{
name: "has_metadata_key in OR triggers predicate",
query: "has_metadata_key=team OR status=open",
requiresPredicate: true,
},
{
name: "has_metadata_key with invalid key",
query: `has_metadata_key="bad key"`,
expectError: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := EvaluateAt(tt.query, now)
if tt.expectError {
if err == nil {
t.Fatalf("expected error for %q, got nil", tt.query)
}
return
}
if err != nil {
t.Fatalf("EvaluateAt(%q) error = %v", tt.query, err)
}
if tt.expectFilter != nil && !tt.expectFilter(&result.Filter) {
t.Errorf("filter check failed for %q, filter=%+v", tt.query, result.Filter)
}
if result.RequiresPredicate != tt.requiresPredicate {
t.Errorf("RequiresPredicate = %v, want %v for %q", result.RequiresPredicate, tt.requiresPredicate, tt.query)
}
})
}
}
func TestHasMetadataKeyPredicateEvaluation(t *testing.T) {
now := time.Date(2025, 2, 4, 12, 0, 0, 0, time.UTC)
result, err := EvaluateAt("has_metadata_key=team OR status=closed", now)
if err != nil {
t.Fatalf("EvaluateAt error: %v", err)
}
if result.Predicate == nil {
t.Fatal("expected predicate for OR query")
}
// Issue with the key present
issueMatch := &types.Issue{
Status: types.StatusOpen,
Metadata: []byte(`{"team":"platform"}`),
}
if !result.Predicate(issueMatch) {
t.Error("predicate should match issue with team key present")
}
// Issue without the key
issueNoKey := &types.Issue{
Status: types.StatusOpen,
Metadata: []byte(`{"sprint":"Q1"}`),
}
if result.Predicate(issueNoKey) {
t.Error("predicate should not match issue without team key")
}
// Issue with no metadata but closed status (matches second branch)
issueClosed := &types.Issue{
Status: types.StatusClosed,
}
if !result.Predicate(issueClosed) {
t.Error("predicate should match closed issue via OR")
}
}
func TestMetadataPredicateEvaluation(t *testing.T) {
now := time.Date(2025, 2, 4, 12, 0, 0, 0, time.UTC)
result, err := EvaluateAt("metadata.team=platform OR status=closed", now)
if err != nil {
t.Fatalf("EvaluateAt error: %v", err)
}
if result.Predicate == nil {
t.Fatal("expected predicate for OR query")
}
// Issue with matching metadata
issueMatch := &types.Issue{
Status: types.StatusOpen,
Metadata: []byte(`{"team":"platform"}`),
}
if !result.Predicate(issueMatch) {
t.Error("predicate should match issue with team=platform")
}
// Issue with non-matching metadata
issueNoMatch := &types.Issue{
Status: types.StatusOpen,
Metadata: []byte(`{"team":"frontend"}`),
}
if result.Predicate(issueNoMatch) {
t.Error("predicate should not match issue with team=frontend")
}
// Issue with no metadata but closed status (matches second branch)
issueClosed := &types.Issue{
Status: types.StatusClosed,
}
if !result.Predicate(issueClosed) {
t.Error("predicate should match closed issue via OR")
}
}