go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/sdk/selector/parse_test.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package selector

import (
	"fmt"
	"testing"

	. "go.charczuk.com/sdk/assert"
)

func Test_MustParse(t *testing.T) {
	ItsEqual(t, "x == a", MustParse("x==a").String())

	var err error
	func() {
		defer func() {
			if r := recover(); r != nil {
				err = fmt.Errorf("%v", r)
			}
		}()
		MustParse("x!!")
	}()
	ItsNotNil(t, err)
}

func Test_Parse_invalid(t *testing.T) {
	testBadStrings := []string{
		"x=a||y=b",
		"x==a==b",
		"!x=a",
		"x<a",
		"x>1",
		"x>1,z<5",
		"x=",
		"x= ",
		"x=,z= ",
		"x= ,z= ",
		"foo == bar foo",
	}
	var err error
	for _, str := range testBadStrings {
		_, err = Parse(str)
		ItsNotNil(t, err, str)
	}
}

func Test_Parse_semiValid(t *testing.T) {
	testGoodStrings := []string{
		"",
		"x=a,y=b,z=c",
		"x!=a,y=b",
		"x",
		"!x",
		"!x,y",
		"!x,y,z",
		"!x,y,!z",
		"!x,y,z,a",
		"!x,y,z,!a",
	}

	var err error
	for _, str := range testGoodStrings {
		_, err = Parse(str)
		ItsNil(t, err, str)
	}
}

func Test_Parse_trailingComma(t *testing.T) {
	testBadStrings := []string{
		",",
		"x,",
		"!x,",
		"foo==bar,",
		"foo!=bar,",
		"foo in (bar,baz),",
		"foo not in (bar,baz),",
	}

	var err error
	for _, str := range testBadStrings {
		_, err = Parse(str)
		ItsNotNil(t, err, str)
	}
}

func Test_Parse_equals(t *testing.T) {
	valid := Labels{
		"foo": "bar",
		"moo": "lar",
	}
	invalid := Labels{
		"zoo": "mar",
		"moo": "lar",
	}

	selector, err := Parse("foo == bar")
	ItsNil(t, err)
	ItsEqual(t, true, selector.Matches(valid))
	ItsEqual(t, false, selector.Matches(invalid))
}

func Test_Parse_notEquals(t *testing.T) {
	valid := Labels{
		"foo": "far",
		"moo": "lar",
	}
	invalidPresent := Labels{
		"foo": "bar",
		"moo": "lar",
	}
	invalidMissing := Labels{
		"zoo": "mar",
		"moo": "lar",
	}

	selector, err := Parse("foo != bar")
	ItsNil(t, err)
	ItsEqual(t, true, selector.Matches(valid))
	ItsEqual(t, true, selector.Matches(invalidMissing))
	ItsEqual(t, false, selector.Matches(invalidPresent))
}

func Test_Parse_In(t *testing.T) {
	valid := Labels{
		"foo": "far",
		"moo": "lar",
	}
	valid2 := Labels{
		"foo": "bar",
		"moo": "lar",
	}
	invalid := Labels{
		"foo": "mar",
		"moo": "lar",
	}
	invalidMissing := Labels{
		"zoo": "mar",
		"moo": "lar",
	}

	selector, err := Parse("foo in (bar,far)")
	ItsNil(t, err)
	ItsEqual(t, true, selector.Matches(valid), selector.String())
	ItsEqual(t, true, selector.Matches(valid2))
	ItsEqual(t, false, selector.Matches(invalidMissing))
	ItsEqual(t, false, selector.Matches(invalid), selector.String())
}

func Test_Parse_group(t *testing.T) {
	valid := Labels{
		"zoo":   "mar",
		"moo":   "lar",
		"thing": "map",
	}
	invalid := Labels{
		"zoo":   "mar",
		"moo":   "something",
		"thing": "map",
	}
	invalid2 := Labels{
		"zoo":    "mar",
		"moo":    "lar",
		"!thing": "map",
	}
	selector, err := Parse("zoo=mar, moo=lar, thing")
	ItsNil(t, err)
	ItsEqual(t, true, selector.Matches(valid))
	ItsEqual(t, false, selector.Matches(invalid))
	ItsEqual(t, false, selector.Matches(invalid2))

	complicated, err := Parse("zoo in (mar,lar,dar),moo,!thingy")
	ItsNil(t, err)
	ItsNotNil(t, complicated)
	ItsEqual(t, true, complicated.Matches(valid))
}

func Test_Parse_groupComplicated(t *testing.T) {
	valid := Labels{
		"zoo":   "mar",
		"moo":   "lar",
		"thing": "map",
	}
	complicated, err := Parse("zoo in (mar,lar,dar),moo,thing == map,!thingy")
	ItsNil(t, err)
	ItsNotNil(t, complicated)
	ItsEqual(t, true, complicated.Matches(valid))
}

