couchbase 3.4.0 → 3.4.2

data/ext/couchbase/couchbase/subdoc/count.hxx

@@ -54,7 +54,9 @@ class count
     }
 
   private:
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
     friend couchbase::lookup_in_specs;
+#endif
 
     explicit count(std::string path)
       : path_(std::move(path))

data/ext/couchbase/couchbase/subdoc/counter.hxx

@@ -69,7 +69,9 @@ class counter
     }
 
   private:
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
     friend couchbase::mutate_in_specs;
+#endif
 
     counter(std::string path, std::int64_t value)
       : path_(std::move(path))

data/ext/couchbase/couchbase/subdoc/exists.hxx

@@ -54,7 +54,9 @@ class exists
     }
 
   private:
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
     friend couchbase::lookup_in_specs;
+#endif
 
     explicit exists(std::string path)
       : path_(std::move(path))

data/ext/couchbase/couchbase/subdoc/get.hxx

@@ -56,7 +56,9 @@ class get
     }
 
   private:
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
     friend couchbase::lookup_in_specs;
+#endif
 
     explicit get(std::string path)
       : path_(std::move(path))

data/ext/couchbase/couchbase/subdoc/insert.hxx

@@ -71,7 +71,9 @@ class insert
     }
 
   private:
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
     friend couchbase::mutate_in_specs;
+#endif
 
     insert(std::string path, std::vector<std::byte> value)
       : path_(std::move(path))

data/ext/couchbase/couchbase/subdoc/remove.hxx

@@ -54,7 +54,9 @@ class remove
     }
 
   private:
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
     friend couchbase::mutate_in_specs;
+#endif
 
     explicit remove(std::string path)
       : path_(std::move(path))

data/ext/couchbase/couchbase/subdoc/replace.hxx

@@ -56,7 +56,9 @@ class replace
     }
 
   private:
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
     friend couchbase::mutate_in_specs;
+#endif
 
     replace(std::string path, std::vector<std::byte> value)
       : path_(std::move(path))
@@ -86,4 +88,4 @@ class replace
     bool expand_macro_{ false };
 };
 } // namespace subdoc
-} // namespace couchbase
+} // namespace couchbase

data/ext/couchbase/couchbase/subdoc/upsert.hxx

@@ -71,7 +71,9 @@ class upsert
     }
 
   private:
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
     friend couchbase::mutate_in_specs;
+#endif
 
     upsert(std::string path, std::vector<std::byte> value)
       : path_(std::move(path))

data/ext/couchbase/couchbase/transaction_op_error_context.hxx

@@ -46,13 +46,13 @@ class transaction_op_error_context
     }
 
     /**
-     * The error_code associated with this error context.   This will always be a @ref transaction_op_error_code
+     * The error_code associated with this error context.
      *
      * Note that some query errors are not _transaction_ errors, so this error code will be 0, but there will be
-     * a @ref transaction_op_error_code#cause() with a query_error_context in it.  These errors do not rollback a
+     * a @ref cause() with a @ref query_error_context in it.  These errors do not rollback a
      * transaction.   If you want to roll it back, raise an exception.
      *
-     * @return a transaction_op_error_code, if any.
+     * @return a error code, if any.
      */
     [[nodiscard]] std::error_code ec() const
     {
@@ -60,7 +60,7 @@ class transaction_op_error_context
     }
 
     /**
-     * The underlying cause of this error.   This can be either a @ref key_value_error_code or a @ref query_error_context.
+     * The underlying cause of this error.   This can be either a @ref key_value_error_context or a @ref query_error_context.
      *
      * @return the error_context associated with the underlying cause of this error.
      */

data/ext/couchbase/couchbase/transactions/attempt_context.hxx

