CDRIVER-5969 return NULL result if no writes indicated (#1990)

Author: kevinAlbs

src/libmongoc/src/mongoc/mongoc-bulkwrite.c

@@ -865,6 +865,9 @@ struct _mongoc_bulkwriteresult_t {
    bson_t updateresults;
    bson_t deleteresults;
    bool verboseresults;
+   // `parsed_some_results` becomes true if an ok:1 reply to `bulkWrite` is successfully parsed.
+   // Used to determine whether some writes were successful.
+   bool parsed_some_results;
 };
 
 int64_t
@@ -1334,6 +1337,8 @@ _bulkwritereturn_apply_reply (mongoc_bulkwritereturn_t *self, const bson_t *cmd_
       _bulkwriteexception_append_writeconcernerror (self->exc, code, errmsg, &errInfo);
    }
 
+   self->res->parsed_some_results = true;
+
    return true;
 }
 
@@ -1514,6 +1519,7 @@ mongoc_bulkwrite_execute (mongoc_bulkwrite_t *self, const mongoc_bulkwriteopts_t
    BSON_ASSERT_PARAM (self);
    BSON_OPTIONAL_PARAM (opts);
 
+   // `has_successful_results` is set to true if any `bulkWrite` reply indicates some writes succeeded.
    bool has_successful_results = false;
    mongoc_bulkwritereturn_t ret = {0};
    bson_error_t error = {0};
@@ -1945,16 +1951,18 @@ mongoc_bulkwrite_execute (mongoc_bulkwrite_t *self, const mongoc_bulkwriteopts_t
    }
 
 fail:
-   if (is_ordered) {
-      // Ordered writes stop on first error. If the error reported is for an index > 0, assume some writes suceeded.
-      if (ret.res->errorscount == 0 || (ret.res->first_error_index.isset && ret.res->first_error_index.index > 0)) {
-         has_successful_results = true;
-      }
-   } else {
-      BSON_ASSERT (mlib_in_range (size_t, ret.res->errorscount));
-      size_t errorscount_sz = (size_t) ret.res->errorscount;
-      if (errorscount_sz < self->n_ops) {
-         has_successful_results = true;
+   if (ret.res->parsed_some_results) {
+      if (is_ordered) {
+         // Ordered writes stop on first error. If the error reported is for an index > 0, assume some writes suceeded.
+         if (ret.res->errorscount == 0 || (ret.res->first_error_index.isset && ret.res->first_error_index.index > 0)) {
+            has_successful_results = true;
+         }
+      } else {
+         BSON_ASSERT (mlib_in_range (size_t, ret.res->errorscount));
+         size_t errorscount_sz = (size_t) ret.res->errorscount;
+         if (errorscount_sz < self->n_ops) {
+            has_successful_results = true;
+         }
       }
    }
    if (!is_acknowledged || !has_successful_results) {

src/libmongoc/tests/test-mongoc-bulkwrite.c

@@ -219,6 +219,7 @@ test_bulkwrite_double_execute (void *ctx)
    // Execute.
    {
       mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL);
+      ASSERT (bwr.res);
       ASSERT_NO_BULKWRITEEXCEPTION (bwr);
       mongoc_bulkwriteresult_destroy (bwr.res);
       mongoc_bulkwriteexception_destroy (bwr.exc);
@@ -251,6 +252,7 @@ test_bulkwrite_double_execute (void *ctx)
 
    {
       mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL);
+      ASSERT (!bwr.res); // No result due to no successful writes.
       ASSERT (bwr.exc);
       ASSERT (mongoc_bulkwriteexception_error (bwr.exc, &error));
       ASSERT_ERROR_CONTAINS (
@@ -309,6 +311,7 @@ test_bulkwrite_serverid (void *ctx)
    // Execute.
    {
       mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, bwo);
+      ASSERT (bwr.res);
       ASSERT_NO_BULKWRITEEXCEPTION (bwr);
       // Expect the selected server is reported as used.
       uint32_t used_serverid = mongoc_bulkwriteresult_serverid (bwr.res);
@@ -381,6 +384,7 @@ test_bulkwrite_serverid_on_retry (void *ctx)
    // Execute.
    {
       mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, bwo);
+      ASSERT (bwr.res);
       ASSERT_NO_BULKWRITEEXCEPTION (bwr);
       // Expect a different server was used due to retry.
       uint32_t used_serverid = mongoc_bulkwriteresult_serverid (bwr.res);
@@ -444,6 +448,7 @@ test_bulkwrite_extra (void *ctx)
    // Execute.
    {
       mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, bwo);
+      ASSERT (bwr.res);
       ASSERT_NO_BULKWRITEEXCEPTION (bwr);
       mongoc_bulkwriteresult_destroy (bwr.res);
       mongoc_bulkwriteexception_destroy (bwr.exc);
@@ -486,6 +491,7 @@ test_bulkwrite_no_verbose_results (void *ctx)
    // Execute.
    {
       mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL /* opts */);
+      ASSERT (bwr.res);
       ASSERT_NO_BULKWRITEEXCEPTION (bwr);
       // Expect no verbose results.
       ASSERT (NULL == mongoc_bulkwriteresult_insertresults (bwr.res));
@@ -558,6 +564,7 @@ test_bulkwrite_many_namespaces (void *ctx)
    // Execute.
    {
       mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL /* opts */);
+      ASSERT (bwr.res);
       ASSERT_NO_BULKWRITEEXCEPTION (bwr);
       mongoc_bulkwriteresult_destroy (bwr.res);
       mongoc_bulkwriteexception_destroy (bwr.exc);
@@ -606,6 +613,7 @@ test_bulkwrite_execute_requires_client (void *ctx)
    // Attempt execution without assigning a client
    {
       mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL);
+      ASSERT (!bwr.res); // No result due to no successful writes.
       ASSERT (bwr.exc);
       ASSERT (mongoc_bulkwriteexception_error (bwr.exc, &error));
       ASSERT_ERROR_CONTAINS (error,
@@ -620,6 +628,7 @@ test_bulkwrite_execute_requires_client (void *ctx)
    {
       mongoc_bulkwrite_set_client (bw, client);
       mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL);
+      ASSERT (bwr.res);
       ASSERT_NO_BULKWRITEEXCEPTION (bwr);
       mongoc_bulkwriteresult_destroy (bwr.res);
       mongoc_bulkwriteexception_destroy (bwr.exc);
@@ -667,8 +676,8 @@ test_bulkwrite_two_large_inserts (void *unused)
    ASSERT_OR_PRINT (mongoc_bulkwrite_append_insertone (bw, "db.coll", docs[1], NULL, &error), error);
 
    mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, bw_opts);
-   ASSERT_NO_BULKWRITEEXCEPTION (bwr);
    ASSERT (bwr.res);
+   ASSERT_NO_BULKWRITEEXCEPTION (bwr);
    const bson_t *insertresults = mongoc_bulkwriteresult_insertresults (bwr.res);
    ASSERT_MATCH (insertresults,
                  BSON_STR ({"0" : {"insertedId" : "over_2mib_1"}}, {"1" : {"insertedId" : "over_2mib_2"}}));
@@ -682,6 +691,40 @@ test_bulkwrite_two_large_inserts (void *unused)
    bson_free (large_string);
 }
 
+
+// `test_bulkwrite_client_error_no_result` is a regression test for CDRIVER-5969.
+static void
+test_bulkwrite_client_error_no_result (void *unused)
+{
+   BSON_UNUSED (unused);
+
+   bson_error_t error;
+   mongoc_client_t *client = test_framework_new_default_client ();
+   // Trigger a client-side error by adding a too-big document.
+   {
+      mongoc_bulkwrite_t *bw = mongoc_client_bulkwrite_new (client);
+      bson_t too_big = BSON_INITIALIZER;
+      const size_t maxMessageSizeByte = 48000000;
+      char *big_string = bson_malloc (maxMessageSizeByte + 1);
+      memset (big_string, 'a', maxMessageSizeByte);
+      big_string[maxMessageSizeByte] = '\0';
+      BSON_APPEND_UTF8 (&too_big, "big", big_string);
+      ASSERT_OR_PRINT (mongoc_bulkwrite_append_insertone (bw, "db.coll", &too_big, NULL, &error), error);
+      mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL);
+      ASSERT (!bwr.res); // No result due to no successful writes.
+      ASSERT (bwr.exc);
+      ASSERT (mongoc_bulkwriteexception_error (bwr.exc, &error));
+      ASSERT_ERROR_CONTAINS (
+         error, MONGOC_ERROR_COMMAND, MONGOC_ERROR_COMMAND_INVALID_ARG, "Sending would exceed maxMessageSizeBytes");
+      bson_free (big_string);
+      bson_destroy (&too_big);
+      mongoc_bulkwriteresult_destroy (bwr.res);
+      mongoc_bulkwriteexception_destroy (bwr.exc);
+      mongoc_bulkwrite_destroy (bw);
+   }
+
+   mongoc_client_destroy (client);
+}
 void
 test_bulkwrite_install (TestSuite *suite)
 {
@@ -783,4 +826,12 @@ test_bulkwrite_install (TestSuite *suite)
                       NULL /* ctx */,
                       test_framework_skip_if_max_wire_version_less_than_25 // require server 8.0
    );
+
+   TestSuite_AddFull (suite,
+                      "/bulkwrite/client_error_no_result",
+                      test_bulkwrite_client_error_no_result,
+                      NULL /* dtor */,
+                      NULL /* ctx */,
+                      test_framework_skip_if_max_wire_version_less_than_25 // require server 8.0
+   );
 }

src/libmongoc/tests/test-mongoc-crud.c

@@ -367,8 +367,8 @@ prose_test_4 (void *ctx)
    }
 
    mongoc_bulkwritereturn_t ret = mongoc_bulkwrite_execute (bw, NULL /* options */);
-   ASSERT_NO_BULKWRITEEXCEPTION (ret);
    ASSERT (ret.res);
+   ASSERT_NO_BULKWRITEEXCEPTION (ret);
    ASSERT_CMPINT64 (mongoc_bulkwriteresult_insertedcount (ret.res), ==, numModels);
    mongoc_bulkwriteexception_destroy (ret.exc);
    mongoc_bulkwriteresult_destroy (ret.res);
@@ -466,6 +466,7 @@ prose_test_5 (void *ctx)
    }
 
    mongoc_bulkwritereturn_t ret = mongoc_bulkwrite_execute (bw, NULL /* options */);
