k8s.io/client-go@v0.31.1/discovery/fake/discovery.go (about) 1 /* 2 Copyright 2016 The Kubernetes Authors. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package fake 18 19 import ( 20 "fmt" 21 "net/http" 22 23 openapi_v2 "github.com/google/gnostic-models/openapiv2" 24 25 "k8s.io/apimachinery/pkg/api/errors" 26 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" 27 "k8s.io/apimachinery/pkg/runtime/schema" 28 "k8s.io/apimachinery/pkg/version" 29 "k8s.io/client-go/discovery" 30 "k8s.io/client-go/openapi" 31 kubeversion "k8s.io/client-go/pkg/version" 32 restclient "k8s.io/client-go/rest" 33 "k8s.io/client-go/testing" 34 ) 35 36 // FakeDiscovery implements discovery.DiscoveryInterface and sometimes calls testing.Fake.Invoke with an action, 37 // but doesn't respect the return value if any. There is a way to fake static values like ServerVersion by using the Faked... fields on the struct. 38 type FakeDiscovery struct { 39 *testing.Fake 40 FakedServerVersion *version.Info 41 } 42 43 // ServerResourcesForGroupVersion returns the supported resources for a group 44 // and version. 45 func (c *FakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) { 46 action := testing.ActionImpl{ 47 Verb: "get", 48 Resource: schema.GroupVersionResource{Resource: "resource"}, 49 } 50 if _, err := c.Invokes(action, nil); err != nil { 51 return nil, err 52 } 53 for _, resourceList := range c.Resources { 54 if resourceList.GroupVersion == groupVersion { 55 return resourceList, nil 56 } 57 } 58 return nil, &errors.StatusError{ 59 ErrStatus: metav1.Status{ 60 Status: metav1.StatusFailure, 61 Code: http.StatusNotFound, 62 Reason: metav1.StatusReasonNotFound, 63 Message: fmt.Sprintf("the server could not find the requested resource, GroupVersion %q not found", groupVersion), 64 }} 65 } 66 67 // ServerGroupsAndResources returns the supported groups and resources for all groups and versions. 68 func (c *FakeDiscovery) ServerGroupsAndResources() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) { 69 sgs, err := c.ServerGroups() 70 if err != nil { 71 return nil, nil, err 72 } 73 resultGroups := []*metav1.APIGroup{} 74 for i := range sgs.Groups { 75 resultGroups = append(resultGroups, &sgs.Groups[i]) 76 } 77 78 action := testing.ActionImpl{ 79 Verb: "get", 80 Resource: schema.GroupVersionResource{Resource: "resource"}, 81 } 82 if _, err = c.Invokes(action, nil); err != nil { 83 return resultGroups, c.Resources, err 84 } 85 return resultGroups, c.Resources, nil 86 } 87 88 // ServerPreferredResources returns the supported resources with the version 89 // preferred by the server. 90 func (c *FakeDiscovery) ServerPreferredResources() ([]*metav1.APIResourceList, error) { 91 return nil, nil 92 } 93 94 // ServerPreferredNamespacedResources returns the supported namespaced resources 95 // with the version preferred by the server. 96 func (c *FakeDiscovery) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) { 97 return nil, nil 98 } 99 100 // ServerGroups returns the supported groups, with information like supported 101 // versions and the preferred version. 102 func (c *FakeDiscovery) ServerGroups() (*metav1.APIGroupList, error) { 103 action := testing.ActionImpl{ 104 Verb: "get", 105 Resource: schema.GroupVersionResource{Resource: "group"}, 106 } 107 if _, err := c.Invokes(action, nil); err != nil { 108 return nil, err 109 } 110 111 groups := map[string]*metav1.APIGroup{} 112 113 for _, res := range c.Resources { 114 gv, err := schema.ParseGroupVersion(res.GroupVersion) 115 if err != nil { 116 return nil, err 117 } 118 group := groups[gv.Group] 119 if group == nil { 120 group = &metav1.APIGroup{ 121 Name: gv.Group, 122 PreferredVersion: metav1.GroupVersionForDiscovery{ 123 GroupVersion: res.GroupVersion, 124 Version: gv.Version, 125 }, 126 } 127 groups[gv.Group] = group 128 } 129 130 group.Versions = append(group.Versions, metav1.GroupVersionForDiscovery{ 131 GroupVersion: res.GroupVersion, 132 Version: gv.Version, 133 }) 134 } 135 136 list := &metav1.APIGroupList{} 137 for _, apiGroup := range groups { 138 list.Groups = append(list.Groups, *apiGroup) 139 } 140 141 return list, nil 142 143 } 144 145 // ServerVersion retrieves and parses the server's version. 146 func (c *FakeDiscovery) ServerVersion() (*version.Info, error) { 147 action := testing.ActionImpl{} 148 action.Verb = "get" 149 action.Resource = schema.GroupVersionResource{Resource: "version"} 150 _, err := c.Invokes(action, nil) 151 if err != nil { 152 return nil, err 153 } 154 155 if c.FakedServerVersion != nil { 156 return c.FakedServerVersion, nil 157 } 158 159 versionInfo := kubeversion.Get() 160 return &versionInfo, nil 161 } 162 163 // OpenAPISchema retrieves and parses the swagger API schema the server supports. 164 func (c *FakeDiscovery) OpenAPISchema() (*openapi_v2.Document, error) { 165 return &openapi_v2.Document{}, nil 166 } 167 168 func (c *FakeDiscovery) OpenAPIV3() openapi.Client { 169 panic("unimplemented") 170 } 171 172 // RESTClient returns a RESTClient that is used to communicate with API server 173 // by this client implementation. 174 func (c *FakeDiscovery) RESTClient() restclient.Interface { 175 return nil 176 } 177 178 func (c *FakeDiscovery) WithLegacy() discovery.DiscoveryInterface { 179 panic("unimplemented") 180 }