libmongocrypt-helper 1.8.0.0.1001 → 1.11.0.0.1001

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2023-present MongoDB, 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 <mongocrypt-opts-private.h>
+
+#include <test-mongocrypt.h>
+
+#define BSON_STR(...) #__VA_ARGS__
+
+static void test_mongocrypt_opts_kms_providers_lookup(_mongocrypt_tester_t *tester) {
+    mongocrypt_binary_t *bson = TEST_BSON(BSON_STR({"azure" : {"accessToken" : "bar"}}));
+
+    mongocrypt_t *crypt = mongocrypt_new();
+    ASSERT_OK(mongocrypt_setopt_kms_providers(crypt, bson), crypt);
+    ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
+
+    mc_kms_creds_t got;
+    ASSERT(_mongocrypt_opts_kms_providers_lookup(&crypt->opts.kms_providers, "azure", &got));
+    ASSERT(got.type == MONGOCRYPT_KMS_PROVIDER_AZURE);
+
+    ASSERT(!_mongocrypt_opts_kms_providers_lookup(&crypt->opts.kms_providers, "local", &got));
+    ASSERT(got.type == MONGOCRYPT_KMS_PROVIDER_NONE);
+
+    mongocrypt_destroy(crypt);
+}
+
+void _mongocrypt_tester_install_opts(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(test_mongocrypt_opts_kms_providers_lookup);
+}

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

