libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-ctx-rewrap-many-datakey.c

@@ -139,7 +139,7 @@ static int64_t _find_date_field(mongocrypt_binary_t *key, const char *dotkey) {
     ASSERT(bson_iter_init(&iter, &bson));
     ASSERT(bson_iter_find_descendant(&iter, dotkey, &iter));
     ASSERT(BSON_ITER_HOLDS_DATE_TIME(&iter));
-    ASSERT((res = bson_iter_date_time(&iter)) != 0)
+    ASSERT((res = bson_iter_date_time(&iter)) != 0);
 
     return res;
 }
@@ -570,6 +570,33 @@ static void _test_rewrap_many_datakey_need_kms_retry(_mongocrypt_tester_t *teste
     ASSERT(mongocrypt_kms_ctx_bytes_needed(kms) == 0);
     ASSERT_OK(mongocrypt_ctx_kms_done(ctx), ctx);
     ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_NEED_KMS); // To encrypt.
+    mongocrypt_ctx_destroy(ctx);
+
+    /* Clear key cache. */
+    mongocrypt_destroy(crypt);
+    crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
+
+    /* Ensure KMS encrypt requests retry for network errors */
+    ctx = mongocrypt_ctx_new(crypt);
+    ASSERT_OK(mongocrypt_ctx_rewrap_many_datakey_init(ctx, filter), ctx);
+    ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_NEED_MONGO_KEYS);
+    ASSERT_OK(mongocrypt_ctx_mongo_feed(ctx, TEST_FILE("./test/data/rmd/key-document-a.json")), ctx);
+    ASSERT_OK(mongocrypt_ctx_mongo_done(ctx), ctx);
+    ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_NEED_KMS); // To decrypt.
+    ASSERT((kms = mongocrypt_ctx_next_kms_ctx(ctx)));
+    ASSERT_OK(mongocrypt_kms_ctx_feed(kms, TEST_FILE("./test/data/rmd/kms-decrypt-reply-a.txt")), kms);
+    ASSERT(mongocrypt_kms_ctx_bytes_needed(kms) == 0);
+    ASSERT_OK(mongocrypt_ctx_kms_done(ctx), ctx);
+    ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_NEED_KMS); // To encrypt.
+    ASSERT((kms = mongocrypt_ctx_next_kms_ctx(ctx)));
+    ASSERT(mongocrypt_kms_ctx_fail(kms));             // Simulate driver-side network failure for an encrypt request.
+    ASSERT((kms = mongocrypt_ctx_next_kms_ctx(ctx))); // Assert fails. Expected KMS request to retry but did not.
+    ASSERT_OK(mongocrypt_kms_ctx_feed(kms, TEST_FILE("./test/data/rmd/kms-encrypt-reply-a.txt")), kms);
+    ASSERT(mongocrypt_kms_ctx_bytes_needed(kms) == 0);
+    ASSERT_OK(!mongocrypt_ctx_next_kms_ctx(ctx), ctx);
+    ASSERT_OK(mongocrypt_ctx_kms_done(ctx), ctx);
+    ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_READY);
+
     mongocrypt_ctx_destroy(ctx);
     mongocrypt_destroy(crypt);
 }

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

@@ -28,61 +28,61 @@ static char invalid_utf8[] = {(char)0x80, (char)0x00};
 
 /* Convenience macros for setting options */
 #define ASSERT_MASTERKEY_AWS_OK(region, region_len, cmk, cmk_len)                                                      \
-    ASSERT_OK(mongocrypt_ctx_setopt_masterkey_aws(ctx, region, region_len, cmk, cmk_len), ctx);
+    ASSERT_OK(mongocrypt_ctx_setopt_masterkey_aws(ctx, region, region_len, cmk, cmk_len), ctx)
 #define ASSERT_MASTERKEY_AWS_FAILS(region, region_len, cmk, cmk_len, msg)                                              \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_aws(ctx, region, region_len, cmk, cmk_len), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_aws(ctx, region, region_len, cmk, cmk_len), ctx, msg)
 
