changed to use cmp.Diff where appropriate

Signed-off-by: Etai Lev Ran <elevran@gmail.com>

Author: elevran

pkg/epp/datalayer/attributemap_test.go

@@ -14,26 +14,25 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package datalayer_test
+package datalayer
 
 import (
 	"testing"
 
+	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/assert"
-
-	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/datalayer"
 )
 
 type dummy struct {
 	Text string
 }
 
-func (d *dummy) Clone() datalayer.Cloneable {
+func (d *dummy) Clone() Cloneable {
 	return &dummy{Text: d.Text}
 }
 
 func TestExpectPutThenGetToMatch(t *testing.T) {
-	attrs := datalayer.NewAttributes()
+	attrs := NewAttributes()
 	original := &dummy{"foo"}
 	attrs.Put("a", original)
 
@@ -47,34 +46,26 @@ func TestExpectPutThenGetToMatch(t *testing.T) {
 }
 
 func TestExpectKeysToMatchAdded(t *testing.T) {
-	attrs := datalayer.NewAttributes()
+	attrs := NewAttributes()
 	attrs.Put("x", &dummy{"1"})
 	attrs.Put("y", &dummy{"2"})
 
 	keys := attrs.Keys()
 	assert.Len(t, keys, 2)
-
-	found := map[string]bool{}
-	for _, k := range keys {
-		found[k] = true
-	}
-
-	assert.True(t, found["x"])
-	assert.True(t, found["y"])
+	assert.ElementsMatch(t, keys, []string{"x", "y"})
 }
 
 func TestCloneReturnsCopy(t *testing.T) {
-	original := datalayer.NewAttributes()
+	original := NewAttributes()
 	original.Put("k", &dummy{"value"})
 
 	cloned := original.Clone()
 
-	gotOrig, _ := original.Get("k")
-	gotClone, _ := cloned.Get("k")
-
-	assert.NotSame(t, gotOrig, gotClone, "expected cloned value to be a different instance")
+	kOrig, _ := original.Get("k")
+	kClone, _ := cloned.Get("k")
 
-	dv, ok := gotClone.(*dummy)
-	assert.True(t, ok)
-	assert.Equal(t, "value", dv.Text)
+	assert.NotSame(t, kOrig, kClone, "expected cloned value to be a different instance")
+	if diff := cmp.Diff(kOrig, kClone); diff != "" {
+		t.Errorf("Unexpected output (-want +got): %v", diff)
+	}
 }

pkg/epp/datalayer/datasource.go

@@ -106,15 +106,15 @@ func GetSources() []DataSource {
 // ValidateExtractorType checks if an extractor can handle
 // the DataSource's output. It should be called by a DataSource
 // when an extractor is added.
-func ValidateExtractorType(output, input reflect.Type) error {
-	if output == nil || input == nil {
+func ValidateExtractorType(collectorOutput, extractorInput reflect.Type) error {
+	if collectorOutput == nil || extractorInput == nil {
 		return errors.New("extractor input type or data source output type can't be nil")
 	}
-	if output == input ||
-		(input.Kind() == reflect.Interface && input.NumMethod() == 0) ||
-		(input.Kind() == reflect.Interface && output.Implements(input)) {
+	if collectorOutput == extractorInput ||
+		(extractorInput.Kind() == reflect.Interface && extractorInput.NumMethod() == 0) ||
+		(extractorInput.Kind() == reflect.Interface && collectorOutput.Implements(extractorInput)) {
 		return nil
 	}
 	return fmt.Errorf("extractor input type %v cannot handle data source output type %v",
-		input, output)
+		extractorInput, collectorOutput)
 }

pkg/epp/datalayer/datasource_test.go

@@ -14,27 +14,25 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package datalayer_test
+package datalayer
 
 import (
 	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-
-	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/datalayer"
 )
 
 type mockDataSource struct {
 	name string
 }
 
-func (m *mockDataSource) Name() string                             { return m.name }
-func (m *mockDataSource) AddExtractor(_ datalayer.Extractor) error { return nil }
-func (m *mockDataSource) Collect(_ datalayer.Endpoint)             {}
+func (m *mockDataSource) Name() string                   { return m.name }
+func (m *mockDataSource) AddExtractor(_ Extractor) error { return nil }
+func (m *mockDataSource) Collect(_ Endpoint)             {}
 
 func TestRegisterAndGetSource(t *testing.T) {
-	reg := datalayer.DataSourceRegistry{}
+	reg := DataSourceRegistry{}
 	ds := &mockDataSource{name: "test"}
 
 	err := reg.Register(ds)
@@ -56,7 +54,7 @@ func TestRegisterAndGetSource(t *testing.T) {
 }
 
 func TestGetNamedSourceWhenNotFound(t *testing.T) {
-	reg := datalayer.DataSourceRegistry{}
+	reg := DataSourceRegistry{}
 	_, found := reg.GetNamedSource("missing")
 	assert.False(t, found, "expected source to be missing")
 }
@@ -78,7 +76,7 @@ func TestValidateExtractorType(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		err := datalayer.ValidateExtractorType(tt.output, tt.input)
+		err := ValidateExtractorType(tt.output, tt.input)
 		if tt.valid {
 			assert.NoError(t, err, "%s: expected valid extractor type", tt.name)
 		} else {

pkg/epp/datalayer/metrics_test.go

@@ -14,20 +14,18 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package datalayer_test
+package datalayer
 
 import (
 	"testing"
 	"time"
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/assert"
-
-	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/datalayer"
 )
 
 func TestMetricsClone(t *testing.T) {
-	m := &datalayer.Metrics{
+	m := &Metrics{
 		ActiveModels:            map[string]int{"modelA": 1},
 		WaitingModels:           map[string]int{"modelB": 2},
 		MaxActiveModels:         5,
@@ -39,8 +37,6 @@ func TestMetricsClone(t *testing.T) {
 	}
 
 	clone := m.Clone()
-
-	assert.NotNil(t, clone)
 	if diff := cmp.Diff(m, clone); diff != "" {
 		t.Errorf("Unexpected output (-want +got): %v", diff)
 	}
@@ -53,14 +49,14 @@ func TestMetricsClone(t *testing.T) {
 }
 
 func TestMetricsCloneOfNil(t *testing.T) {
-	var m *datalayer.Metrics
+	var m *Metrics
 	assert.Nil(t, m.Clone())
 }
 
 func TestMetricsToString(t *testing.T) {
-	m := datalayer.NewMetrics()
+	m := NewMetrics()
 	assert.NotEmpty(t, m.String())
 
-	var none *datalayer.Metrics
+	var none *Metrics
 	assert.Equal(t, "", none.String())
 }

pkg/epp/datalayer/podinfo_test.go

@@ -14,17 +14,16 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package datalayer_test
+package datalayer
 
 import (
 	"testing"
 
+	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/assert"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
-
-	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/datalayer"
 )
 
 const (
@@ -49,35 +48,33 @@ var (
 			PodIP: podip,
 		},
 	}
+	expected = &PodInfo{
+		NamespacedName: types.NamespacedName{Name: name, Namespace: namespace},
+		Address:        podip,
+		Labels:         labels,
+	}
 )
 
 func TestToPodInfo(t *testing.T) {
-	podinfo := datalayer.ToPodInfo(pod)
-
-	assert.Equal(t, name, podinfo.NamespacedName.Name)
-	assert.Equal(t, namespace, podinfo.NamespacedName.Namespace)
-	assert.Equal(t, podip, podinfo.Address)
-	assert.Equal(t, labels, podinfo.Labels)
+	podinfo := ToPodInfo(pod)
+	if diff := cmp.Diff(expected, podinfo); diff != "" {
+		t.Errorf("Unexpected output (-want +got): %v", diff)
+	}
 }
 
 func TestPodInfoClone(t *testing.T) {
-	podinfo := &datalayer.PodInfo{
-		NamespacedName: types.NamespacedName{Name: name, Namespace: namespace},
-		Address:        podip,
-		Labels:         labels,
+	clone := expected.Clone()
+	assert.NotSame(t, expected, clone)
+	if diff := cmp.Diff(expected, clone); diff != "" {
+		t.Errorf("Unexpected output (-want +got): %v", diff)
 	}
 
-	clone := podinfo.Clone()
-
-	assert.Equal(t, podinfo, clone)
-	assert.NotSame(t, podinfo, clone)
-	assert.Equal(t, podinfo.Labels, clone.Labels)
 	clone.Labels["env"] = "staging"
-	assert.Equal(t, "prod", podinfo.Labels["env"], "mutating clone should not affect original")
+	assert.Equal(t, "prod", expected.Labels["env"], "mutating clone should not affect original")
 }
 
 func TestPodInfoString(t *testing.T) {
-	podinfo := datalayer.ToPodInfo(pod)
+	podinfo := ToPodInfo(pod)
 
 	s := podinfo.String()
 	assert.Contains(t, s, name)