From 4e8477bd3bd41c6eb0266689763cad49ae8425c2 Mon Sep 17 00:00:00 2001 From: Jefftree Date: Wed, 23 Oct 2024 01:29:55 +0000 Subject: [PATCH 1/5] Bump binary version to 1.33 --- staging/src/k8s.io/component-base/version/base.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/staging/src/k8s.io/component-base/version/base.go b/staging/src/k8s.io/component-base/version/base.go index 46500118abf96..d1810b7277311 100644 --- a/staging/src/k8s.io/component-base/version/base.go +++ b/staging/src/k8s.io/component-base/version/base.go @@ -66,5 +66,5 @@ const ( // DefaultKubeBinaryVersion is the hard coded k8 binary version based on the latest K8s release. // It is supposed to be consistent with gitMajor and gitMinor, except for local tests, where gitMajor and gitMinor are "". // Should update for each minor release! - DefaultKubeBinaryVersion = "1.32" + DefaultKubeBinaryVersion = "1.33" ) From cf28c0405c02e82e1028193a4ce1aa75d473ae8e Mon Sep 17 00:00:00 2001 From: Jefftree Date: Tue, 10 Dec 2024 16:34:34 +0000 Subject: [PATCH 2/5] Expand emulated version range to n-3 with 1.31 floor --- .../server/options/server_run_options_test.go | 6 +- .../featuregate/registry_test.go | 2 +- .../k8s.io/component-base/version/version.go | 29 +++--- .../component-base/version/version_test.go | 88 +++++++++++++++++-- 4 files changed, 105 insertions(+), 20 deletions(-) diff --git a/staging/src/k8s.io/apiserver/pkg/server/options/server_run_options_test.go b/staging/src/k8s.io/apiserver/pkg/server/options/server_run_options_test.go index 71c66002821ab..69c09ccc4c71b 100644 --- a/staging/src/k8s.io/apiserver/pkg/server/options/server_run_options_test.go +++ b/staging/src/k8s.io/apiserver/pkg/server/options/server_run_options_test.go @@ -34,8 +34,8 @@ import ( func TestServerRunOptionsValidate(t *testing.T) { testRegistry := featuregate.NewComponentGlobalsRegistry() featureGate := utilfeature.DefaultFeatureGate.DeepCopy() - effectiveVersion := utilversion.NewEffectiveVersion("1.30") - effectiveVersion.SetEmulationVersion(version.MajorMinor(1, 32)) + effectiveVersion := utilversion.NewEffectiveVersion("1.35") + effectiveVersion.SetEmulationVersion(version.MajorMinor(1, 31)) testComponent := "test" utilruntime.Must(testRegistry.Register(testComponent, effectiveVersion, featureGate)) @@ -197,7 +197,7 @@ func TestServerRunOptionsValidate(t *testing.T) { ComponentName: testComponent, ComponentGlobalsRegistry: testRegistry, }, - expectErr: "emulation version 1.32 is not between [1.29, 1.30.0]", + expectErr: "emulation version 1.31 is not between [1.32, 1.35.0]", }, { name: "Test when ServerRunOptions is valid", diff --git a/staging/src/k8s.io/component-base/featuregate/registry_test.go b/staging/src/k8s.io/component-base/featuregate/registry_test.go index 85046063c27de..b825fd3d758df 100644 --- a/staging/src/k8s.io/component-base/featuregate/registry_test.go +++ b/staging/src/k8s.io/component-base/featuregate/registry_test.go @@ -118,7 +118,7 @@ func TestVersionFlagOptions(t *testing.T) { func TestVersionFlagOptionsWithMapping(t *testing.T) { r := testRegistry(t) utilruntime.Must(r.SetEmulationVersionMapping(testComponent, DefaultKubeComponent, - func(from *version.Version) *version.Version { return from.OffsetMinor(3) })) + func(from *version.Version) *version.Version { return version.MajorMinor(1, from.Minor()+23) })) emuVers := strings.Join(r.unsafeVersionFlagOptions(true), "\n") expectedEmuVers := "test=2.8..2.8 (default=2.8)" if emuVers != expectedEmuVers { diff --git a/staging/src/k8s.io/component-base/version/version.go b/staging/src/k8s.io/component-base/version/version.go index 99d3685348a33..0c62305839c09 100644 --- a/staging/src/k8s.io/component-base/version/version.go +++ b/staging/src/k8s.io/component-base/version/version.go @@ -25,6 +25,8 @@ import ( apimachineryversion "k8s.io/apimachinery/pkg/version" ) +var minimumKubeEmulationVersion *version.Version = version.MajorMinor(1, 31) + type EffectiveVersion interface { BinaryVersion() *version.Version EmulationVersion() *version.Version @@ -121,8 +123,11 @@ func (m *effectiveVersion) Set(binaryVersion, emulationVersion, minCompatibility func (m *effectiveVersion) SetEmulationVersion(emulationVersion *version.Version) { m.emulationVersion.Store(majorMinor(emulationVersion)) + // set the default minCompatibilityVersion to be emulationVersion - 1 + m.minCompatibilityVersion.Store(majorMinor(emulationVersion.SubtractMinor(1))) } +// SetMinCompatibilityVersion should be called after SetEmulationVersion func (m *effectiveVersion) SetMinCompatibilityVersion(minCompatibilityVersion *version.Version) { m.minCompatibilityVersion.Store(majorMinor(minCompatibilityVersion)) } @@ -134,15 +139,15 @@ func (m *effectiveVersion) Validate() []error { emulationVersion := m.emulationVersion.Load() minCompatibilityVersion := m.minCompatibilityVersion.Load() - // emulationVersion can only be 1.{binaryMinor-1}...1.{binaryMinor}. + // emulationVersion can only be 1.{binaryMinor-3}...1.{binaryMinor} maxEmuVer := binaryVersion - minEmuVer := binaryVersion.SubtractMinor(1) + minEmuVer := binaryVersion.SubtractMinor(3) if emulationVersion.GreaterThan(maxEmuVer) || emulationVersion.LessThan(minEmuVer) { errs = append(errs, fmt.Errorf("emulation version %s is not between [%s, %s]", emulationVersion.String(), minEmuVer.String(), maxEmuVer.String())) } - // minCompatibilityVersion can only be 1.{binaryMinor-1} for alpha. - maxCompVer := binaryVersion.SubtractMinor(1) - minCompVer := binaryVersion.SubtractMinor(1) + // minCompatibilityVersion can only be 1.{binaryMinor-3} to 1.{binaryMinor} + maxCompVer := emulationVersion + minCompVer := binaryVersion.SubtractMinor(4) if minCompatibilityVersion.GreaterThan(maxCompVer) || minCompatibilityVersion.LessThan(minCompVer) { errs = append(errs, fmt.Errorf("minCompatibilityVersion version %s is not between [%s, %s]", minCompatibilityVersion.String(), minCompVer.String(), maxCompVer.String())) } @@ -187,13 +192,15 @@ func DefaultKubeEffectiveVersion() MutableEffectiveVersion { return newEffectiveVersion(binaryVersion, false) } -// ValidateKubeEffectiveVersion validates the EmulationVersion is equal to the binary version at 1.31 for kube components. -// emulationVersion is introduced in 1.31, so it is only allowed to be equal to the binary version at 1.31. +// ValidateKubeEffectiveVersion validates the EmulationVersion is at least 1.31 and MinCompatibilityVersion +// is at least 1.30 for kube components. func ValidateKubeEffectiveVersion(effectiveVersion EffectiveVersion) error { - binaryVersion := version.MajorMinor(effectiveVersion.BinaryVersion().Major(), effectiveVersion.BinaryVersion().Minor()) - if binaryVersion.EqualTo(version.MajorMinor(1, 31)) && !effectiveVersion.EmulationVersion().EqualTo(binaryVersion) { - return fmt.Errorf("emulation version needs to be equal to binary version(%s) in compatibility-version alpha, got %s", - binaryVersion.String(), effectiveVersion.EmulationVersion().String()) + if !effectiveVersion.EmulationVersion().AtLeast(minimumKubeEmulationVersion) { + return fmt.Errorf("emulation version needs to be greater or equal to 1.31, got %s", effectiveVersion.EmulationVersion().String()) + } + if !effectiveVersion.MinCompatibilityVersion().AtLeast(minimumKubeEmulationVersion.SubtractMinor(1)) { + return fmt.Errorf("minCompatibilityVersion version needs to be greater or equal to 1.30, got %s", effectiveVersion.MinCompatibilityVersion().String()) } + return nil } diff --git a/staging/src/k8s.io/component-base/version/version_test.go b/staging/src/k8s.io/component-base/version/version_test.go index aff8a8e4a0bc2..3f6c34bd46e90 100644 --- a/staging/src/k8s.io/component-base/version/version_test.go +++ b/staging/src/k8s.io/component-base/version/version_test.go @@ -43,9 +43,22 @@ func TestValidate(t *testing.T) { minCompatibilityVersion: "v1.31.0", }, { - name: "emulation version two minor lower than binary not ok", + name: "emulation version two minor lower than binary ok", binaryVersion: "v1.33.2", emulationVersion: "v1.31.0", + minCompatibilityVersion: "v1.31.0", + expectErrors: false, + }, + { + name: "emulation version three minor lower than binary ok", + binaryVersion: "v1.35.0", + emulationVersion: "v1.32.0", + minCompatibilityVersion: "v1.32.0", + }, + { + name: "emulation version four minor lower than binary not ok", + binaryVersion: "v1.36.0", + emulationVersion: "v1.32.0", minCompatibilityVersion: "v1.32.0", expectErrors: true, }, @@ -64,18 +77,25 @@ func TestValidate(t *testing.T) { expectErrors: true, }, { - name: "compatibility version same as binary not ok", + name: "compatibility version same as binary ok", binaryVersion: "v1.32.2", emulationVersion: "v1.32.0", minCompatibilityVersion: "v1.32.0", - expectErrors: true, + expectErrors: false, }, { - name: "compatibility version two minor lower than binary not ok", + name: "compatibility version two minor lower than binary ok", binaryVersion: "v1.32.2", emulationVersion: "v1.32.0", minCompatibilityVersion: "v1.30.0", - expectErrors: true, + expectErrors: false, + }, + { + name: "compatibility version three minor lower than binary ok", + binaryVersion: "v1.34.2", + emulationVersion: "v1.33.0", + minCompatibilityVersion: "v1.31.0", + expectErrors: false, }, { name: "compatibility version one minor higher than binary not ok", @@ -84,6 +104,13 @@ func TestValidate(t *testing.T) { minCompatibilityVersion: "v1.33.0", expectErrors: true, }, + { + name: "emulation version lower than compatibility version not ok", + binaryVersion: "v1.34.2", + emulationVersion: "v1.32.0", + minCompatibilityVersion: "v1.33.0", + expectErrors: true, + }, } for _, test := range tests { @@ -105,3 +132,54 @@ func TestValidate(t *testing.T) { }) } } + +func TestValidateKubeEffectiveVersion(t *testing.T) { + tests := []struct { + name string + emulationVersion string + minCompatibilityVersion string + expectErr bool + }{ + { + name: "valid versions", + emulationVersion: "v1.31.0", + minCompatibilityVersion: "v1.31.0", + expectErr: false, + }, + { + name: "emulationVersion too low", + emulationVersion: "v1.30.0", + minCompatibilityVersion: "v1.31.0", + expectErr: true, + }, + { + name: "minCompatibilityVersion too low", + emulationVersion: "v1.31.0", + minCompatibilityVersion: "v1.29.0", + expectErr: true, + }, + { + name: "both versions too low", + emulationVersion: "v1.30.0", + minCompatibilityVersion: "v1.30.0", + expectErr: true, + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + + effective := NewEffectiveVersion("1.32") + effective.SetEmulationVersion(version.MustParseGeneric(test.emulationVersion)) + effective.SetMinCompatibilityVersion(version.MustParseGeneric(test.minCompatibilityVersion)) + + err := ValidateKubeEffectiveVersion(effective) + if test.expectErr && err == nil { + t.Error("expected error, but got nil") + } + if !test.expectErr && err != nil { + t.Errorf("unexpected error: %v", err) + } + }) + } +} From dc476e968d9160efb66022a4b48f217b526d32f9 Mon Sep 17 00:00:00 2001 From: Jefftree Date: Wed, 18 Dec 2024 15:13:10 +0000 Subject: [PATCH 3/5] remove emulated version test for un-emulatable 1.30 --- test/integration/apiserver/apiserver_test.go | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/test/integration/apiserver/apiserver_test.go b/test/integration/apiserver/apiserver_test.go index 58e4df84c26bb..e360cd3342cd9 100644 --- a/test/integration/apiserver/apiserver_test.go +++ b/test/integration/apiserver/apiserver_test.go @@ -2975,20 +2975,6 @@ func TestEmulatedStorageVersion(t *testing.T) { expectedStorageVersion schema.GroupVersion } cases := []testCase{ - { - name: "vap first ga release", - emulatedVersion: "1.30", - gvr: schema.GroupVersionResource{ - Group: "admissionregistration.k8s.io", - Version: "v1", - Resource: "validatingadmissionpolicies", - }, - object: validVap, - expectedStorageVersion: schema.GroupVersion{ - Group: "admissionregistration.k8s.io", - Version: "v1beta1", - }, - }, { name: "vap after ga release", emulatedVersion: "1.31", From 6c94adcc630591b579a30e8da70d8211fddd44b8 Mon Sep 17 00:00:00 2001 From: Jefftree Date: Tue, 10 Dec 2024 16:21:52 +0000 Subject: [PATCH 4/5] expand etcd storage tests to test for 1.31..1.33 --- .../transformation/kms_transformation_test.go | 3 - test/integration/etcd/data.go | 80 +++++++++++++++---- .../etcd/etcd_storage_path_test.go | 41 ++++++++-- test/integration/etcd/server.go | 19 ++++- 4 files changed, 119 insertions(+), 24 deletions(-) diff --git a/test/integration/controlplane/transformation/kms_transformation_test.go b/test/integration/controlplane/transformation/kms_transformation_test.go index 01858351ea39a..9e70ef3c3217c 100644 --- a/test/integration/controlplane/transformation/kms_transformation_test.go +++ b/test/integration/controlplane/transformation/kms_transformation_test.go @@ -618,9 +618,6 @@ resources: endpoint: unix:///@encrypt-all-kms-provider.sock ` - // KUBE_APISERVER_SERVE_REMOVED_APIS_FOR_ONE_RELEASE allows for APIs pending removal to not block tests - t.Setenv("KUBE_APISERVER_SERVE_REMOVED_APIS_FOR_ONE_RELEASE", "true") - t.Run("encrypt all resources", func(t *testing.T) { _ = mock.NewBase64Plugin(t, "@encrypt-all-kms-provider.sock") // To ensure we are checking all REST resources diff --git a/test/integration/etcd/data.go b/test/integration/etcd/data.go index d2ef43b7c9cea..2d8618f01b312 100644 --- a/test/integration/etcd/data.go +++ b/test/integration/etcd/data.go @@ -17,26 +17,54 @@ limitations under the License. package etcd import ( + "strings" + apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" "k8s.io/apiextensions-apiserver/test/integration/fixtures" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime/schema" + utilversion "k8s.io/component-base/version" "k8s.io/kubernetes/test/utils/image" ) -// GetEtcdStorageData returns etcd data for all persisted objects. +// GetSupportedEmulatedVersions provides the list of supported emulated versions in the etcd data. +// Tests aiming for full coverage of versions should test fixtures of all supported versions. +func GetSupportedEmulatedVersions() []string { + return []string{ + utilversion.DefaultKubeEffectiveVersion().BinaryVersion().SubtractMinor(2).String(), + utilversion.DefaultKubeEffectiveVersion().BinaryVersion().SubtractMinor(1).String(), + utilversion.DefaultKubeEffectiveVersion().BinaryVersion().String(), + } +} + +// GetEtcdStorageData returns etcd data for all persisted objects at the latest release version. // It is exported so that it can be reused across multiple tests. // It returns a new map on every invocation to prevent different tests from mutating shared state. func GetEtcdStorageData() map[schema.GroupVersionResource]StorageData { - return GetEtcdStorageDataForNamespace("etcdstoragepathtestnamespace") + return GetEtcdStorageDataServedAt(utilversion.DefaultKubeBinaryVersion, false) } -// GetEtcdStorageDataForNamespace returns etcd data for all persisted objects. +// GetEtcdStorageDataServedAt returns etcd data for all persisted objects at a particular release version. +// It is exported so that it can be reused across multiple tests. +// It returns a new map on every invocation to prevent different tests from mutating shared state. +func GetEtcdStorageDataServedAt(version string, removeAlphas bool) map[schema.GroupVersionResource]StorageData { + return GetEtcdStorageDataForNamespaceServedAt("etcdstoragepathtestnamespace", version, removeAlphas) +} + +// GetEtcdStorageDataForNamespace returns etcd data for all persisted objects at the latest release version. // It is exported so that it can be reused across multiple tests. // It returns a new map on every invocation to prevent different tests from mutating shared state. // Namespaced objects keys are computed for the specified namespace. func GetEtcdStorageDataForNamespace(namespace string) map[schema.GroupVersionResource]StorageData { + return GetEtcdStorageDataForNamespaceServedAt(namespace, utilversion.DefaultKubeBinaryVersion, false) +} + +// GetEtcdStorageDataForNamespaceServedAt returns etcd data for all persisted objects at a particular release version. +// It is exported so that it can be reused across multiple tests. +// It returns a new map on every invocation to prevent different tests from mutating shared state. +// Namespaced objects keys are computed for the specified namespace. +func GetEtcdStorageDataForNamespaceServedAt(namespace string, version string, removeAlphas bool) map[schema.GroupVersionResource]StorageData { image := image.GetE2EImage(image.BusyBox) etcdStorageData := map[schema.GroupVersionResource]StorageData{ // k8s.io/kubernetes/pkg/api/v1 @@ -465,22 +493,46 @@ func GetEtcdStorageDataForNamespace(namespace string) map[schema.GroupVersionRes }, // -- - } + // k8s.io/kubernetes/pkg/apis/storage/v1 + gvr("storage.k8s.io", "v1", "csinodes"): { + Stub: `{"metadata": {"name": "csini2"}, "spec": {"drivers": [{"name": "test-driver", "nodeID": "localhost", "topologyKeys": ["company.com/zone1", "company.com/zone2"]}]}}`, + ExpectedEtcdPath: "/registry/csinodes/csini2", + }, + // -- - // add csinodes - // k8s.io/kubernetes/pkg/apis/storage/v1 - etcdStorageData[gvr("storage.k8s.io", "v1", "csinodes")] = StorageData{ - Stub: `{"metadata": {"name": "csini2"}, "spec": {"drivers": [{"name": "test-driver", "nodeID": "localhost", "topologyKeys": ["company.com/zone1", "company.com/zone2"]}]}}`, - ExpectedEtcdPath: "/registry/csinodes/csini2", + // k8s.io/kubernetes/pkg/apis/storage/v1 + gvr("storage.k8s.io", "v1", "csidrivers"): { + Stub: `{"metadata": {"name": "csid2"}, "spec": {"attachRequired": true, "podInfoOnMount": true}}`, + ExpectedEtcdPath: "/registry/csidrivers/csid2", + }, + // -- } - // add csidrivers - // k8s.io/kubernetes/pkg/apis/storage/v1 - etcdStorageData[gvr("storage.k8s.io", "v1", "csidrivers")] = StorageData{ - Stub: `{"metadata": {"name": "csid2"}, "spec": {"attachRequired": true, "podInfoOnMount": true}}`, - ExpectedEtcdPath: "/registry/csidrivers/csid2", + // Delete types no longer served or not yet added at a particular emulated version. + // When adding a brand new type non-alpha type in the latest release, please ensure that + // it is removed in previous emulated versions otherwise emulated version tests will fail. + // TODO: derive this programatically from gvk --> instance --> APILifecycle info + switch version { + case "1.33": + delete(etcdStorageData, gvr("flowcontrol.apiserver.k8s.io", "v1beta3", "flowschemas")) + delete(etcdStorageData, gvr("flowcontrol.apiserver.k8s.io", "v1beta3", "prioritylevelconfigurations")) + case "1.32": + delete(etcdStorageData, gvr("flowcontrol.apiserver.k8s.io", "v1beta3", "flowschemas")) + delete(etcdStorageData, gvr("flowcontrol.apiserver.k8s.io", "v1beta3", "prioritylevelconfigurations")) + case "1.31": + delete(etcdStorageData, gvr("resource.k8s.io", "v1beta1", "deviceclasses")) + delete(etcdStorageData, gvr("resource.k8s.io", "v1beta1", "resourceclaims")) + delete(etcdStorageData, gvr("resource.k8s.io", "v1beta1", "resourceclaimtemplates")) + delete(etcdStorageData, gvr("resource.k8s.io", "v1beta1", "resourceslices")) } + if removeAlphas { + for key := range etcdStorageData { + if strings.Contains(key.Version, "alpha") { + delete(etcdStorageData, key) + } + } + } return etcdStorageData } diff --git a/test/integration/etcd/etcd_storage_path_test.go b/test/integration/etcd/etcd_storage_path_test.go index bedc000856bb1..e4e8ed4473aca 100644 --- a/test/integration/etcd/etcd_storage_path_test.go +++ b/test/integration/etcd/etcd_storage_path_test.go @@ -39,9 +39,12 @@ import ( "k8s.io/apimachinery/pkg/runtime/serializer/recognizer" utiljson "k8s.io/apimachinery/pkg/util/json" "k8s.io/apimachinery/pkg/util/sets" + "k8s.io/apimachinery/pkg/util/version" "k8s.io/apiserver/pkg/util/feature" "k8s.io/client-go/dynamic" featuregatetesting "k8s.io/component-base/featuregate/testing" + componentbaseversion "k8s.io/component-base/version" + "k8s.io/kubernetes/cmd/kube-apiserver/app/options" ) // Only add kinds to this list when this a virtual resource with get and create verbs that doesn't actually @@ -75,13 +78,32 @@ var allowMissingTestdataFixtures = map[schema.GroupVersionKind]bool{ // It will also fail when a type gets moved to a different location. Be very careful in this situation because // it essentially means that you will be break old clusters unless you create some migration path for the old data. func TestEtcdStoragePath(t *testing.T) { - // KUBE_APISERVER_SERVE_REMOVED_APIS_FOR_ONE_RELEASE allows for APIs pending removal to not block tests - t.Setenv("KUBE_APISERVER_SERVE_REMOVED_APIS_FOR_ONE_RELEASE", "true") + supportedVersions := GetSupportedEmulatedVersions() + for _, v := range supportedVersions { + t.Run(v, func(t *testing.T) { + testEtcdStoragePathWithVersion(t, v) + }) + } +} - featuregatetesting.SetFeatureGateDuringTest(t, feature.DefaultFeatureGate, "AllAlpha", true) - featuregatetesting.SetFeatureGateDuringTest(t, feature.DefaultFeatureGate, "AllBeta", true) +func testEtcdStoragePathWithVersion(t *testing.T, v string) { + if v == componentbaseversion.DefaultKubeBinaryVersion { + featuregatetesting.SetFeatureGateDuringTest(t, feature.DefaultFeatureGate, "AllAlpha", true) + featuregatetesting.SetFeatureGateDuringTest(t, feature.DefaultFeatureGate, "AllBeta", true) + } else { + // Only test for beta and GA APIs with emulated version. + featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, feature.DefaultFeatureGate, version.MustParse(v)) + featuregatetesting.SetFeatureGateDuringTest(t, feature.DefaultFeatureGate, "AllBeta", true) + registerEffectiveEmulationVersion(t) + } + + apiServer := StartRealAPIServerOrDie(t, func(opts *options.ServerRunOptions) { + // Disable alphas when emulating previous versions. + if v != componentbaseversion.DefaultKubeBinaryVersion { + opts.Options.APIEnablement.RuntimeConfig["api/alpha"] = "false" + } + }) - apiServer := StartRealAPIServerOrDie(t) defer apiServer.Cleanup() defer dumpEtcdKVOnFailure(t, apiServer.KV) @@ -91,7 +113,14 @@ func TestEtcdStoragePath(t *testing.T) { t.Fatal(err) } - etcdStorageData := GetEtcdStorageData() + var etcdStorageData map[schema.GroupVersionResource]StorageData + if v == componentbaseversion.DefaultKubeBinaryVersion { + etcdStorageData = GetEtcdStorageDataForNamespaceServedAt("etcdstoragepathtestnamespace", v, false) + } else { + // Drop alphas from etcd data fixtures when emulating previous versions + // as alphas are not supported with emulation. + etcdStorageData = GetEtcdStorageDataForNamespaceServedAt("etcdstoragepathtestnamespace", v, true) + } kindSeen := sets.NewString() pathSeen := map[string][]schema.GroupVersionResource{} diff --git a/test/integration/etcd/server.go b/test/integration/etcd/server.go index 03911859aafe8..cb8d71a335b02 100644 --- a/test/integration/etcd/server.go +++ b/test/integration/etcd/server.go @@ -36,14 +36,19 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" utilerrors "k8s.io/apimachinery/pkg/util/errors" "k8s.io/apimachinery/pkg/util/json" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" genericapiserveroptions "k8s.io/apiserver/pkg/server/options" + "k8s.io/apiserver/pkg/util/feature" cacheddiscovery "k8s.io/client-go/discovery/cached/memory" "k8s.io/client-go/dynamic" clientset "k8s.io/client-go/kubernetes" restclient "k8s.io/client-go/rest" "k8s.io/client-go/restmapper" utiltesting "k8s.io/client-go/util/testing" + "k8s.io/component-base/featuregate" + featuregatetesting "k8s.io/component-base/featuregate/testing" + utilversion "k8s.io/component-base/version" "k8s.io/kubernetes/cmd/kube-apiserver/app" "k8s.io/kubernetes/cmd/kube-apiserver/app/options" "k8s.io/kubernetes/test/integration" @@ -62,11 +67,23 @@ AwEHoUQDQgAEH6cuzP8XuD5wal6wf9M6xDljTOPLX2i8uIp/C/ASqiIGUeeKQtX0 /IR3qCXyThP/dbCiHrF3v1cuhBOHY8CLVg== -----END EC PRIVATE KEY-----` +func registerEffectiveEmulationVersion(t *testing.T) { + featureGate := feature.DefaultMutableFeatureGate + featureGate.AddMetrics() + + effectiveVersion := utilversion.DefaultKubeEffectiveVersion() + effectiveVersion.SetEmulationVersion(featureGate.EmulationVersion()) + featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, featureGate, effectiveVersion.EmulationVersion()) + featuregate.DefaultComponentGlobalsRegistry.Reset() + utilruntime.Must(featuregate.DefaultComponentGlobalsRegistry.Register(featuregate.DefaultKubeComponent, effectiveVersion, featureGate)) +} + // StartRealAPIServerOrDie starts an API server that is appropriate for use in tests that require one of every resource func StartRealAPIServerOrDie(t *testing.T, configFuncs ...func(*options.ServerRunOptions)) *APIServer { tCtx := ktesting.Init(t) - certDir, err := os.MkdirTemp("", t.Name()) + // Strip out "/" in subtests + certDir, err := os.MkdirTemp("", strings.ReplaceAll(t.Name(), "/", "")) if err != nil { t.Fatal(err) } From 59fcd7b770d7981a96e4d3a725da1b0d55acf59e Mon Sep 17 00:00:00 2001 From: Jefftree Date: Fri, 20 Dec 2024 17:48:49 +0000 Subject: [PATCH 5/5] fix metrics test --- test/integration/metrics/metrics_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/integration/metrics/metrics_test.go b/test/integration/metrics/metrics_test.go index 423db1f210da0..f38f1f33220d9 100644 --- a/test/integration/metrics/metrics_test.go +++ b/test/integration/metrics/metrics_test.go @@ -119,7 +119,7 @@ func TestAPIServerMetrics(t *testing.T) { } // Make a request to a deprecated API to ensure there's at least one data point - if _, err := client.FlowcontrolV1beta3().FlowSchemas().List(context.TODO(), metav1.ListOptions{}); err != nil { + if _, err := client.AdmissionregistrationV1beta1().ValidatingAdmissionPolicies().List(context.TODO(), metav1.ListOptions{}); err != nil { t.Fatalf("unexpected error: %v", err) }