-#define ASSERT_MASTERKEY_LOCAL_OK ASSERT_OK(mongocrypt_ctx_setopt_masterkey_local(ctx), ctx);
-#define ASSERT_MASTERKEY_LOCAL_FAILS(msg) ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_local(ctx), ctx, msg);
+#define ASSERT_MASTERKEY_LOCAL_OK ASSERT_OK(mongocrypt_ctx_setopt_masterkey_local(ctx), ctx)
+#define ASSERT_MASTERKEY_LOCAL_FAILS(msg) ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_local(ctx), ctx, msg)
 
-#define ASSERT_KEY_ENCRYPTION_KEY_OK(bin) ASSERT_OK(mongocrypt_ctx_setopt_key_encryption_key(ctx, bin), ctx);
+#define ASSERT_KEY_ENCRYPTION_KEY_OK(bin) ASSERT_OK(mongocrypt_ctx_setopt_key_encryption_key(ctx, bin), ctx)
 #define ASSERT_KEY_ENCRYPTION_KEY_FAILS(bin, msg)                                                                      \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_key_encryption_key(ctx, bin), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_key_encryption_key(ctx, bin), ctx, msg)
 
-#define ASSERT_KEY_ID_OK(key_id) ASSERT_OK(mongocrypt_ctx_setopt_key_id(ctx, key_id), ctx);
-#define ASSERT_KEY_ID_FAILS(key_id, msg) ASSERT_FAILS(mongocrypt_ctx_setopt_key_id(ctx, key_id), ctx, msg);
+#define ASSERT_KEY_ID_OK(key_id) ASSERT_OK(mongocrypt_ctx_setopt_key_id(ctx, key_id), ctx)
+#define ASSERT_KEY_ID_FAILS(key_id, msg) ASSERT_FAILS(mongocrypt_ctx_setopt_key_id(ctx, key_id), ctx, msg)
 
-#define ASSERT_KEY_ALT_NAME_OK(key_alt_name) ASSERT_OK(mongocrypt_ctx_setopt_key_alt_name(ctx, key_alt_name), ctx);
+#define ASSERT_KEY_ALT_NAME_OK(key_alt_name) ASSERT_OK(mongocrypt_ctx_setopt_key_alt_name(ctx, key_alt_name), ctx)
 #define ASSERT_KEY_ALT_NAME_FAILS(key_alt_name, msg)                                                                   \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_key_alt_name(ctx, key_alt_name), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_key_alt_name(ctx, key_alt_name), ctx, msg)
 
-#define ASSERT_KEY_MATERIAL_OK(key_material) ASSERT_OK(mongocrypt_ctx_setopt_key_material(ctx, key_material), ctx);
+#define ASSERT_KEY_MATERIAL_OK(key_material) ASSERT_OK(mongocrypt_ctx_setopt_key_material(ctx, key_material), ctx)
 #define ASSERT_KEY_MATERIAL_FAILS(key_material, msg)                                                                   \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_key_material(ctx, key_material), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_key_material(ctx, key_material), ctx, msg)
 
-#define ASSERT_ALGORITHM_OK(algo, algo_len) ASSERT_OK(mongocrypt_ctx_setopt_algorithm(ctx, algo, algo_len), ctx);
+#define ASSERT_ALGORITHM_OK(algo, algo_len) ASSERT_OK(mongocrypt_ctx_setopt_algorithm(ctx, algo, algo_len), ctx)
 #define ASSERT_ALGORITHM_FAILS(algo, algo_len, msg)                                                                    \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_algorithm(ctx, algo, algo_len), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_algorithm(ctx, algo, algo_len), ctx, msg)
 
-#define ASSERT_QUERY_TYPE_OK(qt, qt_len) ASSERT_OK(mongocrypt_ctx_setopt_query_type(ctx, qt, qt_len), ctx);
+#define ASSERT_QUERY_TYPE_OK(qt, qt_len) ASSERT_OK(mongocrypt_ctx_setopt_query_type(ctx, qt, qt_len), ctx)
 #define ASSERT_QUERY_TYPE_FAILS(qt, qt_len, msg)                                                                       \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_query_type(ctx, qt, qt_len), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_query_type(ctx, qt, qt_len), ctx, msg)
 
 #define ASSERT_ENDPOINT_OK(endpoint, endpoint_len)                                                                     \
