Increase test coverage

Signed-off-by: Jonathan Ogilvie <[email protected]>

Author: jcogilvie

pkg/cache/cluster_test.go

@@ -1255,6 +1255,312 @@ func TestIterateHierarchyV2_CrossNamespaceOwnerReference(t *testing.T) {
 	assert.True(t, foundNamespacedChild, "Should visit Deployment child (this tests the fix)")
 }
 
+// TestBuildGraph_NilAllResources tests buildGraph with nil allResources parameter
+func TestBuildGraph_NilAllResources(t *testing.T) {
+	// Create test resources
+	parentUID := types.UID("parent-123")
+	childUID := types.UID("child-456")
+
+	parent := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			Namespace:  "test-ns",
+			UID:        parentUID,
+		},
+	}
+
+	child := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "v1",
+			Kind:       "Pod",
+			Name:       "child",
+			Namespace:  "test-ns",
+			UID:        childUID,
+		},
+		OwnerRefs: []metav1.OwnerReference{{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			UID:        parentUID,
+		}},
+	}
+
+	nsNodes := map[kube.ResourceKey]*Resource{
+		parent.ResourceKey(): parent,
+		child.ResourceKey():  child,
+	}
+
+	// Call buildGraph with nil allResources
+	graph := buildGraph(nsNodes, nil)
+
+	// Should still work for same-namespace relationships
+	assert.Contains(t, graph, parent.ResourceKey())
+	assert.Contains(t, graph[parent.ResourceKey()], childUID)
+}
+
+// TestBuildGraph_InvalidAPIVersion tests handling of invalid API versions in owner references
+func TestBuildGraph_InvalidAPIVersion(t *testing.T) {
+	childUID := types.UID("child-123")
+
+	child := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "v1",
+			Kind:       "Pod",
+			Name:       "child",
+			Namespace:  "test-ns",
+			UID:        childUID,
+		},
+		OwnerRefs: []metav1.OwnerReference{{
+			APIVersion: "invalid/api/version", // Invalid API version
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			// No UID - should trigger API version parsing
+		}},
+	}
+
+	nsNodes := map[kube.ResourceKey]*Resource{
+		child.ResourceKey(): child,
+	}
+
+	allResources := map[kube.ResourceKey]*Resource{
+		child.ResourceKey(): child,
+	}
+
+	// Should not panic and should handle invalid API version gracefully
+	graph := buildGraph(nsNodes, allResources)
+
+	// No parent should be found due to invalid API version
+	assert.Empty(t, graph)
+}
+
+// TestBuildGraph_CrossNamespaceMissingUID tests cross-namespace parent resolution with missing UID
+func TestBuildGraph_CrossNamespaceMissingUID(t *testing.T) {
+	parentUID := types.UID("parent-123")
+	childUID := types.UID("child-456")
+
+	// Cluster-scoped parent
+	parent := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			Namespace:  "", // Cluster-scoped
+			UID:        parentUID,
+		},
+	}
+
+	// Namespaced child with owner reference missing UID
+	child := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "v1",
+			Kind:       "Pod",
+			Name:       "child",
+			Namespace:  "test-ns",
+			UID:        childUID,
+		},
+		OwnerRefs: []metav1.OwnerReference{{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			// UID is missing - should be resolved via cross-namespace lookup
+		}},
+	}
+
+	nsNodes := map[kube.ResourceKey]*Resource{
+		child.ResourceKey(): child,
+	}
+
+	allResources := map[kube.ResourceKey]*Resource{
+		parent.ResourceKey(): parent,
+		child.ResourceKey():  child,
+	}
+
+	graph := buildGraph(nsNodes, allResources)
+
+	// Should find the parent via cross-namespace lookup and establish relationship
+	assert.Contains(t, graph, parent.ResourceKey())
+	assert.Contains(t, graph[parent.ResourceKey()], childUID)
+
+	// Verify UID was backfilled
+	assert.Equal(t, parentUID, child.OwnerRefs[0].UID)
+}
+
+// TestBuildGraph_NonExistentParent tests cross-namespace child with non-existent parent
+func TestBuildGraph_NonExistentParent(t *testing.T) {
+	childUID := types.UID("child-456")
+
+	child := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "v1",
+			Kind:       "Pod",
+			Name:       "child",
+			Namespace:  "test-ns",
+			UID:        childUID,
+		},
+		OwnerRefs: []metav1.OwnerReference{{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "non-existent-parent",
+			// No UID - should trigger lookup that fails
+		}},
+	}
+
+	nsNodes := map[kube.ResourceKey]*Resource{
+		child.ResourceKey(): child,
+	}
+
+	allResources := map[kube.ResourceKey]*Resource{
+		child.ResourceKey(): child,
+		// Parent is not in allResources
+	}
+
+	graph := buildGraph(nsNodes, allResources)
+
+	// No relationships should be established
+	assert.Empty(t, graph)
+}
+
+// TestBuildGraph_CrossNamespaceUIDLookup tests cross-namespace parent lookup by UID
+func TestBuildGraph_CrossNamespaceUIDLookup(t *testing.T) {
+	parentUID := types.UID("parent-123")
+	childUID := types.UID("child-456")
+
+	// Cluster-scoped parent
+	parent := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			Namespace:  "", // Cluster-scoped
+			UID:        parentUID,
+		},
+	}
+
+	// Namespaced child with owner reference that has UID but parent not in same namespace
+	child := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "v1",
+			Kind:       "Pod",
+			Name:       "child",
+			Namespace:  "test-ns",
+			UID:        childUID,
+		},
+		OwnerRefs: []metav1.OwnerReference{{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			UID:        parentUID, // UID is present
+		}},
+	}
+
+	nsNodes := map[kube.ResourceKey]*Resource{
+		child.ResourceKey(): child,
+		// Parent is not in same namespace
+	}
+
+	allResources := map[kube.ResourceKey]*Resource{
+		parent.ResourceKey(): parent,
+		child.ResourceKey():  child,
+	}
+
+	graph := buildGraph(nsNodes, allResources)
+
+	// Should establish cross-namespace relationship via UID lookup
+	assert.Contains(t, graph, parent.ResourceKey())
+	assert.Contains(t, graph[parent.ResourceKey()], childUID)
+}
+
+// TestBuildGraph_DuplicateUIDs tests handling of resources with duplicate UIDs
+func TestBuildGraph_DuplicateUIDs(t *testing.T) {
+	parentUID := types.UID("parent-123")
+	duplicateUID := types.UID("duplicate-456")
+
+	parent := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			Namespace:  "test-ns",
+			UID:        parentUID,
+		},
+	}
+
+	// Two children with the same UID (simulating replicasets from different API groups)
+	child1 := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "apps/v1",
+			Kind:       "ReplicaSet",
+			Name:       "child-apps",
+			Namespace:  "test-ns",
+			UID:        duplicateUID,
+		},
+		OwnerRefs: []metav1.OwnerReference{{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			UID:        parentUID,
+		}},
+	}
+
+	child2 := &Resource{
+		Ref: corev1.ObjectReference{
+			APIVersion: "extensions/v1beta1",
+			Kind:       "ReplicaSet",
+			Name:       "child-extensions",
+			Namespace:  "test-ns",
+			UID:        duplicateUID,
+		},
+		OwnerRefs: []metav1.OwnerReference{{
+			APIVersion: "v1",
+			Kind:       "ConfigMap",
+			Name:       "parent",
+			UID:        parentUID,
+		}},
+	}
+
+	nsNodes := map[kube.ResourceKey]*Resource{
+		parent.ResourceKey(): parent,
+		child1.ResourceKey(): child1,
+		child2.ResourceKey(): child2,
+	}
+
+	graph := buildGraph(nsNodes, nil)
+
+	// Should handle duplicate UIDs gracefully by picking consistently
+	assert.Contains(t, graph, parent.ResourceKey())
+	assert.Contains(t, graph[parent.ResourceKey()], duplicateUID)
+
+	// Should pick the same child consistently (based on string comparison)
+	selectedChild := graph[parent.ResourceKey()][duplicateUID]
+	assert.NotNil(t, selectedChild)
+}
+
+// TestIterateHierarchyV2_EdgeCases tests additional edge cases for hierarchy iteration
+func TestIterateHierarchyV2_EdgeCases(t *testing.T) {
+	cluster := newCluster(t)
+
+	t.Run("EmptyKeysList", func(t *testing.T) {
+		var visited []kube.ResourceKey
+		cluster.IterateHierarchyV2([]kube.ResourceKey{}, func(resource *Resource, _ map[kube.ResourceKey]*Resource) bool {
+			visited = append(visited, resource.ResourceKey())
+			return true
+		})
+		assert.Empty(t, visited)
+	})
+
+	t.Run("NonExistentKeys", func(t *testing.T) {
+		var visited []kube.ResourceKey
+		nonExistentKey := kube.ResourceKey{Group: "fake", Kind: "Fake", Namespace: "fake", Name: "fake"}
+		cluster.IterateHierarchyV2([]kube.ResourceKey{nonExistentKey}, func(resource *Resource, _ map[kube.ResourceKey]*Resource) bool {
+			visited = append(visited, resource.ResourceKey())
+			return true
+		})
+		assert.Empty(t, visited)
+	})
+}
+
 // Test_watchEvents_Deadlock validates that starting watches will not create a deadlock
 // caused by using improper locking in various callback methods when there is a high load on the
 // system.