public Future<Void> singlePodDeploymentRollingUpdate(Reconciliation reconciliation, String namespace, String name, long operationTimeoutMs) {
        return podOperations.listAsync(namespace, Labels.EMPTY.withStrimziName(name))
                .compose(pods -> {
                    if (pods != null && !pods.isEmpty())    {
                        return podOperations.deleteAsync(reconciliation, namespace, pods.get(0).getMetadata().getName(), true);
                    } else {
                        LOGGER.warnCr(reconciliation, "No Pods were found for Deployment {} in namespace {}", name, namespace);
                        // We return success as there is nothing to roll
                        return Future.succeededFuture();
                    }
                })
                .compose(ignored -> readiness(reconciliation, namespace, name, 1_000, operationTimeoutMs));
    }
@SuppressWarnings({"unchecked", "rawtypes"})
    @Test
    public void testSinglePodDeploymentRollingUpdateWithMissingPod(VertxTestContext context)  {
        String depName = "my-dep";
        String podName = depName + "-123456";

        // Mock Pod handling
        KubernetesResourceList mockPodResourceList = mock(KubernetesResourceList.class);
        when(mockPodResourceList.getItems()).thenReturn(List.of());

        Resource mockPodResource = mock(Resource.class);

        NonNamespaceOperation mockPodNonNamespaceOp = mock(NonNamespaceOperation.class);
        when(mockPodNonNamespaceOp.list(any())).thenReturn(mockPodResourceList);
        when(mockPodNonNamespaceOp.withLabels(any())).thenReturn(mockPodNonNamespaceOp);
        when(mockPodNonNamespaceOp.withName(eq(podName))).thenReturn(mockPodResource);

        MixedOperation mockPods = mock(MixedOperation.class);
        when(mockPods.inNamespace(eq(NAMESPACE))).thenReturn(mockPodNonNamespaceOp);

        // Mock Deployment handling
        Resource mockDeploymentResource = mock(resourceType());
        when(mockDeploymentResource.get()).thenReturn(new Deployment());
        when(mockDeploymentResource.isReady()).thenReturn(true);

        NonNamespaceOperation mockDeploymentNonNamespaceOp = mock(NonNamespaceOperation.class);
        when(mockDeploymentNonNamespaceOp.withName(eq(depName))).thenReturn(mockDeploymentResource);

        MixedOperation mockDeployments = mock(MixedOperation.class);
        when(mockDeployments.inNamespace(eq(NAMESPACE))).thenReturn(mockDeploymentNonNamespaceOp);

        AppsAPIGroupDSL mockApps = mock(AppsAPIGroupDSL.class);
        when(mockApps.deployments()).thenReturn(mockDeployments);

        // Mock Kube Client
        KubernetesClient mockClient = mock(KubernetesClient.class);
        when(mockClient.pods()).thenReturn(mockPods);
        when(mockClient.apps()).thenReturn(mockApps);

        DeploymentOperator op = new DeploymentOperator(vertx, mockClient);

        Checkpoint async = context.checkpoint();
        op.singlePodDeploymentRollingUpdate(Reconciliation.DUMMY_RECONCILIATION, NAMESPACE, depName, 5_000)
                .onComplete(context.succeeding(v -> {

                    verify(mockPodResource, never()).delete();

                    async.flag();
                }));
    }