github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-29 22:46:12 +00:00
Code Issues Projects Releases Wiki Activity

fixing tests

Browse Source
This commit is contained in:
Chao Xu 2015-09-10 23:37:26 -07:00
parent 190ca2ebf2
commit 0b6fd8c5c4
9 changed files with 23 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
examples/examples_test.go
View File

@ -27,7 +27,7 @@ import (
"github.com/golang/glog"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/api/validation"
"k8s.io/kubernetes/pkg/capabilities"
"k8s.io/kubernetes/pkg/runtime"
@ -365,7 +365,7 @@ func TestExampleObjectSchemas(t *testing.T) {
}
//TODO: Add validate method for &schedulerapi.Policy
} else {
if err := latest.GroupOrDie("").Codec.DecodeInto(data, expectedType); err != nil {
if err := testapi.Default.Codec().DecodeInto(data, expectedType); err != nil {
t.Errorf("%s did not decode correctly: %v\n%s", path, err, string(data))
return
}
@ -451,14 +451,14 @@ func TestReadme(t *testing.T) {
if err != nil {
t.Errorf("%s could not be converted to JSON: %v\n%s", path, err, string(content))
}
if err := latest.GroupOrDie("").Codec.DecodeInto(json, expectedType); err != nil {
if err := testapi.Default.Codec().DecodeInto(json, expectedType); err != nil {
t.Errorf("%s did not decode correctly: %v\n%s", path, err, string(content))
continue
}
if errors := validateObject(expectedType); len(errors) > 0 {
t.Errorf("%s did not validate correctly: %v", path, errors)
}
_, err = latest.GroupOrDie("").Codec.Encode(expectedType)
_, err = testapi.Default.Codec().Encode(expectedType)
if err != nil {
t.Errorf("Could not encode object: %v", err)
continue

6
pkg/api/install/install.go
View File

@ -18,9 +18,10 @@ package install
import (
"fmt"
"runtime/debug"
"strings"
"github.com/golang/glog"
"k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/util/sets"
@ -40,10 +41,9 @@ const importPrefix = "k8s.io/kubernetes/pkg/api"
var accessor = meta.NewAccessor()
func init() {
debug.PrintStack()
groupMeta, err := latest.RegisterGroup("")
if err != nil {
fmt.Println(err)
glog.V(4).Infof("%v", err)
return
}
// Use the first API version in the list of registered versions as the latest.

2
pkg/api/latest/latest.go
View File

@ -39,7 +39,7 @@ func (g GroupMetaMap) RegisterGroup(group string) (*GroupMeta, error) {
return nil, fmt.Errorf("group %v is already registered", g)
}
if len(registered.GroupVersionsForGroup(group)) == 0 {
return nil, fmt.Errorf("No version is registered for %v", g)
return nil, fmt.Errorf("No version is registered for group %v", group)
}
g[group] = &GroupMeta{}
return g[group], nil

111
pkg/api/latest/latest_test.go
View File

@ -1,111 +0,0 @@
/*
Copyright 2014 The Kubernetes Authors All rights reserved.
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 latest
import (
"encoding/json"
"testing"
internal "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/meta"
)
var accessor = meta.NewAccessor()
func TestResourceVersioner(t *testing.T) {
pod := internal.Pod{ObjectMeta: internal.ObjectMeta{ResourceVersion: "10"}}
version, err := accessor.ResourceVersion(&pod)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if version != "10" {
t.Errorf("unexpected version %v", version)
}
podList := internal.PodList{ListMeta: internal.ListMeta{ResourceVersion: "10"}}
version, err = accessor.ResourceVersion(&podList)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if version != "10" {
t.Errorf("unexpected version %v", version)
}
}
func TestCodec(t *testing.T) {
pod := internal.Pod{}
data, err := GroupOrDie("").Codec.Encode(&pod)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
other := internal.Pod{}
if err := json.Unmarshal(data, &other); err != nil {
t.Fatalf("unexpected error: %v", err)
}
if other.APIVersion != GroupOrDie("").Version || other.Kind != "Pod" {
t.Errorf("unexpected unmarshalled object %#v", other)
}
}
func TestInterfacesFor(t *testing.T) {
if _, err := GroupOrDie("").InterfacesFor(""); err == nil {
t.Fatalf("unexpected non-error: %v", err)
}
for i, version := range append([]string{GroupOrDie("").Version}, GroupOrDie("").Versions...) {
if vi, err := GroupOrDie("").InterfacesFor(version); err != nil || vi == nil {
t.Fatalf("%d: unexpected result: %v", i, err)
}
}
}
func TestRESTMapper(t *testing.T) {
if v, k, err := GroupOrDie("").RESTMapper.VersionAndKindForResource("replicationcontrollers"); err != nil || v != "v1" || k != "ReplicationController" {
t.Errorf("unexpected version mapping: %s %s %v", v, k, err)
}
if m, err := GroupOrDie("").RESTMapper.RESTMapping("PodTemplate", ""); err != nil || m.APIVersion != "v1" || m.Resource != "podtemplates" {
t.Errorf("unexpected version mapping: %#v %v", m, err)
}
for _, version := range GroupOrDie("").Versions {
mapping, err := GroupOrDie("").RESTMapper.RESTMapping("ReplicationController", version)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if mapping.Resource != "replicationControllers" && mapping.Resource != "replicationcontrollers" {
t.Errorf("incorrect resource name: %#v", mapping)
}
if mapping.APIVersion != version {
t.Errorf("incorrect version: %v", mapping)
}
interfaces, _ := GroupOrDie("").InterfacesFor(version)
if mapping.Codec != interfaces.Codec {
t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
}
rc := &internal.ReplicationController{ObjectMeta: internal.ObjectMeta{Name: "foo"}}
name, err := mapping.MetadataAccessor.Name(rc)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if name != "foo" {
t.Errorf("unable to retrieve object meta with: %v", mapping.MetadataAccessor)
}
}
}

2
pkg/api/registered/registered.go
View File

@ -37,7 +37,7 @@ func init() {
}
// The default list of supported api versions, in order of most preferred to the least.
defaultSupportedVersions := "v1"
defaultSupportedVersions := "v1,experimental/v1"
// Env var KUBE_API_VERSIONS is a comma separated list of API versions that should be registered in the scheme.
// The versions should be in the order of most preferred to the least.
supportedVersions := os.Getenv("KUBE_API_VERSIONS")

2
pkg/client/unversioned/helper.go
View File

@ -290,8 +290,6 @@ func SetKubernetesDefaults(config *Config) error {
config.Version = defaultVersionFor(config)
}
version := config.Version
fmt.Println("CHAO:")
fmt.Println(latest.GroupOrDie(""))
versionInterfaces, err := latest.GroupOrDie("").InterfacesFor(version)
if err != nil {
return fmt.Errorf("API version '%s' is not recognized (valid values: %s)", version, strings.Join(latest.GroupOrDie("").Versions, ", "))

7
pkg/expapi/install/install.go
View File

@ -20,6 +20,8 @@ import (
"fmt"
"strings"
"github.com/golang/glog"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/api/meta"
@ -38,7 +40,7 @@ var accessor = meta.NewAccessor()
func init() {
groupMeta, err := latest.RegisterGroup("experimental")
if err != nil {
fmt.Println(err)
glog.V(4).Infof("%v", err)
return
}
registeredGroupVersions := registered.GroupVersionsForGroup("experimental")
@ -47,7 +49,8 @@ func init() {
GroupVersion: groupVersion,
Group: apiutil.GetGroup(groupVersion),
Version: apiutil.GetVersion(groupVersion),
Codec: runtime.CodecFor(api.Scheme, groupVersion),
// TODO: caesarxuchao: change it to groupVersion when we support multiple groups
Codec: runtime.CodecFor(api.Scheme, apiutil.GetVersion(groupVersion)),
}
var versions []string
for i := len(registeredGroupVersions) - 1; i >= 0; i-- {

4
pkg/kubelet/config/common_test.go
View File

@ -69,7 +69,7 @@ func TestDecodeSinglePod(t *testing.T) {
t.Errorf("expected:\n%#v\ngot:\n%#v\n%s", pod, podOut, string(json))
}
for _, version := range registered.RegisteredVersions {
for _, version := range registered.GroupVersionsForGroup("") {
externalPod, err := testapi.Default.Converter().ConvertToVersion(pod, version)
if err != nil {
t.Errorf("unexpected error: %v", err)
@ -134,7 +134,7 @@ func TestDecodePodList(t *testing.T) {
t.Errorf("expected:\n%#v\ngot:\n%#v\n%s", podList, &podListOut, string(json))
}
for _, version := range registered.RegisteredVersions {
for _, version := range registered.GroupVersionsForGroup("") {
externalPodList, err := testapi.Default.Converter().ConvertToVersion(podList, version)
if err != nil {
t.Errorf("unexpected error: %v", err)

13
pkg/master/master_test.go
View File

@ -60,7 +60,7 @@ func setUp(t *testing.T) (Master, Config, *assert.Assertions) {
fakeClient := tools.NewFakeEtcdClient(t)
fakeClient.Machines = []string{"http://machine1:4001", "http://machine2", "http://machine3:4003"}
config.DatabaseStorage = etcdstorage.NewEtcdStorage(fakeClient, testapi.Default.Codec(), etcdtest.PathPrefix())
config.ExpDatabaseStorage = etcdstorage.NewEtcdStorage(fakeClient, explatest.Codec, etcdtest.PathPrefix())
config.ExpDatabaseStorage = etcdstorage.NewEtcdStorage(fakeClient, testapi.Experimental.Codec(), etcdtest.PathPrefix())
master.nodeRegistry = registrytest.NewNodeRegistry([]string{"node1", "node2"}, api.NodeResources{})
@ -458,7 +458,7 @@ func initThirdParty(t *testing.T, version string) (*tools.FakeEtcdClient, *httpt
fakeClient := tools.NewFakeEtcdClient(t)
fakeClient.Machines = []string{"http://machine1:4001", "http://machine2", "http://machine3:4003"}
master.thirdPartyStorage = etcdstorage.NewEtcdStorage(fakeClient, explatest.Codec, etcdtest.PathPrefix())
master.thirdPartyStorage = etcdstorage.NewEtcdStorage(fakeClient, testapi.Experimental.Codec(), etcdtest.PathPrefix())
if !assert.NoError(master.InstallThirdPartyAPI(api)) {
t.FailNow()
@ -629,11 +629,12 @@ func testInstallThirdPartyAPIPostForVersion(t *testing.T, version string) {
t.FailNow()
}
obj, err := explatest.Codec.Decode([]byte(etcdResp.Node.Value))
assert.NoError(err)
obj, err := testapi.Experimental.Codec().Decode([]byte(etcdResp.Node.Value))
if err != nil {
t.Errorf("unexpected error: %v", err)
}
thirdPartyObj, ok := obj.(*experimental.ThirdPartyResourceData)
if !assert.True(ok) {
if !ok {
t.Errorf("unexpected object: %v", obj)
}
item = Foo{}