couchbase 3.4.2 → 3.4.3

data/ext/couchbase/test/test_integration_collections.cxx

@@ -25,7 +25,7 @@ TEST_CASE("integration: missing scope and collection", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     SECTION("get missing scope")
@@ -77,7 +77,7 @@ TEST_CASE("integration: get and insert non default scope and collection", "[inte
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     auto scope_name = test::utils::uniq_id("scope");
@@ -121,7 +121,7 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     auto scope_name = test::utils::uniq_id("scope");
@@ -166,6 +166,10 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
         REQUIRE(dropped);
     }
 
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES does not generate error when inserting into dropped collection. See "
+             "https://github.com/couchbaselabs/gocaves/issues/108");
+    }
     {
         couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);

data/ext/couchbase/test/test_integration_connect.cxx

@@ -42,9 +42,9 @@ TEST_CASE("integration: connecting with unresponsive first node in bootstrap nod
     test::utils::init_logger();
     asio::io_context io{};
     auto ctx = test::utils::test_context::load_from_environment();
-    if (ctx.deployment == test::utils::deployment_type::capella) {
+    if (ctx.deployment == test::utils::deployment_type::capella || ctx.deployment == test::utils::deployment_type::elixir) {
         // This breaks SRV assumptions (only one host in connection string)
-        return;
+        SKIP("capella deployment uses single host in the connection string, which assumed to be reachable");
     }
     auto connstr = couchbase::core::utils::parse_connection_string(ctx.connection_string);
     REQUIRE_FALSE(connstr.bootstrap_nodes.empty());
@@ -125,6 +125,10 @@ TEST_CASE("integration: destroy cluster without waiting for close completion", "
     test::utils::init_logger();
     auto ctx = test::utils::test_context::load_from_environment();
 
+    if (ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("elixir deployment is incompatible with parts of this test, but it is probably bug in SDK. FIXME");
+    }
+
     asio::io_context io{};
 
     auto cluster = couchbase::core::cluster::create(io);
@@ -143,7 +147,7 @@ TEST_CASE("integration: destroy cluster without waiting for close completion", "
     }
 
     // hit Query
-    {
+    if (ctx.version.supports_query()) {
         couchbase::core::operations::query_request req{ R"(SELECT 42 AS the_answer)" };
         auto resp = test::utils::execute(cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec);

data/ext/couchbase/test/test_integration_crud.cxx

@@ -35,6 +35,10 @@ TEST_CASE("integration: switching off mutation token", "[integration]")
     opts.enable_mutation_tokens = false;
     test::utils::integration_test_guard integration(opts);
 
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES does not allow to switching off mutation tokens. See https://github.com/couchbaselabs/gocaves/issues/100");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
 
@@ -228,7 +232,8 @@ 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) {
+        if (integration.ctx.deployment == test::utils::deployment_type::capella ||
+            integration.ctx.deployment == test::utils::deployment_type::elixir) {
             req.timeout = std::chrono::seconds{ 2 };
         }
         auto resp = test::utils::execute(integration.cluster, req);
@@ -489,7 +494,7 @@ TEST_CASE("integration: upsert preserve expiry", "[integration]")
     test::utils::integration_test_guard integration;
 
     if (!integration.cluster_version().supports_preserve_expiry()) {
-        return;
+        SKIP("cluster does not support preserve expiry");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -670,6 +675,10 @@ TEST_CASE("integration: open bucket that does not exist", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES returns not_found (0x01) instead of no_access (0x24). See https://github.com/couchbaselabs/gocaves/issues/102");
+    }
+
     auto bucket_name = test::utils::uniq_id("missing_bucket");
 
     auto barrier = std::make_shared<std::promise<std::error_code>>();
@@ -814,7 +823,8 @@ TEST_CASE("integration: pessimistic locking with public API", "[integration]")
     // it is not allowed to lock the same key twice
     {
         couchbase::get_and_lock_options options{};
-        if (integration.ctx.deployment == test::utils::deployment_type::capella) {
+        if (integration.ctx.deployment == test::utils::deployment_type::capella ||
+            integration.ctx.deployment == test::utils::deployment_type::elixir) {
             options.timeout(std::chrono::seconds{ 2 });
         }
         auto [ctx, resp] = collection.get_and_lock(id, lock_time, options).get();

data/ext/couchbase/test/test_integration_diagnostics.cxx

@@ -321,14 +321,18 @@ TEST_CASE("integration: fetch diagnostics after N1QL query", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query() || integration.ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("cluster does not support query or cluster level query");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     {
         couchbase::core::operations::query_request req{ "SELECT 'hello, couchbase' AS greetings" };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec);
-        INFO("rows.size() =" << resp.rows.size())
+        INFO("rows.size() =" << resp.rows.size());
         REQUIRE(resp.rows.size() == 1);
-        INFO("row=" << resp.rows[0])
+        INFO("row=" << resp.rows[0]);
         REQUIRE(resp.rows[0] == R"({"greetings":"hello, couchbase"})");
     }
     {
@@ -365,8 +369,10 @@ TEST_CASE("integration: ping", "[integration]")
         REQUIRE(res.services.count(couchbase::core::service_type::management) > 0);
         REQUIRE(res.services[couchbase::core::service_type::management].size() > 0);
 
-        REQUIRE(res.services.count(couchbase::core::service_type::view) > 0);
-        REQUIRE(res.services[couchbase::core::service_type::view].size() > 0);
+        if (integration.ctx.deployment != test::utils::deployment_type::elixir) {
+            REQUIRE(res.services.count(couchbase::core::service_type::view) > 0);
+            REQUIRE(res.services[couchbase::core::service_type::view].size() > 0);
+        }
 
         REQUIRE(res.services.count(couchbase::core::service_type::query) > 0);
         REQUIRE(res.services[couchbase::core::service_type::query].size() > 0);
@@ -385,7 +391,7 @@ TEST_CASE("integration: ping", "[integration]")
         }
 
         REQUIRE(res.id == "my_report_id");
-        INFO(res.sdk)
+        INFO(res.sdk);
         REQUIRE(res.sdk.find("cxx/") == 0);
     }
 }

data/ext/couchbase/test/test_integration_durability.cxx

@@ -25,7 +25,7 @@ TEST_CASE("integration: durable operations", "[integration]")
 {
     test::utils::integration_test_guard integration;
     if (!integration.cluster_version().supports_enhanced_durability()) {
-        return;
+        SKIP("cluster does not support enhanced durability");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -68,7 +68,7 @@ TEST_CASE("integration: durable operations", "[integration]")
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.value == couchbase::core::utils::to_binary(R"({"foo":"bar","baz":42})"));
+        REQUIRE(couchbase::core::utils::json::parse_binary(resp.value) == couchbase::core::utils::json::parse(R"({"foo":"bar","baz":42})"));
     }
     {
         couchbase::core::operations::remove_request req{ id };
@@ -83,8 +83,13 @@ TEST_CASE("integration: durable operations", "[integration]")
 TEST_CASE("integration: legacy durability persist to active and replicate to one", "[integration]")
 {
     test::utils::integration_test_guard integration;
-    if (integration.number_of_replicas() == 0 || integration.number_of_nodes() <= integration.number_of_replicas()) {
-        return;
+    if (integration.number_of_replicas() == 0) {
+        SKIP("bucket has zero replicas");
+    }
+    if (integration.number_of_nodes() <= integration.number_of_replicas()) {
+        SKIP(fmt::format("number of nodes ({}) is less or equal to number of replicas ({})",
+                         integration.number_of_nodes(),
+                         integration.number_of_replicas()));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -124,7 +129,7 @@ TEST_CASE("integration: low level legacy durability impossible if number of node
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (integration.number_of_replicas() == 3) {
-        return;
+        SKIP("bucket has three replicas configured, so the test will not be applicable");
     }
 
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
@@ -159,7 +164,7 @@ TEST_CASE("integration: low level legacy durability persist to active and replic
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (integration.number_of_replicas() < 1) {
-        return;
+        SKIP("bucket does not have replicas configured");
     }
 
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
@@ -211,7 +216,7 @@ TEST_CASE("integration: low level legacy durability persist to active and replic
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.value == couchbase::core::utils::to_binary(R"({"foo":"bar","baz":42})"));
+        REQUIRE(couchbase::core::utils::json::parse_binary(resp.value) == couchbase::core::utils::json::parse(R"({"foo":"bar","baz":42})"));
     }
     {
         couchbase::core::operations::remove_request_with_legacy_durability req{

data/ext/couchbase/test/test_integration_examples.cxx

@@ -21,9 +21,14 @@
 #include "core/operations/management/query_index_create.hxx"
 #include "core/operations/management/query_index_get_all.hxx"
 
+#include <couchbase/boolean_query.hxx>
 #include <couchbase/cluster.hxx>
 #include <couchbase/fmt/cas.hxx>
 #include <couchbase/fmt/mutation_token.hxx>
+#include <couchbase/match_query.hxx>
+#include <couchbase/numeric_range_query.hxx>
+#include <couchbase/query_string_query.hxx>
+#include <couchbase/term_facet.hxx>
 
 #include <tao/json.hpp>
 
@@ -44,9 +49,9 @@ main(int argc, const char* argv[])
         return 1;
     }
 
-    std::string connection_string{ argv[1] };
-    std::string username{ argv[2] };
-    std::string password{ argv[3] };
+    std::string connection_string{ argv[1] }; // "couchbase://127.0.0.1"
+    std::string username{ argv[2] };          // "Administrator"
+    std::string password{ argv[3] };          // "password"
     std::string bucket_name{ "travel-sample" };
 
     // run IO context on separate thread
@@ -59,6 +64,7 @@ main(int argc, const char* argv[])
     // For example, optimize timeouts for WAN
     options.apply_profile("wan_development");
 
+    // [1] connect to cluster using the given connection string and the options
     auto [cluster, ec] = couchbase::cluster::connect(io, connection_string, options).get();
     if (ec) {
         fmt::print("unable to connect to the cluster: {}\n", ec.message());
@@ -72,8 +78,7 @@ main(int argc, const char* argv[])
     auto scope = bucket.scope("tenant_agent_00");
     auto collection = scope.collection("users");
 
-    {
-        // upsert document
+    { // [2] upsert document
         auto [ctx, upsert_result] = collection.upsert("my-document", tao::json::value{ { "name", "mike" } }).get();
         if (ctx.ec()) {
             fmt::print("unable to upsert the document \"{}\": {}\n", ctx.id(), ctx.ec().message());
@@ -82,8 +87,7 @@ main(int argc, const char* argv[])
         fmt::print("saved document \"{}\", cas={}, token={}\n", ctx.id(), upsert_result.cas(), upsert_result.mutation_token().value());
     }
 
-    {
-        // get document
+    { // [3] get document
         auto [ctx, get_result] = collection.get("my-document").get();
         if (ctx.ec()) {
             fmt::print("unable to get the document \"{}\": {}\n", ctx.id(), ctx.ec().message());
@@ -93,8 +97,7 @@ main(int argc, const char* argv[])
         fmt::print("retrieved document \"{}\", name=\"{}\"\n", ctx.id(), name);
     }
 
-    {
-        // N1QL query
+    { // [4] N1QL query
         auto inventory_scope = bucket.scope("inventory");
         auto [ctx, query_result] = inventory_scope.query("SELECT * FROM airline WHERE id = 10").get();
         if (ctx.ec()) {
@@ -106,7 +109,7 @@ main(int argc, const char* argv[])
         }
     }
 
-    // close cluster connection
+    // [5] close cluster connection
     cluster.close();
     guard.reset();
 
@@ -130,7 +133,10 @@ TEST_CASE("example: start using", "[integration]")
 {
     test::utils::integration_test_guard integration;
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
+    }
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES cannot load travel-sample bucket. See https://github.com/couchbaselabs/gocaves/issues/101");
     }
 
     {
@@ -180,3 +186,269 @@ TEST_CASE("example: start using", "[integration]")
 
     REQUIRE(start_using::main(4, argv) == 0);
 }
+
+namespace example_search
+{
+//! [example-search]
+#include <couchbase/cluster.hxx>
+
+#include <couchbase/boolean_query.hxx>
+#include <couchbase/match_query.hxx>
+#include <couchbase/numeric_range_query.hxx>
+#include <couchbase/query_string_query.hxx>
+
+#include <couchbase/fmt/cas.hxx>
+#include <couchbase/fmt/mutation_token.hxx>
+
+#include <tao/json.hpp>
+
+int
+main(int argc, const char* argv[])
+{
+    if (argc != 4) {
+        fmt::print("USAGE: ./example_search couchbase://127.0.0.1 Administrator password\n");
+        return 1;
+    }
+
+    std::string connection_string{ argv[1] }; // "couchbase://127.0.0.1"
+    std::string username{ argv[2] };          // "Administrator"
+    std::string password{ argv[3] };          // "password"
+    std::string bucket_name{ "travel-sample" };
+
+    // run IO context on separate thread
+    asio::io_context io;
+    auto guard = asio::make_work_guard(io);
+    std::thread io_thread([&io]() { io.run(); });
+
+    auto options = couchbase::cluster_options(username, password);
+    // customize through the 'options'.
+    // For example, optimize timeouts for WAN
+    options.apply_profile("wan_development");
+
+    auto [cluster, ec] = couchbase::cluster::connect(io, connection_string, options).get();
+    if (ec) {
+        fmt::print("unable to connect to the cluster: {}\n", ec.message());
+        return 1;
+    }
+
+    {
+        fmt::print("--- simple query\n");
+        auto [ctx, result] = cluster.search_query("travel-sample-index", couchbase::query_string_query("nice bar")).get();
+
+        if (ctx.ec()) {
+            fmt::print("unable to perform search query: {}, ({}, {})\n", ctx.ec().message(), ctx.status(), ctx.error());
+            return 1;
+        }
+        fmt::print("{} hits, total: {}\n", result.rows().size(), result.meta_data().metrics().total_rows());
+        for (const auto& row : result.rows()) {
+            fmt::print("id: {}, score: {}\n", row.id(), row.score());
+        }
+    }
+
+    {
+        fmt::print("--- simple query with fields\n");
+        auto [ctx, result] = cluster
+                               .search_query("travel-sample-index",
+                                             couchbase::query_string_query("nice bar"),
+                                             couchbase::search_options{}.fields({ "description" }))
+                               .get();
+
+        if (ctx.ec()) {
+            fmt::print("unable to perform search query: {}, ({}, {})\n", ctx.ec().message(), ctx.status(), ctx.error());
+            return 1;
+        }
+        fmt::print("{} hits, total: {}\n", result.rows().size(), result.meta_data().metrics().total_rows());
+        for (const auto& row : result.rows()) {
+            auto fields = row.fields_as<couchbase::codec::tao_json_serializer>();
+            fmt::print("id: {}, score: {}, description: {}\n", row.id(), row.score(), fields["description"].as<std::string>());
+        }
+    }
+
+    {
+        fmt::print("--- simple query with limit\n");
+        auto [ctx, result] =
+          cluster
+            .search_query("travel-sample-index", couchbase::query_string_query("nice bar"), couchbase::search_options{}.skip(3).limit(4))
+            .get();
+
+        if (ctx.ec()) {
+            fmt::print("unable to perform search query: {}, ({}, {})\n", ctx.ec().message(), ctx.status(), ctx.error());
+            return 1;
+        }
+        fmt::print("{} hits, total: {}\n", result.rows().size(), result.meta_data().metrics().total_rows());
+        for (const auto& row : result.rows()) {
+            fmt::print("id: {}, score: {}\n", row.id(), row.score());
+        }
+    }
+
+    {
+        fmt::print("--- simple query with highlight\n");
+        auto [ctx, result] =
+          cluster
+            .search_query("travel-sample-index",
+                          couchbase::query_string_query("nice bar"),
+                          couchbase::search_options{}.highlight(couchbase::highlight_style::html, { "description", "title" }))
+            .get();
+
+        if (ctx.ec()) {
+            fmt::print("unable to perform search query: {}, ({}, {})\n", ctx.ec().message(), ctx.status(), ctx.error());
+            return 1;
+        }
+        fmt::print("{} hits, total: {}\n", result.rows().size(), result.meta_data().metrics().total_rows());
+        for (const auto& row : result.rows()) {
+            fmt::print("id: {}, score: {}\n", row.id(), row.score());
+            for (const auto& [field, fragments] : row.fragments()) {
+                fmt::print("- {}:\n", field);
+                for (const auto& fragment : fragments) {
+                    fmt::print("-- {}\n", fragment);
+                }
+            }
+        }
+    }
+
+    {
+        fmt::print("--- simple query with collections\n");
+        auto [ctx, result] = cluster
+                               .search_query("travel-sample-index",
+                                             couchbase::query_string_query("west"),
+                                             couchbase::search_options{}.collections({ "airline" }))
+                               .get();
+
+        if (ctx.ec()) {
+            fmt::print("unable to perform search query: {}, ({}, {})\n", ctx.ec().message(), ctx.status(), ctx.error());
+            return 1;
+        }
+        fmt::print("{} hits, total: {}\n", result.rows().size(), result.meta_data().metrics().total_rows());
+        for (const auto& row : result.rows()) {
+            fmt::print("id: {}, score: {}\n", row.id(), row.score());
+        }
+    }
+
+    {
+        fmt::print("--- query with consistency requirements\n");
+
+        auto bucket = cluster.bucket(bucket_name);
+        auto collection = bucket.scope("inventory").collection("hotel");
+
+        couchbase::mutation_state state;
+
+        {
+            auto [ctx, upsert_result] =
+              collection
+                .upsert(
+                  "prancing-pony",
+                  tao::json::value{
+                    { "title", "The Prancing Pony" },
+                    { "type", "hotel" },
+                    { "description",
+                      "The inn was located just where the East Road bent round the foot of Bree-hill, within the dike that stretched "
+                      "around the town. The building was three stories tall with many windows. Its front faced the Road and it had two "
+                      "wings that ran back towards the elevated ground of the hill, such that in the rear the second floor was at ground "
+                      "level. " } })
+                .get();
+            if (ctx.ec()) {
+                fmt::print("unable to upsert the document \"{}\": {}\n", ctx.id(), ctx.ec().message());
+                return 1;
+            }
+            fmt::print("saved document \"{}\", cas={}, token={}\n",
+                       ctx.id(),
+                       upsert_result.cas(),
+                       upsert_result.mutation_token().value_or(couchbase::mutation_token{}));
+            state.add(upsert_result);
+        }
+
+        auto [ctx, result] =
+          cluster
+            .search_query("travel-sample-index", couchbase::query_string_query("bree"), couchbase::search_options{}.consistent_with(state))
+            .get();
+
+        if (ctx.ec()) {
+            fmt::print("unable to perform search query: {}, ({}, {})\n", ctx.ec().message(), ctx.status(), ctx.error());
+            return 1;
+        }
+        fmt::print("{} hits, total: {}\n", result.rows().size(), result.meta_data().metrics().total_rows());
+        for (const auto& row : result.rows()) {
+            fmt::print("id: {}, score: {}\n", row.id(), row.score());
+        }
+    }
+
+    {
+        fmt::print("--- complex query\n");
+        auto [ctx, result] = cluster
+                               .search_query("travel-sample-index",
+                                             couchbase::boolean_query()
+                                               .must(couchbase::match_query("honeymoon").field("reviews.content"),
+                                                     couchbase::numeric_range_query().field("reviews.ratings.Overall").min(4))
+                                               .must_not(couchbase::match_query("San Francisco").field("city")),
+                                             couchbase::search_options{}.collections({ "hotel" }).highlight())
+                               .get();
+        if (ctx.ec()) {
+            fmt::print("unable to perform search query: {}, ({}, {})\n", ctx.ec().message(), ctx.status(), ctx.error());
+            return 1;
+        }
+        fmt::print("{} hits, total: {}\n", result.rows().size(), result.meta_data().metrics().total_rows());
+        for (const auto& row : result.rows()) {
+            fmt::print("id: {}, score: {}\n", row.id(), row.score());
+        }
+    }
+
+    {
+        fmt::print("--- simple query with facets\n");
+        auto [ctx, result] =
+          cluster
+            .search_query("travel-sample-index",
+                          couchbase::query_string_query("honeymoon"),
+                          couchbase::search_options{}.collections({ "hotel" }).facet("by_country", couchbase::term_facet("country", 3)))
+            .get();
+        if (ctx.ec()) {
+            fmt::print("unable to perform search query: {}, ({}, {})\n", ctx.ec().message(), ctx.status(), ctx.error());
+            return 1;
+        }
+        fmt::print("{} hits, total: {}\n", result.rows().size(), result.meta_data().metrics().total_rows());
+        for (const auto& [name, facet] : result.facets()) {
+            fmt::print("{} facet: total={}, missing={}\n", name, facet->total(), facet->missing());
+            if (name == "by_country") {
+                auto term_facet = std::static_pointer_cast<couchbase::term_facet_result>(facet);
+                for (const auto& group : term_facet->terms()) {
+                    fmt::print("* {}: {}\n", group.name(), group.count());
+                }
+            }
+        }
+    }
+
+    // close cluster connection
+    cluster.close();
+    guard.reset();
+
+    io_thread.join();
+    return 0;
+}
+
+/*
+
+$ ./example_search couchbase://127.0.0.1 Administrator password
+saved document "my-document", cas=17486a1722b20000
+retrieved document "my-document", name="mike"
+row: {"airline":{"callsign":"MILE-AIR","country":"United States","iata":"Q5","icao":"MLA","id":10,"name":"40-Mile Air","type":"airline"}}
+
+ */
+//! [example-search]
+} // namespace example_search
+
+TEST_CASE("example: search", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+    if (!integration.cluster_version().supports_collections()) {
+        return;
+    }
+
+    const auto env = test::utils::test_context::load_from_environment();
+    const char* argv[] = {
+        "example_search", // name of the "executable"
+        env.connection_string.c_str(),
+        env.username.c_str(),
+        env.password.c_str(),
+    };
+
+    REQUIRE(example_search::main(4, argv) == 0);
+}