func Test_Parse_docsExample(t *testing.T) {
	sel, err := Parse("x in (foo,,baz),y,z notin ()")
	ItsNil(t, err)
	ItsNotNil(t, sel)
}

func Test_Parse_subdomainKey(t *testing.T) {
	sel, err := Parse("example.com/failure-domain == primary")
	ItsNil(t, err)
	ItsNotNil(t, sel)
	ItsEqual(t, "example.com/failure-domain == primary", sel.String())
	ItsEqual(t, true, sel.Matches(map[string]string{
		"bar":                        "foo",
		"example.com/failure-domain": "primary",
		"foo":                        "bar",
	}))
}

func Test_Parse_equalsOperators(t *testing.T) {
	selector, err := Parse("notin=in")
	ItsNil(t, err)

	typed, isTyped := selector.(Equals)
	ItsEqual(t, true, isTyped)
	ItsEqual(t, "notin", typed.Key)
	ItsEqual(t, "in", typed.Value)
}

func Test_Parse_validate(t *testing.T) {
	_, err := Parse("zoo=bar")
	ItsNil(t, err)

	_, err = Parse("_zoo=bar")
	ItsNotNil(t, err)

	_, err = Parse("_zoo=_bar")
	ItsNotNil(t, err)

	_, err = Parse("zoo=bar,foo=_mar")
	ItsNotNil(t, err)
}

func Test_Parse_regressionCSVSymbols(t *testing.T) {
	sel, err := Parse("foo in (bar-bar, baz.baz, buzz_buzz), moo=boo")
	ItsNil(t, err, "regression is csv values can have '-', '.' and '_' in them")
	ItsNotEmpty(t, sel.String())
}

func Test_Parse_regressionCSVEarlyTermination(t *testing.T) {
	sel, err := Parse("foo in (bar,), moo=boo")
	ItsNil(t, err)
	ItsNotEmpty(t, sel.String())
}

func Test_Parse_regressionCSVMultipleSpaces(t *testing.T) {
	sel, err := Parse("foo in (bar,  foo), moo=boo")
	ItsNil(t, err)
	ItsNotEmpty(t, sel.String())
}

func Test_Parse_regressionIn(t *testing.T) {
	_, err := Parse("foo in bar, buzz)")
	ItsNotNil(t, err)
}

func Test_Parse_multiByte(t *testing.T) {
	selector, err := Parse("함=수,목=록") // number=number, number=rock
	ItsNil(t, err)
	ItsNotNil(t, selector)

	typed, isTyped := selector.(And)
	ItsEqual(t, true, isTyped)
	ItsEqual(t, 2, Len(typed))
}

func Test_Parse_options(t *testing.T) {
	selQuery := "bar=foo@bar"
	labels := Labels{
		"foo": "bar",
		"bar": "foo@bar",
	}

	sel, err := Parse(selQuery)
	ItsNotNil(t, err)
	ItsNil(t, sel)

	sel, err = Parse(selQuery, SkipValidation)
	ItsNil(t, err)
	ItsNotNil(t, sel)

	ItsEqual(t, true, sel.Matches(labels))
}

func Benchmark_Parse(b *testing.B) {
	valid := Labels{
		"zoo":   "mar",
		"moo":   "lar",
		"thing": "map",
	}

	for i := 0; i < b.N; i++ {
		selector, err := Parse("zoo in (mar,lar,dar),moo,!thingy")
		if err != nil {
			b.Fail()
		}
		if !selector.Matches(valid) {
			b.Fail()
		}
	}
}

func Test_Parse_fuzzRegressions(t *testing.T) {
	var sel Selector
	var err error
	testBadStrings := []string{
		"!0!0",
		"0!=0,!",
	}
	for _, str := range testBadStrings {
		_, err = Parse(str)
		ItsNotNil(t, err, str, err)
	}

	testGoodStrings := []string{
		"0,!0",
		"0 in (0), !0",
	}
	for _, str := range testGoodStrings {
		sel, err = Parse(str)
		ItsNil(t, err)
		_, err = Parse(sel.String())
		ItsNil(t, err)
	}
}

func TestParse_InRegression(t *testing.T) {
	good0 := Labels{
		"role": "job",
		"team": "internal-engineering",
	}
	good1 := Labels{
		"role": "job-worker",
		"team": "internal-engineering",
	}
	bad0 := Labels{
		"role": "not-job",
	}

	sel, err := Parse("role in (job, job-worker),team=internal-engineering")
	ItsNil(t, err)

	ItsEqual(t, true, sel.Matches(good0))
	ItsEqual(t, true, sel.Matches(good1))
	ItsEqual(t, false, sel.Matches(bad0))
}