-    ASSERT_OK(mongocrypt_ctx_setopt_masterkey_aws_endpoint(ctx, endpoint, endpoint_len), ctx);
+    ASSERT_OK(mongocrypt_ctx_setopt_masterkey_aws_endpoint(ctx, endpoint, endpoint_len), ctx)
 #define ASSERT_ENDPOINT_FAILS(endpoint, endpoint_len, msg)                                                             \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_aws_endpoint(ctx, endpoint, endpoint_len), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_aws_endpoint(ctx, endpoint, endpoint_len), ctx, msg)
 
-#define ASSERT_DATAKEY_INIT_OK ASSERT_OK(mongocrypt_ctx_datakey_init(ctx), ctx);
-#define ASSERT_DATAKEY_INIT_FAILS(msg) ASSERT_FAILS(mongocrypt_ctx_datakey_init(ctx), ctx, msg);
+#define ASSERT_DATAKEY_INIT_OK ASSERT_OK(mongocrypt_ctx_datakey_init(ctx), ctx)
+#define ASSERT_DATAKEY_INIT_FAILS(msg) ASSERT_FAILS(mongocrypt_ctx_datakey_init(ctx), ctx, msg)
 
-#define ASSERT_ENCRYPT_INIT_OK(db, db_len, cmd) ASSERT_OK(mongocrypt_ctx_encrypt_init(ctx, db, db_len, cmd), ctx);
+#define ASSERT_ENCRYPT_INIT_OK(db, db_len, cmd) ASSERT_OK(mongocrypt_ctx_encrypt_init(ctx, db, db_len, cmd), ctx)
 #define ENCRYPT_INIT_FAILS(db, db_len, cmd, msg)                                                                       \
-    ASSERT_FAILS(mongocrypt_ctx_encrypt_init(ctx, db, db_len, cmd), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_encrypt_init(ctx, db, db_len, cmd), ctx, msg)
 
-#define ASSERT_EX_ENCRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_explicit_encrypt_init(ctx, bin), ctx);
-#define ASSERT_EX_ENCRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_explicit_encrypt_init(ctx, bin), ctx, msg);
+#define ASSERT_EX_ENCRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_explicit_encrypt_init(ctx, bin), ctx)
+#define ASSERT_EX_ENCRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_explicit_encrypt_init(ctx, bin), ctx, msg)
 
 #define ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bin)                                                                      \
-    ASSERT_OK(mongocrypt_ctx_explicit_encrypt_expression_init(ctx, bin), ctx);
+    ASSERT_OK(mongocrypt_ctx_explicit_encrypt_expression_init(ctx, bin), ctx)
 #define ASSERT_EX_ENCRYPT_EXPRESSION_INIT_FAILS(bin, msg)                                                              \
-    ASSERT_FAILS(mongocrypt_ctx_explicit_encrypt_expression_init(ctx, bin), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_explicit_encrypt_expression_init(ctx, bin), ctx, msg)
 
-#define ASSERT_DECRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_decrypt_init(ctx, bin), ctx);
-#define ASSERT_DECRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_decrypt_init(ctx, bin), ctx, msg);
+#define ASSERT_DECRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_decrypt_init(ctx, bin), ctx)
+#define ASSERT_DECRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_decrypt_init(ctx, bin), ctx, msg)
 
