existingConfigMap: createConfigMap(namespaceName, configMapName, map[string]string{}),
			expectedActions: []ktesting.Action{
				ktesting.NewUpdateAction(gvr, namespaceName, createConfigMap(namespaceName, configMapName, testData)),
			},
			expectedErr: "",
		},
		{
			name:              "existing nop ConfigMap",
			existingConfigMap: createConfigMap(namespaceName, configMapName, testData),
			expectedActions:   []ktesting.Action{},

	configMapName := kubeadmconstants.KubeProxyConfigMap
	klog.V(1).Infof("attempting to download the KubeProxyConfiguration from ConfigMap %q", configMapName)
	cm, err := h.fromConfigMap(clientset, configMapName, kubeadmconstants.KubeProxyConfigMapKey, false)
	if err != nil {

	if label == "" {
		return &v1.ConfigMap{
			ObjectMeta: metav1.ObjectMeta{Namespace: metav1.NamespaceSystem, Name: legacytokentracking.ConfigMapName},
		}
	}
	return &v1.ConfigMap{
		ObjectMeta: metav1.ObjectMeta{Namespace: metav1.NamespaceSystem, Name: legacytokentracking.ConfigMapName},
		Data:       map[string]string{legacytokentracking.ConfigMapDataKey: label},
	}
}

	e := &Signer{
		client:             cl,
		configMapKey:       options.ConfigMapNamespace + "/" + options.ConfigMapName,
		configMapName:      options.ConfigMapName,
		configMapNamespace: options.ConfigMapNamespace,
		secretNamespace:    options.TokenSecretNamespace,
		secretLister:       secrets.Lister(),
		secretSynced:       secrets.Informer().HasSynced,

			},
		},
		{
			name: "create configmap should ignore AlreadyExists error [no cache, live object exists]",
			clientObjects: []runtime.Object{

	configMapNamespace string
	configMapName      string
	callback           func(*v1.ConfigMap)

	hasSynced atomic.Bool
}

// NewController returns a new ConfigMap watcher controller.
func NewController(client kube.Client, namespace, name string, callback func(*v1.ConfigMap)) *Controller {
	c := &Controller{
		configMapNamespace: namespace,
		configMapName:      name,
		callback:           callback,
	}

	return newCM
}

func resetCalled() {
	called = false
	newCM = nil
}

func Test_ConfigMapWatcher(t *testing.T) {
	client := kube.NewFakeClient()
	cm := makeConfigMap(configMapName, "1")
	cm1 := makeConfigMap(configMapName, "2")
	cm2 := makeConfigMap("not-watched", "1")
	steps := []struct {
		added        *v1.ConfigMap
		updated      *v1.ConfigMap
		deleted      *v1.ConfigMap
		expectCalled bool

	"k8s.io/client-go/util/workqueue"
	"k8s.io/klog/v2"
	"k8s.io/utils/clock"
)

const (
	ConfigMapName    = "kube-apiserver-legacy-service-account-token-tracking"
	ConfigMapDataKey = "since"
	dateFormat       = "2006-01-02"
)

var (
	queueKey = metav1.NamespaceSystem + "/" + ConfigMapName
)

// Controller maintains a timestamp value configmap `kube-apiserver-legacy-service-account-token-tracking`

			if cast, ok := obj.(*corev1.ConfigMap); ok {
				return cast.Namespace == configMapNamespace && cast.Name == configMapName
			}
			if tombstone, ok := obj.(cache.DeletedFinalStateUnknown); ok {
				if cast, ok := tombstone.Obj.(*corev1.ConfigMap); ok {
					return cast.Namespace == configMapNamespace && cast.Name == configMapName
				}
			}
			return true // always return true just in case.  The checks are fairly cheap
		},

	ic.mu.Lock()
	myic := ic.injectConfig
	ic.mu.Unlock()

	if myic == nil {
		c := ic.ctx.AllClusters().Configs()[0]

		cfgMap, err := ic.getConfigMap(c, ic.configMapName())
		if err != nil {
			return nil, err
		}

		// Get the MeshConfig yaml from the config map.
		icYAML, err := getInjectConfigYaml(cfgMap, "config")
		if err != nil {
			return nil, err
		}