String getLockName(String namespace, String name) {
        return "lock::" + namespace + "::" + kind() + "::" + name;
    }
@Test
    /*
     * Verifies that the lock is released by a call to `releaseLockAndTimer`. 
     * The call is made through a chain of futures ending with `eventually` after a normal/successful execution of the `Callable`
     */
    void testWithLockCallableSuccessfulReleasesLock(VertxTestContext context) {
        var resourceOperator = new DefaultWatchableStatusedResourceOperator<>(vertx, null, "TestResource");
        @SuppressWarnings({ "unchecked", "rawtypes" })
        var target = new DefaultOperator(vertx, "Test", resourceOperator, new MicrometerMetricsProvider(BackendRegistries.getDefaultNow()), null);
        Reconciliation reconciliation = new Reconciliation("test", "TestResource", "my-namespace", "my-resource");
        String lockName = target.getLockName(reconciliation);

        Checkpoint callableSucceeded = context.checkpoint();
        Checkpoint lockObtained  = context.checkpoint();
        @SuppressWarnings("unchecked")
        Future<String> result = target.withLockTest(reconciliation, () -> Future.succeededFuture("OK"));
        Promise<Void> successHandlerCalled = Promise.promise();

        result.onComplete(context.succeeding(v -> context.verify(() -> {
            assertThat(v, is("OK"));
            successHandlerCalled.complete();
            callableSucceeded.flag();
        })));

        successHandlerCalled.future()
            .compose(v -> vertx.sharedData().getLockWithTimeout(lockName, 10000L))
            .onComplete(context.succeeding(lock -> context.verify(() -> {
                assertThat(lock, instanceOf(Lock.class));
                lock.release();
                lockObtained.flag();
            })));
    }