@Override
    protected Future<ReconcileResult<Service>> internalUpdate(Reconciliation reconciliation, String namespace, String name, Service current, Service desired) {
        try {
            if (current.getSpec() != null && desired.getSpec() != null) {
                if (("NodePort".equals(current.getSpec().getType()) && "NodePort".equals(desired.getSpec().getType()))
                        || ("LoadBalancer".equals(current.getSpec().getType()) && "LoadBalancer".equals(desired.getSpec().getType())))   {
                    patchNodePorts(current, desired);
                    patchHealthCheckPorts(current, desired);
                    patchAnnotations(current, desired);
                    patchLoadBalancerClass(current, desired);
                }

                patchDualStackNetworking(current, desired);
            }

            return super.internalUpdate(reconciliation, namespace, name, current, desired);
        } catch (Exception e) {
            LOGGER.errorCr(reconciliation, "Caught exception while patching {} {} in namespace {}", resourceKind, name, namespace, e);
            return Future.failedFuture(e);
        }
    }
@Test
    void testCattleAnnotationPatching() {
        KubernetesClient client = mock(KubernetesClient.class);

        Map<String, String> currentAnnotations = Map.of(
                "field.cattle.io~1publicEndpoints", "foo",
                "cattle.io/test", "bar",
                "some-other", "baz"
        );

        Service current = new ServiceBuilder()
                .withNewMetadata()
                    .withNamespace(NAMESPACE)
                    .withName(RESOURCE_NAME)
                    .withAnnotations(currentAnnotations)
                .endMetadata()
                .withNewSpec()
                    .withType("LoadBalancer")
                .endSpec()
                .build();

        Service desired = new ServiceBuilder()
                .withNewMetadata()
                    .withNamespace(NAMESPACE)
                    .withName(RESOURCE_NAME)
                .endMetadata()
                .withNewSpec()
                    .withType("LoadBalancer")
                .endSpec()
                .build();

        ServiceOperator op = new ServiceOperator(vertx, client);
        op.internalUpdate(Reconciliation.DUMMY_RECONCILIATION, NAMESPACE, RESOURCE_NAME, current, desired);

        assertThat(desired.getMetadata().getAnnotations().get("field.cattle.io~1publicEndpoints"), equalTo("foo"));
        assertThat(desired.getMetadata().getAnnotations().get("cattle.io/test"), equalTo("bar"));
        assertThat(desired.getMetadata().getAnnotations().containsKey("some-other"), is(false));
    }