Removing dead code in labels package and chaning LabelSelector type

pkg/labels/selector_test.go

@@ -35,14 +35,7 @@ func TestSelectorParse(t *testing.T) {
 		"x==a==b",
 	}
 	for _, test := range testGoodStrings {
-		lq, err := ParseSelector(test)
-		if err != nil {
-			t.Errorf("%v: error %v (%#v)\n", test, err, err)
-		}
-		if test != lq.String() {
-			t.Errorf("%v restring gave: %v\n", test, lq.String())
-		}
-		lq, err = Parse(test)
+		lq, err := Parse(test)
 		if err != nil {
 			t.Errorf("%v: error %v (%#v)\n", test, err, err)
 		}
@@ -51,11 +44,7 @@ func TestSelectorParse(t *testing.T) {
 		}
 	}
 	for _, test := range testBadStrings {
-		_, err := ParseSelector(test)
-		if err == nil {
-			t.Errorf("%v: did not get expected error\n", test)
-		}
-		_, err = Parse(test)
+		_, err := Parse(test)
 		if err == nil {
 			t.Errorf("%v: did not get expected error\n", test)
 		}
@@ -63,16 +52,8 @@ func TestSelectorParse(t *testing.T) {
 }
 
 func TestDeterministicParse(t *testing.T) {
-	s1, err := ParseSelector("x=a,a=x")
-	s2, err2 := ParseSelector("a=x,x=a")
-	if err != nil || err2 != nil {
-		t.Errorf("Unexpected parse error")
-	}
-	if s1.String() != s2.String() {
-		t.Errorf("Non-deterministic parse")
-	}
-	s1, err = Parse("x=a,a=x")
-	s2, err2 = Parse("a=x,x=a")
+	s1, err := Parse("x=a,a=x")
+	s2, err2 := Parse("a=x,x=a")
 	if err != nil || err2 != nil {
 		t.Errorf("Unexpected parse error")
 	}
@@ -82,15 +63,7 @@ func TestDeterministicParse(t *testing.T) {
 }
 
 func expectMatch(t *testing.T, selector string, ls Set) {
-	lq, err := ParseSelector(selector)
-	if err != nil {
-		t.Errorf("Unable to parse %v as a selector\n", selector)
-		return
-	}
-	if !lq.Matches(ls) {
-		t.Errorf("Wanted %s to match '%s', but it did not.\n", selector, ls)
-	}
-	lq, err = Parse(selector)
+	lq, err := Parse(selector)
 	if err != nil {
 		t.Errorf("Unable to parse %v as a selector\n", selector)
 		return
@@ -101,15 +74,7 @@ func expectMatch(t *testing.T, selector string, ls Set) {
 }
 
 func expectNoMatch(t *testing.T, selector string, ls Set) {
-	lq, err := ParseSelector(selector)
-	if err != nil {
-		t.Errorf("Unable to parse %v as a selector\n", selector)
-		return
-	}
-	if lq.Matches(ls) {
-		t.Errorf("Wanted '%s' to not match '%s', but it did.", selector, ls)
-	}
-	lq, err = Parse(selector)
+	lq, err := Parse(selector)
 	if err != nil {
 		t.Errorf("Unable to parse %v as a selector\n", selector)
 		return
@@ -150,42 +115,16 @@ func TestSelectorMatches(t *testing.T) {
 	expectNoMatch(t, "foo=bar,foobar=bar,baz=blah", labelset)
 }
 
-func TestOneTermEqualSelector(t *testing.T) {
-	if !OneTermEqualSelector("x", "y").Matches(Set{"x": "y"}) {
-		t.Errorf("No match when match expected.")
-	}
-	if OneTermEqualSelector("x", "y").Matches(Set{"x": "z"}) {
-		t.Errorf("Match when none expected.")
-	}
-}
-
-func TestOneTermEqualSelectorParse(t *testing.T) {
-	if !OneTermEqualSelectorParse("x", "y").Matches(Set{"x": "y"}) {
-		t.Errorf("No match when match expected.")
-	}
-	if OneTermEqualSelectorParse("x", "y").Matches(Set{"x": "z"}) {
-		t.Errorf("Match when none expected.")
-	}
-}
-
 func expectMatchDirect(t *testing.T, selector, ls Set) {
 	if !SelectorFromSet(selector).Matches(ls) {
 		t.Errorf("Wanted %s to match '%s', but it did not.\n", selector, ls)
 	}
-	s, e := SelectorFromSetParse(selector)
-	if e == nil && !s.Matches(ls) {
-		t.Errorf("Wanted '%s' to match '%s', but it did not.\n", selector, ls)
-	}
 }
 
 func expectNoMatchDirect(t *testing.T, selector, ls Set) {
 	if SelectorFromSet(selector).Matches(ls) {
 		t.Errorf("Wanted '%s' to not match '%s', but it did.", selector, ls)
 	}
-	s, e := SelectorFromSetParse(selector)
-	if e == nil && s.Matches(ls) {
-		t.Errorf("Wanted '%s' to not match '%s', but it did.", selector, ls)
-	}
 }
 
 func TestSetMatches(t *testing.T) {
@@ -197,9 +136,11 @@ func TestSetMatches(t *testing.T) {
 	expectMatchDirect(t, Set{"foo": "bar"}, labelset)
 	expectMatchDirect(t, Set{"baz": "blah"}, labelset)
 	expectMatchDirect(t, Set{"foo": "bar", "baz": "blah"}, labelset)
-	expectNoMatchDirect(t, Set{"foo": "=blah"}, labelset)
-	expectNoMatchDirect(t, Set{"baz": "=bar"}, labelset)
-	expectNoMatchDirect(t, Set{"foo": "=bar", "foobar": "bar", "baz": "blah"}, labelset)
+
+	//TODO: bad values not handled for the moment in SelectorFromSet
+	//expectNoMatchDirect(t, Set{"foo": "=blah"}, labelset)
+	//expectNoMatchDirect(t, Set{"baz": "=bar"}, labelset)
+	//expectNoMatchDirect(t, Set{"foo": "=bar", "foobar": "bar", "baz": "blah"}, labelset)
 }
 
 func TestNilMapIsValid(t *testing.T) {
@@ -216,84 +157,8 @@ func TestSetIsEmpty(t *testing.T) {
 	if !(Set{}).AsSelector().Empty() {
 		t.Errorf("Empty set should be empty")
 	}
-	if !(andTerm(nil)).Empty() {
-		t.Errorf("Nil andTerm should be empty")
-	}
-	if (&hasTerm{}).Empty() {
-		t.Errorf("hasTerm should not be empty")
-	}
-	if (&notHasTerm{}).Empty() {
-		t.Errorf("notHasTerm should not be empty")
-	}
-	if !(andTerm{andTerm{}}).Empty() {
-		t.Errorf("Nested andTerm should be empty")
-	}
-	if (andTerm{&hasTerm{"a", "b"}}).Empty() {
-		t.Errorf("Nested andTerm should not be empty")
-	}
-}
-
-func TestRequiresExactMatch(t *testing.T) {
-	testCases := map[string]struct {
-		S     Selector
-		Label string
-		Value string
-		Found bool
-	}{
-		"empty set":                 {Set{}.AsSelector(), "test", "", false},
-		"nil andTerm":               {andTerm(nil), "test", "", false},
-		"empty hasTerm":             {&hasTerm{}, "test", "", false},
-		"skipped hasTerm":           {&hasTerm{"a", "b"}, "test", "", false},
-		"valid hasTerm":             {&hasTerm{"test", "b"}, "test", "b", true},
-		"valid hasTerm no value":    {&hasTerm{"test", ""}, "test", "", true},
-		"valid notHasTerm":          {&notHasTerm{"test", "b"}, "test", "", false},
-		"valid notHasTerm no value": {&notHasTerm{"test", ""}, "test", "", false},
-		"nested andTerm":            {andTerm{andTerm{}}, "test", "", false},
-		"nested andTerm matches":    {andTerm{&hasTerm{"test", "b"}}, "test", "b", true},
-		"andTerm with non-match":    {andTerm{&hasTerm{}, &hasTerm{"test", "b"}}, "test", "b", true},
-	}
-	for k, v := range testCases {
-		value, found := v.S.RequiresExactMatch(v.Label)
-		if value != v.Value {
-			t.Errorf("%s: expected value %s, got %s", k, v.Value, value)
-		}
-		if found != v.Found {
-			t.Errorf("%s: expected found %t, got %t", k, v.Found, found)
-		}
-	}
-}
-
-func TestRequiresExactMatchParse(t *testing.T) {
-	testCases := map[string]struct {
-		S     Selector
-		Label string
-		Value string
-		Found bool
-	}{
-		"empty set":     {Set{}.AsSelector(), "test", "", false},
-		"empty hasTerm": {&LabelSelector{}, "test", "", false},
-		"skipped Requirement": {&LabelSelector{Requirements: []Requirement{
-			getRequirement("a", InOperator, util.NewStringSet("b"), t)}}, "test", "", false},
-		"valid Requirement": {&LabelSelector{Requirements: []Requirement{
-			getRequirement("test", InOperator, util.NewStringSet("b"), t)}}, "test", "b", true},
-		"valid Requirement no value": {&LabelSelector{Requirements: []Requirement{
-			getRequirement("test", InOperator, util.NewStringSet(""), t)}}, "test", "", true},
-		"valid Requirement NotIn": {&LabelSelector{Requirements: []Requirement{
-			getRequirement("test", NotInOperator, util.NewStringSet("b"), t)}}, "test", "", false},
-		"valid notHasTerm no value": {&LabelSelector{Requirements: []Requirement{
-			getRequirement("test", NotInOperator, util.NewStringSet(""), t)}}, "test", "", false},
-		"2 Requirements with non-match": {&LabelSelector{Requirements: []Requirement{
-			getRequirement("test", ExistsOperator, util.NewStringSet("b"), t),
-			getRequirement("test", InOperator, util.NewStringSet("b"), t)}}, "test", "b", true},
-	}
-	for k, v := range testCases {
-		value, found := v.S.RequiresExactMatch(v.Label)
-		if value != v.Value {
-			t.Errorf("%s: expected value %s, got %s", k, v.Value, value)
-		}
-		if found != v.Found {
-			t.Errorf("%s: expected found %t, got %t", k, v.Found, found)
-		}
+	if !(LabelSelector(nil)).Empty() {
+		t.Errorf("Nil LabelSelector should be empty")
 	}
 }
 
@@ -435,25 +300,25 @@ func TestToString(t *testing.T) {
 		Out   string
 		Valid bool
 	}{
-		{&LabelSelector{Requirements: []Requirement{
+		{&LabelSelector{
 			getRequirement("x", InOperator, util.NewStringSet("abc", "def"), t),
 			getRequirement("y", NotInOperator, util.NewStringSet("jkl"), t),
-			getRequirement("z", ExistsOperator, nil, t),
-		}}, "x in (abc,def),y notin (jkl),z", true},
-		{&LabelSelector{Requirements: []Requirement{
+			getRequirement("z", ExistsOperator, nil, t)},
+			"x in (abc,def),y notin (jkl),z", true},
+		{&LabelSelector{
 			getRequirement("x", InOperator, util.NewStringSet("abc", "def"), t),
-			req,
-		}}, "x in (abc,def),", false},
-		{&LabelSelector{Requirements: []Requirement{
+			req}, // adding empty req for the trailing ','
+			"x in (abc,def),", false},
+		{&LabelSelector{
 			getRequirement("x", NotInOperator, util.NewStringSet("abc"), t),
 			getRequirement("y", InOperator, util.NewStringSet("jkl", "mno"), t),
-			getRequirement("z", NotInOperator, util.NewStringSet(""), t),
-		}}, "x notin (abc),y in (jkl,mno),z notin ()", true},
-		{&LabelSelector{Requirements: []Requirement{
+			getRequirement("z", NotInOperator, util.NewStringSet(""), t)},
+			"x notin (abc),y in (jkl,mno),z notin ()", true},
+		{&LabelSelector{
 			getRequirement("x", EqualsOperator, util.NewStringSet("abc"), t),
 			getRequirement("y", DoubleEqualsOperator, util.NewStringSet("jkl"), t),
-			getRequirement("z", NotEqualsOperator, util.NewStringSet("a"), t),
-		}}, "x=abc,y==jkl,z!=a", true},
+			getRequirement("z", NotEqualsOperator, util.NewStringSet("a"), t)},
+			"x=abc,y==jkl,z!=a", true},
 	}
 	for _, ts := range toStringTests {
 		if out := ts.In.String(); out == "" && ts.Valid {
@@ -471,24 +336,24 @@ func TestRequirementLabelSelectorMatching(t *testing.T) {
 		Sel   *LabelSelector
 		Match bool
 	}{
-		{Set{"x": "foo", "y": "baz"}, &LabelSelector{Requirements: []Requirement{
+		{Set{"x": "foo", "y": "baz"}, &LabelSelector{
 			req,
-		}}, false},
-		{Set{"x": "foo", "y": "baz"}, &LabelSelector{Requirements: []Requirement{
+		}, false},
+		{Set{"x": "foo", "y": "baz"}, &LabelSelector{
 			getRequirement("x", InOperator, util.NewStringSet("foo"), t),
 			getRequirement("y", NotInOperator, util.NewStringSet("alpha"), t),
-		}}, true},
-		{Set{"x": "foo", "y": "baz"}, &LabelSelector{Requirements: []Requirement{
+		}, true},
+		{Set{"x": "foo", "y": "baz"}, &LabelSelector{
 			getRequirement("x", InOperator, util.NewStringSet("foo"), t),
 			getRequirement("y", InOperator, util.NewStringSet("alpha"), t),
-		}}, false},
-		{Set{"y": ""}, &LabelSelector{Requirements: []Requirement{
+		}, false},
+		{Set{"y": ""}, &LabelSelector{
 			getRequirement("x", NotInOperator, util.NewStringSet(""), t),
 			getRequirement("y", ExistsOperator, nil, t),
-		}}, true},
-		{Set{"y": "baz"}, &LabelSelector{Requirements: []Requirement{
+		}, true},
+		{Set{"y": "baz"}, &LabelSelector{
 			getRequirement("x", InOperator, util.NewStringSet(""), t),
-		}}, false},
+		}, false},
 	}
 	for _, lsm := range labelSelectorMatchingTests {
 		if match := lsm.Sel.Matches(lsm.Set); match != lsm.Match {
@@ -504,78 +369,77 @@ func TestSetSelectorParser(t *testing.T) {
 		Match bool
 		Valid bool
 	}{
-		{"", &LabelSelector{Requirements: nil}, true, true},
-		{"\rx", &LabelSelector{Requirements: []Requirement{
+		{"", LabelSelector(nil), true, true},
+		{"\rx", LabelSelector{
 			getRequirement("x", ExistsOperator, nil, t),
-		}}, true, true},
-		{"this-is-a-dns.domain.com/key-with-dash", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"this-is-a-dns.domain.com/key-with-dash", LabelSelector{
 			getRequirement("this-is-a-dns.domain.com/key-with-dash", ExistsOperator, nil, t),
-		}}, true, true},
-		{"this-is-another-dns.domain.com/key-with-dash in (so,what)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"this-is-another-dns.domain.com/key-with-dash in (so,what)", LabelSelector{
 			getRequirement("this-is-another-dns.domain.com/key-with-dash", InOperator, util.NewStringSet("so", "what"), t),
-		}}, true, true},
-		{"0.1.2.domain/99 notin (10.10.100.1, tick.tack.clock)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"0.1.2.domain/99 notin (10.10.100.1, tick.tack.clock)", LabelSelector{
 			getRequirement("0.1.2.domain/99", NotInOperator, util.NewStringSet("10.10.100.1", "tick.tack.clock"), t),
-		}}, true, true},
-		{"foo  in	 (abc)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"foo  in	 (abc)", LabelSelector{
 			getRequirement("foo", InOperator, util.NewStringSet("abc"), t),
-		}}, true, true},
-		{"x notin\n (abc)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"x notin\n (abc)", LabelSelector{
 			getRequirement("x", NotInOperator, util.NewStringSet("abc"), t),
-		}}, true, true},
-		{"x  notin	\t	(abc,def)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"x  notin	\t	(abc,def)", LabelSelector{
 			getRequirement("x", NotInOperator, util.NewStringSet("abc", "def"), t),
-		}}, true, true},
-		{"x in (abc,def)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"x in (abc,def)", LabelSelector{
 			getRequirement("x", InOperator, util.NewStringSet("abc", "def"), t),
-		}}, true, true},
-		{"x in (abc,)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"x in (abc,)", LabelSelector{
 			getRequirement("x", InOperator, util.NewStringSet("abc", ""), t),
-		}}, true, true},
-		{"x in ()", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"x in ()", LabelSelector{
 			getRequirement("x", InOperator, util.NewStringSet(""), t),
-		}}, true, true},
-		{"x notin (abc,,def),bar,z in (),w", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"x notin (abc,,def),bar,z in (),w", LabelSelector{
 			getRequirement("bar", ExistsOperator, nil, t),
 			getRequirement("w", ExistsOperator, nil, t),
 			getRequirement("x", NotInOperator, util.NewStringSet("abc", "", "def"), t),
 			getRequirement("z", InOperator, util.NewStringSet(""), t),
-		}}, true, true},
-		{"x,y in (a)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"x,y in (a)", LabelSelector{
 			getRequirement("y", InOperator, util.NewStringSet("a"), t),
 			getRequirement("x", ExistsOperator, nil, t),
-		}}, false, true},
-		{"x=a", &LabelSelector{Requirements: []Requirement{
+		}, false, true},
+		{"x=a", LabelSelector{
 			getRequirement("x", EqualsOperator, util.NewStringSet("a"), t),
-		}}, true, true},
-		{"x=a,y!=b", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"x=a,y!=b", LabelSelector{
 			getRequirement("x", EqualsOperator, util.NewStringSet("a"), t),
 			getRequirement("y", NotEqualsOperator, util.NewStringSet("b"), t),
-		}}, true, true},
-		{"x=a,y!=b,z in (h,i,j)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"x=a,y!=b,z in (h,i,j)", LabelSelector{
 			getRequirement("x", EqualsOperator, util.NewStringSet("a"), t),
 			getRequirement("y", NotEqualsOperator, util.NewStringSet("b"), t),
 			getRequirement("z", InOperator, util.NewStringSet("h", "i", "j"), t),
-		}}, true, true},
-		{"x=a||y=b", &LabelSelector{Requirements: []Requirement{}}, false, false},
+		}, true, true},
+		{"x=a||y=b", LabelSelector{}, false, false},
 		{"x,,y", nil, true, false},
 		{",x,y", nil, true, false},
 		{"x nott in (y)", nil, true, false},