+   ASSERT (ret.res); // Has partial results.
    ASSERT (ret.exc);
 
    // Expect no top-level error.
@@ -536,6 +537,7 @@ prose_test_6 (void *ctx)
       mongoc_bulkwriteopts_t *opts = mongoc_bulkwriteopts_new ();
       mongoc_bulkwriteopts_set_ordered (opts, false);
       mongoc_bulkwritereturn_t ret = mongoc_bulkwrite_execute (bw, opts);
+      ASSERT (!ret.res); // No result due to no successful writes.
       ASSERT (ret.exc);
 
       if (mongoc_bulkwriteexception_error (ret.exc, &error)) {
@@ -575,6 +577,7 @@ prose_test_6 (void *ctx)
       mongoc_bulkwriteopts_t *opts = mongoc_bulkwriteopts_new ();
       mongoc_bulkwriteopts_set_ordered (opts, true);
       mongoc_bulkwritereturn_t ret = mongoc_bulkwrite_execute (bw, opts);
+      ASSERT (!ret.res); // No result due to no successful writes.
       ASSERT (ret.exc);
 
       if (mongoc_bulkwriteexception_error (ret.exc, &error)) {
@@ -656,7 +659,7 @@ prose_test_7 (void *ctx)
    mongoc_bulkwriteopts_t *opts = mongoc_bulkwriteopts_new ();
    mongoc_bulkwriteopts_set_verboseresults (opts, true);
    mongoc_bulkwritereturn_t ret = mongoc_bulkwrite_execute (bw, opts);
-
+   ASSERT (ret.res);
    ASSERT_NO_BULKWRITEEXCEPTION (ret);
 
    ASSERT_CMPINT64 (mongoc_bulkwriteresult_upsertedcount (ret.res), ==, 2);
@@ -742,7 +745,7 @@ prose_test_8 (void *ctx)
    mongoc_bulkwriteopts_t *opts = mongoc_bulkwriteopts_new ();
    mongoc_bulkwriteopts_set_verboseresults (opts, true);
    mongoc_bulkwritereturn_t ret = mongoc_bulkwrite_execute (bw, opts);
-
+   ASSERT (ret.res);
    ASSERT_NO_BULKWRITEEXCEPTION (ret);
 
    ASSERT_CMPINT64 (mongoc_bulkwriteresult_upsertedcount (ret.res), ==, 2);
@@ -843,13 +846,13 @@ prose_test_9 (void *ctx)
    mongoc_bulkwriteopts_t *opts = mongoc_bulkwriteopts_new ();
    mongoc_bulkwriteopts_set_verboseresults (opts, true);
    mongoc_bulkwritereturn_t ret = mongoc_bulkwrite_execute (bw, opts);
+   ASSERT (ret.res);
    ASSERT (ret.exc);
 
    if (!mongoc_bulkwriteexception_error (ret.exc, &error)) {
       test_error ("Expected top-level error but got:\n%s", test_bulkwriteexception_str (ret.exc));
    }
    ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_QUERY, 8, "Failing command via 'failCommand' failpoint");
-   ASSERT (ret.res);
    ASSERT_CMPSIZE_T ((size_t) mongoc_bulkwriteresult_upsertedcount (ret.res), ==, numModels);
 
    // Check length of update results.
@@ -912,12 +915,12 @@ prose_test_10 (void *ctx)
       ASSERT_OR_PRINT (ok, error);
 
       mongoc_bulkwritereturn_t ret = mongoc_bulkwrite_execute (bw, opts);
+      ASSERT (!ret.res); // No result due to unacknowledged write concern.
       ASSERT (ret.exc);
       if (!mongoc_bulkwriteexception_error (ret.exc, &error)) {
          test_error ("Expected top-level error but got:\n%s", test_bulkwriteexception_str (ret.exc));
       }
       ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, MONGOC_ERROR_COMMAND_INVALID_ARG, "of size");
