/test: rename CachedResource to ClusterCachedResource

Signed-off-by: Lubomir I. Ivanov <neolit123@gmail.com>

Author: neolit123

test/e2e/cache/assets/published-resource-instances.yaml

@@ -1,5 +1,5 @@
 apiVersion: cache.kcp.io/v1alpha1
-kind: CachedResource
+kind: ClusterCachedResource
 metadata:
   name: instances
 spec:

test/e2e/cache/replication_api_cache_test.go

@@ -133,7 +133,7 @@ func TestCacheServerReplicationAPI(t *testing.T) {
 
 			t.Logf("Wait for replication api to be ready and reporting 7 replicas")
 			kcptestinghelpers.Eventually(t, func() (bool, string) {
-				publishedResource, err := orgProviderKCPClient.Cluster(rootOrg).CacheV1alpha1().CachedResources().Get(ctx, "instances", metav1.GetOptions{})
+				publishedResource, err := orgProviderKCPClient.Cluster(rootOrg).CacheV1alpha1().ClusterCachedResources().Get(ctx, "instances", metav1.GetOptions{})
 				require.NoError(t, err)
 				return publishedResource != nil && publishedResource.Status.ResourceCounts != nil && publishedResource.Status.ResourceCounts.Cache == 7, yamlMarshal(t, publishedResource)
 			}, wait.ForeverTestTimeout, 100*time.Millisecond, "waiting for replication api to be ready and reporting 7 replicas")
@@ -144,7 +144,7 @@ func TestCacheServerReplicationAPI(t *testing.T) {
 			err = dynamicClusterClient.Cluster(rootOrg).Resource(schema.GroupVersionResource{Group: "machines.svm.io", Version: "v1alpha1", Resource: "instances"}).Delete(ctx, "analytics-2", metav1.DeleteOptions{})
 			require.NoError(t, err)
 			kcptestinghelpers.Eventually(t, func() (bool, string) {
-				publishedResource, err := orgProviderKCPClient.Cluster(rootOrg).CacheV1alpha1().CachedResources().Get(ctx, "instances", metav1.GetOptions{})
+				publishedResource, err := orgProviderKCPClient.Cluster(rootOrg).CacheV1alpha1().ClusterCachedResources().Get(ctx, "instances", metav1.GetOptions{})
 				require.NoError(t, err)
 				return publishedResource != nil && publishedResource.Status.ResourceCounts != nil && publishedResource.Status.ResourceCounts.Cache == 5, yamlMarshal(t, publishedResource)
 			}, wait.ForeverTestTimeout, 100*time.Millisecond, "waiting for replication api to be ready and reporting 5 replicas")
@@ -208,7 +208,7 @@ func TestReplicationWithWildcardListing(t *testing.T) {
 				t.Parallel()
 				var err error
 
-				// We need the Instances CRD + a few of its CRs for testing and a CachedResource for that Instance resource + its identity secret.
+				// We need the Instances CRD + a few of its CRs for testing and a ClusterCachedResource for that Instance resource + its identity secret.
 				// We iterate over two different identities, so we should have two distinct Instance resources across the cache server.
 
 				t.Logf("Install Instances CRD into workspace %q", ws)
@@ -245,13 +245,13 @@ func TestReplicationWithWildcardListing(t *testing.T) {
 				}, metav1.CreateOptions{})
 				require.NoError(t, err, "error creating identity secret %s workspace", ws)
 
-				t.Logf("Create a CachedResource in workspace %q", ws)
-				_, err = kcpClusterClient.Cluster(ws).CacheV1alpha1().CachedResources().
-					Create(ctx, &cachev1alpha1.CachedResource{
+				t.Logf("Create a ClusterCachedResource in workspace %q", ws)
+				_, err = kcpClusterClient.Cluster(ws).CacheV1alpha1().ClusterCachedResources().
+					Create(ctx, &cachev1alpha1.ClusterCachedResource{
 						ObjectMeta: metav1.ObjectMeta{
 							Name: "instances",
 						},
-						Spec: cachev1alpha1.CachedResourceSpec{
+						Spec: cachev1alpha1.ClusterCachedResourceSpec{
 							GroupVersionResource: cachev1alpha1.GroupVersionResource{
 								Group:    "machines.svm.io",
 								Version:  "v1alpha1",
@@ -270,11 +270,11 @@ func TestReplicationWithWildcardListing(t *testing.T) {
 							},
 						},
 					}, metav1.CreateOptions{})
-				require.NoError(t, err, "error creating CachedResource in workspace %s", ws)
+				require.NoError(t, err, "error creating ClusterCachedResource in workspace %s", ws)
 
 				t.Logf("Wait while the Instance objects in workspace %q are replicated", ws)
 				kcptestinghelpers.Eventually(t, func() (bool, string) {
-					cr, err := kcpClusterClient.Cluster(ws).CacheV1alpha1().CachedResources().
+					cr, err := kcpClusterClient.Cluster(ws).CacheV1alpha1().ClusterCachedResources().
 						Get(ctx, "instances", metav1.GetOptions{})
 					require.NoError(t, err)
 					if cr.Status.ResourceCounts == nil {
@@ -289,7 +289,7 @@ func TestReplicationWithWildcardListing(t *testing.T) {
 					return true, ""
 				}, wait.ForeverTestTimeout, 100*time.Millisecond, "waiting for CRD to be established")
 
-				cr, err := kcpClusterClient.Cluster(ws).CacheV1alpha1().CachedResources().
+				cr, err := kcpClusterClient.Cluster(ws).CacheV1alpha1().ClusterCachedResources().
 					Get(ctx, "instances", metav1.GetOptions{})
 				require.NoError(t, err)
 				require.NotEmpty(t, cr.Status.IdentityHash, "identity hash should not be empty")
@@ -338,16 +338,16 @@ func TestReplicationWithWildcardListing(t *testing.T) {
 	)
 	require.NoError(t, err, "scoped get from cache should succeed")
 
-	// Once the CachedResource in B1's ws is deleted, the instances resource should be gone from cache too.
+	// Once the ClusterCachedResource in B1's ws is deleted, the instances resource should be gone from cache too.
 
-	t.Logf("Wait while CachedResource in %q workspace is deleted", wsB1Path)
-	err = kcpClusterClient.CacheV1alpha1().CachedResources().Cluster(wsB1Path).Delete(t.Context(), "instances", metav1.DeleteOptions{})
-	require.NoError(t, err, "deleting CachedResource %s|%s should not fail", wsB1Path, "instances")
+	t.Logf("Wait while ClusterCachedResource in %q workspace is deleted", wsB1Path)
+	err = kcpClusterClient.CacheV1alpha1().ClusterCachedResources().Cluster(wsB1Path).Delete(t.Context(), "instances", metav1.DeleteOptions{})
+	require.NoError(t, err, "deleting ClusterCachedResource %s|%s should not fail", wsB1Path, "instances")
 	kcptestinghelpers.Eventually(t, func() (bool, string) {
-		_, err = kcpClusterClient.CacheV1alpha1().CachedResources().Cluster(wsB1Path).Get(t.Context(), "instances", metav1.GetOptions{})
+		_, err = kcpClusterClient.CacheV1alpha1().ClusterCachedResources().Cluster(wsB1Path).Get(t.Context(), "instances", metav1.GetOptions{})
 		return apierrors.IsNotFound(err), fmt.Sprintf("expected NotFound, got err=%v", err)
-	}, wait.ForeverTestTimeout, 100*time.Millisecond, "waiting for CachedResource to be deleted")
-	// Just to be safe it's better to be polling for NotFound, because the CachedResource informer
+	}, wait.ForeverTestTimeout, 100*time.Millisecond, "waiting for ClusterCachedResource to be deleted")
+	// Just to be safe it's better to be polling for NotFound, because the ClusterCachedResource informer
 	// in cache-server's CRD lister might be behind, and/or the resources still being GC'd.
 	kcptestinghelpers.Eventually(t, func() (bool, string) {
 		_, err = cacheDynClient.Cluster(b1ClusterName).Resource(schema.GroupVersionResource{

test/e2e/framework/util.go

@@ -95,10 +95,10 @@ func ExportVirtualWorkspaceURLs(export *apisv1alpha1.APIExportEndpointSlice) []s
 }
 
 // ReplicationVirtualWorkspaceURLs returns the URLs of the virtual workspaces of the
-// given CachedResourceEndpointSlice.
-func ReplicationVirtualWorkspaceURLs(slice *cachev1alpha1.CachedResourceEndpointSlice) []string {
-	urls := make([]string, 0, len(slice.Status.CachedResourceEndpoints))
-	for _, vw := range slice.Status.CachedResourceEndpoints {
+// given ClusterCachedResourceEndpointSlice.
+func ReplicationVirtualWorkspaceURLs(slice *cachev1alpha1.ClusterCachedResourceEndpointSlice) []string {
+	urls := make([]string, 0, len(slice.Status.ClusterCachedResourceEndpoints))
+	for _, vw := range slice.Status.ClusterCachedResourceEndpoints {
 		urls = append(urls, vw.URL)
 	}
 	return urls

test/e2e/reconciler/cache/replication_test.go

@@ -54,7 +54,7 @@ import (
 
 	cacheclient "github.com/kcp-dev/kcp/pkg/cache/client"
 	"github.com/kcp-dev/kcp/pkg/cache/client/shard"
-	"github.com/kcp-dev/kcp/pkg/reconciler/cache/cachedresources/replication"
+	"github.com/kcp-dev/kcp/pkg/reconciler/cache/clustercachedresources/replication"
 	"github.com/kcp-dev/kcp/test/e2e/framework"
 )
 
@@ -414,18 +414,18 @@ func replicateResourceNegative(ctx context.Context, t *testing.T,
 	scenario.VerifyReplication(t.Context(), t)
 
 	t.Logf("Delete cached %s %s/%s and check if it was brought back by the replication controller", kind, clusterName, resourceName)
-	scenario.DeleteCachedResource(t.Context(), t)
+	scenario.DeleteClusterCachedResource(t.Context(), t)
 	scenario.VerifyReplication(t.Context(), t)
 
 	if resWithModifiedSpec != nil {
 		t.Logf("Update cached %s %s/%s so that it differs from the source resource", kind, clusterName, scenario.resourceName)
-		scenario.UpdateSpecCachedResource(t.Context(), t, resWithModifiedSpec)
+		scenario.UpdateSpecClusterCachedResource(t.Context(), t, resWithModifiedSpec)
 		t.Logf("Verify that the cached %s %s/%s was brought back by the replication controller after an update", kind, clusterName, resourceName)
 		scenario.VerifyReplication(t.Context(), t)
 	}
 
 	t.Logf("Update cached %s %s/%s so that it differs from the source resource", kind, clusterName, scenario.resourceName)
-	scenario.UpdateMetaCachedResource(t.Context(), t)
+	scenario.UpdateMetaClusterCachedResource(t.Context(), t)
 	t.Logf("Verify that the cached %s %s/%s was brought back by the replication controller after an update", kind, clusterName, resourceName)
 	scenario.VerifyReplication(t.Context(), t)
 }
@@ -562,7 +562,7 @@ func (b *replicateResourceScenario) UpdateSpecSourceResource(ctx context.Context
 	})
 }
 
-func (b *replicateResourceScenario) UpdateMetaCachedResource(ctx context.Context, t *testing.T) {
+func (b *replicateResourceScenario) UpdateMetaClusterCachedResource(ctx context.Context, t *testing.T) {
 	t.Helper()
 	b.resourceUpdateHelper(t.Context(), t, func(ctx context.Context) (*unstructured.Unstructured, error) {
 		return b.cacheKcpClusterDynamicClient.Resource(b.gvr).Cluster(b.cluster.Path()).Get(cacheclient.WithShardInContext(t.Context(), shard.New("root")), b.resourceName, metav1.GetOptions{})
@@ -579,7 +579,7 @@ func (b *replicateResourceScenario) UpdateMetaCachedResource(ctx context.Context
 	})
 }
 
-func (b *replicateResourceScenario) UpdateSpecCachedResource(ctx context.Context, t *testing.T, resWithModifiedSpec runtime.Object) {
+func (b *replicateResourceScenario) UpdateSpecClusterCachedResource(ctx context.Context, t *testing.T, resWithModifiedSpec runtime.Object) {
 	t.Helper()
 	b.resourceUpdateHelper(t.Context(), t, func(ctx context.Context) (*unstructured.Unstructured, error) {
 		return b.cacheKcpClusterDynamicClient.Resource(b.gvr).Cluster(b.cluster.Path()).Get(cacheclient.WithShardInContext(t.Context(), shard.New("root")), b.resourceName, metav1.GetOptions{})
@@ -627,7 +627,7 @@ func (b *replicateResourceScenario) DeleteSourceResourceAndVerify(ctx context.Co
 	}, wait.ForeverTestTimeout, 100*time.Millisecond)
 }
 
-func (b *replicateResourceScenario) DeleteCachedResource(ctx context.Context, t *testing.T) {
+func (b *replicateResourceScenario) DeleteClusterCachedResource(ctx context.Context, t *testing.T) {
 	t.Helper()
 	err := b.cacheKcpClusterDynamicClient.Resource(b.gvr).Cluster(b.cluster.Path()).Delete(cacheclient.WithShardInContext(t.Context(), shard.New("root")), b.resourceName, metav1.DeleteOptions{})
 	require.NoError(t, err)
@@ -679,7 +679,7 @@ func (b *replicateResourceScenario) verifyResourceReplicationHelper(ctx context.
 		if err != nil {
 			return false, err.Error()
 		}
-		cachedResource, err := b.cacheKcpClusterDynamicClient.Resource(b.gvr).Cluster(b.cluster.Path()).Get(cacheclient.WithShardInContext(t.Context(), shard.New("root")), b.resourceName, metav1.GetOptions{})
+		clusterCachedResource, err := b.cacheKcpClusterDynamicClient.Resource(b.gvr).Cluster(b.cluster.Path()).Get(cacheclient.WithShardInContext(t.Context(), shard.New("root")), b.resourceName, metav1.GetOptions{})
 		if err != nil {
 			if !errors.IsNotFound(err) {
 				return true, err.Error()
@@ -692,40 +692,40 @@ func (b *replicateResourceScenario) verifyResourceReplicationHelper(ctx context.
 			replication.AnnotationKeyOriginalResourceVersion,
 			replication.AnnotationKeyOriginalResourceUID,
 		)
-		cachedResourceMeta, err := meta.Accessor(cachedResource)
+		clusterCachedResourceMeta, err := meta.Accessor(clusterCachedResource)
 		if err != nil {
 			return false, err.Error()
 		}
-		if _, found := cachedResourceMeta.GetAnnotations()[genericapirequest.ShardAnnotationKey]; !found {
-			t.Fatalf("replicated %s root|%s/%s, doesn't have %s annotation", b.gvr, cluster, cachedResourceMeta.GetName(), genericapirequest.ShardAnnotationKey)
+		if _, found := clusterCachedResourceMeta.GetAnnotations()[genericapirequest.ShardAnnotationKey]; !found {
+			t.Fatalf("replicated %s root|%s/%s, doesn't have %s annotation", b.gvr, cluster, clusterCachedResourceMeta.GetName(), genericapirequest.ShardAnnotationKey)
 		}
-		if _, found := cachedResourceMeta.GetAnnotations()[replication.AnnotationKeyOriginalResourceVersion]; !found {
-			t.Fatalf("replicated %s root|%s/%s, doesn't have %s annotation", b.gvr, cluster, cachedResourceMeta.GetName(), replication.AnnotationKeyOriginalResourceVersion)
+		if _, found := clusterCachedResourceMeta.GetAnnotations()[replication.AnnotationKeyOriginalResourceVersion]; !found {
+			t.Fatalf("replicated %s root|%s/%s, doesn't have %s annotation", b.gvr, cluster, clusterCachedResourceMeta.GetName(), replication.AnnotationKeyOriginalResourceVersion)
 		}
-		if _, found := cachedResourceMeta.GetAnnotations()[replication.AnnotationKeyOriginalResourceUID]; !found {
-			t.Fatalf("replicated %s root|%s/%s, doesn't have %s annotation", b.gvr, cluster, cachedResourceMeta.GetName(), replication.AnnotationKeyOriginalResourceUID)
+		if _, found := clusterCachedResourceMeta.GetAnnotations()[replication.AnnotationKeyOriginalResourceUID]; !found {
+			t.Fatalf("replicated %s root|%s/%s, doesn't have %s annotation", b.gvr, cluster, clusterCachedResourceMeta.GetName(), replication.AnnotationKeyOriginalResourceUID)
 		}
 		unstructured.RemoveNestedField(originalResource.Object, "metadata", "resourceVersion")
-		unstructured.RemoveNestedField(cachedResource.Object, "metadata", "resourceVersion")
+		unstructured.RemoveNestedField(clusterCachedResource.Object, "metadata", "resourceVersion")
 
 		// TODO(davidfestal): find out why the generation is not equal, specially for rbacv1.
 		// Is it a characteristic of all built-in kcp resources (which are not backed by CRDs) ?
 		// Issue opened: https://github.com/kcp-dev/kcp/issues/2935
 		if b.gvr.Group == rbacv1.SchemeGroupVersion.Group {
 			unstructured.RemoveNestedField(originalResource.Object, "metadata", "generation")
-			unstructured.RemoveNestedField(cachedResource.Object, "metadata", "generation")
+			unstructured.RemoveNestedField(clusterCachedResource.Object, "metadata", "generation")
 		}
 
-		unstructured.RemoveNestedField(cachedResource.Object, "metadata", "annotations", genericapirequest.ShardAnnotationKey)
-		unstructured.RemoveNestedField(cachedResource.Object, "metadata", "annotations", replication.AnnotationKeyOriginalResourceVersion)
-		unstructured.RemoveNestedField(cachedResource.Object, "metadata", "annotations", replication.AnnotationKeyOriginalResourceUID)
-		if cachedStatus, ok := cachedResource.Object["status"]; ok && cachedStatus == nil || (cachedStatus != nil && len(cachedStatus.(map[string]interface{})) == 0) {
+		unstructured.RemoveNestedField(clusterCachedResource.Object, "metadata", "annotations", genericapirequest.ShardAnnotationKey)
+		unstructured.RemoveNestedField(clusterCachedResource.Object, "metadata", "annotations", replication.AnnotationKeyOriginalResourceVersion)
+		unstructured.RemoveNestedField(clusterCachedResource.Object, "metadata", "annotations", replication.AnnotationKeyOriginalResourceUID)
+		if cachedStatus, ok := clusterCachedResource.Object["status"]; ok && cachedStatus == nil || (cachedStatus != nil && len(cachedStatus.(map[string]interface{})) == 0) {
 			// TODO: worth investigating:
 			// for some reason cached resources have an empty status set whereas the original resources don't
-			unstructured.RemoveNestedField(cachedResource.Object, "status")
+			unstructured.RemoveNestedField(clusterCachedResource.Object, "status")
 		}
-		if diff := cmp.Diff(cachedResource.Object, originalResource.Object); len(diff) > 0 {
-			return false, fmt.Sprintf("replicated %s root|%s/%s is different from the original: %s", b.gvr, cluster, cachedResourceMeta.GetName(), diff)
+		if diff := cmp.Diff(clusterCachedResource.Object, originalResource.Object); len(diff) > 0 {
+			return false, fmt.Sprintf("replicated %s root|%s/%s is different from the original: %s", b.gvr, cluster, clusterCachedResourceMeta.GetName(), diff)
 		}
 		return true, ""
 	}, wait.ForeverTestTimeout, 100*time.Millisecond)