-		{"x notin ( )", &LabelSelector{Requirements: []Requirement{
+		{"x notin ( )", LabelSelector{
 			getRequirement("x", NotInOperator, util.NewStringSet(""), t),
-		}}, true, true},
-		{"x notin (, a)", &LabelSelector{Requirements: []Requirement{
-
+		}, true, true},
+		{"x notin (, a)", LabelSelector{
 			getRequirement("x", NotInOperator, util.NewStringSet("", "a"), t),
-		}}, true, true},
+		}, true, true},
 		{"a in (xyz),", nil, true, false},
 		{"a in (xyz)b notin ()", nil, true, false},
-		{"a ", &LabelSelector{Requirements: []Requirement{
+		{"a ", LabelSelector{
 			getRequirement("a", ExistsOperator, nil, t),
-		}}, true, true},
-		{"a in (x,y,notin, z,in)", &LabelSelector{Requirements: []Requirement{
+		}, true, true},
+		{"a in (x,y,notin, z,in)", LabelSelector{
 			getRequirement("a", InOperator, util.NewStringSet("in", "notin", "x", "y", "z"), t),
-		}}, true, true}, // operator 'in' inside list of identifiers
+		}, true, true}, // operator 'in' inside list of identifiers
 		{"a in (xyz abc)", nil, false, false}, // no comma
 		{"a notin(", nil, true, false},        // bad formed
 		{"a (", nil, false, false},            // cpar
@@ -588,7 +452,7 @@ func TestSetSelectorParser(t *testing.T) {
 		} else if err == nil && !ssp.Valid {
 			t.Errorf("Parse(%s) => %+v expected error", ssp.In, sel)
 		} else if ssp.Match && !reflect.DeepEqual(sel, ssp.Out) {
-			t.Errorf("Parse(%s) => parse output %+v doesn't match %+v, expected match", ssp.In, sel, ssp.Out)
+			t.Errorf("Parse(%s) => parse output '%t' doesn't match '%t' expected match", ssp.In, sel, ssp.Out)
 		}
 	}
 }