-
       mongoc_bulkwriteexception_destroy (ret.exc);
       mongoc_bulkwriteresult_destroy (ret.res);
       mongoc_bulkwrite_destroy (bw);
@@ -930,12 +933,12 @@ prose_test_10 (void *ctx)
       ASSERT_OR_PRINT (ok, error);
 
       mongoc_bulkwritereturn_t ret = mongoc_bulkwrite_execute (bw, opts);
+      ASSERT (!ret.res); // No result due to unacknowledged write concern.
       ASSERT (ret.exc);
       if (!mongoc_bulkwriteexception_error (ret.exc, &error)) {
          test_error ("Expected top-level error but got:\n%s", test_bulkwriteexception_str (ret.exc));
       }
       ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, MONGOC_ERROR_COMMAND_INVALID_ARG, "of size");
-
       mongoc_bulkwriteexception_destroy (ret.exc);
       mongoc_bulkwriteresult_destroy (ret.res);
       mongoc_bulkwrite_destroy (bw);
@@ -1076,6 +1079,7 @@ prose_test_11 (void *ctx)
       // Execute.
       {
          mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (tf->bw, NULL /* opts */);
+         ASSERT (bwr.res);
          ASSERT_NO_BULKWRITEEXCEPTION (bwr);
          ASSERT (mlib_in_range (int64_t, tf->numModels));
          ASSERT_CMPINT64 (mongoc_bulkwriteresult_insertedcount (bwr.res), ==, (int64_t) tf->numModels + 1);
@@ -1126,6 +1130,7 @@ prose_test_11 (void *ctx)
       // Execute.
       {
          mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (tf->bw, NULL /* opts */);
+         ASSERT (bwr.res);
          ASSERT_NO_BULKWRITEEXCEPTION (bwr);
          ASSERT (mlib_in_range (int64_t, tf->numModels));
          ASSERT_CMPINT64 (mongoc_bulkwriteresult_insertedcount (bwr.res), ==, (int64_t) tf->numModels + 1);
@@ -1206,6 +1211,7 @@ prose_test_12 (void *ctx)
       // Execute.
       {
          mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL);
+         ASSERT (!bwr.res); // No result due to no successful writes.
          ASSERT (bwr.exc);
          if (!mongoc_bulkwriteexception_error (bwr.exc, &error)) {
             test_error ("Expected top-level error but got:\n%s", test_bulkwriteexception_str (bwr.exc));
@@ -1234,6 +1240,7 @@ prose_test_12 (void *ctx)
       // Execute.
       {
          mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL);
+         ASSERT (!bwr.res); // No result due to no successful writes.
          ASSERT (bwr.exc);
          if (!mongoc_bulkwriteexception_error (bwr.exc, &error)) {
             test_error ("Expected top-level error but got:\n%s", test_bulkwriteexception_str (bwr.exc));
@@ -1283,6 +1290,7 @@ prose_test_13 (void *ctx)
       // Execute.
       {
          mongoc_bulkwritereturn_t bwr = mongoc_bulkwrite_execute (bw, NULL);
+         ASSERT (!bwr.res); // No result due to no successful writes.
          ASSERT (bwr.exc);
          if (!mongoc_bulkwriteexception_error (bwr.exc, &error)) {
             test_error ("Expected top-level error but got:\n%s", test_bulkwriteexception_str (bwr.exc));