@@ -33,7 +33,7 @@ class attempt_context
                                                                            const Content& content)
     {
         if constexpr (std::is_same_v<Content, std::vector<std::byte>>) {
-            return insert_raw(content, id, content);
+            return insert_raw(coll, id, content);
         } else {
             return insert_raw(coll, id, codec::tao_json_serializer::serialize(content));
         }

data/ext/couchbase/couchbase/transactions/transaction_get_result.hxx

@@ -24,36 +24,31 @@
 #include <couchbase/result.hxx>
 #include <couchbase/transaction_op_error_context.hxx>
 
+// forward declarations...
+namespace couchbase::core::transactions
+{
+class transaction_get_result;
+class transaction_links;
+class document_metadata;
+} // namespace couchbase::core::transactions
+
 namespace couchbase::transactions
 {
 
-class transaction_get_result : public result
+class transaction_get_result
 {
-  protected:
-    std::string bucket_{};
-    std::string scope_{};
-    std::string collection_{};
-    std::string key_{};
-    std::vector<std::byte> content_{};
+    friend class couchbase::core::transactions::transaction_get_result;
 
-  public:
-    transaction_get_result() = default;
-
-    transaction_get_result(std::string bucket,
-                           std::string scope,
-                           std::string collection,
-                           std::string key,
-                           couchbase::cas cas,
-                           std::vector<std::byte> content)
-      : result(cas)
-      , bucket_(std::move(bucket))
-      , scope_(std::move(scope))
-      , collection_(std::move(collection))
-      , key_(std::move(key))
-      , content_(std::move(content))
+  private:
+    std::shared_ptr<couchbase::core::transactions::transaction_get_result> base_{};
+
+    transaction_get_result(std::shared_ptr<couchbase::core::transactions::transaction_get_result> base)
+      : base_(base)
     {
     }
 
+  public:
+    transaction_get_result();
     /**
      * Content of the document.
      *
@@ -62,7 +57,7 @@ class transaction_get_result : public result
     template<typename Content>
     [[nodiscard]] Content content() const
     {
-        return codec::tao_json_serializer::deserialize<Content>(content_);
+        return codec::tao_json_serializer::deserialize<Content>(content());
     }
 
     /**
@@ -70,64 +65,54 @@ class transaction_get_result : public result
      *
      * @return content
      */
-    [[nodiscard]] const std::vector<std::byte>& content() const
-    {
-        return content_;
-    }
+    [[nodiscard]] const std::vector<std::byte>& content() const;
+
     /**
      * Copy content into document
      * @param content
      */
-    void content(std::vector<std::byte> content)
-    {
-        content_ = std::move(content);
-    }
+    void content(std::vector<std::byte> content);
+
     /**
      * Move content into document
      *
      * @param content
      */
-    void content(std::vector<std::byte>&& content)
-    {
-        content_ = std::move(content);
-    }
+    void content(std::vector<std::byte>&& content);
 
     /**
      * Get document id.
      *
      * @return the id of this document.
      */
-    [[nodiscard]] const std::string key() const
-    {
-        return key_;
-    }
+    [[nodiscard]] const std::string key() const;
 
     /**
      * Get the name of the bucket this document is in.
      *
      * @return name of the bucket which contains the document.
      */
-    [[nodiscard]] const std::string bucket() const
-    {
-        return bucket_;
-    }
+    [[nodiscard]] const std::string bucket() const;
+
     /**
      * Get the name of the scope this document is in.
      *
      * @return name of the scope which contains the document.
      */
-    [[nodiscard]] const std::string scope() const
-    {
-        return scope_;
-    }
+    [[nodiscard]] const std::string scope() const;
+
     /**
      * Get the name of the collection this document is in.
      *
      * @return name of the collection which contains the document.
      */
-    [[nodiscard]] const std::string collection() const
-    {
-        return collection_;
-    }
+    [[nodiscard]] const std::string collection() const;
+
+    /**
+     * Get the CAS fot this document
+     *
+     * @return the CAS of the document.
+     */
+    [[nodiscard]] const couchbase::cas cas() const;
 };
 } // namespace couchbase::transactions

data/ext/couchbase/couchbase/transactions/transactions_config.hxx

@@ -115,7 +115,7 @@ class transactions_config
     /**
      * @brief Set the expiration time for transactions.
      *
-     * @param duration desired expiration for transactions. see @expiration_time().
+     * @param duration desired expiration for transactions. see @ref expiration_time().
      * @return reference to this, so calls can be chained.
      */
     template<typename T>

data/ext/couchbase/test/CMakeLists.txt

@@ -16,6 +16,7 @@ integration_test(tracer)
 integration_test(meter)
 integration_test(transcoders)
 integration_test(range_scan)
+integration_test(search)
 
 unit_test(connection_string)
 unit_test(utils)
@@ -28,8 +29,6 @@ target_link_libraries(test_unit_jsonsl jsonsl)
 
 integration_benchmark(get)
 
-add_subdirectory(tools)
-
 transaction_test(transaction_context)
 transaction_test(transaction_simple)
 transaction_test(transaction_simple_async)
@@ -39,3 +38,5 @@ transaction_test(transaction_public_async_api)
 unit_test(transaction_logging)
 unit_test(transaction_utils)
 unit_test(waitable_op_list)
+
+integration_test(examples)

data/ext/couchbase/test/test_helper.hxx

@@ -21,7 +21,7 @@
 
 #include "utils/binary.hxx"
 #include "utils/test_context.hxx"
-#include "utils/uniq_id.hxx"
+#include "utils/test_data.hxx"
 
 #include <catch2/catch.hpp>
 

data/ext/couchbase/test/test_integration_analytics.cxx

@@ -17,7 +17,7 @@
 
 #include "core/operations/management/analytics.hxx"
 #include "core/operations/management/collection_create.hxx"
-#include "core/operations/management/scope_create.hxx"
+#include "core/operations/management/collections.hxx"
 #include "test_helper_integration.hxx"
 
 TEST_CASE("integration: analytics query")
@@ -78,7 +78,7 @@ TEST_CASE("integration: analytics query")
         REQUIRE(test::utils::wait_until([&]() {
             couchbase::core::operations::analytics_request req{};
             req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = ?)", dataset_name);
-            req.positional_parameters.emplace_back(couchbase::core::json_string(couchbase::core::utils::json::generate(test_value)));
+            req.positional_parameters.emplace_back(couchbase::core::utils::json::generate(test_value));
             resp = test::utils::execute(integration.cluster, req);
             return resp.rows.size() == 1;
         }));
