diff --git a/crd/current/gerritclusters.gerritoperator.google.com-v1.yml b/crd/current/gerritclusters.gerritoperator.google.com-v1.yml
index e043fc3..3c38017 100644
--- a/crd/current/gerritclusters.gerritoperator.google.com-v1.yml
+++ b/crd/current/gerritclusters.gerritoperator.google.com-v1.yml
@@ -509,17 +509,6 @@
                                       fieldPath:
                                         type: string
                                     type: object
-                                  fileKeyRef:
-                                    properties:
-                                      key:
-                                        type: string
-                                      optional:
-                                        type: boolean
-                                      path:
-                                        type: string
-                                      volumeName:
-                                        type: string
-                                    type: object
                                   resourceFieldRef:
                                     properties:
                                       containerName:
diff --git a/crd/current/gerrits.gerritoperator.google.com-v1.yml b/crd/current/gerrits.gerritoperator.google.com-v1.yml
index 0159127..5e857bd 100644
--- a/crd/current/gerrits.gerritoperator.google.com-v1.yml
+++ b/crd/current/gerrits.gerritoperator.google.com-v1.yml
@@ -411,17 +411,6 @@
                             fieldPath:
                               type: string
                           type: object
-                        fileKeyRef:
-                          properties:
-                            key:
-                              type: string
-                            optional:
-                              type: boolean
-                            path:
-                              type: string
-                            volumeName:
-                              type: string
-                          type: object
                         resourceFieldRef:
                           properties:
                             containerName:
diff --git a/helm-charts/gerrit-operator-crds/templates/gerritclusters.gerritoperator.google.com-v1.yml b/helm-charts/gerrit-operator-crds/templates/gerritclusters.gerritoperator.google.com-v1.yml
index 55d3d7e..8dca827 100644
--- a/helm-charts/gerrit-operator-crds/templates/gerritclusters.gerritoperator.google.com-v1.yml
+++ b/helm-charts/gerrit-operator-crds/templates/gerritclusters.gerritoperator.google.com-v1.yml
@@ -3057,17 +3057,6 @@
                                         fieldPath:
                                           type: string
                                       type: object
-                                    fileKeyRef:
-                                      properties:
-                                        key:
-                                          type: string
-                                        optional:
-                                          type: boolean
-                                        path:
-                                          type: string
-                                        volumeName:
-                                          type: string
-                                      type: object
                                     resourceFieldRef:
                                       properties:
                                         containerName:
diff --git a/helm-charts/gerrit-operator-crds/templates/gerrits.gerritoperator.google.com-v1.yml b/helm-charts/gerrit-operator-crds/templates/gerrits.gerritoperator.google.com-v1.yml
index 5f7fd56..fc3b2c8 100644
--- a/helm-charts/gerrit-operator-crds/templates/gerrits.gerritoperator.google.com-v1.yml
+++ b/helm-charts/gerrit-operator-crds/templates/gerrits.gerritoperator.google.com-v1.yml
@@ -411,17 +411,6 @@
                               fieldPath:
                                 type: string
                             type: object
-                          fileKeyRef:
-                            properties:
-                              key:
-                                type: string
-                              optional:
-                                type: boolean
-                              path:
-                                type: string
-                              volumeName:
-                                type: string
-                            type: object
                           resourceFieldRef:
                             properties:
                               containerName:
diff --git a/operator/pom.xml b/operator/pom.xml
index d1ad9d0..ae73112 100644
--- a/operator/pom.xml
+++ b/operator/pom.xml
@@ -15,13 +15,13 @@
 	<properties>
 		<revision>1.0.0-SNAPSHOT</revision>
 
-		<fabric8.version>7.5.2</fabric8.version>
+		<fabric8.version>7.3.1</fabric8.version>
 		<flogger.version>0.8</flogger.version>
 		<guice.version>7.0.0</guice.version>
-		<javaoperatorsdk.version>5.2.3</javaoperatorsdk.version>
+		<javaoperatorsdk.version>5.1.0</javaoperatorsdk.version>
 		<jetty.version>11.0.25</jetty.version>