-#define ASSERT_EX_DECRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_explicit_decrypt_init(ctx, bin), ctx);
-#define ASSERT_EX_DECRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_explicit_decrypt_init(ctx, bin), ctx, msg);
+#define ASSERT_EX_DECRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_explicit_decrypt_init(ctx, bin), ctx)
+#define ASSERT_EX_DECRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_explicit_decrypt_init(ctx, bin), ctx, msg)
 
 #define REFRESH                                                                                                        \
     do {                                                                                                               \
@@ -296,11 +296,13 @@ static void _test_setopt_key_alt_name(_mongocrypt_tester_t *tester) {
 }
 
 static void _test_setopt_key_material(_mongocrypt_tester_t *tester) {
+#define KEY_MATERIAL_PATTERN "{'keyMaterial': {'$binary': {'base64': '%s', 'subType': '00'}}%s}"
+
     /* "0123456789abcef", repeated 6 times. */
     const char *const material = "MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWYwMTIzNDU2Nzg5YWJjZGVmMDEyMzQ1"
                                  "Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWYwMTIzNDU2Nzg5YWJjZGVm";
-    const char *const pattern = "{'keyMaterial': {'$binary': {'base64': '%s', 'subType': '00'}}%s}";
-    mongocrypt_binary_t *const valid = TEST_BSON(pattern, material, "");
+
+    mongocrypt_binary_t *const valid = TEST_BSON(KEY_MATERIAL_PATTERN, material, "");
 
     mongocrypt_t *crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
     mongocrypt_ctx_t *ctx = NULL;
@@ -320,18 +322,19 @@ static void _test_setopt_key_material(_mongocrypt_tester_t *tester) {
 
     /* Test empty key material. */
     REFRESH;
-    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(pattern, "", ""), "keyMaterial should have length 96, but has length 0");
+    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(KEY_MATERIAL_PATTERN, "", ""),
+                              "keyMaterial should have length 96, but has length 0");
 
     /* Test too short key material. */
     REFRESH;
-    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(pattern,
+    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(KEY_MATERIAL_PATTERN,
                                         "dG9vc2hvcnQ=", /* "tooshort" */
                                         ""),
                               "keyMaterial should have length 96, but has length 8");
 
     /* Test too long key material. */
     REFRESH;
-    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(pattern,
+    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(KEY_MATERIAL_PATTERN,
                                         /* "0123456789abcdef", repeated 6 times, followed by "toolong". */
                                         "MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWYwMTIzNDU2Nzg5YWJjZGVmMDEyM"
                                         "zQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWYwMTIzNDU2Nzg5YWJjZGVmdG9vbG9uZw"
@@ -351,7 +354,7 @@ static void _test_setopt_key_material(_mongocrypt_tester_t *tester) {
 
     /* Test extra key. */
     REFRESH;
-    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(pattern, material, ", 'a': 1"),
+    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(KEY_MATERIAL_PATTERN, material, ", 'a': 1"),
                               "unrecognized field, only keyMaterial expected");
 
     /* Test error propagation. */
@@ -361,6 +364,8 @@ static void _test_setopt_key_material(_mongocrypt_tester_t *tester) {
 
     mongocrypt_ctx_destroy(ctx);
     mongocrypt_destroy(crypt);
+
+#undef KEY_MATERIAL_PATTERN
 }
 
 static void _test_setopt_algorithm(_mongocrypt_tester_t *tester) {
@@ -393,7 +398,7 @@ static void _test_setopt_algorithm(_mongocrypt_tester_t *tester) {
 
     REFRESH;
     _mongocrypt_ctx_fail_w_msg(ctx, "test");
-    ASSERT_ALGORITHM_FAILS(RAND, -1, "test")
+    ASSERT_ALGORITHM_FAILS(RAND, -1, "test");
 
     /* Test case insensitive. */
     REFRESH;
@@ -435,7 +440,7 @@ static void _test_setopt_query_type(_mongocrypt_tester_t *tester) {
     /* Test with failed context. */
     REFRESH;
     _mongocrypt_ctx_fail_w_msg(ctx, "test");
-    ASSERT_QUERY_TYPE_FAILS(MONGOCRYPT_QUERY_TYPE_EQUALITY_STR, -1, "test")
+    ASSERT_QUERY_TYPE_FAILS(MONGOCRYPT_QUERY_TYPE_EQUALITY_STR, -1, "test");
 
     /* Test case insensitive. */
     REFRESH;
@@ -652,7 +657,7 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
 
     REFRESH;
     ASSERT_ALGORITHM_OK(RAND, -1);
-    ASSERT_EX_ENCRYPT_INIT_FAILS(bson, "key id or key alt name required")
+    ASSERT_EX_ENCRYPT_INIT_FAILS(bson, "key id or key alt name required");
 
     REFRESH;
     ASSERT_KEY_ID_OK(uuid);
@@ -843,7 +848,7 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
     {
         // Create a crypt with rangeV2 enabled.
         mongocrypt_destroy(crypt);
-        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT | TESTER_MONGOCRYPT_WITH_RANGE_V2);
+        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT | TESTER_MONGOCRYPT_DEFAULT);
         REFRESH_CTX;
         /* Set key ID to get past the 'either key id or key alt name required'
          * error */
@@ -899,7 +904,7 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
     // Can't use "rangePreview" algorithm or query type with range V2.
     {
         mongocrypt_destroy(crypt);
-        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_WITH_RANGE_V2);
+        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
         REFRESH_CTX;
         ASSERT_KEY_ID_OK(uuid);
         ASSERT_FAILS(mongocrypt_ctx_setopt_algorithm(ctx, MONGOCRYPT_ALGORITHM_RANGEPREVIEW_DEPRECATED_STR, -1),
@@ -907,7 +912,7 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
                      "'rangePreview' is deprecated");
 
         mongocrypt_destroy(crypt);
-        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_WITH_RANGE_V2);
+        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
         REFRESH_CTX;
         ASSERT_KEY_ID_OK(uuid);
         ASSERT_FAILS(mongocrypt_ctx_setopt_query_type(ctx, MONGOCRYPT_QUERY_TYPE_RANGEPREVIEW_DEPRECATED_STR, -1),
@@ -915,58 +920,12 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
                      "'rangePreview' is deprecated");
     }
 
-    /* Error if query type == "rangePreview" and algorithm == "range" for range V1. */
-    // Explanation: Algorithm "rangePreview" accepts both query type "rangePreview" (for compatibility) and "range" (new
-    // behavior), but algorithm "range" only accepts query type "range". This is because if we are using the new
-    // algorithm type, we don't need to support the deprecated name for compatibility.
+    /* If query type == algorithm == "range", succeeds. */
     {
         REFRESH;
         ASSERT_KEY_ID_OK(uuid);
         ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
         ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGE_STR, -1);
-        ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGEPREVIEW_DEPRECATED_STR, -1);
-        ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
-        ASSERT_EX_ENCRYPT_EXPRESSION_INIT_FAILS(bson, "must match index_type");
-    }
-
-    /* If query type == "range" and algorithm == "rangePreview", succeeds for range V1 */
-    {
-        REFRESH;
-        ASSERT_KEY_ID_OK(uuid);
-        ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
-        ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGEPREVIEW_DEPRECATED_STR, -1);
-        ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGE_STR, -1);
-        ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
-        ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bson);
-    }
-
-    /* If query type == algorithm == "rangePreview", succeeds for range V1. */
-    {
-        REFRESH;
-        ASSERT_KEY_ID_OK(uuid);
-        ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
-        ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGEPREVIEW_DEPRECATED_STR, -1);
-        ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGEPREVIEW_DEPRECATED_STR, -1);
-        ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
-        ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bson);
-    }
-
-    /* If query type == algorithm == "range", succeeds for both V2 and V1. */
-    {
-        REFRESH;
-        ASSERT_KEY_ID_OK(uuid);
-        ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
-        ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGE_STR, -1);
-        ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGE_STR, -1);
-        ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
-        ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bson);
-
-        mongocrypt_destroy(crypt);
-        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_WITH_RANGE_V2);
-        REFRESH_CTX;
-        ASSERT_KEY_ID_OK(uuid);
-        ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
-        ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGE_STR, -1);
         ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGE_STR, -1);
         ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
         ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bson);
