couchbase 4.2.1 → 4.2.3

package/deps/couchbase-cxx-client/core/transactions/attempt_context_impl.hxx

@@ -44,7 +44,7 @@
 namespace couchbase::core::impl
 {
 
-couchbase::transactions::transaction_query_result
+std::pair<couchbase::transaction_op_error_context, couchbase::transactions::transaction_query_result>
 build_transaction_query_result(operations::query_response resp, std::error_code ec = {});
 
 core::operations::query_request
@@ -87,14 +87,14 @@ class attempt_context_impl
     // transaction_context needs access to the two functions below
     friend class transaction_context;
 
-    couchbase::transactions::transaction_get_result_ptr insert_raw(const couchbase::collection& coll,
-                                                                   const std::string& id,
-                                                                   std::vector<std::byte> content) override
+    std::pair<couchbase::transaction_op_error_context, couchbase::transactions::transaction_get_result>
+    insert_raw(const couchbase::collection& coll, const std::string& id, std::vector<std::byte> content) override
     {
         return wrap_call_for_public_api([this, coll, &id, &content]() -> transaction_get_result {
             return insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), id }, content);
         });
     }
+
     transaction_get_result insert_raw(const core::document_id& id, const std::vector<std::byte>& content) override;
     void insert_raw(const collection& coll,
                     std::string id,
@@ -110,17 +110,20 @@ class attempt_context_impl
     void insert_raw(const core::document_id& id, const std::vector<std::byte>& content, Callback&& cb) override;
 
     transaction_get_result replace_raw(const transaction_get_result& document, const std::vector<std::byte>& content) override;
-    couchbase::transactions::transaction_get_result_ptr replace_raw(const couchbase::transactions::transaction_get_result_ptr doc,
-                                                                    std::vector<std::byte> content) override
+
+    std::pair<couchbase::transaction_op_error_context, couchbase::transactions::transaction_get_result> replace_raw(
+      const couchbase::transactions::transaction_get_result& doc,
+      std::vector<std::byte> content) override
     {
         return wrap_call_for_public_api(
-          [this, doc, &content]() -> transaction_get_result { return replace_raw(dynamic_cast<transaction_get_result&>(*doc), content); });
+          [this, doc, &content]() -> transaction_get_result { return replace_raw(transaction_get_result(doc), content); });
     }