-		<log42.version>2.25.3</log42.version>
-		<sundrio.version>0.230.1</sundrio.version>
+		<log42.version>2.24.3</log42.version>
+		<sundrio.version>0.200.0</sundrio.version>
 		<lombok.version>1.18.38</lombok.version>
 		<maven.compiler.source>17</maven.compiler.source>
 		<maven.compiler.target>17</maven.compiler.target>
diff --git a/operator/src/main/java/com/google/gerrit/k8s/operator/cluster/dependent/ClusterManagedGerrit.java b/operator/src/main/java/com/google/gerrit/k8s/operator/cluster/dependent/ClusterManagedGerrit.java
index c2393e6..7603c30 100644
--- a/operator/src/main/java/com/google/gerrit/k8s/operator/cluster/dependent/ClusterManagedGerrit.java
+++ b/operator/src/main/java/com/google/gerrit/k8s/operator/cluster/dependent/ClusterManagedGerrit.java
@@ -21,29 +21,26 @@
 import io.javaoperatorsdk.operator.api.reconciler.Context;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.Deleter;
 import io.javaoperatorsdk.operator.processing.dependent.BulkDependentResource;
-import io.javaoperatorsdk.operator.processing.event.ResourceID;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
 public class ClusterManagedGerrit extends KubernetesDependentCustomResource<Gerrit, GerritCluster>
