Addressing feedback:Add DV-preferred test coverage and typed initializer

Author: itzPranshul

pkg/analysis/maxlength/analyzer_test.go

@@ -20,7 +20,6 @@ import (
 
 	"golang.org/x/tools/go/analysis/analysistest"
 	"k8s.io/apimachinery/pkg/util/validation/field"
-	"sigs.k8s.io/kube-api-linter/pkg/analysis/initializer"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/maxlength"
 	"sigs.k8s.io/kube-api-linter/pkg/markers"
 )
@@ -33,27 +32,14 @@ func TestMaxLength(t *testing.T) {
 	analysistest.Run(t, testdata, maxlength.Analyzer, "a")
 }
 
-// TestMaxLength_DVMarkers tests that the linter (default config) accepts DV
-// markers as satisfying the max-length/max-items/max-properties constraints.
-func TestMaxLength_DVMarkers(t *testing.T) {
-	testdata := analysistest.TestData()
-
-	// The DV testdata lives in the same package "a" (c.go + d.go).
-	// Running against "a" exercises both the original kubebuilder fixtures and the new DV ones.
-	analysistest.Run(t, testdata, maxlength.Analyzer, "a")
-}
-
-// TestMaxLength_DVPreferred tests the linter configured to prefer DV markers in
-// diagnostic messages.
+// TestMaxLength_DVPreferred tests the linter configured to prefer DV markers:
+// - DV-style markers (k8s:maxLength, k8s:maxItems, k8s:maxProperties, k8s:maxBytes)
+//   satisfy the constraints and produce no diagnostic.
+// - Missing markers produce diagnostics citing the k8s:* form.
 func TestMaxLength_DVPreferred(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	ci, ok := maxlength.Initializer().(initializer.ConfigurableAnalyzerInitializer)
-	if !ok {
-		t.Fatal("maxlength.Initializer() does not implement ConfigurableAnalyzerInitializer")
-	}
-
-	a, err := ci.Init(&maxlength.MaxLengthConfig{
+	a, err := maxlength.Initializer().Initialize(&maxlength.MaxLengthConfig{
 		PreferredMaxLengthMarker:     markers.K8sMaxLengthMarker,
 		PreferredMaxItemsMarker:      markers.K8sMaxItemsMarker,
 		PreferredMaxPropertiesMarker: markers.K8sMaxPropertiesMarker,
@@ -62,21 +48,16 @@ func TestMaxLength_DVPreferred(t *testing.T) {
 		t.Fatalf("failed to init analyzer: %v", err)
 	}
 
-	// Run only against c.go-style testdata when DV markers are preferred.
-	// The want-comments in a.go cite kubebuilder markers; for this run we use a
-	// separate package that has no want-comments (happy-path only).
-	// For now we verify the analyzer initialises and runs without panicking.
-	_ = a
-	_ = testdata
+	// Package "b" has want-comments referencing k8s:* marker names, so the
+	// analyser must emit diagnostics with those names when a field is missing a
+	// marker, and must not emit anything for fields that carry a DV marker.
+	analysistest.Run(t, testdata, a, "b")
 }
 
 // TestMaxLengthInitializerValidation tests that the MaxLengthConfig validator
 // accepts valid values and rejects invalid ones.
 func TestMaxLengthInitializerValidation(t *testing.T) {
-	ci, ok := maxlength.Initializer().(initializer.ConfigurableAnalyzerInitializer)
-	if !ok {
-		t.Fatal("maxlength.Initializer() does not implement ConfigurableAnalyzerInitializer")
-	}
+	ci := maxlength.Initializer()
 
 	tests := []struct {
 		name        string

pkg/analysis/maxlength/initializer.go

@@ -29,15 +29,29 @@ func init() {
 	registry.DefaultRegistry().RegisterLinter(Initializer())
 }
 
-// Initializer returns the AnalyzerInitializer for this
+// MaxLengthInitializer is the initializer for the maxlength analyzer.
+// It embeds ConfigurableAnalyzerInitializer and adds a typed Initialize
+// method so callers can skip the runtime type assertion.
+type MaxLengthInitializer struct {
+	initializer.ConfigurableAnalyzerInitializer
+}
+
+// Initialize creates a new maxlength analyzer configured with cfg.
+func (m MaxLengthInitializer) Initialize(cfg *MaxLengthConfig) (*analysis.Analyzer, error) {
+	return m.Init(cfg)
+}
+
+// Initializer returns the MaxLengthInitializer for this
 // Analyzer so that it can be added to the registry.
-func Initializer() initializer.AnalyzerInitializer {
-	return initializer.NewConfigurableInitializer(
-		name,
-		initAnalyzer,
-		false, // For now, CRD only, and so not on by default.
-		validateConfig,
-	)
+func Initializer() MaxLengthInitializer {
+	return MaxLengthInitializer{
+		ConfigurableAnalyzerInitializer: initializer.NewConfigurableInitializer(
+			name,
+			initAnalyzer,
+			false, // For now, CRD only, and so not on by default.
+			validateConfig,
+		),
+	}
 }
 
 func initAnalyzer(cfg *MaxLengthConfig) (*analysis.Analyzer, error) {

pkg/analysis/maxlength/testdata/src/b/b.go

@@ -0,0 +1,96 @@
+package b
+
+// DVPreferredMaxLength exercises the linter when configured to prefer DV markers.
+// Fields that carry only DV markers should NOT lint.
+// Fields that are missing markers should lint with a diagnostic citing the k8s:* form.
+type DVPreferredMaxLength struct {
+	// +k8s:maxLength=256
+	StringWithDVMaxLength string // satisfied by DV marker — no lint
+
+	// +kubebuilder:validation:MaxLength:=128
+	StringWithKubebuilderMaxLength string // kubebuilder marker also satisfies — no lint
+
+	StringWithoutMaxLength string // want `field DVPreferredMaxLength.StringWithoutMaxLength must have a maximum length, add k8s:maxLength marker`
+
+	// +k8s:maxBytes=512
+	ByteSliceWithDVMaxBytes []byte // satisfied by k8s:maxBytes — no lint
+
+	ByteSliceWithoutMax []byte // want `field DVPreferredMaxLength.ByteSliceWithoutMax must have a maximum length, add k8s:maxLength marker`
+
+	// +k8s:maxItems=128
+	ArrayWithDVMaxItems []int // satisfied by k8s:maxItems — no lint
+
+	// +kubebuilder:validation:MaxItems:=64
+	ArrayWithKubebuilderMaxItems []int // kubebuilder marker also satisfies — no lint
+
+	ArrayWithoutMaxItems []int // want `field DVPreferredMaxLength.ArrayWithoutMaxItems must have a maximum items, add k8s:maxItems marker`
+
+	// +k8s:maxProperties=64
+	MapWithDVMaxProperties map[string]string // satisfied by k8s:maxProperties — no lint
+
+	// +kubebuilder:validation:MaxProperties:=32
+	MapWithKubebuilderMaxProperties map[string]string // kubebuilder marker also satisfies — no lint
+
+	MapWithoutMaxProperties map[string]string // want `field DVPreferredMaxLength.MapWithoutMaxProperties must have a maximum properties, add k8s:maxProperties marker`
+
+	// Non-string-keyed map — never linted regardless of config.
+	MapWithIntKey map[int]string
+
+	// +k8s:enum
+	DVEnumString string // enum exempts from max-length — no lint
+
+	// +kubebuilder:validation:Enum:="A";"B"
+	KubebuilderEnumString string // kubebuilder enum also exempts in DV-preferred mode — no lint
+
+	// +k8s:format=date-time
+	DVDateTimeString string // format exempts from max-length — no lint
+
+	// +k8s:format=date
+	DVDateString string // format exempts from max-length — no lint
+
+	// +k8s:format=duration
+	DVDurationString string // format exempts from max-length — no lint
+
+	// +kubebuilder:validation:Format:=date-time
+	KubebuilderDateTimeString string // kubebuilder format also exempts in DV-preferred mode — no lint
+
+	// +kubebuilder:validation:Format:=date
+	KubebuilderDateString string // kubebuilder format also exempts in DV-preferred mode — no lint
+
+	// +kubebuilder:validation:Format:=duration
+	KubebuilderDurationString string // kubebuilder format also exempts in DV-preferred mode — no lint
+
+	// +k8s:maxLength=256 on a []byte field is the WRONG DV marker; +k8s:maxBytes should be used.
+	// The linter must still report the field as missing a valid max-length constraint.
+	// +k8s:maxLength=256
+	ByteSliceWithWrongDVMarker []byte // want `field DVPreferredMaxLength.ByteSliceWithWrongDVMarker must have a maximum length, add k8s:maxLength marker`
+
+	// Raw []string — needs both MaxItems and items:MaxLength.
+	// +k8s:maxItems=16
+	// +kubebuilder:validation:items:MaxLength:=64
+	StringArrayWithMaxItemsAndElementLength []string // no lint
+
+	// +k8s:maxItems=16
+	StringArrayWithMaxItemsWithoutElementLength []string // want `field DVPreferredMaxLength.StringArrayWithMaxItemsWithoutElementLength array element must have a maximum length, add kubebuilder:validation:items:MaxLength`
+
+	StringArrayWithoutMaxItemsOrElementLength []string // want `field DVPreferredMaxLength.StringArrayWithoutMaxItemsOrElementLength must have a maximum items, add k8s:maxItems marker` `field DVPreferredMaxLength.StringArrayWithoutMaxItemsOrElementLength array element must have a maximum length, add kubebuilder:validation:items:MaxLength`
+}
+
+// StringAliasDVMaxLength is a string alias carrying a DV maxLength marker.
+// +k8s:maxLength=512
+type StringAliasDVMaxLength string
+
+// StringAliasNoMaxLength is a string alias without any max-length marker.
+type StringAliasNoMaxLength string
+
+// DVPreferredAliases exercises alias-level DV markers.
+type DVPreferredAliases struct {
+	StringWithAliasMaxLength StringAliasDVMaxLength // satisfied by alias marker — no lint
+
+	StringWithoutMaxLength StringAliasNoMaxLength // want `field DVPreferredAliases.StringWithoutMaxLength type StringAliasNoMaxLength must have a maximum length, add k8s:maxLength marker`
+
+	// +k8s:maxItems=64
+	AliasArrayWithMaxItems []StringAliasDVMaxLength // array element max-length satisfied by alias — no lint
+
+	AliasArrayWithoutMaxItems []StringAliasDVMaxLength // want `field DVPreferredAliases.AliasArrayWithoutMaxItems must have a maximum items, add k8s:maxItems marker`
+}