@@ -130,10 +130,30 @@ TEST_CASE("integration: analytics query")
 
     SECTION("consistency")
     {
-        couchbase::core::operations::analytics_request req{};
-        req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
-        req.scan_consistency = couchbase::core::analytics_scan_consistency::request_plus;
-        auto resp = test::utils::execute(integration.cluster, req);
+        couchbase::core::operations::analytics_response resp{};
+        CHECK(test::utils::wait_until([&]() {
+            /*
+             * In consistency test, always do fresh mutation
+             */
+            test_value = test::utils::uniq_id("value");
+            value = couchbase::core::utils::json::generate({ { "testkey", test_value } });
+            {
+                auto id = couchbase::core::document_id(integration.ctx.bucket, "_default", "_default", key);
+                couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary(value) };
+                REQUIRE_SUCCESS(test::utils::execute(integration.cluster, req).ctx.ec());
+            }
+
+            couchbase::core::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
+            req.scan_consistency = couchbase::core::analytics_scan_consistency::request_plus;
+            resp = test::utils::execute(integration.cluster, req);
+            /* Analytics might give us code 23027, ignore it here
+             *
+             * "errors": [{"code": 23027, "msg": "Bucket default on link Default.Local is not connected"} ],
+             */
+            return resp.ctx.first_error_code != 23027;
+        }));
+
         REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows.size() == 1);
         REQUIRE(resp.rows[0] == value);
@@ -185,13 +205,15 @@ TEST_CASE("integration: analytics scope query")
         REQUIRE(created);
     }
 