-    implements Deleter<GerritCluster>, BulkDependentResource<Gerrit, GerritCluster, ResourceID> {
+    implements Deleter<GerritCluster>, BulkDependentResource<Gerrit, GerritCluster> {
 
   public ClusterManagedGerrit() {
     super(Gerrit.class);
   }
 
   @Override
-  public Map<ResourceID, Gerrit> desiredResources(
+  public Map<String, Gerrit> desiredResources(
       GerritCluster gerritCluster, Context<GerritCluster> context) {
-    Map<ResourceID, Gerrit> gerrits = new HashMap<>();
+    Map<String, Gerrit> gerrits = new HashMap<>();
     for (GerritTemplate template : gerritCluster.getSpec().getGerrits()) {
-      Gerrit desired = desired(gerritCluster, template);
-      ResourceID id = ResourceID.fromResource(desired);
-      if (gerrits.get(id) != null) {
+      if (gerrits.get(template.getMetadata().getName()) != null) {
         throw new IllegalArgumentException("Each gerrit spec must use a different metadata.name");
       }
-      gerrits.put(id, desired);
+      gerrits.put(template.getMetadata().getName(), desired(gerritCluster, template));
     }
     return gerrits;
   }
@@ -53,12 +50,12 @@
   }
 
   @Override
-  public Map<ResourceID, Gerrit> getSecondaryResources(
+  public Map<String, Gerrit> getSecondaryResources(
       GerritCluster primary, Context<GerritCluster> context) {
     Set<Gerrit> gerrits = context.getSecondaryResources(Gerrit.class);
-    Map<ResourceID, Gerrit> result = new HashMap<>(gerrits.size());
+    Map<String, Gerrit> result = new HashMap<>(gerrits.size());
     for (Gerrit gerrit : gerrits) {
-      result.put(ResourceID.fromResource(gerrit), gerrit);
+      result.put(gerrit.getMetadata().getName(), gerrit);
     }
     return result;
   }
diff --git a/operator/src/main/java/com/google/gerrit/k8s/operator/cluster/dependent/ClusterManagedIncomingReplicationTask.java b/operator/src/main/java/com/google/gerrit/k8s/operator/cluster/dependent/ClusterManagedIncomingReplicationTask.java
index a00e33d..a822a36 100644
--- a/operator/src/main/java/com/google/gerrit/k8s/operator/cluster/dependent/ClusterManagedIncomingReplicationTask.java
+++ b/operator/src/main/java/com/google/gerrit/k8s/operator/cluster/dependent/ClusterManagedIncomingReplicationTask.java
@@ -22,7 +22,6 @@
 import io.javaoperatorsdk.operator.api.reconciler.dependent.Deleter;
 import io.javaoperatorsdk.operator.processing.dependent.BulkDependentResource;
 import io.javaoperatorsdk.operator.processing.dependent.kubernetes.KubernetesDependent;
-import io.javaoperatorsdk.operator.processing.event.ResourceID;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
@@ -31,33 +30,33 @@
 public class ClusterManagedIncomingReplicationTask
     extends KubernetesDependentCustomResource<IncomingReplicationTask, GerritCluster>
     implements Deleter<GerritCluster>,
-        BulkDependentResource<IncomingReplicationTask, GerritCluster, ResourceID> {
+        BulkDependentResource<IncomingReplicationTask, GerritCluster> {
 
   public ClusterManagedIncomingReplicationTask() {
     super(IncomingReplicationTask.class);
   }
 
   @Override
-  public Map<ResourceID, IncomingReplicationTask> desiredResources(
+  public Map<String, IncomingReplicationTask> desiredResources(
       GerritCluster primary, Context<GerritCluster> context) {
-    Map<ResourceID, IncomingReplicationTask> incomingReplTasks = new HashMap<>();
+    Map<String, IncomingReplicationTask> incomingReplTasks = new HashMap<>();
     for (IncomingReplicationTaskTemplate incomingReplTaskTemplate :
         primary.getSpec().getScheduledTasks().getIncomingReplication()) {
       IncomingReplicationTask incomingReplTask =
           incomingReplTaskTemplate.toIncomingReplicationTask(primary);
-      incomingReplTasks.put(ResourceID.fromResource(incomingReplTask), incomingReplTask);
+      incomingReplTasks.put(incomingReplTask.getMetadata().getName(), incomingReplTask);
     }
     return incomingReplTasks;
   }
 
   @Override
-  public Map<ResourceID, IncomingReplicationTask> getSecondaryResources(
+  public Map<String, IncomingReplicationTask> getSecondaryResources(
       GerritCluster primary, Context<GerritCluster> context) {
     Set<IncomingReplicationTask> incomingReplTasks =
         context.getSecondaryResources(IncomingReplicationTask.class);
-    Map<ResourceID, IncomingReplicationTask> result = new HashMap<>(incomingReplTasks.size());
+    Map<String, IncomingReplicationTask> result = new HashMap<>(incomingReplTasks.size());
     for (IncomingReplicationTask incomingReplTask : incomingReplTasks) {
-      result.put(ResourceID.fromResource(incomingReplTask), incomingReplTask);
+      result.put(incomingReplTask.getMetadata().getName(), incomingReplTask);
     }
     return result;
   }
diff --git a/operator/src/main/java/com/google/gerrit/k8s/operator/maintenance/dependent/GerritMaintenanceCronJobs.java b/operator/src/main/java/com/google/gerrit/k8s/operator/maintenance/dependent/GerritMaintenanceCronJobs.java
index 9e737cf..901ac2a 100644
--- a/operator/src/main/java/com/google/gerrit/k8s/operator/maintenance/dependent/GerritMaintenanceCronJobs.java
+++ b/operator/src/main/java/com/google/gerrit/k8s/operator/maintenance/dependent/GerritMaintenanceCronJobs.java
@@ -22,7 +22,6 @@
 import io.fabric8.kubernetes.api.model.batch.v1.CronJob;
 import io.javaoperatorsdk.operator.api.reconciler.Context;
 import io.javaoperatorsdk.operator.processing.dependent.BulkDependentResource;
-import io.javaoperatorsdk.operator.processing.event.ResourceID;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
@@ -33,7 +32,7 @@
 
 public class GerritMaintenanceCronJobs
     extends KubernetesDependentCustomResource<CronJob, GerritMaintenance>
-    implements BulkDependentResource<CronJob, GerritMaintenance, ResourceID> {
+    implements BulkDependentResource<CronJob, GerritMaintenance> {
   private static final FluentLogger logger = FluentLogger.forEnclosingClass();
 
   public GerritMaintenanceCronJobs() {
@@ -41,28 +40,28 @@
   }
 
   @Override
-  public Map<ResourceID, CronJob> desiredResources(
+  public Map<String, CronJob> desiredResources(
       GerritMaintenance primary, Context<GerritMaintenance> context) {
-    Map<ResourceID, CronJob> cronJobs = new HashMap<>();
+    Map<String, CronJob> cronJobs = new HashMap<>();
     GerritProjectsTasks projectsTasks = primary.getSpec().getProjects();
     if (projectsTasks != null) {
       List<GitGcTask> gcTasks = List.copyOf(projectsTasks.getGc());
       checkForConflict(gcTasks);
       for (GitGcTask gcTask : gcTasks) {
-        CronJob desired = GitGarbageCollectionCronJob.desired(primary, gcTask, context);
-        cronJobs.put(ResourceID.fromResource(desired), desired);
+        cronJobs.put(
+            gcTask.getName(), GitGarbageCollectionCronJob.desired(primary, gcTask, context));
       }
     }
     return cronJobs;
   }
 
   @Override
-  public Map<ResourceID, CronJob> getSecondaryResources(
+  public Map<String, CronJob> getSecondaryResources(
       GerritMaintenance primary, Context<GerritMaintenance> context) {
     Set<CronJob> cronjobs = context.getSecondaryResources(CronJob.class);
-    Map<ResourceID, CronJob> result = new HashMap<>(cronjobs.size());
+    Map<String, CronJob> result = new HashMap<>(cronjobs.size());
     for (CronJob cj : cronjobs) {
-      result.put(ResourceID.fromResource(cj), cj);
+      result.put(cj.getMetadata().getName(), cj);
     }
     return result;
   }
diff --git a/operator/src/main/java/com/google/gerrit/k8s/operator/network/istio/dependent/GerritIstioDestinationRule.java b/operator/src/main/java/com/google/gerrit/k8s/operator/network/istio/dependent/GerritIstioDestinationRule.java
index a8c7e32..b875b8e 100644
--- a/operator/src/main/java/com/google/gerrit/k8s/operator/network/istio/dependent/GerritIstioDestinationRule.java
+++ b/operator/src/main/java/com/google/gerrit/k8s/operator/network/istio/dependent/GerritIstioDestinationRule.java
@@ -27,15 +27,13 @@
 import io.javaoperatorsdk.operator.api.reconciler.Context;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.Deleter;
 import io.javaoperatorsdk.operator.processing.dependent.BulkDependentResource;
-import io.javaoperatorsdk.operator.processing.event.ResourceID;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
 public class GerritIstioDestinationRule
     extends CRUDReconcileAddKubernetesDependentResource<DestinationRule, GerritNetwork>
-    implements Deleter<GerritNetwork>,
-        BulkDependentResource<DestinationRule, GerritNetwork, ResourceID> {
+    implements Deleter<GerritNetwork>, BulkDependentResource<DestinationRule, GerritNetwork> {
 
   public GerritIstioDestinationRule() {
     super(DestinationRule.class);
@@ -92,29 +90,27 @@
   }
 
   @Override
-  public Map<ResourceID, DestinationRule> desiredResources(
+  public Map<String, DestinationRule> desiredResources(
       GerritNetwork gerritNetwork, Context<GerritNetwork> context) {
-    Map<ResourceID, DestinationRule> drs = new HashMap<>();
+    Map<String, DestinationRule> drs = new HashMap<>();
     if (gerritNetwork.hasPrimaryGerrit()) {
       String primaryGerritName = gerritNetwork.getSpec().getPrimaryGerrit().getName();
-      DestinationRule dr = desired(gerritNetwork, primaryGerritName, false);
-      drs.put(ResourceID.fromResource(dr), dr);
+      drs.put(primaryGerritName, desired(gerritNetwork, primaryGerritName, false));
     }
     if (gerritNetwork.hasGerritReplica()) {
       String gerritReplicaName = gerritNetwork.getSpec().getGerritReplica().getName();
-      DestinationRule dr = desired(gerritNetwork, gerritReplicaName, true);
-      drs.put(ResourceID.fromResource(dr), dr);
+      drs.put(gerritReplicaName, desired(gerritNetwork, gerritReplicaName, true));
     }
     return drs;
   }
 
   @Override
-  public Map<ResourceID, DestinationRule> getSecondaryResources(
+  public Map<String, DestinationRule> getSecondaryResources(
       GerritNetwork gerritNetwork, Context<GerritNetwork> context) {
     Set<DestinationRule> drs = context.getSecondaryResources(DestinationRule.class);
-    Map<ResourceID, DestinationRule> result = new HashMap<>(drs.size());
+    Map<String, DestinationRule> result = new HashMap<>(drs.size());
     for (DestinationRule dr : drs) {
-      result.put(ResourceID.fromResource(dr), dr);
+      result.put(dr.getMetadata().getName(), dr);
     }
     return result;
   }
diff --git a/operator/src/main/java/com/google/gerrit/k8s/operator/network/istio/dependent/GerritIstioServiceEntries.java b/operator/src/main/java/com/google/gerrit/k8s/operator/network/istio/dependent/GerritIstioServiceEntries.java
index 436476d..3795472 100644
--- a/operator/src/main/java/com/google/gerrit/k8s/operator/network/istio/dependent/GerritIstioServiceEntries.java
+++ b/operator/src/main/java/com/google/gerrit/k8s/operator/network/istio/dependent/GerritIstioServiceEntries.java
@@ -34,7 +34,6 @@
 import io.javaoperatorsdk.operator.api.reconciler.Context;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.Deleter;
 import io.javaoperatorsdk.operator.processing.dependent.BulkDependentResource;
-import io.javaoperatorsdk.operator.processing.event.ResourceID;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -42,8 +41,7 @@
 
 public class GerritIstioServiceEntries
     extends CRUDReconcileAddKubernetesDependentResource<ServiceEntry, GerritNetwork>
-    implements Deleter<GerritNetwork>,
-        BulkDependentResource<ServiceEntry, GerritNetwork, ResourceID> {
+    implements Deleter<GerritNetwork>, BulkDependentResource<ServiceEntry, GerritNetwork> {
 
   public GerritIstioServiceEntries() {
     super(ServiceEntry.class);
@@ -91,9 +89,9 @@
   }
 
   @Override
-  public Map<ResourceID, ServiceEntry> desiredResources(
+  public Map<String, ServiceEntry> desiredResources(
       GerritNetwork gerritNetwork, Context<GerritNetwork> context) {
-    Map<ResourceID, ServiceEntry> serviceEntries = new HashMap<>();
+    Map<String, ServiceEntry> serviceEntries = new HashMap<>();
     if (gerritNetwork.hasPrimaryGerrit()) {
       String primaryGerritName = gerritNetwork.getSpec().getPrimaryGerrit().getName();
 
@@ -112,7 +110,8 @@
       for (int i = 0; i < sts.getSpec().getReplicas(); i++) {
         String podName = String.format("%s-%d", primaryGerritName, i);
         String namespace = gerritNetwork.getMetadata().getNamespace();
-        ServiceEntry se =
+        serviceEntries.put(
+            podName,
             desired(
                 podName,
                 podName,
@@ -121,9 +120,9 @@
                     podName,
                     new GerritService()
                         .getName(gerritNetwork.getSpec().getPrimaryGerrit().getName()),
-                    namespace));
-        serviceEntries.put(ResourceID.fromResource(se), se);
-        ServiceEntry headlessSe =
+                    namespace)));
+        serviceEntries.put(
+            podName + "-headless",
             desired(
                 podName + "-headless",
                 podName,
@@ -132,20 +131,19 @@
                     podName,
                     new GerritHeadlessService()
                         .getName(gerritNetwork.getSpec().getPrimaryGerrit().getName()),
-                    namespace));
-        serviceEntries.put(ResourceID.fromResource(headlessSe), headlessSe);
+                    namespace)));
       }
     }
     return serviceEntries;
   }
 
   @Override
-  public Map<ResourceID, ServiceEntry> getSecondaryResources(
+  public Map<String, ServiceEntry> getSecondaryResources(
       GerritNetwork gerritNetwork, Context<GerritNetwork> context) {
     Set<ServiceEntry> serviceEntries = context.getSecondaryResources(ServiceEntry.class);
-    Map<ResourceID, ServiceEntry> result = new HashMap<>(serviceEntries.size());
+    Map<String, ServiceEntry> result = new HashMap<>(serviceEntries.size());
     for (ServiceEntry se : serviceEntries) {
-      result.put(ResourceID.fromResource(se), se);
+      result.put(se.getMetadata().getName(), se);
     }
     return result;
   }
diff --git a/operator/src/test/java/com/google/gerrit/k8s/operator/cluster/dependent/GerritClusterGerritsTest.java b/operator/src/test/java/com/google/gerrit/k8s/operator/cluster/dependent/GerritClusterGerritsTest.java
index a8ec789..4b10745 100644
--- a/operator/src/test/java/com/google/gerrit/k8s/operator/cluster/dependent/GerritClusterGerritsTest.java
+++ b/operator/src/test/java/com/google/gerrit/k8s/operator/cluster/dependent/GerritClusterGerritsTest.java
@@ -23,7 +23,6 @@
 import com.google.gerrit.k8s.operator.gerrit.dependent.GerritConfigMap;
 import io.fabric8.kubernetes.api.model.ConfigMap;
 import io.javaoperatorsdk.operator.ReconcilerUtils;
-import io.javaoperatorsdk.operator.processing.event.ResourceID;
 import java.util.Map;
 import java.util.stream.Stream;
 import org.eclipse.jgit.errors.ConfigInvalidException;
@@ -47,7 +46,7 @@
     GerritCluster gerritCluster =
         ReconcilerUtils.loadYaml(GerritCluster.class, this.getClass(), inputFile);
     ClusterManagedGerrit clusterManagedGerrit = new ClusterManagedGerrit();
-    Map<ResourceID, Gerrit> gerrits = clusterManagedGerrit.desiredResources(gerritCluster, null);
+    Map<String, Gerrit> gerrits = clusterManagedGerrit.desiredResources(gerritCluster, null);
     for (Gerrit g : gerrits.values()) {
       switch (g.getSpec().getMode()) {
         case PRIMARY:
diff --git a/operator/src/test/java/com/google/gerrit/k8s/operator/gerrit/dependent/GerritTest.java b/operator/src/test/java/com/google/gerrit/k8s/operator/gerrit/dependent/GerritTest.java
index a65fbfd..6fa4f27 100644
--- a/operator/src/test/java/com/google/gerrit/k8s/operator/gerrit/dependent/GerritTest.java
+++ b/operator/src/test/java/com/google/gerrit/k8s/operator/gerrit/dependent/GerritTest.java
@@ -103,7 +103,7 @@
             kubernetesServer.createClient());
 
     return new DefaultContext<Gerrit>(
-        new GenericRetryExecution(new GenericRetry()), controller, primary, false, false);
+        new GenericRetryExecution(new GenericRetry()), controller, primary);
   }
 
   private static Stream<Arguments> provideYamlManifests() {
diff --git a/operator/src/test/java/com/google/gerrit/k8s/operator/gitgc/dependent/GitGarbageCollectionTest.java b/operator/src/test/java/com/google/gerrit/k8s/operator/gitgc/dependent/GitGarbageCollectionTest.java
index adbf913..bafcb24 100644
--- a/operator/src/test/java/com/google/gerrit/k8s/operator/gitgc/dependent/GitGarbageCollectionTest.java
+++ b/operator/src/test/java/com/google/gerrit/k8s/operator/gitgc/dependent/GitGarbageCollectionTest.java
@@ -81,7 +81,7 @@
             kubernetesServer.createClient());
 
     return new DefaultContext<GitGarbageCollection>(
-        new GenericRetryExecution(new GenericRetry()), controller, primary, false, false);
+        new GenericRetryExecution(new GenericRetry()), controller, primary);
   }
 
   private static Stream<Arguments> provideYamlManifests() {
diff --git a/operator/src/test/java/com/google/gerrit/k8s/operator/indexer/dependent/GerritIndexerTest.java b/operator/src/test/java/com/google/gerrit/k8s/operator/indexer/dependent/GerritIndexerTest.java
index 0d8de0b..0058c1e 100644
--- a/operator/src/test/java/com/google/gerrit/k8s/operator/indexer/dependent/GerritIndexerTest.java
+++ b/operator/src/test/java/com/google/gerrit/k8s/operator/indexer/dependent/GerritIndexerTest.java
@@ -112,7 +112,7 @@
             kubernetesServer.createClient());
 
     return new DefaultContext<GerritIndexer>(
-        new GenericRetryExecution(new GenericRetry()), controller, primary, false, false);
+        new GenericRetryExecution(new GenericRetry()), controller, primary);
   }
 
   private void assertDesiredConfigMapCreated(ConfigMap actual, ConfigMap expected) {
diff --git a/operator/src/test/java/com/google/gerrit/k8s/operator/maintenance/dependent/GerritMaintenanceTest.java b/operator/src/test/java/com/google/gerrit/k8s/operator/maintenance/dependent/GerritMaintenanceTest.java
index 97ff769..cc7268a 100644
--- a/operator/src/test/java/com/google/gerrit/k8s/operator/maintenance/dependent/GerritMaintenanceTest.java
+++ b/operator/src/test/java/com/google/gerrit/k8s/operator/maintenance/dependent/GerritMaintenanceTest.java
@@ -19,7 +19,6 @@
 import com.google.gerrit.k8s.operator.api.model.maintenance.GerritMaintenance;
 import io.fabric8.kubernetes.api.model.batch.v1.CronJob;
 import io.javaoperatorsdk.operator.ReconcilerUtils;
-import io.javaoperatorsdk.operator.processing.event.ResourceID;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -42,11 +41,10 @@
     for (String file : expectedOutputFiles) {
       expected.add(ReconcilerUtils.loadYaml(CronJob.class, this.getClass(), file));
     }
-    Map<ResourceID, CronJob> cronJobs =
-        new GerritMaintenanceCronJobs().desiredResources(input, null);
+    Map<String, CronJob> cronJobs = new GerritMaintenanceCronJobs().desiredResources(input, null);
 
     for (CronJob expectedCronJob : expected) {
-      assertThat(cronJobs.get(ResourceID.fromResource(expectedCronJob))).isEqualTo(expectedCronJob);
+      assertThat(cronJobs.get(expectedCronJob.getMetadata().getName())).isEqualTo(expectedCronJob);
     }
   }
 
diff --git a/operator/src/test/java/com/google/gerrit/k8s/operator/tasks/incomingrepl/dependent/IncomingReplicationTaskTest.java b/operator/src/test/java/com/google/gerrit/k8s/operator/tasks/incomingrepl/dependent/IncomingReplicationTaskTest.java
index ca7eee2..ec805ec 100644
--- a/operator/src/test/java/com/google/gerrit/k8s/operator/tasks/incomingrepl/dependent/IncomingReplicationTaskTest.java
+++ b/operator/src/test/java/com/google/gerrit/k8s/operator/tasks/incomingrepl/dependent/IncomingReplicationTaskTest.java
@@ -31,7 +31,6 @@
 import io.javaoperatorsdk.operator.api.reconciler.DefaultContext;
 import io.javaoperatorsdk.operator.api.reconciler.Reconciler;
 import io.javaoperatorsdk.operator.processing.Controller;
-import io.javaoperatorsdk.operator.processing.event.ResourceID;
 import io.javaoperatorsdk.operator.processing.retry.GenericRetry;
 import io.javaoperatorsdk.operator.processing.retry.GenericRetryExecution;
 import java.net.HttpURLConnection;
@@ -64,7 +63,7 @@
     IncomingReplicationTask incomingReplTask =
         new ClusterManagedIncomingReplicationTask()
             .desiredResources(input, null)
-            .get(ResourceID.fromResource(expectedReplTask));
+            .get(expectedReplTask.getMetadata().getName());
     assertThat(incomingReplTask).isEqualTo(expectedReplTask);
 
     Secret testSecret =
@@ -111,7 +110,7 @@
             kubernetesServer.createClient());
 
     return new DefaultContext<IncomingReplicationTask>(
-        new GenericRetryExecution(new GenericRetry()), controller, primary, false, false);
+        new GenericRetryExecution(new GenericRetry()), controller, primary);
   }
 
   private static Stream<Arguments> provideYamlManifests() {
