CDRIVER-2621 write concern tests fixed

spencemc · spencemc · commit aefdd2bad028 · 2018-06-21T13:50:48.000-04:00
diff --git a/src/libmongoc/src/mongoc/mongoc-uri.c b/src/libmongoc/src/mongoc/mongoc-uri.c
@@ -1345,6 +1345,13 @@ _mongoc_uri_build_write_concern (mongoc_uri_t *uri, bson_error_t *error)
    }
 
    wtimeoutms = mongoc_uri_get_option_as_int32 (uri, MONGOC_URI_WTIMEOUTMS, 0);
+   if (wtimeoutms < 0) {
+      MONGOC_URI_ERROR (
+         error, "Unsupported wtimeoutMS value [w=%d]", wtimeoutms);
+      return false;
+   } else {
+      mongoc_write_concern_set_wtimeout (write_concern, wtimeoutms);
+   }
 
    if (bson_iter_init_find_case (&iter, &uri->options, MONGOC_URI_JOURNAL) &&
        BSON_ITER_HOLDS_BOOL (&iter)) {
@@ -1368,9 +1375,6 @@ _mongoc_uri_build_write_concern (mongoc_uri_t *uri, bson_error_t *error)
          default:
             if (value > 0) {
                mongoc_write_concern_set_w (write_concern, value);
-               if (value > 1) {
-                  mongoc_write_concern_set_wtimeout (write_concern, wtimeoutms);
-               }
                break;
             }
             MONGOC_URI_ERROR (error, "Unsupported w value [w=%d]", value);
@@ -1383,7 +1387,6 @@ _mongoc_uri_build_write_concern (mongoc_uri_t *uri, bson_error_t *error)
             mongoc_write_concern_set_wmajority (write_concern, wtimeoutms);
          } else {
             mongoc_write_concern_set_wtag (write_concern, str);
-            mongoc_write_concern_set_wtimeout (write_concern, wtimeoutms);
          }
       } else {
          BSON_ASSERT (false);
diff --git a/src/libmongoc/tests/test-mongoc-read-write-concern.c b/src/libmongoc/tests/test-mongoc-read-write-concern.c
@@ -1,51 +1,109 @@
 #include <mongoc.h>
+#include <bson-types.h>
 
 #include "mongoc-util-private.h"
 #include "mongoc-write-concern-private.h"
+#include "mongoc-read-concern-private.h"
+#include "mongoc-opts-helpers-private.h"
 #include "json-test.h"
 #include "test-libmongoc.h"
 
 
 static void
-compare_write_concern (const bson_t *wc_doc, const mongoc_write_concern_t *wc)
+compare_write_concern (const mongoc_write_concern_t *wc_correct,
+                       const mongoc_write_concern_t *wc)
 {
-   if (bson_has_field (wc_doc, "w")) {
-      ASSERT_CMPINT32 (wc->w, ==, bson_lookup_int32 (wc_doc, "w"));
-   } else {
-      ASSERT_CMPINT32 (wc->w, ==, MONGOC_WRITE_CONCERN_W_DEFAULT);
-   }
+   ASSERT_CMPINT32 (wc_correct->w, ==, wc->w);
+   ASSERT_CMPINT32 (wc_correct->wtimeout, ==, wc->wtimeout);
+   ASSERT_CMPINT (wc_correct->journal, ==, wc->journal);
+}
 
-   if (bson_has_field (wc_doc, "wtimeoutMS")) {
-      ASSERT_CMPINT32 (
-         wc->wtimeout, ==, bson_lookup_int32 (wc_doc, "wtimeoutMS"));
-   } else {
-      ASSERT_CMPINT32 (wc->wtimeout, ==, 0);
-   }
 
-   if (bson_has_field (wc_doc, "journal")) {
-      if (_mongoc_lookup_bool (wc_doc, "journal", false)) {
-         ASSERT_CMPINT ((int) wc->journal, ==, 1);
-      } else {
-         ASSERT_CMPINT ((int) wc->journal, ==, 0);
+static void
+compare_read_concern (const mongoc_read_concern_t *rc_correct,
+                      const mongoc_read_concern_t *rc)
+{
+   ASSERT_CMPSTR (rc_correct->level, rc->level);
+}
+
+mongoc_write_concern_t *
+convert_write_concern (const bson_t *wc_doc)
+{
+   mongoc_write_concern_t *wc;
+   bson_iter_t iter;
+   const char *key;
+
+   wc = mongoc_write_concern_new ();
+   bson_iter_init (&iter, wc_doc);
+
+   while (bson_iter_next (&iter)) {
+      key = bson_iter_key (&iter);
+
+      if (strcmp (key, "w") == 0) {
+         if (BSON_ITER_HOLDS_UTF8 (&iter)) {
+            if (strcmp (bson_lookup_utf8 (wc_doc, "w"), "majority") == 0) {
+               mongoc_write_concern_set_w (wc, MONGOC_WRITE_CONCERN_W_MAJORITY);
+            } else {
+               mongoc_write_concern_set_wtag (wc,
+                                              bson_lookup_utf8 (wc_doc, "w"));
+            }
+         } else {
+            if (bson_lookup_int32 (wc_doc, "w") < 0) {
+               goto invalid;
+            }
+            mongoc_write_concern_set_w (wc, bson_lookup_int32 (wc_doc, "w"));
+         }
+      } else if (strcmp (key, "wtimeoutMS") == 0) {
+         if (bson_lookup_int32 (wc_doc, "wtimeoutMS") < 0) {
+            goto invalid;
+         }
+         mongoc_write_concern_set_wtimeout (
+            wc, bson_lookup_int32 (wc_doc, "wtimeoutMS"));
+      } else if (strcmp (key, "journal") == 0) {
+         mongoc_write_concern_set_journal (
+            wc, bson_iter_value (&iter)->value.v_bool);
       }
-   } else {
-      ASSERT_CMPINT (
-         (int) wc->journal, ==, MONGOC_WRITE_CONCERN_JOURNAL_DEFAULT);
    }
-}
 
+   if (wc->w == 0 && wc->journal == 1) {
+      goto invalid;
+   }
 
-static void
-compare_read_concern (const bson_t *rc_doc, const mongoc_read_concern_t *rc)
-{
-   const char *level;
+   return wc;
 
-   if (bson_has_field (rc_doc, "level")) {
-      level = bson_lookup_utf8 (rc_doc, "level");
-      ASSERT_CMPSTR (level, mongoc_read_concern_get_level (rc));
-   } else {
-      BSON_ASSERT (!mongoc_read_concern_get_level (rc));
+invalid:
+   mongoc_write_concern_destroy (wc);
+   return NULL;
+}
+
+mongoc_read_concern_t *
+convert_read_concern (const bson_t *rc_doc)
+{
+   mongoc_read_concern_t *rc;
+   bson_iter_t iter;
+   const char *key;
+
+   rc = mongoc_read_concern_new ();
+   bson_iter_init (&iter, rc_doc);
+
+   while (bson_iter_next (&iter)) {
+      key = bson_iter_key (&iter);
+
+      if (strcmp (key, "level") == 0) {
+         if (BSON_ITER_HOLDS_UTF8 (&iter)) {
+            mongoc_read_concern_set_level (rc,
+                                           bson_lookup_utf8 (rc_doc, "level"));
+         } else {
+            goto invalid;
+         }
+      }
    }
+
+   return rc;
+
+invalid:
+   mongoc_read_concern_destroy (rc);
+   return NULL;
 }
 
 
@@ -60,10 +118,13 @@ test_rw_concern_uri (bson_t *scenario)
    bool valid;
    mongoc_uri_t *uri;
    bson_t rc_doc;
-   const mongoc_read_concern_t *rc;
    bson_t wc_doc;
+   const mongoc_read_concern_t *rc;
    const mongoc_write_concern_t *wc;
+   mongoc_write_concern_t *wc_correct;
+   mongoc_read_concern_t *rc_correct;
 
+   /* initialize tests with the scenario */
    BSON_ASSERT (bson_iter_init_find (&scenario_iter, scenario, "tests"));
    BSON_ASSERT (bson_iter_recurse (&scenario_iter, &test_iter));
 
@@ -83,71 +144,87 @@ test_rw_concern_uri (bson_t *scenario)
       uri = mongoc_uri_new_with_error (uri_str, NULL);
       if (!valid) {
          BSON_ASSERT (!uri);
-         return;
+         continue;
       }
 
       BSON_ASSERT (uri);
 
       if (bson_has_field (&test, "readConcern")) {
          rc = mongoc_uri_get_read_concern (uri);
          bson_lookup_doc (&test, "readConcern", &rc_doc);
-         compare_read_concern (&rc_doc, rc);
+         rc_correct = convert_read_concern (&rc_doc);
+         compare_read_concern (rc_correct, rc);
+         mongoc_read_concern_destroy (rc_correct);
       }
 
       if (bson_has_field (&test, "writeConcern")) {
          wc = mongoc_uri_get_write_concern (uri);
          bson_lookup_doc (&test, "writeConcern", &wc_doc);
-         compare_write_concern (&wc_doc, wc);
+         wc_correct = convert_write_concern (&wc_doc);
+         compare_write_concern (wc_correct, wc);
+         mongoc_write_concern_destroy (wc_correct);
       }
 
       mongoc_uri_destroy (uri);
    }
 }
 
-
 static void
 test_rw_concern_document (bson_t *scenario)
 {
    bson_iter_t scenario_iter;
    bson_iter_t test_iter;
-   mongoc_read_write_opts_t read_write_opts;
-   bson_error_t error;
    bson_t test;
    bool valid;
-   bool r;
    bson_t rc_doc;
    bson_t wc_doc;
+   mongoc_write_concern_t *wc;
+   mongoc_read_concern_t *rc;
+   const bson_t *wc_doc_result;
+   const bson_t *rc_doc_result;
+   bson_t rc_doc_correct;
+   bson_t wc_doc_correct;
 
    BSON_ASSERT (bson_iter_init_find (&scenario_iter, scenario, "tests"));
    BSON_ASSERT (bson_iter_recurse (&scenario_iter, &test_iter));
 
    while (bson_iter_next (&test_iter)) {
       bson_iter_bson (&test_iter, &test);
-
       valid = _mongoc_lookup_bool (&test, "valid", true);
-      r = _mongoc_read_write_opts_parse (
-         NULL /* client */, &test, &read_write_opts, &error);
-
-      if (!valid) {
-         BSON_ASSERT (!r);
-         _mongoc_read_write_opts_cleanup (&read_write_opts);
-         return;
-      }
-
-      ASSERT_OR_PRINT (r, error);
 
       if (bson_has_field (&test, "readConcern")) {
          bson_lookup_doc (&test, "readConcern", &rc_doc);
-         match_bson (
-            &rc_doc, &read_write_opts.readConcern, false /* is_command */);
+         rc = convert_read_concern (&rc_doc);
+      } else {
+         rc = mongoc_read_concern_new ();
       }
 
       if (bson_has_field (&test, "writeConcern")) {
          bson_lookup_doc (&test, "writeConcern", &wc_doc);
-         compare_write_concern (&wc_doc, read_write_opts.writeConcern);
+         wc = convert_write_concern (&wc_doc);
+      } else {
+         wc = mongoc_write_concern_new ();
+      }
+
+      if (!valid) {
+         BSON_ASSERT (rc == NULL || wc == NULL);
+         continue;
+      }
+
+      if (bson_has_field (&test, "readConcernDocument")) {
+         bson_lookup_doc (&test, "readConcernDocument", &rc_doc_correct);
+         rc_doc_result = _mongoc_read_concern_get_bson (rc);
+         match_bson (&rc_doc_correct, rc_doc_result, false /* is_command */);
+      }
+
+      if (bson_has_field (&test, "writeConcernDocument")) {
+         bson_lookup_doc (&test, "writeConcernDocument", &wc_doc_correct);
+         wc_doc_result = _mongoc_write_concern_get_bson (wc);
+         match_bson (&wc_doc_correct, wc_doc_result, false);
       }
 
-      _mongoc_read_write_opts_cleanup (&read_write_opts);
+      mongoc_write_concern_destroy (wc);
+      mongoc_read_concern_destroy (rc);
    }
 }
 
@@ -161,6 +238,7 @@ test_read_write_concern_install (TestSuite *suite)
       realpath (JSON_DIR "/read_write_concern/connection-string", resolved));
    install_json_test_suite (suite, resolved, &test_rw_concern_uri);
 
-   test_framework_resolve_path (JSON_DIR "/read_write_concern/document", resolved);
+   test_framework_resolve_path (JSON_DIR "/read_write_concern/document",
+                                resolved);
    install_json_test_suite (suite, resolved, &test_rw_concern_document);
 }
