How can I verify if a Kubernetes resource is registered in the scheme without manual string manipulation?

Below is one approach that avoids ad hoc string manipulations: build a RESTMapper using discovery “data” taken from your scheme (or static data that you provide). A RESTMapper offers the canonical mapping from a resource string to its GroupVersionKind (and vice­versa) without guessing pluralization rules.

For example, if you have a static set of API resources registered (or can derive them from your scheme), you can construct a RESTMapper and then call its ResourceFor or RESTMapping method. Because RESTMapper uses the canonical names as defined in the API, it won’t require lower-casing or appending an “s” manually.

A simplified sample might look like this:

GOCopied
package main

import (
	"fmt"
	"log"

	"k8s.io/apimachinery/pkg/api/meta"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/client-go/discovery/fake"
	"k8s.io/client-go/restmapper"
	"k8s.io/client-go/kubernetes/scheme"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func main() {
	// Define the resource, version, and API group.
	resource := "pods"
	version := "v1"
	apiGroup := ""
	
	// Normally, discovery would query an APIServer.
	// In CI without a live server, you can fake discovery data.
	// For illustration, we provide a fake DiscoveryClient with a list of resources.
	fakeDiscovery := fake.NewSimpleClientset().Discovery()
	
	// Alternatively, if you can build a list manually:
	apiResources := []*metav1.APIResourceList{
		{
			GroupVersion: "v1",
			APIResources: []metav1.APIResource{
				{
					Name:         "pods",
					SingularName: "",
					Namespaced:   true,
					Kind:         "Pod",
				},
				// Add other resources if needed
			},
		},
	}
	
	// Build a RESTMapper from the static discovery data.
	mapper := restmapper.NewDiscoveryRESTMapper(apiResources)
	
	// Now create a GroupVersionResource.
	gvr := schema.GroupVersionResource{Group: apiGroup, Version: version, Resource: resource}
	
	// Use the mapper to see if this resource is known.
	// ResourceFor returns a mapping for the provided GVR, if available.
	mapping, err := mapper.ResourceFor(gvr)
	if err != nil {
		log.Fatalf("Resource %q with version %q in group %q is not registered in the schema: %v", resource, version, apiGroup, err)
	}
	
	fmt.Printf("Resource %q with version %q in group %q is registered with Kind %q\n", resource, version, apiGroup, mapping.GroupVersionKind.Kind)
}

How It Works

1. Provide Discovery Data
   In a live environment the RESTMapper is built using discovery data from the API server. Since you don’t have a connection during CI, you can supply a static list (or use a FakeDiscovery client) that represents the APIResources you expect. This avoids “magic” string manipulation.

2. Construct the RESTMapper
   Using restmapper.NewDiscoveryRESTMapper(apiResources), the mapper knows about the canonical names (including proper pluralization) defined for the API types.

3. Lookup the Resource
   Calling mapper.ResourceFor(...) with your GroupVersionResource will perform the lookup against the static data. If the resource isn’t known, it returns an error. Otherwise, you get a mapping that includes the GroupVersionKind.

This approach leverages the Kubernetes API conventions encoded in the discovery data (or your scheme’s registration) to reliably validate your resource strings without any ad hoc string operations.