-    {
-        couchbase::core::operations::analytics_request req{};
-        req.statement =
-          fmt::format("ALTER COLLECTION `{}`.`{}`.`{}` ENABLE ANALYTICS", integration.ctx.bucket, scope_name, collection_name);
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_SUCCESS(resp.ctx.ec);
-    }
+    CHECK(test::utils::wait_until(
+      [&]() {
+          couchbase::core::operations::analytics_request req{};
+          req.statement =
+            fmt::format("ALTER COLLECTION `{}`.`{}`.`{}` ENABLE ANALYTICS", integration.ctx.bucket, scope_name, collection_name);
+          auto resp = test::utils::execute(integration.cluster, req);
+          return !resp.ctx.ec;
+      },
+      std::chrono::minutes{ 5 }));
 
     auto key = test::utils::uniq_id("key");
     auto test_value = test::utils::uniq_id("value");
@@ -259,3 +281,257 @@ TEST_CASE("unit: analytics query")
         REQUIRE(http_req.headers.find("analytics-priority") == http_req.headers.end());
     }
 }
+
+TEST_CASE("integration: public API analytics query")
+{
+    test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_analytics()) {
+        return;
+    }
+
+    auto cluster = couchbase::cluster(integration.cluster);
+    auto bucket = cluster.bucket(integration.ctx.bucket);
+    auto collection = bucket.default_collection();
+
+    auto dataset_name = test::utils::uniq_id("dataset");
+
+    {
+        couchbase::core::operations::management::analytics_dataset_create_request req{};
+        req.dataset_name = dataset_name;
+        req.bucket_name = integration.ctx.bucket;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+    }
+
+    {
+        couchbase::core::operations::management::analytics_link_connect_request req{};
+        req.force = true;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+    }
+
+    auto key = test::utils::uniq_id("key");
+    auto test_value = test::utils::uniq_id("value");
+    tao::json::value document = {
+        { "testkey", test_value },
+    };
+    {
+        auto [ctx, resp] = collection.upsert(key, document).get();
+        REQUIRE_SUCCESS(ctx.ec());
+    }
+
+    SECTION("simple query")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) =
+              cluster.analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value))
+                .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        REQUIRE_FALSE(resp.meta_data().request_id().empty());
+        REQUIRE_FALSE(resp.meta_data().client_context_id().empty());
+        REQUIRE(resp.meta_data().status() == couchbase::analytics_status::success);
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("positional params")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) = cluster
+                                    .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = ?)", dataset_name),
+                                                     couchbase::analytics_options{}.positional_parameters(test_value))
+                                    .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("named params")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) =
+              cluster
+                .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name),
+                                 couchbase::analytics_options{}.named_parameters(std::pair{ "testkey", test_value }))
+                .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("named params preformatted")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) =
+              cluster
+                .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name),
+                                 couchbase::analytics_options{}.encoded_named_parameters(
+                                   { { "testkey", couchbase::core::utils::json::generate_binary(test_value) } }))
+                .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("raw")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) =
+              cluster
+                .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name),
+                                 couchbase::analytics_options{}.raw("$testkey", test_value))
+                .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("consistency")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            /*
+             * In consistency test, always do fresh mutation
+             */
+            test_value = test::utils::uniq_id("value");
+            document = {
+                { "testkey", test_value },
+            };
+            {
+                auto [ctx2, _] = collection.upsert(key, document).get();
+                REQUIRE_SUCCESS(ctx2.ec());
+            }
+
+            std::tie(ctx, resp) =
+              cluster
+                .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value),
+                                 couchbase::analytics_options{}.scan_consistency(couchbase::analytics_scan_consistency::request_plus))
+                .get();
+            /* Analytics might give us code 23027, ignore it here
+             *
+             * "errors": [{"code": 23027, "msg": "Bucket default on link Default.Local is not connected"} ],
+             */
+            return ctx.first_error_code() != 23027;
+        }));
+
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("readonly")
+    {
+        auto [ctx, resp] =
+          cluster.analytics_query(fmt::format("DROP DATASET Default.`{}`", dataset_name), couchbase::analytics_options{}.readonly(true))
+            .get();
+
+        REQUIRE(ctx.ec() == couchbase::errc::common::internal_server_failure);
+        REQUIRE(resp.meta_data().status() == couchbase::analytics_status::fatal);
+    }
+
+    {
+        couchbase::core::operations::management::analytics_dataset_drop_request req{};
+        req.dataset_name = dataset_name;
+        test::utils::execute(integration.cluster, req);
+    }
+}
+
+TEST_CASE("integration: public API analytics scope query")
+{
+    test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_analytics() || !integration.cluster_version().supports_collections()) {
+        return;
+    }
+
+    auto cluster = couchbase::cluster(integration.cluster);
+    auto bucket = cluster.bucket(integration.ctx.bucket);
+
+    auto scope_name = test::utils::uniq_id("scope");
+    auto collection_name = test::utils::uniq_id("collection");
+
+    {
+        const couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
+    }
+
+    {
+        const couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
+    }
+
+    CHECK(test::utils::wait_until(
+      [&]() {
+          auto [ctx, resp] = cluster
+                               .analytics_query(fmt::format(
+                                 "ALTER COLLECTION `{}`.`{}`.`{}` ENABLE ANALYTICS", integration.ctx.bucket, scope_name, collection_name))
+                               .get();
+          return !ctx.ec();
+      },
+      std::chrono::minutes{ 5 }));
+
+    auto scope = bucket.scope(scope_name);
+    auto collection = scope.collection(collection_name);
+
+    auto key = test::utils::uniq_id("key");
+    auto test_value = test::utils::uniq_id("value");
+    const tao::json::value document = {
+        { "testkey", test_value },
+    };
+    {
+        auto [ctx, resp] = collection.upsert(key, document).get();
+        REQUIRE_SUCCESS(ctx.ec());
+    }
+
+    couchbase::analytics_result resp{};
+    couchbase::analytics_error_context ctx{};
+    CHECK(test::utils::wait_until([&]() {
+        std::tie(ctx, resp) =
+          scope.analytics_query(fmt::format(R"(SELECT testkey FROM `{}` WHERE testkey = "{}")", collection_name, test_value)).get();
+        return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+    }));
+    REQUIRE_SUCCESS(ctx.ec());
+    REQUIRE(resp.rows_as_json()[0] == document);
+    REQUIRE_FALSE(resp.meta_data().request_id().empty());
+    REQUIRE_FALSE(resp.meta_data().client_context_id().empty());
+    REQUIRE(resp.meta_data().status() == couchbase::analytics_status::success);
+
+    {
+        const couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        test::utils::execute(integration.cluster, req);
+    }
+}

