mirror of https://github.com/k3s-io/k3s
533 lines
14 KiB
Go
533 lines
14 KiB
Go
/*
|
|
Copyright 2014 Google Inc. 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 cmd
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
|
|
"github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest"
|
|
"github.com/GoogleCloudPlatform/kubernetes/pkg/client"
|
|
"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
|
|
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
|
|
"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"
|
|
"github.com/GoogleCloudPlatform/kubernetes/pkg/watch/json"
|
|
)
|
|
|
|
func testData() (*api.PodList, *api.ServiceList, *api.ReplicationControllerList) {
|
|
pods := &api.PodList{
|
|
ListMeta: api.ListMeta{
|
|
ResourceVersion: "15",
|
|
},
|
|
Items: []api.Pod{
|
|
{
|
|
ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test", ResourceVersion: "10"},
|
|
Spec: api.PodSpec{
|
|
RestartPolicy: api.RestartPolicyAlways,
|
|
DNSPolicy: api.DNSClusterFirst,
|
|
},
|
|
},
|
|
{
|
|
ObjectMeta: api.ObjectMeta{Name: "bar", Namespace: "test", ResourceVersion: "11"},
|
|
Spec: api.PodSpec{
|
|
RestartPolicy: api.RestartPolicyAlways,
|
|
DNSPolicy: api.DNSClusterFirst,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
svc := &api.ServiceList{
|
|
ListMeta: api.ListMeta{
|
|
ResourceVersion: "16",
|
|
},
|
|
Items: []api.Service{
|
|
{
|
|
ObjectMeta: api.ObjectMeta{Name: "baz", Namespace: "test", ResourceVersion: "12"},
|
|
Spec: api.ServiceSpec{
|
|
SessionAffinity: "None",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
rc := &api.ReplicationControllerList{
|
|
ListMeta: api.ListMeta{
|
|
ResourceVersion: "17",
|
|
},
|
|
Items: []api.ReplicationController{
|
|
{
|
|
ObjectMeta: api.ObjectMeta{Name: "rc1", Namespace: "test", ResourceVersion: "18"},
|
|
Spec: api.ReplicationControllerSpec{
|
|
Replicas: 1,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
return pods, svc, rc
|
|
}
|
|
|
|
// Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get.
|
|
func TestGetUnknownSchemaObject(t *testing.T) {
|
|
f, tf, codec := NewTestFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &internalType{Name: "foo"})},
|
|
}
|
|
tf.Namespace = "test"
|
|
tf.ClientConfig = &client.Config{Version: latest.Version}
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
cmd.Run(cmd, []string{"type", "foo"})
|
|
|
|
expected := &internalType{Name: "foo"}
|
|
actual := tf.Printer.(*testPrinter).Objects[0]
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("unexpected object: %#v", actual)
|
|
}
|
|
if buf.String() != fmt.Sprintf("%#v", expected) {
|
|
t.Errorf("unexpected output: %s", buf.String())
|
|
}
|
|
}
|
|
|
|
// Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get.
|
|
func TestGetSchemaObject(t *testing.T) {
|
|
f, tf, _ := NewTestFactory()
|
|
tf.Mapper = latest.RESTMapper
|
|
tf.Typer = api.Scheme
|
|
codec := latest.Codec
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &api.ReplicationController{ObjectMeta: api.ObjectMeta{Name: "foo"}})},
|
|
}
|
|
tf.Namespace = "test"
|
|
tf.ClientConfig = &client.Config{Version: "v1beta3"}
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.Run(cmd, []string{"replicationcontrollers", "foo"})
|
|
|
|
if !strings.Contains(buf.String(), "\"foo\"") {
|
|
t.Errorf("unexpected output: %s", buf.String())
|
|
}
|
|
}
|
|
|
|
func TestGetObjects(t *testing.T) {
|
|
pods, _, _ := testData()
|
|
|
|
f, tf, codec := NewAPIFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])},
|
|
}
|
|
tf.Namespace = "test"
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
cmd.Run(cmd, []string{"pods", "foo"})
|
|
|
|
expected := []runtime.Object{&pods.Items[0]}
|
|
actual := tf.Printer.(*testPrinter).Objects
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("unexpected object: %#v", actual)
|
|
}
|
|
if len(buf.String()) == 0 {
|
|
t.Errorf("unexpected empty output")
|
|
}
|
|
}
|
|
|
|
func TestGetListObjects(t *testing.T) {
|
|
pods, _, _ := testData()
|
|
|
|
f, tf, codec := NewAPIFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Resp: &http.Response{StatusCode: 200, Body: objBody(codec, pods)},
|
|
}
|
|
tf.Namespace = "test"
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
cmd.Run(cmd, []string{"pods"})
|
|
|
|
expected := []runtime.Object{pods}
|
|
actual := tf.Printer.(*testPrinter).Objects
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("unexpected object: %#v %#v", expected, actual)
|
|
}
|
|
if len(buf.String()) == 0 {
|
|
t.Errorf("unexpected empty output")
|
|
}
|
|
}
|
|
|
|
func TestGetMultipleTypeObjects(t *testing.T) {
|
|
pods, svc, _ := testData()
|
|
|
|
f, tf, codec := NewAPIFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Client: client.HTTPClientFunc(func(req *http.Request) (*http.Response, error) {
|
|
switch req.URL.Path {
|
|
case "/namespaces/test/pods":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, nil
|
|
case "/namespaces/test/services":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, svc)}, nil
|
|
default:
|
|
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
|
|
return nil, nil
|
|
}
|
|
}),
|
|
}
|
|
tf.Namespace = "test"
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
cmd.Run(cmd, []string{"pods,services"})
|
|
|
|
expected := []runtime.Object{pods, svc}
|
|
actual := tf.Printer.(*testPrinter).Objects
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("unexpected object: %#v", actual)
|
|
}
|
|
if len(buf.String()) == 0 {
|
|
t.Errorf("unexpected empty output")
|
|
}
|
|
}
|
|
|
|
func TestGetMultipleTypeObjectsAsList(t *testing.T) {
|
|
pods, svc, _ := testData()
|
|
|
|
f, tf, codec := NewAPIFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Client: client.HTTPClientFunc(func(req *http.Request) (*http.Response, error) {
|
|
switch req.URL.Path {
|
|
case "/namespaces/test/pods":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, nil
|
|
case "/namespaces/test/services":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, svc)}, nil
|
|
default:
|
|
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
|
|
return nil, nil
|
|
}
|
|
}),
|
|
}
|
|
tf.Namespace = "test"
|
|
tf.ClientConfig = &client.Config{Version: "v1beta1"}
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
|
|
cmd.Flags().Set("output", "json")
|
|
cmd.Run(cmd, []string{"pods,services"})
|
|
|
|
if tf.Printer.(*testPrinter).Objects != nil {
|
|
t.Errorf("unexpected print to default printer")
|
|
}
|
|
|
|
out, err := codec.Decode(buf.Bytes())
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
expected := &api.List{
|
|
Items: []runtime.Object{
|
|
&pods.Items[0],
|
|
&pods.Items[1],
|
|
&svc.Items[0],
|
|
},
|
|
}
|
|
if !reflect.DeepEqual(expected, out) {
|
|
t.Errorf("unexpected output: %#v", out)
|
|
}
|
|
}
|
|
|
|
func TestGetMultipleTypeObjectsWithSelector(t *testing.T) {
|
|
pods, svc, _ := testData()
|
|
|
|
f, tf, codec := NewAPIFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Client: client.HTTPClientFunc(func(req *http.Request) (*http.Response, error) {
|
|
if req.URL.Query().Get("labels") != "a=b" {
|
|
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
|
|
}
|
|
switch req.URL.Path {
|
|
case "/namespaces/test/pods":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, nil
|
|
case "/namespaces/test/services":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, svc)}, nil
|
|
default:
|
|
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
|
|
return nil, nil
|
|
}
|
|
}),
|
|
}
|
|
tf.Namespace = "test"
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
|
|
cmd.Flags().Set("selector", "a=b")
|
|
cmd.Run(cmd, []string{"pods,services"})
|
|
|
|
expected := []runtime.Object{pods, svc}
|
|
actual := tf.Printer.(*testPrinter).Objects
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("unexpected object: %#v", actual)
|
|
}
|
|
if len(buf.String()) == 0 {
|
|
t.Errorf("unexpected empty output")
|
|
}
|
|
}
|
|
|
|
func TestGetMultipleTypeObjectsWithDirectReference(t *testing.T) {
|
|
_, svc, _ := testData()
|
|
node := &api.Node{
|
|
ObjectMeta: api.ObjectMeta{
|
|
Name: "foo",
|
|
},
|
|
Spec: api.NodeSpec{
|
|
ExternalID: "ext",
|
|
},
|
|
}
|
|
|
|
f, tf, codec := NewAPIFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Client: client.HTTPClientFunc(func(req *http.Request) (*http.Response, error) {
|
|
switch req.URL.Path {
|
|
case "/nodes/foo":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, node)}, nil
|
|
case "/namespaces/test/services/bar":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil
|
|
default:
|
|
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
|
|
return nil, nil
|
|
}
|
|
}),
|
|
}
|
|
tf.Namespace = "test"
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
|
|
cmd.Run(cmd, []string{"services/bar", "node/foo"})
|
|
|
|
expected := []runtime.Object{&svc.Items[0], node}
|
|
actual := tf.Printer.(*testPrinter).Objects
|
|
if !api.Semantic.DeepEqual(expected, actual) {
|
|
t.Errorf("unexpected object: %s", util.ObjectDiff(expected, actual))
|
|
}
|
|
if len(buf.String()) == 0 {
|
|
t.Errorf("unexpected empty output")
|
|
}
|
|
}
|
|
func watchTestData() ([]api.Pod, []watch.Event) {
|
|
pods := []api.Pod{
|
|
{
|
|
ObjectMeta: api.ObjectMeta{
|
|
Name: "foo",
|
|
Namespace: "test",
|
|
ResourceVersion: "10",
|
|
},
|
|
Spec: api.PodSpec{
|
|
RestartPolicy: api.RestartPolicyAlways,
|
|
DNSPolicy: api.DNSClusterFirst,
|
|
},
|
|
},
|
|
}
|
|
events := []watch.Event{
|
|
{
|
|
Type: watch.Modified,
|
|
Object: &api.Pod{
|
|
ObjectMeta: api.ObjectMeta{
|
|
Name: "foo",
|
|
Namespace: "test",
|
|
ResourceVersion: "11",
|
|
},
|
|
Spec: api.PodSpec{
|
|
RestartPolicy: api.RestartPolicyAlways,
|
|
DNSPolicy: api.DNSClusterFirst,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Type: watch.Deleted,
|
|
Object: &api.Pod{
|
|
ObjectMeta: api.ObjectMeta{
|
|
Name: "foo",
|
|
Namespace: "test",
|
|
ResourceVersion: "12",
|
|
},
|
|
Spec: api.PodSpec{
|
|
RestartPolicy: api.RestartPolicyAlways,
|
|
DNSPolicy: api.DNSClusterFirst,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
return pods, events
|
|
}
|
|
|
|
func TestWatchSelector(t *testing.T) {
|
|
pods, events := watchTestData()
|
|
|
|
f, tf, codec := NewAPIFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Client: client.HTTPClientFunc(func(req *http.Request) (*http.Response, error) {
|
|
if req.URL.Query().Get("labels") != "a=b" {
|
|
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
|
|
}
|
|
switch req.URL.Path {
|
|
case "/namespaces/test/pods":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, &api.PodList{Items: pods})}, nil
|
|
case "/watch/namespaces/test/pods":
|
|
return &http.Response{StatusCode: 200, Body: watchBody(codec, events)}, nil
|
|
default:
|
|
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
|
|
return nil, nil
|
|
}
|
|
}),
|
|
}
|
|
tf.Namespace = "test"
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
|
|
cmd.Flags().Set("watch", "true")
|
|
cmd.Flags().Set("selector", "a=b")
|
|
cmd.Run(cmd, []string{"pods"})
|
|
|
|
expected := []runtime.Object{&api.PodList{Items: pods}, events[0].Object, events[1].Object}
|
|
actual := tf.Printer.(*testPrinter).Objects
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("unexpected object: %#v %#v", expected[0], actual[0])
|
|
}
|
|
if len(buf.String()) == 0 {
|
|
t.Errorf("unexpected empty output")
|
|
}
|
|
}
|
|
|
|
func TestWatchResource(t *testing.T) {
|
|
pods, events := watchTestData()
|
|
|
|
f, tf, codec := NewAPIFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Client: client.HTTPClientFunc(func(req *http.Request) (*http.Response, error) {
|
|
switch req.URL.Path {
|
|
case "/namespaces/test/pods/foo":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, &pods[0])}, nil
|
|
case "/watch/namespaces/test/pods/foo":
|
|
return &http.Response{StatusCode: 200, Body: watchBody(codec, events)}, nil
|
|
default:
|
|
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
|
|
return nil, nil
|
|
}
|
|
}),
|
|
}
|
|
tf.Namespace = "test"
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
|
|
cmd.Flags().Set("watch", "true")
|
|
cmd.Run(cmd, []string{"pods", "foo"})
|
|
|
|
expected := []runtime.Object{&pods[0], events[0].Object, events[1].Object}
|
|
actual := tf.Printer.(*testPrinter).Objects
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("unexpected object: %#v", actual)
|
|
}
|
|
if len(buf.String()) == 0 {
|
|
t.Errorf("unexpected empty output")
|
|
}
|
|
}
|
|
|
|
func TestWatchOnlyResource(t *testing.T) {
|
|
pods, events := watchTestData()
|
|
|
|
f, tf, codec := NewAPIFactory()
|
|
tf.Printer = &testPrinter{}
|
|
tf.Client = &client.FakeRESTClient{
|
|
Codec: codec,
|
|
Client: client.HTTPClientFunc(func(req *http.Request) (*http.Response, error) {
|
|
switch req.URL.Path {
|
|
case "/namespaces/test/pods/foo":
|
|
return &http.Response{StatusCode: 200, Body: objBody(codec, &pods[0])}, nil
|
|
case "/watch/namespaces/test/pods/foo":
|
|
return &http.Response{StatusCode: 200, Body: watchBody(codec, events)}, nil
|
|
default:
|
|
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
|
|
return nil, nil
|
|
}
|
|
}),
|
|
}
|
|
tf.Namespace = "test"
|
|
buf := bytes.NewBuffer([]byte{})
|
|
|
|
cmd := f.NewCmdGet(buf)
|
|
cmd.SetOutput(buf)
|
|
|
|
cmd.Flags().Set("watch-only", "true")
|
|
cmd.Run(cmd, []string{"pods", "foo"})
|
|
|
|
expected := []runtime.Object{events[0].Object, events[1].Object}
|
|
actual := tf.Printer.(*testPrinter).Objects
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("unexpected object: %#v", actual)
|
|
}
|
|
if len(buf.String()) == 0 {
|
|
t.Errorf("unexpected empty output")
|
|
}
|
|
}
|
|
|
|
func watchBody(codec runtime.Codec, events []watch.Event) io.ReadCloser {
|
|
buf := bytes.NewBuffer([]byte{})
|
|
enc := json.NewEncoder(buf, codec)
|
|
for i := range events {
|
|
enc.Encode(&events[i])
|
|
}
|
|
return ioutil.NopCloser(buf)
|
|
}
|