libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-status.c

@@ -73,4 +73,4 @@ static void _test_status_len(_mongocrypt_tester_t *tester) {
 
 void _mongocrypt_tester_install_status(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_status_len);
-}
+}

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt.c

@@ -52,7 +52,7 @@ void _load_json_as_bson(const char *path, bson_t *out) {
 
     reader = bson_json_reader_new_from_file(path, &error);
     if (!reader) {
-        fprintf(stderr, "error reading: %s\n", path);
+        TEST_STDERR_PRINTF("error reading: %s\n", path);
     }
     ASSERT_OR_PRINT_BSON(reader, error);
     bson_init(out);
@@ -81,10 +81,13 @@ void _usleep(int64_t usec) {
 }
 
 #define TEST_DATA_COUNT_INC(var)                                                                                       \
-    (var)++;                                                                                                           \
-    if ((var) >= TEST_DATA_COUNT) {                                                                                    \
-        TEST_ERROR("TEST_DATA_COUNT exceeded for %s. Increment TEST_DATA_COUNT.", #var);                               \
-    }
+    if (1) {                                                                                                           \
+        (var)++;                                                                                                       \
+        if ((var) >= TEST_DATA_COUNT) {                                                                                \
+            TEST_ERROR("TEST_DATA_COUNT exceeded for %s. Increment TEST_DATA_COUNT.", #var);                           \
+        }                                                                                                              \
+    } else                                                                                                             \
+        ((void)0)
 
 static void _load_json(_mongocrypt_tester_t *tester, const char *path) {
     bson_t as_bson;
@@ -118,7 +121,7 @@ static void _load_http(_mongocrypt_tester_t *tester, const char *path) {
     }
 
     if (n_read < 0) {
-        fprintf(stderr, "failed to read %s\n", path);
+        TEST_STDERR_PRINTF("failed to read %s\n", path);
         abort();
     }
 
@@ -158,12 +161,12 @@ void _mongocrypt_tester_install(_mongocrypt_tester_t *tester,
 #endif
 
     if (crypto_spec == CRYPTO_REQUIRED && !crypto_enabled) {
-        printf("Skipping test: %s – requires crypto to be enabled\n", name);
+        TEST_PRINTF("Skipping test: %s – requires crypto to be enabled\n", name);
         return;
     }
 
     if (crypto_spec == CRYPTO_PROHIBITED && crypto_enabled) {
-        printf("Skipping test: %s – requires crypto to be disabled\n", name);
+        TEST_PRINTF("Skipping test: %s – requires crypto to be disabled\n", name);
         return;
     }
 
@@ -198,62 +201,120 @@ mongocrypt_binary_t *_mongocrypt_tester_file(_mongocrypt_tester_t *tester, const
     return to_return;
 }
 
-bson_t *_mongocrypt_tester_bson_from_json(_mongocrypt_tester_t *tester, const char *json, ...) {
-    va_list ap;
-    char *full_json;
-    bson_t *bson;
-    bson_error_t error;
-    char *c;
+bson_t *_mongocrypt_tester_file_as_bson(_mongocrypt_tester_t *tester, const char *path) {
+    mongocrypt_binary_t *bin = _mongocrypt_tester_file(tester, path);
+    bson_t *bson = &tester->test_bson[tester->bson_count];
+    TEST_DATA_COUNT_INC(tester->bson_count);
+    ASSERT(_mongocrypt_binary_to_bson(bin, bson));
+    return bson;
+}
+
+bson_t *_mongocrypt_tester_bson_from_str(_mongocrypt_tester_t *tester, const char *json) {
+    char *const full_json = bson_strdup(json);
 
-    va_start(ap, json);
-    full_json = bson_strdupv_printf(json, ap);
     /* Replace ' with " */
-    for (c = full_json; *c; c++) {
+    for (char *c = full_json; *c; c++) {
         if (*c == '\'') {
             *c = '"';
         }
     }
 
-    va_end(ap);
-    bson = &tester->test_bson[tester->bson_count];
+    bson_error_t error;
+    bson_t *const bson = &tester->test_bson[tester->bson_count];
     TEST_DATA_COUNT_INC(tester->bson_count);
-    if (!bson_init_from_json(bson, full_json, strlen(full_json), &error)) {
-        fprintf(stderr, "%s", error.message);
+    if (!bson_init_from_json(bson, full_json, -1, &error)) {
+        TEST_STDERR_PRINTF("%s", error.message);
         abort();
     }
     bson_free(full_json);
     return bson;
 }
 
-mongocrypt_binary_t *_mongocrypt_tester_bin_from_json(_mongocrypt_tester_t *tester, const char *json, ...) {
+bson_t *_mongocrypt_tester_bson_from_json(_mongocrypt_tester_t *tester, const char *json, ...) {
     va_list ap;
-    char *full_json;
-    bson_t *bson;
-    mongocrypt_binary_t *bin;
-    bson_error_t error;
-    char *c;
-
     va_start(ap, json);
-    full_json = bson_strdupv_printf(json, ap);
-    /* Replace ' with " */
-    for (c = full_json; *c; c++) {
-        if (*c == '\'') {
-            *c = '"';
+    char *const full_json = bson_strdupv_printf(json, ap);
+    va_end(ap);
+
+    bson_t *const bson = _mongocrypt_tester_bson_from_str(tester, full_json);
+    bson_free(full_json);
+    return bson;
+}
+
+bson_t *tmp_bsonf(_mongocrypt_tester_t *tester, const char *fmt, ...) {
+    va_list arg;
+    va_start(arg, fmt);
+
+    size_t dst_capacity = strlen(fmt);
+    char *dst = bson_malloc(dst_capacity);
+    size_t dst_len = 0;
+
+#define ENSURE_CAPACITY(len)                                                                                           \
+    if (1) {                                                                                                           \
+        if ((len) + dst_len >= dst_capacity) {                                                                         \
+            dst_capacity = (len) + dst_len;                                                                            \
+            dst_capacity *= 2;                                                                                         \
+            dst = bson_realloc(dst, dst_capacity);                                                                     \
+        }                                                                                                              \
+    } else                                                                                                             \
+        (void)0
+
+    for (const char *ptr = fmt; *ptr != '\0'; ptr++) {
+        // TODO: consider optimizing this loop to use strstr to find MC_STR or MC_BSON.
+        if (0 == strncmp(ptr, "MC_STR", strlen("MC_STR"))) {
+            const char *src = va_arg(arg, const char *);
+            const size_t src_len = strlen(src);
+            ENSURE_CAPACITY(src_len + 2);
+            dst[dst_len++] = '"';
+            memcpy(dst + dst_len, src, src_len);
+            dst_len += src_len;
+            dst[dst_len++] = '"';
+            ptr += strlen("MC_STR") - 1;
+            continue;
         }
-    }
 
-    va_end(ap);
-    bson = &tester->test_bson[tester->bson_count];
-    TEST_DATA_COUNT_INC(tester->bson_count);
-    if (!bson_init_from_json(bson, full_json, strlen(full_json), &error)) {
-        fprintf(stderr, "failed to parse JSON %s: %s", error.message, json);
-        abort();
+        if (0 == strncmp(ptr, "MC_BSON", strlen("MC_BSON"))) {
+            const bson_t *src_bson = va_arg(arg, const bson_t *);
+            size_t src_len;
+            char *src = bson_as_canonical_extended_json(src_bson, &src_len);
+            ENSURE_CAPACITY(src_len);
+            strcpy(dst + dst_len, src);
+            dst_len += src_len;
+            bson_free(src);
+            ptr += strlen("MC_BSON") - 1;
+            continue;
+        }
+
+        ENSURE_CAPACITY(1);
+        dst[dst_len++] = *ptr;
     }
-    bin = mongocrypt_binary_new();
+#undef ENSURE_CAPACITY
+
+    dst[dst_len] = '\0';
+    bson_t *tmp = TMP_BSON_STR(dst);
+    va_end(arg);
+    bson_free(dst);
+    return tmp;
+}
+
+mongocrypt_binary_t *_mongocrypt_tester_bin_from_str(_mongocrypt_tester_t *tester, const char *json) {
+    mongocrypt_binary_t *const bin = mongocrypt_binary_new();
     tester->test_bin[tester->bin_count] = bin;
     TEST_DATA_COUNT_INC(tester->bin_count);
+
+    bson_t *const bson = _mongocrypt_tester_bson_from_str(tester, json);
     bin->data = (uint8_t *)bson_get_data(bson);
     bin->len = bson->len;
+    return bin;
+}
+
+mongocrypt_binary_t *_mongocrypt_tester_bin_from_json(_mongocrypt_tester_t *tester, const char *json, ...) {
+    va_list ap;
+    va_start(ap, json);
+    char *const full_json = bson_strdupv_printf(json, ap);
+    va_end(ap);
+
+    mongocrypt_binary_t *const bin = _mongocrypt_tester_bin_from_str(tester, full_json);
     bson_free(full_json);
     return bin;
 }
@@ -363,7 +424,7 @@ void _mongocrypt_tester_run_ctx_to(_mongocrypt_tester_t *tester,
             break;
         case MONGOCRYPT_CTX_ERROR:
             mongocrypt_ctx_status(ctx, status);
-            fprintf(stderr, "Got error: %s\n", mongocrypt_status_message(status, NULL));
+            TEST_STDERR_PRINTF("Got error: %s\n", mongocrypt_status_message(status, NULL));
             ASSERT_STATE_EQUAL(state, stop_state);
             mongocrypt_status_destroy(status);
             return;
@@ -395,8 +456,8 @@ const char *_mongocrypt_tester_plaintext(_mongocrypt_tester_t *tester) {
     status = mongocrypt_status_new();
     ASSERT_OR_PRINT(_mongocrypt_marking_parse_unowned(&buf, &marking, status), status);
     mongocrypt_status_destroy(status);
-    BSON_ASSERT(BSON_ITER_HOLDS_UTF8(&marking.v_iter));
-    return bson_iter_utf8(&marking.v_iter, NULL);
+    BSON_ASSERT(BSON_ITER_HOLDS_UTF8(&marking.u.fle1.v_iter));
+    return bson_iter_utf8(&marking.u.fle1.v_iter, NULL);
 }
 
 mongocrypt_binary_t *_mongocrypt_tester_encrypted_doc(_mongocrypt_tester_t *tester) {
@@ -508,26 +569,21 @@ mongocrypt_t *_mongocrypt_tester_mongocrypt(tester_mongocrypt_flags flags) {
     ASSERT_OK(mongocrypt_setopt_kms_providers(crypt, bin), crypt);
     bson_destroy(kms_providers);
     mongocrypt_binary_destroy(bin);
-    if (flags & TESTER_MONGOCRYPT_WITH_CRYPT_V1) {
-        ASSERT(mongocrypt_setopt_fle2v2(crypt, false));
-    }
     if (flags & TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB) {
         mongocrypt_setopt_append_crypt_shared_lib_search_path(crypt, "$ORIGIN");
     }
-    if (flags & TESTER_MONGOCRYPT_WITH_RANGE_V2) {
-        ASSERT(mongocrypt_setopt_use_range_v2(crypt));
-    } else {
-        crypt->opts.use_range_v2 = false;
-    }
     if (flags & TESTER_MONGOCRYPT_WITH_SHORT_CACHE) {
         ASSERT(mongocrypt_setopt_key_expiration(crypt, 1));
     }
-    ASSERT_OK(mongocrypt_init(crypt), crypt);
-    if (flags & TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB) {
-        if (mongocrypt_crypt_shared_lib_version(crypt) == 0) {
-            BSON_ASSERT(false
-                        && "tester mongocrypt requested WITH_CRYPT_SHARED_LIB, but "
-                           "no crypt_shared library was loaded by mongocrypt_init");
+    ASSERT_OK(mongocrypt_setopt_enable_multiple_collinfo(crypt), crypt);
+    if (!(flags & TESTER_MONGOCRYPT_SKIP_INIT)) {
+        ASSERT_OK(mongocrypt_init(crypt), crypt);
+        if (flags & TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB) {
+            if (mongocrypt_crypt_shared_lib_version(crypt) == 0) {
+                BSON_ASSERT(false
+                            && "tester mongocrypt requested WITH_CRYPT_SHARED_LIB, but "
+                               "no crypt_shared library was loaded by mongocrypt_init");
+            }
         }
     }
     return crypt;
@@ -535,10 +591,6 @@ mongocrypt_t *_mongocrypt_tester_mongocrypt(tester_mongocrypt_flags flags) {
 
 bool _mongocrypt_init_for_test(mongocrypt_t *crypt) {
     BSON_ASSERT_PARAM(crypt);
-    // Even if the ENABLE_USE_RANGE_V2 compile flag is on, we should have range V2 off by default for testing, as many
-    // existing tests are based around range V2 being disabled. To use range V2, use the TESTER_MONGOCRYPT_WITH_RANGE_V2
-    // flag with the above function.
-    crypt->opts.use_range_v2 = false;
     return mongocrypt_init(crypt);
 }
 
@@ -812,14 +864,14 @@ static void _test_setopt_kms_providers(_mongocrypt_tester_t *tester) {
             mongocrypt_setopt_use_need_kms_credentials_state(crypt);
         }
         if (!test->errmsg) {
-            ASSERT_OK(mongocrypt_setopt_kms_providers(crypt, TEST_BSON(test->value)), crypt);
+            ASSERT_OK(mongocrypt_setopt_kms_providers(crypt, TEST_BSON_STR(test->value)), crypt);
             if (!test->errmsg_init) {
                 ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
             } else {
                 ASSERT_FAILS(_mongocrypt_init_for_test(crypt), crypt, test->errmsg_init);
             }
         } else {
-            ASSERT_FAILS(mongocrypt_setopt_kms_providers(crypt, TEST_BSON(test->value)), crypt, test->errmsg);
+            ASSERT_FAILS(mongocrypt_setopt_kms_providers(crypt, TEST_BSON_STR(test->value)), crypt, test->errmsg);
         }
         mongocrypt_destroy(crypt);
     }
@@ -856,14 +908,24 @@ static void _test_setopt_kms_providers(_mongocrypt_tester_t *tester) {
     }
 }
 
+static void test_tmp_bsonf(_mongocrypt_tester_t *tester) {
+    bson_t *one = TMP_BSONF("{'foo' : MC_STR}", "bar");
+    ASSERT_EQUAL_BSON(one, TMP_BSONF("{'foo': 'bar'}"));
+    bson_t *two = TMP_BSONF("{'blah': MC_BSON}", one);
+    ASSERT_EQUAL_BSON(two, TMP_BSONF("{'blah': {'foo': 'bar'}}"));
+}
+
 bool _aes_ctr_is_supported_by_os = true;
 
 int main(int argc, char **argv) {
-    _mongocrypt_tester_t tester = {0};
+    static _mongocrypt_tester_t tester = {0};
     int i;
 
-    printf("Pass a list of test names to run only specific tests. E.g.:\n");
-    printf("test-mongocrypt _mongocrypt_test_mcgrew\n\n");
+    TEST_PRINTF("Pass a list of patterns to run a subset of tests.\n");
+    TEST_PRINTF("Patterns may be exact matches or include a trailing wildcard (*). Examples:\n");
+    TEST_PRINTF("  test-mongocrypt _mongocrypt_test_mcgrew\n");
+    TEST_PRINTF("  test-mongocrypt 'test_mc_*'\n");
+    TEST_PRINTF("  test-mongocrypt test_mc_named_kms_provider_parse test_mc_named_kms_provider_map\n");
 
     /* Install all tests. */
     _mongocrypt_tester_install_crypto(&tester);
@@ -908,12 +970,14 @@ int main(int argc, char **argv) {
     _mongocrypt_tester_install_efc(&tester);
     _mongocrypt_tester_install_cleanup(&tester);
     _mongocrypt_tester_install_compact(&tester);
+    _mongocrypt_tester_install_fle2_encryption_placeholder(&tester);
     _mongocrypt_tester_install_fle2_payload_uev(&tester);
     _mongocrypt_tester_install_fle2_payload_uev_v2(&tester);
     _mongocrypt_tester_install_fle2_payload_iup(&tester);
     _mongocrypt_tester_install_fle2_payload_iup_v2(&tester);
     _mongocrypt_tester_install_fle2_payload_find_equality_v2(&tester);
     _mongocrypt_tester_install_fle2_payload_find_range_v2(&tester);
+    _mongocrypt_tester_install_fle2_payload_find_text(&tester);
     _mongocrypt_tester_install_fle2_tag_and_encrypted_metadata_block(&tester);
     _mongocrypt_tester_install_range_encoding(&tester);
     _mongocrypt_tester_install_range_edge_generation(&tester);
@@ -926,6 +990,10 @@ int main(int argc, char **argv) {
     _mongocrypt_tester_install_opts(&tester);
     _mongocrypt_tester_install_named_kms_providers(&tester);
     _mongocrypt_tester_install_mc_cmp(&tester);
+    _mongocrypt_tester_install_text_search_str_encode(&tester);
+    _mongocrypt_tester_install_unicode_fold(&tester);
+    _mongocrypt_tester_install(&tester, "test_tmp_bsonf", test_tmp_bsonf, CRYPTO_OPTIONAL);
+    _mongocrypt_tester_install_mc_schema_broker(&tester);
 
 #ifdef MONGOCRYPT_ENABLE_CRYPTO_COMMON_CRYPTO
     char osversion[32];
@@ -954,32 +1022,39 @@ int main(int argc, char **argv) {
 get_os_version_failed:
 #endif
 
-    printf("Running tests...\n");
+    TEST_PRINTF("Running tests...\n");
     for (i = 0; tester.test_names[i]; i++) {
-        int j;
-        bool found = false;
-
         if (argc > 1) {
-            for (j = 1; j < argc; j++) {
-                found = (0 == strcmp(argv[j], tester.test_names[i]));
-                if (found) {
-                    break;
+            for (int j = 1; j < argc; j++) {
+                char *const pattern = argv[j];
+                const size_t pattern_len = strlen(pattern);
+                const bool match_prefix_only = pattern_len > 0u && pattern[pattern_len - 1u] == '*';
+
+                if (match_prefix_only) {
+                    if (0 == strncmp(pattern, tester.test_names[i], pattern_len - 1u)) {
+                        goto found_match;
+                    }
+                } else {
+                    if (0 == strcmp(pattern, tester.test_names[i])) {
+                        goto found_match;
+                    }
                 }
             }
-            if (!found) {
-                continue;
-            }
+
+            continue; // No match found.
         }
-        printf("  begin %s\n", tester.test_names[i]);
+    found_match : {}
+
+        TEST_PRINTF("  begin %s\n", tester.test_names[i]);
         tester.test_fns[i](&tester);
         /* Clear state. */
         memset(&tester.paths, 0, sizeof(tester.paths));
-        printf("  end %s\n", tester.test_names[i]);
+        TEST_PRINTF("  end %s\n", tester.test_names[i]);
     }
-    printf("... done running tests\n");
+    TEST_PRINTF("... done running tests\n");
 
     if (i == 0) {
-        printf("WARNING - no tests run.\n");
+        TEST_PRINTF("WARNING - no tests run.\n");
     }
 
     /* Clean up tester. */

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt.h

@@ -40,17 +40,15 @@ typedef enum tester_mongocrypt_flags {
     /// crypt_shared library must be present in the same directory as the test
     /// executable.
     TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB = 1 << 0,
-    /// Enable wire protocol version v1
-    TESTER_MONGOCRYPT_WITH_CRYPT_V1 = 1 << 1,
-    /// Enable range V2
-    TESTER_MONGOCRYPT_WITH_RANGE_V2 = 1 << 2,
     /// Short cache expiration
     TESTER_MONGOCRYPT_WITH_SHORT_CACHE = 1 << 3,
+    /// Do not call `mongocrypt_init` yet to allow for further configuration of the resulting `mongocrypt_t`.
+    TESTER_MONGOCRYPT_SKIP_INIT = 1 << 4,
 } tester_mongocrypt_flags;
 
-/* Arbitrary max of 2048 instances of temporary test data. Increase as needed.
+/* Arbitrary max of 2148 instances of temporary test data. Increase as needed.
  */
-#define TEST_DATA_COUNT 2048
+#define TEST_DATA_COUNT 2148
 
 typedef struct __mongocrypt_tester_t {
     int test_count;
@@ -180,6 +178,8 @@ void _mongocrypt_tester_install_cleanup(_mongocrypt_tester_t *tester);
 
 void _mongocrypt_tester_install_compact(_mongocrypt_tester_t *tester);
 
+void _mongocrypt_tester_install_fle2_encryption_placeholder(_mongocrypt_tester_t *tester);
+
 void _mongocrypt_tester_install_fle2_payload_uev(_mongocrypt_tester_t *tester);
 
 void _mongocrypt_tester_install_fle2_payload_uev_v2(_mongocrypt_tester_t *tester);
@@ -192,6 +192,8 @@ void _mongocrypt_tester_install_fle2_payload_find_equality_v2(_mongocrypt_tester
 
 void _mongocrypt_tester_install_fle2_payload_find_range_v2(_mongocrypt_tester_t *tester);
 
+void _mongocrypt_tester_install_fle2_payload_find_text(_mongocrypt_tester_t *tester);
+
 void _mongocrypt_tester_install_fle2_tag_and_encrypted_metadata_block(_mongocrypt_tester_t *tester);
 
 void _mongocrypt_tester_install_gcp_auth(_mongocrypt_tester_t *tester);
@@ -216,13 +218,43 @@ void _mongocrypt_tester_install_named_kms_providers(_mongocrypt_tester_t *tester
 
 void _mongocrypt_tester_install_mc_cmp(_mongocrypt_tester_t *tester);
 
+void _mongocrypt_tester_install_text_search_str_encode(_mongocrypt_tester_t *tester);
+
+void _mongocrypt_tester_install_unicode_fold(_mongocrypt_tester_t *tester);
+
+void _mongocrypt_tester_install_mc_schema_broker(_mongocrypt_tester_t *tester);
+
 /* Conveniences for getting test data. */
 
 /* Get a temporary bson_t from a JSON string. Do not free it. */
+bson_t *_mongocrypt_tester_bson_from_str(_mongocrypt_tester_t *tester, const char *json);
+#define TMP_BSON_STR(...) _mongocrypt_tester_bson_from_str(tester, __VA_ARGS__)
+
+/* Get a temporary bson_t from a formattable JSON string. Do not free it. */
+MLIB_ANNOTATE_PRINTF(2, 3)
 bson_t *_mongocrypt_tester_bson_from_json(_mongocrypt_tester_t *tester, const char *json, ...);
 #define TMP_BSON(...) _mongocrypt_tester_bson_from_json(tester, __VA_ARGS__)
 
+// TMP_BSONF builds a temporary bson_t from an extended JSON string. Do not free it.
+// Useful with BSON_STR to write JSON in-place.
+// Supports tokens MC_BSON and MC_STR.
+//
+// Examples:
+// bson_t *b = TMP_BSONF(BSON_STR({"foo": MC_STR}), "bar"); // { "foo" : "bar" }
+// bson_t *b2 = TMP_BSONF(BSON_STR({"buzz": MC_BSON }), b); // { "buzz": { "foo": "bar" }}
+bson_t *tmp_bsonf(_mongocrypt_tester_t *tester, const char *fmt, ...);
+#define TMP_BSONF(...) tmp_bsonf(tester, __VA_ARGS__)
+
+/* Get a temporary bson_t from a JSON file. Do not free it. */
+bson_t *_mongocrypt_tester_file_as_bson(_mongocrypt_tester_t *tester, const char *path);
+#define TEST_FILE_AS_BSON(path) _mongocrypt_tester_file_as_bson(tester, path)
+
 /* Get a temporary binary from a JSON string. Do not free it. */
+mongocrypt_binary_t *_mongocrypt_tester_bin_from_str(_mongocrypt_tester_t *tester, const char *json);
+#define TEST_BSON_STR(...) _mongocrypt_tester_bin_from_str(tester, __VA_ARGS__)
+
+/* Get a temporary binary from a formattable JSON string. Do not free it. */
+MLIB_ANNOTATE_PRINTF(2, 3)
 mongocrypt_binary_t *_mongocrypt_tester_bin_from_json(_mongocrypt_tester_t *tester, const char *json, ...);
 #define TEST_BSON(...) _mongocrypt_tester_bin_from_json(tester, __VA_ARGS__)
 

data/ext/libmongocrypt/libmongocrypt/test/test-named-kms-providers.c

@@ -387,7 +387,7 @@ static void test_create_datakey_with_named_kms_provider(_mongocrypt_tester_t *te
     {
         mongocrypt_t *crypt = mongocrypt_new();
         mongocrypt_binary_t *kms_providers =
-            TEST_BSON(BSON_STR({"local" : {}, "local:name1" : {"key" : "%s"}}), LOCAL_KEK1_BASE64, LOCAL_KEK2_BASE64);
+            TEST_BSON(BSON_STR({"local" : {}, "local:name1" : {"key" : "%s"}}), LOCAL_KEK1_BASE64);
         ASSERT_OK(mongocrypt_setopt_kms_providers(crypt, kms_providers), crypt);
         mongocrypt_setopt_use_need_kms_credentials_state(crypt);
         ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
@@ -425,7 +425,7 @@ static void test_create_datakey_with_named_kms_provider(_mongocrypt_tester_t *te
         bson_t out_bson;
         ASSERT(_mongocrypt_binary_to_bson(out, &out_bson));
         char *pattern = BSON_STR({"masterKey" : {"provider" : "local:name1"}});
-        _assert_match_bson(&out_bson, TMP_BSON(pattern));
+        _assert_match_bson(&out_bson, TMP_BSON_STR(pattern));
         bson_destroy(&out_bson);
         mongocrypt_binary_destroy(out);
         mongocrypt_ctx_destroy(ctx);
@@ -491,7 +491,7 @@ static void test_create_datakey_with_named_kms_provider(_mongocrypt_tester_t *te
         bson_t out_bson;
         ASSERT(_mongocrypt_binary_to_bson(out, &out_bson));
         char *pattern = BSON_STR({"masterKey" : {"provider" : "azure:name1"}});
-        _assert_match_bson(&out_bson, TMP_BSON(pattern));
+        _assert_match_bson(&out_bson, TMP_BSON_STR(pattern));
         bson_destroy(&out_bson);
         mongocrypt_binary_destroy(out);
         mongocrypt_ctx_destroy(ctx);
@@ -536,7 +536,7 @@ static void test_create_datakey_with_named_kms_provider(_mongocrypt_tester_t *te
         bson_t out_bson;
         ASSERT(_mongocrypt_binary_to_bson(out, &out_bson));
         char *pattern = BSON_STR({"masterKey" : {"provider" : "azure:name1"}});
-        _assert_match_bson(&out_bson, TMP_BSON(pattern));
+        _assert_match_bson(&out_bson, TMP_BSON_STR(pattern));
         bson_destroy(&out_bson);
         mongocrypt_binary_destroy(out);
         mongocrypt_ctx_destroy(ctx);
@@ -611,7 +611,7 @@ static void test_create_datakey_with_named_kms_provider(_mongocrypt_tester_t *te
             bson_t out_bson;
             ASSERT(_mongocrypt_binary_to_bson(out, &out_bson));
             char *pattern = BSON_STR({"masterKey" : {"provider" : "azure:name1"}});
-            _assert_match_bson(&out_bson, TMP_BSON(pattern));
+            _assert_match_bson(&out_bson, TMP_BSON_STR(pattern));
             bson_destroy(&out_bson);
             mongocrypt_binary_destroy(out);
             mongocrypt_ctx_destroy(ctx);
@@ -664,7 +664,7 @@ static void test_create_datakey_with_named_kms_provider(_mongocrypt_tester_t *te
             bson_t out_bson;
             ASSERT(_mongocrypt_binary_to_bson(out, &out_bson));
             char *pattern = BSON_STR({"masterKey" : {"provider" : "azure:name2"}});
-            _assert_match_bson(&out_bson, TMP_BSON(pattern));
+            _assert_match_bson(&out_bson, TMP_BSON_STR(pattern));
             bson_destroy(&out_bson);
             mongocrypt_binary_destroy(out);
             mongocrypt_ctx_destroy(ctx);
@@ -717,7 +717,7 @@ static void test_create_datakey_with_named_kms_provider(_mongocrypt_tester_t *te
         bson_t out_bson;
         ASSERT(_mongocrypt_binary_to_bson(out, &out_bson));
         char *pattern = BSON_STR({"masterKey" : {"provider" : "kmip:name1"}});
-        _assert_match_bson(&out_bson, TMP_BSON(pattern));
+        _assert_match_bson(&out_bson, TMP_BSON_STR(pattern));
         bson_destroy(&out_bson);
         mongocrypt_binary_destroy(out);
         mongocrypt_ctx_destroy(ctx);
@@ -810,7 +810,7 @@ static void test_create_datakey_with_named_kms_provider(_mongocrypt_tester_t *te
         bson_t out_bson;
         ASSERT(_mongocrypt_binary_to_bson(out, &out_bson));
         char *pattern = BSON_STR({"masterKey" : {"provider" : "kmip:name1"}});
-        _assert_match_bson(&out_bson, TMP_BSON(pattern));
+        _assert_match_bson(&out_bson, TMP_BSON_STR(pattern));
         bson_destroy(&out_bson);
         mongocrypt_binary_destroy(out);
         mongocrypt_ctx_destroy(ctx);
@@ -2119,7 +2119,7 @@ static void test_rewrap_with_named_kms_provider_local2local(_mongocrypt_tester_t
             bson_t bin_bson;
             ASSERT(_mongocrypt_binary_to_bson(bin, &bin_bson));
             char *pattern = BSON_STR({"v" : [ {"masterKey" : {"provider" : "local:name2"}} ]});
-            _assert_match_bson(&bin_bson, TMP_BSON(pattern));
+            _assert_match_bson(&bin_bson, TMP_BSON_STR(pattern));
         }
         mongocrypt_binary_destroy(bin);
         mongocrypt_ctx_destroy(ctx);
@@ -2242,7 +2242,7 @@ static void test_rewrap_with_named_kms_provider_azure2azure(_mongocrypt_tester_t
             bson_t bin_bson;
             ASSERT(_mongocrypt_binary_to_bson(bin, &bin_bson));
             char *pattern = BSON_STR({"v" : [ {"masterKey" : {"provider" : "azure:name2"}} ]});
-            _assert_match_bson(&bin_bson, TMP_BSON(pattern));
+            _assert_match_bson(&bin_bson, TMP_BSON_STR(pattern));
         }
         mongocrypt_binary_destroy(bin);
         mongocrypt_ctx_destroy(ctx);
@@ -2330,7 +2330,7 @@ static void test_rewrap_with_named_kms_provider_azure2local(_mongocrypt_tester_t
             bson_t bin_bson;
             ASSERT(_mongocrypt_binary_to_bson(bin, &bin_bson));
             char *pattern = BSON_STR({"v" : [ {"masterKey" : {"provider" : "local:name1"}} ]});
-            _assert_match_bson(&bin_bson, TMP_BSON(pattern));
+            _assert_match_bson(&bin_bson, TMP_BSON_STR(pattern));
         }
         mongocrypt_binary_destroy(bin);
         mongocrypt_ctx_destroy(ctx);