John Howard <******@****.***> 1701662091 -0800

			// all resources with scale are seen as equivalent
			ResourcesForV1DeploymentScale: []schema.GroupVersionResource{gvr("apps", "v1", "deployments"), gvr("apps", "v1beta1", "deployments"), gvr("extensions", "v1beta1", "deployments")},

	stop := test.NewStop(t)
	c := kube.NewFakeClient()

	clienttest.MakeCRD(t, c, gvr.VirtualService)
	vsCalls := atomic.NewInt32(0)

	clienttest.MakeCRD(t, c, gvr.GatewayClass)

	ctl := c.CrdWatcher()
	// Created before informer runs
	assert.Equal(t, ctl.KnownOrCallback(gvr.VirtualService, func(s <-chan struct{}) {
		assert.Equal(t, s, stop)
		vsCalls.Inc()
	}), false)

	c.RunAndWait(stop)

{{- end }}
)

// ToGVR converts a GVK to a GVR.
func ToGVR(g config.GroupVersionKind) (schema.GroupVersionResource, bool) {
	switch g {
{{- range $entry := .Entries }}
		case {{$entry.Resource.Identifier}}:
			return gvr.{{$entry.Resource.Identifier}}, true
	{{- range $alias := .Resource.VersionAliases }}
		case {{$entry.Resource.Identifier}}_{{$alias}}:
			return gvr.{{$entry.Resource.Identifier}}_{{$alias}}, true
    {{- end }}

	mapperGVRs, err := rv.mapper.ResourcesFor(gvr)
	if err != nil {
		return false, err
	}

	for _, mapperGVR := range mapperGVRs {
		if mapperGVR.Group == gvr.Group &&
			mapperGVR.Version == gvr.Version &&
			mapperGVR.Resource == gvr.Resource {
			return true, nil
		}
	}

	return false, nil
}

			}
			fc := k.Dynamic().(*dynamicfake.FakeDynamicClient)
			fc.PrependWatchReactor("*", func(action clienttesting.Action) (handled bool, ret watch.Interface, err error) {
				gvr := action.GetResource()
				ns := action.GetNamespace()
				watch, err := fc.Tracker().Watch(gvr, ns)
				if err != nil {
					return false, nil, err
				}
				// Kubernetes Fake watches do not add initial state, but real server does

				return err
			}
			logger.V(4).Error(err, "Failed to migrate the resource", "name", gvrKey, "gvr", gvr.String(), "reason", apierrors.ReasonForError(err))

			return nil
			// Todo: add retry for scenarios where API server returns rate limiting error
		}
		logger.V(4).Info("Successfully migrated the resource", "name", gvrKey, "gvr", gvr.String())
	}

	_, err = svmc.kubeClient.StoragemigrationV1alpha1().

			UID: uid,
			Kind: metav1.GroupVersionKind{
				Group:   gvk.Group,
				Kind:    gvk.Kind,
				Version: gvk.Version,
			},
			Resource: metav1.GroupVersionResource{
				Group:    gvr.Group,
				Resource: gvr.Resource,
				Version:  gvr.Version,
			},
			SubResource: subresource,
			RequestKind: &metav1.GroupVersionKind{
				Group:   requestGVK.Group,
				Kind:    requestGVK.Kind,
				Version: requestGVK.Version,

// store to enable dynamic object translation
func Register[T runtime.Object](
	gvr schema.GroupVersionResource,
	gvk schema.GroupVersionKind,
	list func(c ClientGetter, namespace string, o metav1.ListOptions) (runtime.Object, error),
	watch func(c ClientGetter, namespace string, o metav1.ListOptions) (watch.Interface, error),
) {
	reg := &internalTypeReg[T]{
		gvr:   gvr,
		gvk:   config.FromKubernetesGVK(gvk),
		list:  list,
		watch: watch,

		var reItemList []unstructured.Unstructured
		for _, gvk := range gvkResources {
			resources := strings.ToLower(gvk.Kind) + "s"
			gvr := schema.GroupVersionResource{Group: gvk.Group, Version: gvk.Version, Resource: resources}
			reList, reStr := getRemainingResourcesCluster(cs, gvr, label)
			reItemList = append(reItemList, reList...)
			reStrlist = append(reStrlist, reStr...)
		}