From 0e3f43b9f680e08d99768e3e388af53bd9dd3426 Mon Sep 17 00:00:00 2001 From: Shubham Singh Date: Sat, 3 Aug 2024 01:54:12 +0000 Subject: [PATCH] added tests for pkgs in kubernetes module Signed-off-by: Shubham Singh --- .../metaserver/kubernetes/scope/scope_test.go | 55 +++ .../kubernetes/serializer/serializer_test.go | 330 ++++++++++++++++++ 2 files changed, 385 insertions(+) create mode 100644 edge/pkg/metamanager/metaserver/kubernetes/scope/scope_test.go create mode 100644 edge/pkg/metamanager/metaserver/kubernetes/serializer/serializer_test.go diff --git a/edge/pkg/metamanager/metaserver/kubernetes/scope/scope_test.go b/edge/pkg/metamanager/metaserver/kubernetes/scope/scope_test.go new file mode 100644 index 00000000000..f15a9e6aed4 --- /dev/null +++ b/edge/pkg/metamanager/metaserver/kubernetes/scope/scope_test.go @@ -0,0 +1,55 @@ +/* +Copyright 2024 The KubeEdge Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package scope + +import ( + "testing" + + "github.com/stretchr/testify/assert" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +func TestNewRequestScope(t *testing.T) { + assert := assert.New(t) + + requestScope := NewRequestScope() + + assert.NotNil(requestScope, "NewRequestScope should return a non-nil value") + + assert.NotNil(requestScope.Namer) + assert.NotNil(requestScope.Serializer) + assert.NotNil(requestScope.ParameterCodec) + assert.Empty(requestScope.StandardSerializers) + assert.NotNil(requestScope.Creater) + assert.NotNil(requestScope.Convertor) + assert.NotNil(requestScope.Defaulter) + assert.NotNil(requestScope.Typer) + assert.NotNil(requestScope.UnsafeConvertor) + assert.NotNil(requestScope.Authorizer) + assert.NotNil(requestScope.EquivalentResourceMapper) + assert.NotNil(requestScope.TableConvertor) + assert.NotNil(requestScope.FieldManager) + assert.Nil(requestScope.AcceptsGroupVersionDelegate) + + assert.Equal(schema.GroupVersionResource{}, requestScope.Resource) + assert.Equal(schema.GroupVersionKind{}, requestScope.Kind) + assert.Equal("", requestScope.Subresource) + assert.Equal(metav1.SchemeGroupVersion, requestScope.MetaGroupVersion) + assert.Equal(schema.GroupVersion{}, requestScope.HubGroupVersion) + assert.Equal(int64(3*1024*1024), requestScope.MaxRequestBodyBytes) +} diff --git a/edge/pkg/metamanager/metaserver/kubernetes/serializer/serializer_test.go b/edge/pkg/metamanager/metaserver/kubernetes/serializer/serializer_test.go new file mode 100644 index 00000000000..a065afce5a4 --- /dev/null +++ b/edge/pkg/metamanager/metaserver/kubernetes/serializer/serializer_test.go @@ -0,0 +1,330 @@ +/* +Copyright 2024 The KubeEdge Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package serializer + +import ( + "bytes" + "testing" + + "github.com/stretchr/testify/assert" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructuredscheme" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/runtime/serializer/json" +) + +func TestNewNegotiatedSerializer(t *testing.T) { + assert := assert.New(t) + + serializer := NewNegotiatedSerializer() + assert.NotNil(serializer) + assert.IsType(WithoutConversionCodecFactory{}, serializer) + + codecFactory, ok := serializer.(WithoutConversionCodecFactory) + assert.True(ok, "Serializer should be castable to WithoutConversionCodecFactory") + assert.NotNil(codecFactory.creator) + assert.NotNil(codecFactory.typer) + + supportedMediaTypes := codecFactory.SupportedMediaTypes() + assert.Len(supportedMediaTypes, 2) + assert.Equal("application/json", supportedMediaTypes[0].MediaType, "First media type should be application/json") + assert.Equal("application/yaml", supportedMediaTypes[1].MediaType, "Second media type should be application/yaml") +} + +func TestSupportedMediaTypes(t *testing.T) { + assert := assert.New(t) + + factory := WithoutConversionCodecFactory{} + mediaTypes := factory.SupportedMediaTypes() + + assert.Len(mediaTypes, 2) + + jsonInfo := mediaTypes[0] + assert.Equal("application/json", jsonInfo.MediaType) + assert.Equal("application", jsonInfo.MediaTypeType) + assert.Equal("json", jsonInfo.MediaTypeSubType) + assert.True(jsonInfo.EncodesAsText) + assert.IsType(&json.Serializer{}, jsonInfo.Serializer) + assert.IsType(&json.Serializer{}, jsonInfo.PrettySerializer) + assert.IsType(&json.Serializer{}, jsonInfo.StrictSerializer) + assert.NotNil(jsonInfo.StreamSerializer) + assert.True(jsonInfo.StreamSerializer.EncodesAsText) + assert.IsType(&json.Serializer{}, jsonInfo.StreamSerializer.Serializer) + assert.NotNil(jsonInfo.StreamSerializer.Framer) + + yamlInfo := mediaTypes[1] + assert.Equal("application/yaml", yamlInfo.MediaType) + assert.Equal("application", yamlInfo.MediaTypeType) + assert.Equal("yaml", yamlInfo.MediaTypeSubType) + assert.True(yamlInfo.EncodesAsText) + assert.IsType(&json.Serializer{}, yamlInfo.Serializer) +} + +func TestEncoderForVersion(t *testing.T) { + assert := assert.New(t) + + factory := WithoutConversionCodecFactory{ + creator: unstructuredscheme.NewUnstructuredCreator(), + typer: unstructuredscheme.NewUnstructuredObjectTyper(), + } + + obj := &unstructured.Unstructured{ + Object: map[string]interface{}{ + "apiVersion": "v1", + "kind": "Pod", + "metadata": map[string]interface{}{ + "name": "test-pod", + }, + }, + } + + gvk := schema.GroupVersionKind{Group: "", Version: "v1", Kind: "Pod"} + gv := NewWithKindGroupVersioner(gvk) + + encoder := factory.EncoderForVersion(factory.SupportedMediaTypes()[0].Serializer, gv) + + var buf bytes.Buffer + err := encoder.Encode(obj, &buf) + + assert.NoError(err) + assert.Contains(buf.String(), `"apiVersion":"v1"`) + assert.Contains(buf.String(), `"kind":"Pod"`) +} + +func TestDecoderToVersion(t *testing.T) { + assert := assert.New(t) + + factory := WithoutConversionCodecFactory{ + creator: unstructuredscheme.NewUnstructuredCreator(), + typer: unstructuredscheme.NewUnstructuredObjectTyper(), + } + + originalDecoder := factory.SupportedMediaTypes()[0].Serializer + + gv := schema.GroupVersion{Group: "test", Version: "v1"} + + resultDecoder := factory.DecoderToVersion(originalDecoder, gv) + assert.Equal(originalDecoder, resultDecoder) + + // testing the Decoder + testJSON := `{"apiVersion":"v1","kind":"Pod","metadata":{"name":"test-pod"}}` + obj, _, err := resultDecoder.Decode([]byte(testJSON), nil, nil) + assert.NoError(err) + assert.NotNil(obj) +} + +func TestIdentifier(t *testing.T) { + assert := assert.New(t) + + gvk := schema.GroupVersionKind{Group: "test", Version: "v1", Kind: "Pod"} + gv := NewWithKindGroupVersioner(gvk) + + encoder := &SetVersionEncoder{ + Version: gv, + encoder: nil, + } + + identifier := encoder.Identifier() + expectedIdentifier := runtime.Identifier("SetVersionEncoder:test/v1, Kind=Pod") + assert.Equal(expectedIdentifier, identifier) +} + +func TestEncode(t *testing.T) { + assert := assert.New(t) + + factory := WithoutConversionCodecFactory{ + creator: unstructuredscheme.NewUnstructuredCreator(), + typer: unstructuredscheme.NewUnstructuredObjectTyper(), + } + + gvk := schema.GroupVersionKind{Group: "apps", Version: "v1", Kind: "Deployment"} + gv := NewWithKindGroupVersioner(gvk) + + realEncoder := factory.SupportedMediaTypes()[0].Serializer + encoder := &SetVersionEncoder{ + Version: gv, + encoder: realEncoder, + } + + obj := &unstructured.Unstructured{ + Object: map[string]interface{}{ + "apiVersion": "v1", + "kind": "Pod", + "metadata": map[string]interface{}{ + "name": "test-pod", + }, + }, + } + + var buf bytes.Buffer + err := encoder.Encode(obj, &buf) + + assert.NoError(err) + + encodedContent := buf.String() + assert.Contains(encodedContent, `"apiVersion":"apps/v1"`) + assert.Contains(encodedContent, `"kind":"Deployment"`) + assert.Contains(encodedContent, `"name":"test-pod"`) +} + +func TestDecode(t *testing.T) { + assert := assert.New(t) + + factory := WithoutConversionCodecFactory{ + creator: unstructuredscheme.NewUnstructuredCreator(), + typer: unstructuredscheme.NewUnstructuredObjectTyper(), + } + + realDecoder := factory.SupportedMediaTypes()[0].Serializer + + adapterDecoder := &AdapterDecoder{ + Decoder: realDecoder, + } + + testObj := &unstructured.Unstructured{} + defaultGVK := &schema.GroupVersionKind{Group: "default", Version: "v1", Kind: "DefaultKind"} + + // Test case 1: Incorrect JSON + json := []byte(`{"apiVersion": "v1", "kind": "Pod", "metadata": {`) + + _, resultGVK, err := adapterDecoder.Decode(json, defaultGVK, testObj) + assert.Error(err) + assert.Nil(resultGVK) + assert.Equal(&schema.GroupVersionKind{Group: "default", Version: "v1", Kind: "DefaultKind"}, defaultGVK, "Default GVK should remain unchanged") + + // Test case 2: Correct JSON + correctJSON := []byte(`{"apiVersion": "v1", "kind": "Pod", "metadata": {"name": "test-pod"}}`) + + decodedObj, resultGVK, err := adapterDecoder.Decode(correctJSON, defaultGVK, testObj) + assert.NoError(err) + assert.NotNil(resultGVK) + assert.Equal(&schema.GroupVersionKind{Version: "v1", Kind: "Pod"}, resultGVK, "ResultGVK should match the GVK in the JSON") + + // Check the decoded object + unstructuredObj, ok := decodedObj.(*unstructured.Unstructured) + assert.True(ok, "Decoded object should be of type *unstructured.Unstructured") + assert.Equal("test-pod", unstructuredObj.GetName()) + + objGVK := unstructuredObj.GetObjectKind().GroupVersionKind() + assert.Equal(schema.GroupVersionKind{Version: "v1", Kind: "Pod"}, objGVK) +} + +func TestKindForGroupVersionKinds(t *testing.T) { + assert := assert.New(t) + + expectedGVK := schema.GroupVersionKind{Group: "test", Version: "v1", Kind: "TestKind"} + versioner := NewWithKindGroupVersioner(expectedGVK) + + testCases := [][]schema.GroupVersionKind{ + {}, // Empty slice + { + {Group: "other", Version: "v2", Kind: "OtherKind"}, + }, + { + {Group: "app", Version: "v1", Kind: "Deployment"}, + {Group: "core", Version: "v1", Kind: "Pod"}, + }, + } + + for _, inputGVK := range testCases { + resultGVK, ok := versioner.KindForGroupVersionKinds(inputGVK) + + assert.True(ok) + assert.Equal(expectedGVK, resultGVK) + } +} + +func TestWithKindGroupVersioner_Identifier(t *testing.T) { + assert := assert.New(t) + + testCases := []struct { + name string + gvk schema.GroupVersionKind + expected string + }{ + { + name: "Group, Version, and Kind", + gvk: schema.GroupVersionKind{Group: "apps", Version: "v1", Kind: "Deployment"}, + expected: "apps/v1, Kind=Deployment", + }, + { + name: "No Group", + gvk: schema.GroupVersionKind{Version: "v1", Kind: "Pod"}, + expected: "/v1, Kind=Pod", + }, + { + name: "No Version", + gvk: schema.GroupVersionKind{Group: "custom", Kind: "MyResource"}, + expected: "custom/, Kind=MyResource", + }, + { + name: "No Kind", + gvk: schema.GroupVersionKind{Group: "custom", Version: "v1"}, + expected: "custom/v1, Kind=", + }, + { + name: "Empty GVK", + gvk: schema.GroupVersionKind{}, + expected: "/, Kind=", + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + versioner := NewWithKindGroupVersioner(tc.gvk) + identifier := versioner.Identifier() + assert.Equal(tc.expected, identifier) + }) + } +} + +func TestNewWithKindGroupVersioner(t *testing.T) { + assert := assert.New(t) + + testCases := []struct { + name string + gvk schema.GroupVersionKind + }{ + { + name: "Standard GVK", + gvk: schema.GroupVersionKind{Group: "apps", Version: "v1", Kind: "Deployment"}, + }, + { + name: "Core API GVK", + gvk: schema.GroupVersionKind{Version: "v1", Kind: "Pod"}, + }, + { + name: "Custom Resource GVK", + gvk: schema.GroupVersionKind{Group: "custom.example.com", Version: "v1beta1", Kind: "MyResource"}, + }, + { + name: "Empty GVK", + gvk: schema.GroupVersionKind{}, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + versioner := NewWithKindGroupVersioner(tc.gvk) + assert.NotNil(versioner) + resultGVK, ok := versioner.KindForGroupVersionKinds(nil) + assert.True(ok) + assert.Equal(tc.gvk, resultGVK) + }) + } +}