@@ -101,7 +101,6 @@ static void _assert_correct_fields(bson_t *bson,
                                    int num_binary,
                                    int num_other,
                                    _util_tester_t *tester) {
-    char name[36];
     bson_iter_t iter;
     bson_iter_t child;
     int i;
@@ -112,34 +111,37 @@ static void _assert_correct_fields(bson_t *bson,
     BSON_ASSERT(num_binary < 10);
     BSON_ASSERT(num_other < 10);
 
-    memset(name, 0, 36);
-
     if (tester->parent != NEST_IN_NONE) {
         for (i = 0; i < num_other; i++) {
-            snprintf(name, 13, "other.field%d", i);
+            char *key = bson_strdup_printf("other.field%d", i);
             bson_iter_init(&iter, bson);
-            BSON_ASSERT(bson_iter_find_descendant(&iter, name, &child));
+            BSON_ASSERT(bson_iter_find_descendant(&iter, key, &child));
+            bson_free(key);
         }
 
         for (i = 0; i < num_markings; i++) {
-            snprintf(name, 18, "markings.marking%d", i);
+            char *key = bson_strdup_printf("markings.marking%d", i);
             bson_iter_init(&iter, bson);
-            BSON_ASSERT(bson_iter_find_descendant(&iter, name, &child));
+            BSON_ASSERT(bson_iter_find_descendant(&iter, key, &child));
+            bson_free(key);
         }
         for (i = 0; i < num_random; i++) {
-            snprintf(name, 15, "random.random%d", i);
+            char *key = bson_strdup_printf("random.random%d", i);
             bson_iter_init(&iter, bson);
-            BSON_ASSERT(bson_iter_find_descendant(&iter, name, &child));
+            BSON_ASSERT(bson_iter_find_descendant(&iter, key, &child));
+            bson_free(key);
         }
         for (i = 0; i < num_deterministic; i++) {
-            snprintf(name, 29, "deterministic.deterministic%d", i);
+            char *key = bson_strdup_printf("deterministic.deterministic%d", i);
             bson_iter_init(&iter, bson);
-            BSON_ASSERT(bson_iter_find_descendant(&iter, name, &child));
+            BSON_ASSERT(bson_iter_find_descendant(&iter, key, &child));
+            bson_free(key);
         }
         for (i = 0; i < num_binary; i++) {
-            snprintf(name, 15, "binary.binary%d", i);
+            char *key = bson_strdup_printf("binary.binary%d", i);
             bson_iter_init(&iter, bson);
-            BSON_ASSERT(bson_iter_find_descendant(&iter, name, &child));
+            BSON_ASSERT(bson_iter_find_descendant(&iter, key, &child));
+            bson_free(key);
         }
 
     } else {
@@ -155,7 +157,6 @@ static bson_t *_assemble_bson(int num_markings,
                               int num_binary,
                               int num_other,
                               _util_tester_t *tester) {
-    char name[24];
     bson_t *parent = NULL;
     bson_t bson;
     int i;
@@ -167,8 +168,6 @@ static bson_t *_assemble_bson(int num_markings,
     BSON_ASSERT(num_binary < 10);
     BSON_ASSERT(num_other < 10);
 
-    memset(name, 0, 24);
-
     /* If we have a nesting type, nest each kind of field inside one */
     if (tester->parent == NEST_IN_DOCUMENT) {
         parent = bson_new();
@@ -182,45 +181,50 @@ static bson_t *_assemble_bson(int num_markings,
 
     /* Append some other filler fields */
     for (i = 0; i < num_other; i++) {
-        snprintf(name, 7, "field%d", i);
-        BSON_ASSERT(bson_append_utf8(&bson, name, 6, "hi", -1));
+        char *key = bson_strdup_printf("field%d", i);
+        BSON_ASSERT(bson_append_utf8(&bson, key, 6, "hi", -1));
+        bson_free(key);
     }
 
     _reset_nesting(parent, &bson, tester->parent, "markings");
 
     /* Append some number of markings */
     for (i = 0; i < num_markings; i++) {
-        snprintf(name, 9, "marking%d", i);
-        _append_marking(&bson, name, 8);
+        char *key = bson_strdup_printf("marking%d", i);
+        _append_marking(&bson, key, 8);
+        bson_free(key);
     }
 
     _reset_nesting(parent, &bson, tester->parent, "random");
 
     /* Append some number of random ciphertexts */
     for (i = 0; i < num_random; i++) {
-        snprintf(name, 8, "random%d", i);
-        _append_ciphertext_with_subtype(&bson, name, 7, 6, MONGOCRYPT_ENCRYPTION_ALGORITHM_RANDOM, tester->tester);
+        char *key = bson_strdup_printf("random%d", i);
+        _append_ciphertext_with_subtype(&bson, key, 7, 6, MONGOCRYPT_ENCRYPTION_ALGORITHM_RANDOM, tester->tester);
+        bson_free(key);
     }
 
     _reset_nesting(parent, &bson, tester->parent, "deterministic");
 
     /* Append some number of deterministic ciphertexts */
     for (i = 0; i < num_deterministic; i++) {
-        snprintf(name, 15, "deterministic%d", i);
+        char *key = bson_strdup_printf("deterministic%d", i);
         _append_ciphertext_with_subtype(&bson,
-                                        name,
+                                        key,
                                         14,
                                         6,
                                         MONGOCRYPT_ENCRYPTION_ALGORITHM_DETERMINISTIC,
                                         tester->tester);
+        bson_free(key);
     }
 
     _reset_nesting(parent, &bson, tester->parent, "binary");
 
     /* Append some number of other bson subtype 6 fields */
     for (i = 0; i < num_binary; i++) {
-        snprintf(name, 8, "binary%d", i);
-        _append_ciphertext_with_subtype(&bson, name, 7, 5, MONGOCRYPT_ENCRYPTION_ALGORITHM_NONE, tester->tester);
+        char *key = bson_strdup_printf("binary%d", i);
+        _append_ciphertext_with_subtype(&bson, key, 7, 5, MONGOCRYPT_ENCRYPTION_ALGORITHM_NONE, tester->tester);
+        bson_free(key);
     }
 
     if (tester->parent == NEST_IN_DOCUMENT) {

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

@@ -24,6 +24,7 @@
 const char *mongocrypt_ctx_state_to_string(mongocrypt_ctx_state_t state) {
     switch (state) {
     case MONGOCRYPT_CTX_ERROR: return "MONGOCRYPT_CTX_ERROR";
+    case MONGOCRYPT_CTX_NEED_MONGO_COLLINFO_WITH_DB: return "MONGOCRYPT_CTX_NEED_MONGO_COLLINFO_WITH_DB";
     case MONGOCRYPT_CTX_NEED_MONGO_COLLINFO: return "MONGOCRYPT_CTX_NEED_MONGO_COLLINFO";
     case MONGOCRYPT_CTX_NEED_MONGO_MARKINGS: return "MONGOCRYPT_CTX_NEED_MONGO_MARKINGS";
     case MONGOCRYPT_CTX_NEED_MONGO_KEYS: return "MONGOCRYPT_CTX_NEED_MONGO_KEYS";
@@ -70,6 +71,12 @@ bool kms_ctx_feed_all(mongocrypt_kms_ctx_t *kms_ctx, const uint8_t *data, uint32
     while (mongocrypt_kms_ctx_bytes_needed(kms_ctx) > 0) {
         uint32_t len = mongocrypt_kms_ctx_bytes_needed(kms_ctx);
 
+        // Cap `len` to the total input length.
+        // `mongocrypt_kms_ctx_bytes_needed` may request more bytes than is in the response.
+        // The HTTP response parser defaults to requesting 1024 bytes initially.
+        if (len > datalen - offset) {
+            len = datalen - offset;
+        }
         ASSERT_CMPINT(offset + len, <=, datalen);
         bytes = mongocrypt_binary_new_from_data((uint8_t *)data + offset, len);
         if (!mongocrypt_kms_ctx_feed(kms_ctx, bytes)) {

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

@@ -31,6 +31,9 @@ char *data_to_hex(const uint8_t *data, size_t len);
 /* bson_iter_bson iterates a document or array into a bson_t. */
 void bson_iter_bson(bson_iter_t *iter, bson_t *bson);
 
+// `kms_ctx_feed_all` repeatedly calls `mongocrypt_kms_ctx_feed`.
+// Returns false on a failed call to `mongocrypt_kms_ctx_feed`.
+// Useful for KMIP. The KMIP response parser expects two calls: (length, then data).
 bool kms_ctx_feed_all(mongocrypt_kms_ctx_t *kms_ctx, const uint8_t *data, uint32_t datalen);
 
 #endif /* TEST_MONGOCRYPT_UTIL_H */

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

@@ -24,6 +24,7 @@
 #include "mongocrypt-marking-private.h"
 #include "mongocrypt.h"
 #include "test-mongocrypt.h"
+#include <kms_message/kms_b64.h> // kms_message_b64_pton
 
 #ifdef MONGOCRYPT_ENABLE_CRYPTO_COMMON_CRYPTO
 #include <sys/sysctl.h>
@@ -268,7 +269,7 @@ void _mongocrypt_tester_satisfy_kms(_mongocrypt_tester_t *tester, mongocrypt_kms
 
     BSON_ASSERT(mongocrypt_kms_ctx_endpoint(kms, &endpoint));
     BSON_ASSERT(endpoint == strstr(endpoint, "kms.") && strstr(endpoint, ".amazonaws.com"));
-    mongocrypt_kms_ctx_feed(kms, TEST_FILE("./test/example/kms-decrypt-reply.txt"));
+    mongocrypt_kms_ctx_feed(kms, TEST_FILE("./test/data/kms-aws/decrypt-response.txt"));
     BSON_ASSERT(0 == mongocrypt_kms_ctx_bytes_needed(kms));
 }
 
@@ -287,6 +288,7 @@ void _mongocrypt_tester_run_ctx_to(_mongocrypt_tester_t *tester,
     state = mongocrypt_ctx_state(ctx);
     while (state != stop_state) {
         switch (state) {
+        case MONGOCRYPT_CTX_NEED_MONGO_COLLINFO_WITH_DB:
         case MONGOCRYPT_CTX_NEED_MONGO_COLLINFO:
             if (tester->paths.collection_info) {
                 bin = TEST_FILE(tester->paths.collection_info);
@@ -493,6 +495,11 @@ mongocrypt_t *_mongocrypt_tester_mongocrypt(tester_mongocrypt_flags flags) {
     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;
+    }
     ASSERT_OK(mongocrypt_init(crypt), crypt);
     if (flags & TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB) {
         if (mongocrypt_crypt_shared_lib_version(crypt) == 0) {
@@ -504,6 +511,15 @@ mongocrypt_t *_mongocrypt_tester_mongocrypt(tester_mongocrypt_flags flags) {
     return crypt;
 }
 
+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);
+}
+
 static void _test_mongocrypt_bad_init(_mongocrypt_tester_t *tester) {
     mongocrypt_t *crypt;
     mongocrypt_binary_t *local_key;
@@ -511,7 +527,7 @@ static void _test_mongocrypt_bad_init(_mongocrypt_tester_t *tester) {
 
     /* Omitting a KMS provider must fail. */
     crypt = mongocrypt_new();
-    ASSERT_FAILS(mongocrypt_init(crypt), crypt, "no kms provider set");
+    ASSERT_FAILS(_mongocrypt_init_for_test(crypt), crypt, "no kms provider set");
     mongocrypt_destroy(crypt);
 
     /* Bad KMS provider options must fail. */
@@ -549,13 +565,13 @@ static void _test_mongocrypt_bad_init(_mongocrypt_tester_t *tester) {
     /* Reinitialization must fail. */
     crypt = mongocrypt_new();
     ASSERT_OK(mongocrypt_setopt_kms_provider_aws(crypt, "example", -1, "example", -1), crypt);
-    ASSERT_OK(mongocrypt_init(crypt), crypt);
-    ASSERT_FAILS(mongocrypt_init(crypt), crypt, "already initialized");
+    ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
+    ASSERT_FAILS(_mongocrypt_init_for_test(crypt), crypt, "already initialized");
     mongocrypt_destroy(crypt);
     /* Setting options after initialization must fail. */
     crypt = mongocrypt_new();
     ASSERT_OK(mongocrypt_setopt_kms_provider_aws(crypt, "example", -1, "example", -1), crypt);
-    ASSERT_OK(mongocrypt_init(crypt), crypt);
+    ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
     ASSERT_FAILS(mongocrypt_setopt_kms_provider_aws(crypt, "example", -1, "example", -1),
                  crypt,
                  "options cannot be set after initialization");
@@ -599,7 +615,7 @@ static void _test_setopt_encrypted_field_config_map(_mongocrypt_tester_t *tester
     ASSERT_OK(
         mongocrypt_setopt_encrypted_field_config_map(crypt, TEST_FILE("./test/data/encrypted-field-config-map.json")),
         crypt);
-    ASSERT_OK(mongocrypt_init(crypt), crypt);
+    ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
     mongocrypt_destroy(crypt);
 
     /* Test double setting. */
@@ -640,7 +656,7 @@ static void _test_setopt_encrypted_field_config_map(_mongocrypt_tester_t *tester
     ASSERT_OK(
         mongocrypt_setopt_kms_providers(crypt, TEST_BSON("{'aws': {'accessKeyId': 'foo', 'secretAccessKey': 'bar'}}")),
         crypt);
-    ASSERT_OK(mongocrypt_init(crypt), crypt);
+    ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
     mongocrypt_destroy(crypt);
 
     /* Test that it is an error to set both the encrypted field config map and
@@ -652,7 +668,7 @@ static void _test_setopt_encrypted_field_config_map(_mongocrypt_tester_t *tester
     ASSERT_OK(
         mongocrypt_setopt_kms_providers(crypt, TEST_BSON("{'aws': {'accessKeyId': 'foo', 'secretAccessKey': 'bar'}}")),
         crypt);
-    ASSERT_FAILS(mongocrypt_init(crypt),
+    ASSERT_FAILS(_mongocrypt_init_for_test(crypt),
                  crypt,
                  "db.coll1 is present in both schema_map and encrypted_field_config_map");
     mongocrypt_destroy(crypt);
@@ -665,7 +681,7 @@ static void _test_setopt_invalid_kms_providers(_mongocrypt_tester_t *tester) {
 
     crypt = mongocrypt_new();
     ASSERT_OK(mongocrypt_setopt_kms_provider_aws(crypt, "", 0, "", 0), crypt);
-    ASSERT_OK(mongocrypt_init(crypt), crypt);
+    ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
 
     ctx = mongocrypt_ctx_new(crypt);
     ASSERT_OK(mongocrypt_ctx_setopt_masterkey_aws(ctx, "region", -1, "cmk", 3), ctx);
@@ -683,7 +699,7 @@ static void _test_setopt_invalid_kms_providers(_mongocrypt_tester_t *tester) {
     crypt = mongocrypt_new();
     mongocrypt_setopt_use_need_kms_credentials_state(crypt);
     ASSERT_OK(mongocrypt_setopt_kms_providers(crypt, TEST_BSON("{}")), crypt);
-    ASSERT_FAILS(mongocrypt_init(crypt), crypt, "no kms provider set");
+    ASSERT_FAILS(_mongocrypt_init_for_test(crypt), crypt, "no kms provider set");
     mongocrypt_destroy(crypt);
 }
 
@@ -725,7 +741,7 @@ static void _test_setopt_kms_providers(_mongocrypt_tester_t *tester) {
          "'privateKey': {'$binary': {'base64': 'AAAA', 'subType': '00'}} }}"},
         /* endpoint is not required. */
         {"{'gcp': {'email': 'test', 'privateKey': 'AAAA' }}"},
-        {"{'gcp': {'privateKey': 'AAAA'}}", "expected UTF-8 gcp.email"},
+        {"{'gcp': {'privateKey': 'AAAA'}}", "Failed to parse KMS provider `gcp`: expected UTF-8 email"},
         {"{'gcp': {'email': 'test', 'privateKey': 'invalid base64' }}", "unable to parse base64"},
         {"{'gcp': {'endpoint': 'example', 'email': 'test', 'privateKey': "
          "'AAAA'}}",
@@ -776,15 +792,46 @@ static void _test_setopt_kms_providers(_mongocrypt_tester_t *tester) {
         if (!test->errmsg) {
             ASSERT_OK(mongocrypt_setopt_kms_providers(crypt, TEST_BSON(test->value)), crypt);
             if (!test->errmsg_init) {
-                ASSERT_OK(mongocrypt_init(crypt), crypt);
+                ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
             } else {
-                ASSERT_FAILS(mongocrypt_init(crypt), crypt, test->errmsg_init);
+                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);
         }
         mongocrypt_destroy(crypt);
     }
+
+    // Errors if followed by call to `mongocrypt_setopt_kms_providers` configuring "local".
+    // This is a regression test for: MONGOCRYPT-610
+    {
+        _mongocrypt_buffer_t local_kek_buf;
+        // Create buffer for local KEK to pass data.
+        {
+            _mongocrypt_buffer_init(&local_kek_buf);
+            _mongocrypt_buffer_resize(&local_kek_buf, MONGOCRYPT_KEY_LEN);
+            int result_len =
+                kms_message_b64_pton(EXAMPLE_LOCAL_MATERIAL, local_kek_buf.data, (size_t)local_kek_buf.len);
+            ASSERT_CMPINT(result_len, ==, MONGOCRYPT_KEY_LEN);
+        }
+
+        mongocrypt_binary_t *more = TEST_BSON("{'local' : {'key' : '%s'}}", EXAMPLE_LOCAL_MATERIAL);
+        mongocrypt_t *crypt = mongocrypt_new();
+        ASSERT_OK(mongocrypt_setopt_kms_provider_local(crypt, _mongocrypt_buffer_as_binary(&local_kek_buf)), crypt);
+        ASSERT_FAILS(mongocrypt_setopt_kms_providers(crypt, more), crypt, "already set");
+        mongocrypt_destroy(crypt);
+        _mongocrypt_buffer_cleanup(&local_kek_buf);
+    }
+
+    // Errors if followed by call to `mongocrypt_setopt_kms_providers` configuring "aws".
+    // This is a regression test for: MONGOCRYPT-610
+    {
+        mongocrypt_binary_t *more = TEST_BSON("{'aws' : {'accessKeyId' : 'foo', 'secretAccessKey' : 'bar'}}");
+        mongocrypt_t *crypt = mongocrypt_new();
+        ASSERT_OK(mongocrypt_setopt_kms_provider_aws(crypt, "foo", -1, "bar", -1), crypt);
+        ASSERT_FAILS(mongocrypt_setopt_kms_providers(crypt, more), crypt, "already set");
+        mongocrypt_destroy(crypt);
+    }
 }
 
 bool _aes_ctr_is_supported_by_os = true;
@@ -837,6 +884,7 @@ int main(int argc, char **argv) {
     _mongocrypt_tester_install_fle2_payloads(&tester);
     _mongocrypt_tester_install_fle2_iev_v2_payloads(&tester);
     _mongocrypt_tester_install_efc(&tester);
+    _mongocrypt_tester_install_cleanup(&tester);
     _mongocrypt_tester_install_compact(&tester);
     _mongocrypt_tester_install_fle2_payload_uev(&tester);
     _mongocrypt_tester_install_fle2_payload_uev_v2(&tester);
@@ -852,6 +900,8 @@ int main(int argc, char **argv) {
     _mongocrypt_tester_install_gcp_auth(&tester);
     _mongocrypt_tester_install_mc_reader(&tester);
     _mongocrypt_tester_install_mc_writer(&tester);
+    _mongocrypt_tester_install_opts(&tester);
+    _mongocrypt_tester_install_named_kms_providers(&tester);
 
 #ifdef MONGOCRYPT_ENABLE_CRYPTO_COMMON_CRYPTO
     char osversion[32];
@@ -937,8 +987,10 @@ void _test_ctx_wrap_and_feed_key(mongocrypt_ctx_t *ctx,
                                  const _mongocrypt_buffer_t *id,
                                  _mongocrypt_buffer_t *key,
                                  mongocrypt_status_t *status) {
+    mc_kms_creds_t kc;
+    ASSERT(_mongocrypt_opts_kms_providers_lookup(_mongocrypt_ctx_kms_providers(ctx), "local", &kc));
     // Wrap key using local provider.
-    _mongocrypt_buffer_t kek = _mongocrypt_ctx_kms_providers(ctx)->local.key;
+    _mongocrypt_buffer_t kek = kc.value.local.key;
     _mongocrypt_buffer_t encrypted_key;
     _mongocrypt_buffer_init(&encrypted_key);
     ASSERT_OK_STATUS(_mongocrypt_wrap_key(ctx->crypt->crypto, &kek, key, &encrypted_key, status), status);

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

@@ -42,6 +42,8 @@ typedef enum tester_mongocrypt_flags {
     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,
 } tester_mongocrypt_flags;
 
 /* Arbitrary max of 2048 instances of temporary test data. Increase as needed.
@@ -96,6 +98,9 @@ void _mongocrypt_tester_fill_buffer(_mongocrypt_buffer_t *buf, int n);
 /* Return a new initialized mongocrypt_t for testing. */
 mongocrypt_t *_mongocrypt_tester_mongocrypt(tester_mongocrypt_flags options);
 
+/* Initialize a new mongocrypt_t for use in testing. */
+bool _mongocrypt_init_for_test(mongocrypt_t *);
+
 typedef enum { CRYPTO_REQUIRED, CRYPTO_OPTIONAL, CRYPTO_PROHIBITED } _mongocrypt_tester_crypto_spec_t;
 
 void _mongocrypt_tester_install(_mongocrypt_tester_t *tester,
@@ -165,6 +170,8 @@ void _mongocrypt_tester_install_fle2_iev_v2_payloads(_mongocrypt_tester_t *teste
 
 void _mongocrypt_tester_install_efc(_mongocrypt_tester_t *tester);
 
+void _mongocrypt_tester_install_cleanup(_mongocrypt_tester_t *tester);
+
 void _mongocrypt_tester_install_compact(_mongocrypt_tester_t *tester);
 
 void _mongocrypt_tester_install_fle2_payload_uev(_mongocrypt_tester_t *tester);
@@ -195,6 +202,10 @@ void _mongocrypt_tester_install_mc_reader(_mongocrypt_tester_t *tester);
 
 void _mongocrypt_tester_install_mc_writer(_mongocrypt_tester_t *tester);
 
+void _mongocrypt_tester_install_opts(_mongocrypt_tester_t *tester);
+
+void _mongocrypt_tester_install_named_kms_providers(_mongocrypt_tester_t *tester);
+
 /* Conveniences for getting test data. */
 
 /* Get a temporary bson_t from a JSON string. Do not free it. */