-    void replace_raw(couchbase::transactions::transaction_get_result_ptr doc,
+
+    void replace_raw(couchbase::transactions::transaction_get_result doc,
                      std::vector<std::byte> content,
                      couchbase::transactions::async_result_handler&& handler) override
     {
-        replace_raw(dynamic_cast<transaction_get_result&>(*doc),
+        replace_raw(core::transactions::transaction_get_result(doc),
                     content,
                     [this, handler = std::move(handler)](std::exception_ptr err, std::optional<transaction_get_result> res) mutable {
                         wrap_callback_for_async_public_api(err, res, std::move(handler));
@@ -138,9 +141,12 @@ class attempt_context_impl
     void commit_with_query(VoidCallback&& cb);
     void rollback_with_query(VoidCallback&& cb);
 
-    void query_begin_work(std::function<void(std::exception_ptr)>&& cb);
+    void query_begin_work(std::optional<std::string> query_context, std::function<void(std::exception_ptr)>&& cb);
 
-    void do_query(const std::string& statement, const couchbase::transactions::transaction_query_options& opts, QueryCallback&& cb);
+    void do_query(const std::string& statement,
+                  const couchbase::transactions::transaction_query_options& opts,
+                  std::optional<std::string> query_context,
+                  QueryCallback&& cb);
     std::exception_ptr handle_query_error(const core::operations::query_response& resp);
     void wrap_query(const std::string& statement,
                     const couchbase::transactions::transaction_query_options& opts,
@@ -148,6 +154,7 @@ class attempt_context_impl
                     const tao::json::value& txdata,
                     const std::string& hook_point,
                     bool check_expiry,
+                    std::optional<std::string> query_context,
                     std::function<void(std::exception_ptr, core::operations::query_response)>&& cb);
 
     void handle_err_from_callback(std::exception_ptr e)
@@ -155,27 +162,28 @@ class attempt_context_impl
         try {
             throw e;
         } catch (const transaction_operation_failed& ex) {
-            txn_log->error("op callback called a txn operation that threw exception {}", ex.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback called a txn operation that threw exception {}", ex.what());
             op_list_.decrement_ops();
             // presumably that op called op_completed_with_error already, so
             // don't do anything here but swallow it.
         } catch (const async_operation_conflict& op_ex) {
             // the count isn't changed when this is thrown, so just swallow it and log
-            txn_log->error("op callback called a txn operation that threw exception {}", op_ex.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback called a txn operation that threw exception {}", op_ex.what());
         } catch (const op_exception& op_ex) {
-            txn_log->warn("op callback called a txn operation that threw (and didn't handle) a op_exception {}", op_ex.what());
+            CB_ATTEMPT_CTX_LOG_WARNING(
+              this, "op callback called a txn operation that threw (and didn't handle) a op_exception {}", op_ex.what());
             errors_.push_back(
               transaction_operation_failed(error_class_from_external_exception(op_ex.cause()), op_ex.what()).cause(op_ex.cause()));
             op_list_.decrement_ops();
         } catch (const std::exception& std_ex) {
             // if the callback throws something which wasn't handled
             // we just want to handle as a rollback
-            txn_log->error("op callback threw exception {}", std_ex.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback threw exception {}", std_ex.what());
             errors_.push_back(transaction_operation_failed(FAIL_OTHER, std_ex.what()));
             op_list_.decrement_ops();
         } catch (...) {
             // could be something really arbitrary, still...
-            txn_log->error("op callback threw unexpected exception");
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback threw unexpected exception");
             errors_.push_back(transaction_operation_failed(FAIL_OTHER, "unexpected error"));
             op_list_.decrement_ops();
         }
@@ -293,11 +301,23 @@ class attempt_context_impl
             existing_error();
             return func();
         } catch (const async_operation_conflict& e) {
-            // can't do anything here but log and eat it.
-            error("Attempted to perform txn operation after commit/rollback started: {}", e.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "Attempted to perform txn operation after commit/rollback started: {}", e.what());
             // you cannot call op_completed_with_error, as it tries to decrement
             // the op count, however it didn't successfully increment it, so...
-            op_completed_with_error_no_cache(std::move(cb), std::current_exception());
+            auto err = transaction_operation_failed(FAIL_OTHER, "async operation conflict");
+            switch (state()) {
+                case attempt_state::ABORTED:
+                case attempt_state::ROLLED_BACK:
+                    err.cause(TRANSACTION_ALREADY_ABORTED);
+                    break;
+                case attempt_state::COMMITTED:
+                case attempt_state::COMPLETED:
+                    err.cause(TRANSACTION_ALREADY_COMMITTED);
+                    break;
+                default:
+                    err.cause(UNKNOWN);
+            }
+            op_completed_with_error_no_cache(std::move(cb), std::make_exception_ptr(err));
         } catch (const transaction_operation_failed& e) {
             // thrown only from call_func when previous error exists, so eat it, unless
             // it has PREVIOUS_OP_FAILED cause
@@ -311,30 +331,6 @@ class attempt_context_impl
         }
     }
 
-    template<typename... Args>
-    void trace(const std::string& fmt, Args... args)
-    {
-        txn_log->trace(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
-    template<typename... Args>
-    void debug(const std::string& fmt, Args... args)
-    {
-        txn_log->debug(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
-    template<typename... Args>
-    void info(const std::string& fmt, Args... args)
-    {
-        txn_log->info(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
-    template<typename... Args>
-    void error(const std::string& fmt, Args... args)
-    {
-        txn_log->error(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
     std::shared_ptr<core::cluster> cluster_ref();
 
   public:
@@ -342,23 +338,28 @@ class attempt_context_impl
     ~attempt_context_impl() override;
 
     transaction_get_result get(const core::document_id& id) override;
-    couchbase::transactions::transaction_get_result_ptr get(const couchbase::collection& coll, const std::string& id) override
+    std::pair<couchbase::transaction_op_error_context, couchbase::transactions::transaction_get_result> get(
+      const couchbase::collection& coll,
+      const std::string& id) override
     {
-        return wrap_call_for_public_api([this, coll, id]() mutable -> transaction_get_result {
+        auto [ctx, res] = wrap_call_for_public_api([this, coll, id]() mutable -> transaction_get_result {
             auto ret = get_optional({ coll.bucket_name(), coll.scope_name(), coll.name(), id });
             if (ret) {
-                return *ret;
+                return ret.value();
             }
-            return { transaction_op_error_context{ errc::transaction_op::document_not_found_exception } };
+            return {};
         });
+        if (!ctx.ec() && res.cas().empty()) {
+            return { transaction_op_error_context{ errc::transaction_op::document_not_found_exception }, res };
+        }
+        return { ctx, res };
     }
     void get(const couchbase::collection& coll, std::string id, couchbase::transactions::async_result_handler&& handler) override
     {
         get_optional({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
                      [this, handler = std::move(handler)](std::exception_ptr err, std::optional<transaction_get_result> res) mutable {
                          if (!res) {
-                             return handler(std::make_shared<transaction_get_result>(
-                               transaction_op_error_context{ errc::transaction_op::document_not_found_exception }));
+                             return handler(transaction_op_error_context{ errc::transaction_op::document_not_found_exception }, {});
                          }
                          return wrap_callback_for_async_public_api(err, res, std::move(handler));
                      });
@@ -369,51 +370,56 @@ class attempt_context_impl
     void get_optional(const core::document_id& id, Callback&& cb) override;
 
     void remove(const transaction_get_result& document) override;
-    couchbase::transaction_op_error_context remove(couchbase::transactions::transaction_get_result_ptr doc) override
+    couchbase::transaction_op_error_context remove(const couchbase::transactions::transaction_get_result& doc) override
     {
-        return wrap_void_call_for_public_api([this, doc]() { remove(dynamic_cast<transaction_get_result&>(*doc)); });
+        return wrap_void_call_for_public_api([this, doc]() { remove(transaction_get_result(doc)); });
     }
     void remove(const transaction_get_result& document, VoidCallback&& cb) override;
-    void remove(couchbase::transactions::transaction_get_result_ptr doc, couchbase::transactions::async_err_handler&& handler) override
+    void remove(couchbase::transactions::transaction_get_result doc, couchbase::transactions::async_err_handler&& handler) override
     {
-        remove(dynamic_cast<transaction_get_result&>(*doc), [this, handler = std::move(handler)](std::exception_ptr e) mutable {
+        remove(transaction_get_result(doc), [this, handler = std::move(handler)](std::exception_ptr e) mutable {
             wrap_err_callback_for_async_api(e, std::move(handler));
         });
     };
 
     core::operations::query_response do_core_query(const std::string& statement,
-                                                   const couchbase::transactions::transaction_query_options& options) override;
+                                                   const couchbase::transactions::transaction_query_options& options,
+                                                   std::optional<std::string> query_context) override;
 
-    couchbase::transactions::transaction_query_result_ptr do_public_query(
+    std::pair<couchbase::transaction_op_error_context, couchbase::transactions::transaction_query_result> do_public_query(
       const std::string& statement,
-      const couchbase::transactions::transaction_query_options& opts) override;
+      const couchbase::transactions::transaction_query_options& opts,
+      std::optional<std::string> query_context) override;
 
     void query(const std::string& statement,
                const couchbase::transactions::transaction_query_options& options,
+               std::optional<std::string> query_context,
                QueryCallback&& cb) override;
 
     void query(std::string statement,
                couchbase::transactions::transaction_query_options opts,
+               std::optional<std::string> query_context,
                couchbase::transactions::async_query_handler&& handler) override
     {
-        query(
-          statement, opts, [handler = std::move(handler)](std::exception_ptr err, std::optional<core::operations::query_response> resp) {
-              if (err) {
-                  try {
-                      std::rethrow_exception(err);
-                  } catch (const transaction_operation_failed& e) {
-                      return handler(std::make_shared<couchbase::transactions::transaction_query_result>(e.get_error_ctx()));
-                  } catch (const op_exception& ex) {
-                      return handler(std::make_shared<couchbase::transactions::transaction_query_result>(ex.ctx()));
-                  } catch (...) {
-                      // just in case...
-                      return handler(std::make_shared<couchbase::transactions::transaction_query_result>(
-                        transaction_op_error_context(couchbase::errc::transaction_op::unknown)));
+        query(statement,
+              opts,
+              query_context,
+              [handler = std::move(handler)](std::exception_ptr err, std::optional<core::operations::query_response> resp) {
+                  if (err) {
+                      try {
+                          std::rethrow_exception(err);
+                      } catch (const transaction_operation_failed& e) {
+                          return handler(e.get_error_ctx(), {});
+                      } catch (const op_exception& ex) {
+                          return handler(ex.ctx(), {});
+                      } catch (...) {
+                          // just in case...
+                          return handler(transaction_op_error_context(couchbase::errc::transaction_op::unknown), {});
+                      }
                   }
-              }
-              handler(
-                std::make_shared<couchbase::transactions::transaction_query_result>(core::impl::build_transaction_query_result(*resp)));
-          });
+                  auto [ctx, res] = core::impl::build_transaction_query_result(*resp);
+                  handler(ctx, res);
+              });
     }
 
     void commit() override;
@@ -450,7 +456,7 @@ class attempt_context_impl
 
     void state(attempt_state s)
     {
-        overall_.current_attempt().state = s;
+        overall_.current_attempt_state(s);
     }
 
     [[nodiscard]] const std::string atr_id()
@@ -519,6 +525,7 @@ class attempt_context_impl
     core::operations::mutate_in_request create_staging_request(const core::document_id& in,
                                                                const transaction_get_result* document,
                                                                const std::string type,
+                                                               const std::string op_id,
                                                                std::optional<std::vector<std::byte>> content = std::nullopt);
 
     template<typename Handler, typename Delay>
@@ -526,31 +533,37 @@ class attempt_context_impl
                               const std::vector<std::byte>& content,
                               uint64_t cas,
                               Delay&& delay,
+                              const std::string& op_id,
                               Handler&& cb);
 
     template<typename Handler>
-    void create_staged_replace(const transaction_get_result& document, const std::vector<std::byte>& content, Handler&& cb);
+    void create_staged_replace(const transaction_get_result& document,
+                               const std::vector<std::byte>& content,
+                               const std::string& op_id,
+                               Handler&& cb);
 
     template<typename Handler, typename Delay>
     void create_staged_insert_error_handler(const core::document_id& id,
                                             const std::vector<std::byte>& content,
                                             uint64_t cas,
                                             Delay&& delay,
+                                            const std::string& op_id,
                                             Handler&& cb,
                                             error_class ec,
                                             const std::string& message);
 
-    couchbase::transactions::transaction_get_result_ptr wrap_call_for_public_api(std::function<transaction_get_result()>&& handler)
+    std::pair<couchbase::transaction_op_error_context, couchbase::transactions::transaction_get_result> wrap_call_for_public_api(
+      std::function<transaction_get_result()>&& handler)
     {
         try {
-            return std::make_shared<transaction_get_result>(handler());
+            return { {}, handler().to_public_result() };
         } catch (const transaction_operation_failed& e) {
-            return std::make_shared<transaction_get_result>(e.get_error_ctx());
+            return { e.get_error_ctx(), {} };
         } catch (const op_exception& ex) {
-            return std::make_shared<transaction_get_result>(ex.ctx());
+            return { ex.ctx(), {} };
         } catch (...) {
             // the handler should catch everything else, but just in case...
-            return std::make_shared<transaction_get_result>(transaction_op_error_context(errc::transaction_op::unknown));
+            return { transaction_op_error_context(errc::transaction_op::unknown), {} };
         }
     }
 
@@ -567,25 +580,26 @@ class attempt_context_impl
         }
     }
 
-    void wrap_callback_for_async_public_api(std::exception_ptr err,
-                                            std::optional<transaction_get_result> res,
-                                            std::function<void(couchbase::transactions::transaction_get_result_ptr)>&& cb)
+    void wrap_callback_for_async_public_api(
+      std::exception_ptr err,
+      std::optional<transaction_get_result> res,
+      std::function<void(couchbase::transaction_op_error_context, couchbase::transactions::transaction_get_result)>&& cb)
     {
         if (res) {
-            return cb(std::make_shared<transaction_get_result>(*res));
+            return cb({}, res->to_public_result());
         }
         if (err) {
             try {
                 std::rethrow_exception(err);
             } catch (const op_exception& e) {
-                return cb(std::make_shared<transaction_get_result>(e.ctx()));
+                return cb(e.ctx(), {});
             } catch (const transaction_operation_failed& e) {
-                return cb(std::make_shared<transaction_get_result>(e.get_error_ctx()));
+                return cb(e.get_error_ctx(), {});
             } catch (...) {
-                return cb(std::make_shared<transaction_get_result>(transaction_op_error_context(errc::transaction_op::unknown)));
+                return cb(transaction_op_error_context(errc::transaction_op::unknown), {});
             }
         }
-        return cb(std::make_shared<transaction_get_result>(transaction_op_error_context(errc::transaction_op::unknown)));
+        return cb(transaction_op_error_context(errc::transaction_op::unknown), {});
     }
 
     void wrap_err_callback_for_async_api(std::exception_ptr err, std::function<void(couchbase::transaction_op_error_context)>&& cb)
@@ -604,6 +618,10 @@ class attempt_context_impl
 
     void ensure_open_bucket(std::string bucket_name, std::function<void(std::error_code)>&& handler)
     {
+        if (bucket_name.empty()) {
+            CB_LOG_DEBUG("ensure_open_bucket called with empty bucket_name");
+            return handler(couchbase::errc::common::bucket_not_found);
+        }
         cluster_ref()->open_bucket(bucket_name, [handler = std::move(handler)](std::error_code ec) { handler(ec); });
     }
 };

package/deps/couchbase-cxx-client/core/transactions/attempt_context_testing_hooks.cxx

@@ -0,0 +1,93 @@
+/*
+ *     Copyright 2021-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "attempt_context_testing_hooks.hxx"
+
+namespace couchbase::core::transactions
+{
+namespace
+{
+inline std::optional<error_class>
+noop_1(attempt_context*)
+{
+    return {};
+}
+
+inline std::optional<error_class>
+noop_2(attempt_context*, const std::string&)
+{
+    return {};
+}
+
+inline std::optional<const std::string>
+noop_3(attempt_context*)
+{
+    return {};
+}
+
+inline bool
+noop_4(attempt_context*, const std::string&, std::optional<const std::string>)
+{
+    return false;
+}
+} // namespace
+
+attempt_context_testing_hooks::attempt_context_testing_hooks()
+  : before_atr_commit{ noop_1 }
+  , before_atr_commit_ambiguity_resolution{ noop_1 }
+  , after_atr_commit{ noop_1 }
+  , before_doc_committed{ noop_2 }
+  , before_removing_doc_during_staged_insert{ noop_2 }
+  , before_rollback_delete_inserted{ noop_2 }
+  , after_doc_committed_before_saving_cas{ noop_2 }
+  , after_doc_committed{ noop_2 }
+  , before_staged_insert{ noop_2 }
+  , before_staged_remove{ noop_2 }
+  , before_staged_replace{ noop_2 }
+  , before_doc_removed{ noop_2 }
+  , before_doc_rolled_back{ noop_2 }
+  , after_doc_removed_pre_retry{ noop_2 }
+  , after_doc_removed_post_retry{ noop_2 }
+  , after_get_complete{ noop_2 }
+  , after_staged_replace_complete_before_cas_saved{ noop_2 }
+  , after_staged_replace_complete{ noop_2 }
+  , after_staged_remove_complete{ noop_2 }
+  , after_staged_insert_complete{ noop_2 }
+  , after_rollback_replace_or_remove{ noop_2 }
+  , after_rollback_delete_inserted{ noop_2 }
+  , before_check_atr_entry_for_blocking_doc{ noop_2 }
+  , before_doc_get{ noop_2 }
+  , before_get_doc_in_exists_during_staged_insert{ noop_2 }
+  , before_query{ noop_2 }
+  , after_query{ noop_2 }
+  , before_remove_staged_insert{ noop_2 }
+  , after_remove_staged_insert{ noop_2 }
+  , after_docs_committed{ noop_1 }
+  , after_docs_removed{ noop_1 }
+  , after_atr_pending{ noop_1 }
+  , before_atr_pending{ noop_1 }
+  , before_atr_complete{ noop_1 }
+  , before_atr_rolled_back{ noop_1 }
+  , after_atr_complete{ noop_1 }
+  , before_get_atr_for_abort{ noop_1 }
+  , before_atr_aborted{ noop_1 }
+  , after_atr_aborted{ noop_1 }
+  , after_atr_rolled_back{ noop_1 }
+  , random_atr_id_for_vbucket{ noop_3 }
+  , has_expired_client_side{ noop_4 }
+{
+}
+} // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/attempt_context_testing_hooks.hxx

@@ -28,33 +28,6 @@ class attempt_context;
 using error_func1 = std::function<std::optional<error_class>(attempt_context*)>;
 using error_func2 = std::function<std::optional<error_class>(attempt_context*, const std::string&)>;
 
-namespace
-{
-std::optional<error_class>
-noop_1(attempt_context*)
-{
-    return {};
-}
-
-std::optional<error_class>
-noop_2(attempt_context*, const std::string&)
-{
-    return {};
-}
-
-std::optional<const std::string>
-noop_3(attempt_context*)
-{
-    return {};
-}
-
-bool
-noop_4(attempt_context*, const std::string&, std::optional<const std::string>)
-{
-    return false;
-}
-} // namespace
-
 static const std::string STAGE_ROLLBACK = "rollback";
 static const std::string STAGE_GET = "get";
 static const std::string STAGE_INSERT = "insert";
@@ -91,55 +64,55 @@ static const std::string STAGE_QUERY_KV_INSERT = "queryKvInsert";
  * about your use-case: we are always open to adding good ideas into the transactions library.
  */
 struct attempt_context_testing_hooks {
-    error_func1 before_atr_commit = noop_1;
-    error_func1 before_atr_commit_ambiguity_resolution = noop_1;
-    error_func1 after_atr_commit = noop_1;
-    error_func2 before_doc_committed = noop_2;
-    error_func2 before_removing_doc_during_staged_insert = noop_2;
-    error_func2 before_rollback_delete_inserted = noop_2;
-    error_func2 after_doc_committed_before_saving_cas = noop_2;
-    error_func2 after_doc_committed = noop_2;
-    error_func2 before_staged_insert = noop_2;
-    error_func2 before_staged_remove = noop_2;
-    error_func2 before_staged_replace = noop_2;
-    error_func2 before_doc_removed = noop_2;
-    error_func2 before_doc_rolled_back = noop_2;
-    error_func2 after_doc_removed_pre_retry = noop_2;
-    error_func2 after_doc_removed_post_retry = noop_2;
-    error_func2 after_get_complete = noop_2;
-    error_func2 after_staged_replace_complete_before_cas_saved = noop_2;
-    error_func2 after_staged_replace_complete = noop_2;
-    error_func2 after_staged_remove_complete = noop_2;
-    error_func2 after_staged_insert_complete = noop_2;
-    error_func2 after_rollback_replace_or_remove = noop_2;
-    error_func2 after_rollback_delete_inserted = noop_2;
-    error_func2 before_check_atr_entry_for_blocking_doc = noop_2;
-    error_func2 before_doc_get = noop_2;
-    error_func2 before_get_doc_in_exists_during_staged_insert = noop_2;
-    error_func2 before_query = noop_2;
-    error_func2 after_query = noop_2;
-    error_func2 before_remove_staged_insert = noop_2;
-    error_func2 after_remove_staged_insert = noop_2;
-
-    error_func1 after_docs_committed = noop_1;
-    error_func1 after_docs_removed = noop_1;
-    error_func1 after_atr_pending = noop_1;
-    error_func1 before_atr_pending = noop_1;
-    error_func1 before_atr_complete = noop_1;
-    error_func1 before_atr_rolled_back = noop_1;
-    error_func1 after_atr_complete = noop_1;
-    error_func1 before_get_atr_for_abort = noop_1;
-    error_func1 before_atr_aborted = noop_1;
-    error_func1 after_atr_aborted = noop_1;
-    error_func1 after_atr_rolled_back = noop_1;
-
-    std::function<std::optional<const std::string>(attempt_context*)> random_atr_id_for_vbucket = noop_3;
-
-    std::function<bool(attempt_context*, const std::string&, std::optional<const std::string>)> has_expired_client_side = noop_4;
+    error_func1 before_atr_commit;
+    error_func1 before_atr_commit_ambiguity_resolution;
+    error_func1 after_atr_commit;
+    error_func2 before_doc_committed;
+    error_func2 before_removing_doc_during_staged_insert;
+    error_func2 before_rollback_delete_inserted;
+    error_func2 after_doc_committed_before_saving_cas;
+    error_func2 after_doc_committed;
+    error_func2 before_staged_insert;
+    error_func2 before_staged_remove;
+    error_func2 before_staged_replace;
+    error_func2 before_doc_removed;
+    error_func2 before_doc_rolled_back;
+    error_func2 after_doc_removed_pre_retry;
+    error_func2 after_doc_removed_post_retry;
+    error_func2 after_get_complete;
+    error_func2 after_staged_replace_complete_before_cas_saved;
+    error_func2 after_staged_replace_complete;
+    error_func2 after_staged_remove_complete;
+    error_func2 after_staged_insert_complete;
+    error_func2 after_rollback_replace_or_remove;
+    error_func2 after_rollback_delete_inserted;
+    error_func2 before_check_atr_entry_for_blocking_doc;
+    error_func2 before_doc_get;
+    error_func2 before_get_doc_in_exists_during_staged_insert;
+    error_func2 before_query;
+    error_func2 after_query;
+    error_func2 before_remove_staged_insert;
+    error_func2 after_remove_staged_insert;
+
+    error_func1 after_docs_committed;
+    error_func1 after_docs_removed;
+    error_func1 after_atr_pending;
+    error_func1 before_atr_pending;
+    error_func1 before_atr_complete;
+    error_func1 before_atr_rolled_back;
+    error_func1 after_atr_complete;
+    error_func1 before_get_atr_for_abort;
+    error_func1 before_atr_aborted;
+    error_func1 after_atr_aborted;
+    error_func1 after_atr_rolled_back;
+
+    std::function<std::optional<const std::string>(attempt_context*)> random_atr_id_for_vbucket;
+
+    std::function<bool(attempt_context*, const std::string&, std::optional<const std::string>)> has_expired_client_side;
+
+    attempt_context_testing_hooks();
 
     // needed for unique_ptr<attempt_context_testing_hooks> in transaction_config, with a forward declaration.
-    ~attempt_context_testing_hooks()
-    {
-    }
+    ~attempt_context_testing_hooks() = default;
 };
 } // namespace couchbase::core::transactions