data/ext/couchbase/test/test_integration_crud.cxx

@@ -228,6 +228,9 @@ TEST_CASE("integration: pessimistic locking", "[integration]")
     {
         couchbase::core::operations::get_and_lock_request req{ id };
         req.lock_time = lock_time;
+        if (integration.ctx.deployment == test::utils::deployment_type::capella) {
+            req.timeout = std::chrono::seconds{ 2 };
+        }
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec() == couchbase::errc::common::ambiguous_timeout);
         REQUIRE(resp.ctx.retried_because_of(couchbase::retry_reason::key_value_locked));
@@ -810,7 +813,11 @@ TEST_CASE("integration: pessimistic locking with public API", "[integration]")
 
     // it is not allowed to lock the same key twice
     {
-        auto [ctx, resp] = collection.get_and_lock(id, lock_time, {}).get();
+        couchbase::get_and_lock_options options{};
+        if (integration.ctx.deployment == test::utils::deployment_type::capella) {
+            options.timeout(std::chrono::seconds{ 2 });
+        }
+        auto [ctx, resp] = collection.get_and_lock(id, lock_time, options).get();
         REQUIRE(ctx.ec() == couchbase::errc::common::ambiguous_timeout);
         REQUIRE(ctx.retried_because_of(couchbase::retry_reason::key_value_locked));
     }