Function TestBasicParser

parser/parser_test.go:10–232

(t *testing.T)

)

func TestBasicParser(t *testing.T) {
	g := NewGomegaWithT(t)
	t.Run("parse expression succeeds", func(t *testing.T) {
		s := "name=max"
		parser := NewParser(s)
		expr, err := parser.parseExpression()
		g.Expect(err).To(BeNil())
		g.Expect(expr).To(Equal(&Expression{
			Field:      "name",
			Comparator: "=",
			Value:      "max",
		}))
	})
	t.Run("parse expression succeeds with whitespace", func(t *testing.T) {
		s := "name=  max "
		parser := NewParser(s)
		expr, err := parser.parseExpression()
		g.Expect(err).To(BeNil())
		g.Expect(expr).To(Equal(&Expression{
			Field:      "name",
			Comparator: "=",
			Value:      "max",
		}))
	})
	t.Run("parse expression fails invalid", func(t *testing.T) {
		s := "name==dog"
		parser := NewParser(s)
		_, err := parser.parseExpression()
		g.Expect(err).ToNot(BeNil())
	})
	t.Run("parse operations badly formatted return errors", func(t *testing.T) {
		tests := []string{
			"name=max AND AND artifact=wow",
			"name=max artifact=wow",
			")(name = max)",
		}
		for _, test := range tests {
			parser := NewParser(test)
			_, err := parser.parseOperation()
			g.Expect(err).ToNot(BeNil(), fmt.Sprintf("failed case: `%s`", test))
		}
	})
	t.Run("parse operations correctly formatted succeeds", func(t *testing.T) {
		test := "name=max AND artifact%art1"
		parser := NewParser(test)
		expected := &Operation{
			LeftNode: &Expression{
				Field:      "name",
				Comparator: "=",
				Value:      "max",
			},
			Gate: "AND",
			RightNode: &Expression{
				Field:      "artifact",
				Comparator: "%",
				Value:      "art1",
			},
		}