mirror of https://github.com/k3s-io/k3s
459 lines
12 KiB
Go
459 lines
12 KiB
Go
/*
|
|
Copyright 2014 The Kubernetes 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 pod
|
|
|
|
import (
|
|
"context"
|
|
"net/url"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"k8s.io/apimachinery/pkg/api/errors"
|
|
"k8s.io/apimachinery/pkg/api/resource"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/apimachinery/pkg/fields"
|
|
"k8s.io/apimachinery/pkg/labels"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/types"
|
|
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
|
|
apitesting "k8s.io/kubernetes/pkg/api/testing"
|
|
api "k8s.io/kubernetes/pkg/apis/core"
|
|
"k8s.io/kubernetes/pkg/kubelet/client"
|
|
|
|
// install all api groups for testing
|
|
_ "k8s.io/kubernetes/pkg/api/testapi"
|
|
)
|
|
|
|
func TestMatchPod(t *testing.T) {
|
|
testCases := []struct {
|
|
in *api.Pod
|
|
fieldSelector fields.Selector
|
|
expectMatch bool
|
|
}{
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{NodeName: "nodeA"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("spec.nodeName=nodeA"),
|
|
expectMatch: true,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{NodeName: "nodeB"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("spec.nodeName=nodeA"),
|
|
expectMatch: false,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{RestartPolicy: api.RestartPolicyAlways},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("spec.restartPolicy=Always"),
|
|
expectMatch: true,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{RestartPolicy: api.RestartPolicyAlways},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("spec.restartPolicy=Never"),
|
|
expectMatch: false,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{SchedulerName: "scheduler1"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("spec.schedulerName=scheduler1"),
|
|
expectMatch: true,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{SchedulerName: "scheduler1"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("spec.schedulerName=scheduler2"),
|
|
expectMatch: false,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{ServiceAccountName: "serviceAccount1"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("spec.serviceAccountName=serviceAccount1"),
|
|
expectMatch: true,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{SchedulerName: "serviceAccount1"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("spec.serviceAccountName=serviceAccount2"),
|
|
expectMatch: false,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Status: api.PodStatus{Phase: api.PodRunning},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("status.phase=Running"),
|
|
expectMatch: true,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Status: api.PodStatus{Phase: api.PodRunning},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("status.phase=Pending"),
|
|
expectMatch: false,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Status: api.PodStatus{PodIP: "1.2.3.4"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("status.podIP=1.2.3.4"),
|
|
expectMatch: true,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Status: api.PodStatus{PodIP: "1.2.3.4"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("status.podIP=4.3.2.1"),
|
|
expectMatch: false,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Status: api.PodStatus{NominatedNodeName: "node1"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("status.nominatedNodeName=node1"),
|
|
expectMatch: true,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Status: api.PodStatus{NominatedNodeName: "node1"},
|
|
},
|
|
fieldSelector: fields.ParseSelectorOrDie("status.nominatedNodeName=node2"),
|
|
expectMatch: false,
|
|
}}
|
|
for _, testCase := range testCases {
|
|
m := MatchPod(labels.Everything(), testCase.fieldSelector)
|
|
result, err := m.Matches(testCase.in)
|
|
if err != nil {
|
|
t.Errorf("Unexpected error %v", err)
|
|
}
|
|
if result != testCase.expectMatch {
|
|
t.Errorf("Result %v, Expected %v, Selector: %v, Pod: %v", result, testCase.expectMatch, testCase.fieldSelector.String(), testCase.in)
|
|
}
|
|
}
|
|
}
|
|
|
|
func getResourceList(cpu, memory string) api.ResourceList {
|
|
res := api.ResourceList{}
|
|
if cpu != "" {
|
|
res[api.ResourceCPU] = resource.MustParse(cpu)
|
|
}
|
|
if memory != "" {
|
|
res[api.ResourceMemory] = resource.MustParse(memory)
|
|
}
|
|
return res
|
|
}
|
|
|
|
func getResourceRequirements(requests, limits api.ResourceList) api.ResourceRequirements {
|
|
res := api.ResourceRequirements{}
|
|
res.Requests = requests
|
|
res.Limits = limits
|
|
return res
|
|
}
|
|
|
|
func newContainer(name string, requests api.ResourceList, limits api.ResourceList) api.Container {
|
|
return api.Container{
|
|
Name: name,
|
|
Resources: getResourceRequirements(requests, limits),
|
|
}
|
|
}
|
|
|
|
func newPod(name string, containers []api.Container) *api.Pod {
|
|
return &api.Pod{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: name,
|
|
},
|
|
Spec: api.PodSpec{
|
|
Containers: containers,
|
|
},
|
|
}
|
|
}
|
|
|
|
func TestGetPodQOS(t *testing.T) {
|
|
testCases := []struct {
|
|
pod *api.Pod
|
|
expected api.PodQOSClass
|
|
}{
|
|
{
|
|
pod: newPod("guaranteed", []api.Container{
|
|
newContainer("guaranteed", getResourceList("100m", "100Mi"), getResourceList("100m", "100Mi")),
|
|
}),
|
|
expected: api.PodQOSGuaranteed,
|
|
},
|
|
{
|
|
pod: newPod("best-effort", []api.Container{
|
|
newContainer("best-effort", getResourceList("", ""), getResourceList("", "")),
|
|
}),
|
|
expected: api.PodQOSBestEffort,
|
|
},
|
|
{
|
|
pod: newPod("burstable", []api.Container{
|
|
newContainer("burstable", getResourceList("100m", "100Mi"), getResourceList("", "")),
|
|
}),
|
|
expected: api.PodQOSBurstable,
|
|
},
|
|
}
|
|
for id, testCase := range testCases {
|
|
Strategy.PrepareForCreate(genericapirequest.NewContext(), testCase.pod)
|
|
actual := testCase.pod.Status.QOSClass
|
|
if actual != testCase.expected {
|
|
t.Errorf("[%d]: invalid qos pod %s, expected: %s, actual: %s", id, testCase.pod.Name, testCase.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCheckGracefulDelete(t *testing.T) {
|
|
defaultGracePeriod := int64(30)
|
|
tcs := []struct {
|
|
in *api.Pod
|
|
gracePeriod int64
|
|
}{
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{NodeName: "something"},
|
|
Status: api.PodStatus{Phase: api.PodPending},
|
|
},
|
|
|
|
gracePeriod: defaultGracePeriod,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{NodeName: "something"},
|
|
Status: api.PodStatus{Phase: api.PodFailed},
|
|
},
|
|
gracePeriod: 0,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{},
|
|
Status: api.PodStatus{Phase: api.PodPending},
|
|
},
|
|
gracePeriod: 0,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{},
|
|
Status: api.PodStatus{Phase: api.PodSucceeded},
|
|
},
|
|
gracePeriod: 0,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{},
|
|
Status: api.PodStatus{},
|
|
},
|
|
gracePeriod: 0,
|
|
},
|
|
}
|
|
for _, tc := range tcs {
|
|
out := &metav1.DeleteOptions{GracePeriodSeconds: &defaultGracePeriod}
|
|
Strategy.CheckGracefulDelete(genericapirequest.NewContext(), tc.in, out)
|
|
if out.GracePeriodSeconds == nil {
|
|
t.Errorf("out grace period was nil but supposed to be %v", tc.gracePeriod)
|
|
}
|
|
if *(out.GracePeriodSeconds) != tc.gracePeriod {
|
|
t.Errorf("out grace period was %v but was expected to be %v", *out, tc.gracePeriod)
|
|
}
|
|
}
|
|
}
|
|
|
|
type mockPodGetter struct {
|
|
pod *api.Pod
|
|
}
|
|
|
|
func (g mockPodGetter) Get(context.Context, string, *metav1.GetOptions) (runtime.Object, error) {
|
|
return g.pod, nil
|
|
}
|
|
|
|
func TestCheckLogLocation(t *testing.T) {
|
|
ctx := genericapirequest.NewDefaultContext()
|
|
tcs := []struct {
|
|
in *api.Pod
|
|
opts *api.PodLogOptions
|
|
expectedErr error
|
|
}{
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{},
|
|
Status: api.PodStatus{},
|
|
},
|
|
opts: &api.PodLogOptions{},
|
|
expectedErr: errors.NewBadRequest("a container name must be specified for pod test"),
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{
|
|
Containers: []api.Container{
|
|
{Name: "mycontainer"},
|
|
},
|
|
},
|
|
Status: api.PodStatus{},
|
|
},
|
|
opts: &api.PodLogOptions{},
|
|
expectedErr: nil,
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{
|
|
Containers: []api.Container{
|
|
{Name: "container1"},
|
|
{Name: "container2"},
|
|
},
|
|
},
|
|
Status: api.PodStatus{},
|
|
},
|
|
opts: &api.PodLogOptions{},
|
|
expectedErr: errors.NewBadRequest("a container name must be specified for pod test, choose one of: [container1 container2]"),
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{
|
|
Containers: []api.Container{
|
|
{Name: "container1"},
|
|
{Name: "container2"},
|
|
},
|
|
InitContainers: []api.Container{
|
|
{Name: "initcontainer1"},
|
|
},
|
|
},
|
|
Status: api.PodStatus{},
|
|
},
|
|
opts: &api.PodLogOptions{},
|
|
expectedErr: errors.NewBadRequest("a container name must be specified for pod test, choose one of: [container1 container2] or one of the init containers: [initcontainer1]"),
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{
|
|
Containers: []api.Container{
|
|
{Name: "container1"},
|
|
{Name: "container2"},
|
|
},
|
|
},
|
|
Status: api.PodStatus{},
|
|
},
|
|
opts: &api.PodLogOptions{
|
|
Container: "unknown",
|
|
},
|
|
expectedErr: errors.NewBadRequest("container unknown is not valid for pod test"),
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{
|
|
Containers: []api.Container{
|
|
{Name: "container1"},
|
|
{Name: "container2"},
|
|
},
|
|
},
|
|
Status: api.PodStatus{},
|
|
},
|
|
opts: &api.PodLogOptions{
|
|
Container: "container2",
|
|
},
|
|
expectedErr: nil,
|
|
},
|
|
}
|
|
for _, tc := range tcs {
|
|
getter := &mockPodGetter{tc.in}
|
|
_, _, err := LogLocation(getter, nil, ctx, "test", tc.opts)
|
|
if !reflect.DeepEqual(err, tc.expectedErr) {
|
|
t.Errorf("expected %v, got %v", tc.expectedErr, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSelectableFieldLabelConversions(t *testing.T) {
|
|
apitesting.TestSelectableFieldLabelConversionsOfKind(t,
|
|
"v1",
|
|
"Pod",
|
|
PodToSelectableFields(&api.Pod{}),
|
|
nil,
|
|
)
|
|
}
|
|
|
|
type mockConnectionInfoGetter struct {
|
|
info *client.ConnectionInfo
|
|
}
|
|
|
|
func (g mockConnectionInfoGetter) GetConnectionInfo(ctx context.Context, nodeName types.NodeName) (*client.ConnectionInfo, error) {
|
|
return g.info, nil
|
|
}
|
|
|
|
func TestPortForwardLocation(t *testing.T) {
|
|
ctx := genericapirequest.NewDefaultContext()
|
|
tcs := []struct {
|
|
in *api.Pod
|
|
info *client.ConnectionInfo
|
|
opts *api.PodPortForwardOptions
|
|
expectedErr error
|
|
expectedURL *url.URL
|
|
}{
|
|
{
|
|
in: &api.Pod{
|
|
Spec: api.PodSpec{},
|
|
},
|
|
opts: &api.PodPortForwardOptions{},
|
|
expectedErr: errors.NewBadRequest("pod test does not have a host assigned"),
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Namespace: "ns",
|
|
Name: "pod1",
|
|
},
|
|
Spec: api.PodSpec{
|
|
NodeName: "node1",
|
|
},
|
|
},
|
|
info: &client.ConnectionInfo{},
|
|
opts: &api.PodPortForwardOptions{},
|
|
expectedURL: &url.URL{Host: ":", Path: "/portForward/ns/pod1"},
|
|
},
|
|
{
|
|
in: &api.Pod{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Namespace: "ns",
|
|
Name: "pod1",
|
|
},
|
|
Spec: api.PodSpec{
|
|
NodeName: "node1",
|
|
},
|
|
},
|
|
info: &client.ConnectionInfo{},
|
|
opts: &api.PodPortForwardOptions{Ports: []int32{80}},
|
|
expectedURL: &url.URL{Host: ":", Path: "/portForward/ns/pod1", RawQuery: "port=80"},
|
|
},
|
|
}
|
|
for _, tc := range tcs {
|
|
getter := &mockPodGetter{tc.in}
|
|
connectionGetter := &mockConnectionInfoGetter{tc.info}
|
|
loc, _, err := PortForwardLocation(getter, connectionGetter, ctx, "test", tc.opts)
|
|
if !reflect.DeepEqual(err, tc.expectedErr) {
|
|
t.Errorf("expected %v, got %v", tc.expectedErr, err)
|
|
}
|
|
if !reflect.DeepEqual(loc, tc.expectedURL) {
|
|
t.Errorf("expected %v, got %v", tc.expectedURL, loc)
|
|
}
|
|
}
|
|
}
|