@@ -1148,7 +1107,7 @@ static void _test_setopt_endpoint(_mongocrypt_tester_t *tester) {
 
     REFRESH;
     _mongocrypt_ctx_fail_w_msg(ctx, "test");
-    ASSERT_ENDPOINT_FAILS(RAND, -1, "test")
+    ASSERT_ENDPOINT_FAILS(RAND, -1, "test");
 
     mongocrypt_ctx_destroy(ctx);
     mongocrypt_destroy(crypt);
@@ -1169,7 +1128,7 @@ static void _test_createdatakey_with_wrong_kms_provider_helper(_mongocrypt_teste
     mongocrypt_setopt_use_need_kms_credentials_state(crypt);
     ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
     ctx = mongocrypt_ctx_new(crypt);
-    ASSERT_OK(mongocrypt_ctx_setopt_key_encryption_key(ctx, TEST_BSON(kek)), ctx);
+    ASSERT_OK(mongocrypt_ctx_setopt_key_encryption_key(ctx, TEST_BSON_STR(kek)), ctx);
     ASSERT_FAILS(mongocrypt_ctx_datakey_init(ctx), ctx, "kms provider required by datakey is not configured");
 
     mongocrypt_ctx_destroy(ctx);

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

@@ -539,7 +539,7 @@ static void _test_create_datakey_with_retry(_mongocrypt_tester_t *tester) {
             const char *str = (const char *)mongocrypt_binary_data(bin);
             ASSERT_STRCONTAINS(str, "oauth2");
             mongocrypt_binary_destroy(bin);
-        };
+        }
 
         // Feed a successful response.
         ASSERT_OK(mongocrypt_kms_ctx_feed(kms_ctx, TEST_FILE("./test/data/kms-azure/oauth-response.txt")), kms_ctx);

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

@@ -13,10 +13,13 @@ static void _test_load_simple_library(_mongocrypt_tester_t *t) {
     mstr dll_path =
         mpath_join(mpath_parent(self_path.view, MPATH_NATIVE), mstrv_view_cstr("test-dll.dll"), MPATH_NATIVE);
 
-    mcr_dll lib = mcr_dll_open(dll_path.data);
-    BSON_ASSERT(lib.error_string.len == 0);
+    mcr_dll lib = mcr_dll_open(dll_path.raw.data);
+    BSON_ASSERT(lib.error_string.raw.len == 0);
+
+    MC_BEGIN_CAST_FUNCTION_TYPE_STRICT_IGNORE
+    int (*say_hello)(void) = (int (*)(void))mcr_dll_sym(lib, "say_hello");
+    MC_END_CAST_FUNCTION_TYPE_STRICT_IGNORE
 
-    int (*say_hello)(void) = mcr_dll_sym(lib, "say_hello");
     BSON_ASSERT(say_hello != NULL);
 
     int rval = say_hello();
@@ -31,7 +34,7 @@ static void _test_load_nonesuch(_mongocrypt_tester_t *t) {
     (void)t;
     mcr_dll lib = mcr_dll_open("no-such-directory/no-such-lib.dll");
     BSON_ASSERT(lib._native_handle == NULL);
-    BSON_ASSERT(lib.error_string.len > 0);
+    BSON_ASSERT(lib.error_string.raw.len > 0);
     mcr_dll_close(lib);
 }
 

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

@@ -18,7 +18,7 @@
 
 #include "test-mongocrypt.h"
 
-void _test_mongocrypt_endpoint(_mongocrypt_tester_t *tester) {
+static void _test_mongocrypt_endpoint(_mongocrypt_tester_t *tester) {
     _mongocrypt_endpoint_t *endpoint;
     mongocrypt_status_t *status;
     _mongocrypt_endpoint_parse_opts_t opts;

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

@@ -46,7 +46,7 @@ static void _run_one_test(_mongocrypt_tester_t *tester, bson_t *test) {
     }
 
     input_str = bson_as_relaxed_extended_json(&input, NULL);
-    printf("- testcase: %s\n", input_str);
+    TEST_PRINTF("- testcase: %s\n", input_str);
     bson_free(input_str);
 
     ret = _mongocrypt_kek_parse_owned(&input, &kek, status);
@@ -81,7 +81,7 @@ static void _run_one_test(_mongocrypt_tester_t *tester, bson_t *test) {
     mongocrypt_status_destroy(status);
 }
 
-void test_mongocrypt_kek_parsing(_mongocrypt_tester_t *tester) {
+static void test_mongocrypt_kek_parsing(_mongocrypt_tester_t *tester) {
     bson_t test_file;
     bson_iter_t iter;
 

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

@@ -30,7 +30,7 @@ typedef struct {
 
 /* The JSON spec tests refer to key ids by a shorthand integer.
  * This function maps that integer to a UUID buffer. */
-void lookup_key_id(uint32_t index, _mongocrypt_buffer_t *buf) {
+static void lookup_key_id(uint32_t index, _mongocrypt_buffer_t *buf) {
     const char *key_ids[] = {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
                              "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
                              "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"};
@@ -44,10 +44,8 @@ void lookup_key_id(uint32_t index, _mongocrypt_buffer_t *buf) {
 /* Generate a realistic key document given a @key_description, which contains an
  * _id
  * and possible keyAltNames. key_out and key_doc_out are NULLable outputs. */
-void gen_key(_mongocrypt_tester_t *tester,
-             bson_t *key_description,
-             bson_t *key_out,
-             _mongocrypt_key_doc_t *key_doc_out) {
+static void
+gen_key(_mongocrypt_tester_t *tester, bson_t *key_description, bson_t *key_out, _mongocrypt_key_doc_t *key_doc_out) {
     bson_iter_t iter;
     _mongocrypt_buffer_t key_material;
     _mongocrypt_buffer_t key_id;
@@ -236,7 +234,7 @@ static bool _match_one_cache_entry(_mongocrypt_cache_pair_t *pair, bson_t *expec
     }
 
     if (!_mongocrypt_key_alt_name_unique_list_equal(key_alt_names, attr->alt_names)) {
-        printf("failed to match key alt names\n");
+        TEST_PRINTF("failed to match key alt names\n");
         goto done;
     }
 
@@ -268,7 +266,7 @@ static void _match_cache_entry(_mongocrypt_tester_t *tester, mongocrypt_ctx_t *c
     while (pair) {
         if (_match_one_cache_entry(pair, expected_entry)) {
             if (matched) {
-                printf("double matched entry: %s\n", bson_as_relaxed_extended_json(expected_entry, NULL));
+                TEST_PRINTF("double matched entry: %s\n", bson_as_relaxed_extended_json(expected_entry, NULL));
                 BSON_ASSERT(false);
             }
             matched = true;
@@ -278,7 +276,7 @@ static void _match_cache_entry(_mongocrypt_tester_t *tester, mongocrypt_ctx_t *c
     }
 
     if (!matched) {
-        printf("could not match entry: %s\n", bson_as_relaxed_extended_json(expected_entry, NULL));
+        TEST_PRINTF("could not match entry: %s\n", bson_as_relaxed_extended_json(expected_entry, NULL));
         BSON_ASSERT(false);
     }
 }
@@ -291,11 +289,11 @@ static void _run_one_test(_mongocrypt_tester_t *tester, mongocrypt_ctx_t *ctx, b
     mongocrypt_status_t *status;
 
     if (bson_iter_init_find(&iter, test, "description")) {
-        printf("- %s\n", bson_iter_utf8(&iter, NULL));
+        TEST_PRINTF("- %s\n", bson_iter_utf8(&iter, NULL));
     }
 
     if (bson_iter_init_find(&iter, test, "skipReason")) {
-        printf("  - skipping: %s\n", bson_iter_utf8(&iter, NULL));
+        TEST_PRINTF("  - skipping: %s\n", bson_iter_utf8(&iter, NULL));
         return;
     }
 
@@ -407,7 +405,7 @@ static void _test_key_cache(_mongocrypt_tester_t *tester) {
 
         bson_iter_bson(&iter, &test);
 
-        BSON_ASSERT(mongocrypt_ctx_encrypt_init(ctx, "test", -1, TEST_BSON("{'insert': 'coll'}")));
+        BSON_ASSERT(mongocrypt_ctx_encrypt_init(ctx, "test", -1, TEST_BSON("{'insert': 'test'}")));
         _run_one_test(tester, ctx, &test);
         bson_destroy(&test);
 

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

@@ -611,7 +611,7 @@ static void _test_mongocrypt_kms_ctx_kmip_encrypt(_mongocrypt_tester_t *tester)
     _mongocrypt_endpoint_t *endpoint;
 
     _mongocrypt_buffer_t plaintext = {0};
-    ASSERT(_mongocrypt_buffer_copy_from_data_and_size(&plaintext, PLAINTEXT, sizeof(PLAINTEXT)))
+    ASSERT(_mongocrypt_buffer_copy_from_data_and_size(&plaintext, PLAINTEXT, sizeof(PLAINTEXT)));
 
     status = mongocrypt_status_new();
     endpoint = _mongocrypt_endpoint_new("example.com", -1, NULL /* opts */, status);
@@ -748,7 +748,7 @@ static void _test_mongocrypt_kms_ctx_kmip_decrypt(_mongocrypt_tester_t *tester)
     key_doc.kek.kms_provider = MONGOCRYPT_KMS_PROVIDER_KMIP;
     key_doc.kek.provider.kmip.delegated = true;
     key_doc.kek.provider.kmip.key_id = (char *)KEK_UNIQUE_IDENTIFIER;
-    ASSERT(_mongocrypt_buffer_copy_from_data_and_size(&key_doc.key_material, IV_CIPHERTEXT, sizeof(IV_CIPHERTEXT)))
+    ASSERT(_mongocrypt_buffer_copy_from_data_and_size(&key_doc.key_material, IV_CIPHERTEXT, sizeof(IV_CIPHERTEXT)));
 
     status = mongocrypt_status_new();
     endpoint = _mongocrypt_endpoint_new("example.com", -1, NULL /* opts */, status);

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

@@ -51,7 +51,7 @@ static void _test_one_kms_response(_mongocrypt_tester_t *tester, bson_t *test) {
     bson_iter_t ctx_iter;
 
     BSON_ASSERT(bson_iter_init_find(&iter, test, "description"));
-    printf("- %s\n", bson_iter_utf8(&iter, NULL));
+    TEST_PRINTF("- %s\n", bson_iter_utf8(&iter, NULL));
     BSON_ASSERT(bson_iter_init_find(&ctx_iter, test, "ctx"));
     BSON_ASSERT(bson_iter_recurse(&ctx_iter, &ctx_iter));
     while (bson_iter_next(&ctx_iter)) {
@@ -94,7 +94,7 @@ static void _test_one_kms_response(_mongocrypt_tester_t *tester, bson_t *test) {
             tester->paths.key_file = "./test/data/key-document-gcp.json";
             ASSERT_OK(mongocrypt_ctx_decrypt_init(ctx, bin), ctx);
         } else {
-            fprintf(stderr, "unsupported ctx type: %s\n", ctx_type);
+            TEST_STDERR_PRINTF("unsupported ctx type: %s\n", ctx_type);
             abort();
         }
 

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

@@ -75,4 +75,4 @@ static void _test_local_roundtrip(_mongocrypt_tester_t *tester) {
 
 void _mongocrypt_tester_install_local_kms(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_local_roundtrip);
-}
+}

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

@@ -88,10 +88,10 @@ static void _test_trace_log(_mongocrypt_tester_t *tester) {
 
 #if defined(__GLIBC__) || defined(__APPLE__)
 static void _test_no_log(_mongocrypt_tester_t *tester) {
-    const int buffer_size = BUFSIZ;
     mongocrypt_t *crypt;
     mongocrypt_status_t *status;
-    char captured_logs[buffer_size];
+    char captured_logs[BUFSIZ];
+    const int buffer_size = sizeof(captured_logs);
     int saved_stdout = dup(1);
 
     /* Redirect stdout to /dev/null and capture output in a buffer