horizoncd/horizon

View on GitHub
pkg/util/kube/fake/fake.go

Summary

Maintainability
A
3 hrs
Test Coverage
// Copyright © 2023 Horizoncd.
//
// 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 fake
 
import (
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"strings"
 
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema"
restclient "k8s.io/client-go/rest"
"k8s.io/client-go/rest/fake"
"k8s.io/client-go/tools/remotecommand"
cmdtesting "k8s.io/kubectl/pkg/cmd/testing"
"k8s.io/kubectl/pkg/scheme"
)
 
func NewFakeClient() *fake.RESTClient {
codec := scheme.Codecs.LegacyCodec(scheme.Scheme.PrioritizedVersionsAllGroups()...)
ns := scheme.Codecs.WithoutConversion()
restClient := &fake.RESTClient{
GroupVersion: schema.GroupVersion{Group: "", Version: "v1"},
NegotiatedSerializer: ns,
Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
switch m, url := req.Method, req.URL.String(); {
case m == http.MethodGet && strings.Contains(url, "foo1"):
body := cmdtesting.ObjBody(codec, execPod1())
return &http.Response{StatusCode: http.StatusOK, Header: cmdtesting.DefaultHeader(), Body: body}, nil
case m == http.MethodGet && strings.Contains(url, "foo2"):
body := cmdtesting.ObjBody(codec, execPod2())
return &http.Response{StatusCode: http.StatusOK, Header: cmdtesting.DefaultHeader(), Body: body}, nil
case m == http.MethodPost:
body := cmdtesting.StringBody(req.URL.String())
return &http.Response{StatusCode: http.StatusOK, Header: http.Header{}, Body: body}, nil
default:
return nil, fmt.Errorf("unexpected request")
}
}),
}
return restClient
}
 
func NewEmptyClient() *restclient.Config {
return &restclient.Config{
APIPath: "/api",
ContentConfig: restclient.ContentConfig{
NegotiatedSerializer: scheme.Codecs,
GroupVersion: &schema.GroupVersion{
Version: "v1",
},
},
}
}
 
Similar blocks of code found in 2 locations. Consider refactoring.
func execPod1() *corev1.Pod {
return &corev1.Pod{
ObjectMeta: metav1.ObjectMeta{Name: "foo1", Namespace: "test", ResourceVersion: "10"},
Spec: corev1.PodSpec{
RestartPolicy: corev1.RestartPolicyAlways,
DNSPolicy: corev1.DNSClusterFirst,
Containers: []corev1.Container{
{
Name: "bar",
},
},
},
Status: corev1.PodStatus{
Phase: corev1.PodRunning,
},
}
}
 
Similar blocks of code found in 2 locations. Consider refactoring.
func execPod2() *corev1.Pod {
return &corev1.Pod{
ObjectMeta: metav1.ObjectMeta{Name: "foo2", Namespace: "test", ResourceVersion: "10"},
Spec: corev1.PodSpec{
RestartPolicy: corev1.RestartPolicyAlways,
DNSPolicy: corev1.DNSClusterFirst,
Containers: []corev1.Container{
{
Name: "bar",
},
},
},
Status: corev1.PodStatus{
Phase: corev1.PodRunning,
},
}
}
 
type RemoteExecutor struct {
Client *http.Client
}
 
Method `RemoteExecutor.Execute` has 7 arguments (exceeds 4 allowed). Consider refactoring.
func (f *RemoteExecutor) Execute(method string, url *url.URL,
config *restclient.Config, stdin io.Reader, stdout, stderr io.Writer,
tty bool, terminalSizeQueue remotecommand.TerminalSizeQueue) error {
req, err := http.NewRequest(method, url.String(), nil)
if err != nil {
return err
}
 
resp, err := f.Client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
 
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
 
stdout.Write(data)
return nil
}