libmongocrypt-helper 1.7.4.0.1002 → 1.11.0.0.1001

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

@@ -16,251 +16,227 @@
 
 #include <mongocrypt-marking-private.h>
 
-#include "test-mongocrypt.h"
 #include "test-mongocrypt-assert.h"
+#include "test-mongocrypt.h"
 
 #include "mongocrypt-endian-private.h"
 
 #define TEST_STRING "?????" /* 3F 3F 3F 3F 3F */
 #define TEST_INT 5555555    /* 54 C5 63 */
 
-static void
-_get_bytes (const void *in, char *out, int len)
-{
-   const unsigned char *src = in;
-   char *dest = out;
+static void _get_bytes(const void *in, char *out, int len) {
+    const unsigned char *src = in;
+    char *dest = out;
 
-   for (int i = 0; i < len; i++, dest += 3) {
-      sprintf (dest, "%02X ", src[i]);
-   }
-   dest[-1] = '\0';
+    for (int i = 0; i < len; i++, dest += 3) {
+        sprintf(dest, "%02X ", src[i]);
+    }
+    dest[-1] = '\0';
 }
 
-bool
-assert_excess_bytes_removed (
-   char *key, char *wrapped, char *unwrapped, uint32_t type, bson_value_t *out)
-{
-   _mongocrypt_buffer_t plaintext = {0};
-   _mongocrypt_marking_t marking = {0};
-   bson_iter_t iter;
-   bson_t wrapper = BSON_INITIALIZER;
-   char actual[100] = {0};
-   bool ret = false;
-   bson_t bson = BSON_INITIALIZER;
+bool assert_excess_bytes_removed(char *key, char *wrapped, char *unwrapped, uint32_t type, bson_value_t *out) {
+    _mongocrypt_buffer_t plaintext = {0};
+    _mongocrypt_marking_t marking = {0};
+    bson_iter_t iter;
+    bson_t wrapper = BSON_INITIALIZER;
+    char actual[100] = {0};
+    bool ret = false;
+    bson_t bson = BSON_INITIALIZER;
 
-   BSON_APPEND_UTF8 (&bson, "str_key", TEST_STRING);
-   BSON_APPEND_INT32 (&bson, "int_key", TEST_INT);
+    BSON_APPEND_UTF8(&bson, "str_key", TEST_STRING);
+    BSON_APPEND_INT32(&bson, "int_key", TEST_INT);
 
-   bson_iter_init_find (&iter, &bson, key);
-   memcpy (&marking.v_iter, &iter, sizeof (bson_iter_t));
+    bson_iter_init_find(&iter, &bson, key);
+    memcpy(&marking.v_iter, &iter, sizeof(bson_iter_t));
 
-   bson_append_iter (&wrapper, "", 0, &marking.v_iter);
-   _get_bytes (bson_get_data (&wrapper), actual, wrapper.len);
-   BSON_ASSERT (0 == strcmp (wrapped, actual));
+    bson_append_iter(&wrapper, "", 0, &marking.v_iter);
+    _get_bytes(bson_get_data(&wrapper), actual, wrapper.len);
+    BSON_ASSERT(0 == strcmp(wrapped, actual));
 
-   _mongocrypt_buffer_from_iter (&plaintext, &(&marking)->v_iter);
-   _get_bytes (plaintext.data, actual, plaintext.len);
-   BSON_ASSERT (0 == strcmp (unwrapped, actual));
+    _mongocrypt_buffer_from_iter(&plaintext, &(&marking)->v_iter);
+    _get_bytes(plaintext.data, actual, plaintext.len);
+    BSON_ASSERT(0 == strcmp(unwrapped, actual));
 
-   _mongocrypt_marking_cleanup (&marking);
-   bson_destroy (&wrapper);
+    _mongocrypt_marking_cleanup(&marking);
+    bson_destroy(&wrapper);
 
-   ret = _mongocrypt_buffer_to_bson_value (&plaintext, type, out);
+    ret = _mongocrypt_buffer_to_bson_value(&plaintext, type, out);
 
-   _mongocrypt_buffer_cleanup (&plaintext);
-   bson_destroy (&bson);
-   return ret;
+    _mongocrypt_buffer_cleanup(&plaintext);
+    bson_destroy(&bson);
+    return ret;
 }
 
-static void
-_test_mongocrypt_buffer_from_iter (_mongocrypt_tester_t *tester)
-{
-   /*
-    * This section explains the purpose of each byte in a BSON document. This is
-    * used to extract only the value of a BSON document for later storage. Below
-    * is an example of the leftmost derivation of one of the BSON documents
-    * used for this test.
-    *
-    * NOTES:
-    * - When used as a unary operator, * means that the repetition can occur 0
-    *   or more times.
-    *
-    * - int32     4 bytes (32-bit signed integer, two's complement)
-    * - (byte*)   Zero or more modified UTF-8 encoded characters followed by
-    *             '\x00'. The (byte*) MUST NOT contain '\x00', hence it is
-    *             not full UTF-8.
-    *
-    * RULES:
-    * 1. document ::=  int32 e_list "\x00"     int32 is the total number of
-    *                                          bytes comprising the doc.
-    * 2. e_list   ::=  element e_list
-    *              |   ""
-    * 3. element  ::=  "\x02" e_name string    UTF-8 string
-    *              |   "\x10" e_name int32 	  32-bit integer
-    * 4. e_name   ::=  cstring                 Key name
-    * 5. string   ::=  int32 (byte*) "\x00"
-    * 6. cstring  ::=  (byte*) "\x00"
-    *
-    * BELOW IS A LEFTMOST DERIVATION:
-    * Let doc = { "" : "?????" }
-    *
-    * -  doc  ::= int32 e_list "\x00"
-    *
-    * -- rule2 -> int32 element e_list "\x00"
-    * -- rule3 -> int32 "\x02" e_name string e_list "\x00"
-    * -- rule4 -> int32 "\x02" cstring string e_list "\x00"
-    * -- rule6 -> int32 "\x02" (byte*) "\x00" string e_list "\x00"
-    * -- key   -> int32 "\x02" "" "\x00" string e_list "\x00"
-    ** The key is an empty string, i.e. 0 bytes **
-    * -- rule5 -> int32 "\x02" "" "\x00" int32 (byte*) "\x00" e_list "\x00"
-    * -- value -> int32 "\x02" "" "\x00" int32=6 "?????" "\x00" e_list "\x00"
-    ** Above, the value is set. The int32 before the value is the size of the **
-    ** value in bytes, plus one for the the null char. **
-    * -- rule2 -> int32=17 "\x02" "" "\x00" int32=6 "?????" "\x00" "" "\x00"
-    *
-    * Finally, we have the byte sequence:
-    *    "11000000 02 "" 00 06000000 "?????" 00 00"
-    *
-    * Note, the hexcode for '?' is '3F'. Grouping the sequence by byte for
-    * readability, more precisely we have:
-    *    "11 00 00 00 02 00 06 00 00 00 3F 3F 3F 3F 3F 00 00"
-    *
-    * with the value, including its length and null terminator being:
-    *    "06 00 00 00 3F 3F 3F 3F 3F 00".
-    * This is what we will store.
-    */
-
-   bson_t wrapper = BSON_INITIALIZER;
-   bson_value_t out;
-
-
-   BSON_ASSERT (assert_excess_bytes_removed (
-      "str_key",
-      "11 00 00 00 02 00 06 00 00 00 3F 3F 3F 3F 3F 00 00",
-      /** no prefix **/ "06 00 00 00 3F 3F 3F 3F 3F 00",
-      0x02, /* string type */
-      &out));
-
-   BSON_ASSERT (out.value_type == BSON_TYPE_UTF8);
-   BSON_ASSERT (0 == strcmp (TEST_STRING, out.value.v_utf8.str));
-   BSON_ASSERT (5 == out.value.v_utf8.len);
-   bson_value_destroy (&out);
-
-   BSON_ASSERT (assert_excess_bytes_removed ("int_key",
+static void _test_mongocrypt_buffer_from_iter(_mongocrypt_tester_t *tester) {
+    /*
+     * This section explains the purpose of each byte in a BSON document. This is
+     * used to extract only the value of a BSON document for later storage. Below
+     * is an example of the leftmost derivation of one of the BSON documents
+     * used for this test.
+     *
+     * NOTES:
+     * - When used as a unary operator, * means that the repetition can occur 0
+     *   or more times.
+     *
+     * - int32     4 bytes (32-bit signed integer, two's complement)
+     * - (byte*)   Zero or more modified UTF-8 encoded characters followed by
+     *             '\x00'. The (byte*) MUST NOT contain '\x00', hence it is
+     *             not full UTF-8.
+     *
+     * RULES:
+     * 1. document ::=  int32 e_list "\x00"     int32 is the total number of
+     *                                          bytes comprising the doc.
+     * 2. e_list   ::=  element e_list
+     *              |   ""
+     * 3. element  ::=  "\x02" e_name string    UTF-8 string
+     *              |   "\x10" e_name int32 	  32-bit integer
+     * 4. e_name   ::=  cstring                 Key name
+     * 5. string   ::=  int32 (byte*) "\x00"
+     * 6. cstring  ::=  (byte*) "\x00"
+     *
+     * BELOW IS A LEFTMOST DERIVATION:
+     * Let doc = { "" : "?????" }
+     *
+     * -  doc  ::= int32 e_list "\x00"
+     *
+     * -- rule2 -> int32 element e_list "\x00"
+     * -- rule3 -> int32 "\x02" e_name string e_list "\x00"
+     * -- rule4 -> int32 "\x02" cstring string e_list "\x00"
+     * -- rule6 -> int32 "\x02" (byte*) "\x00" string e_list "\x00"
+     * -- key   -> int32 "\x02" "" "\x00" string e_list "\x00"
+     ** The key is an empty string, i.e. 0 bytes **
+     * -- rule5 -> int32 "\x02" "" "\x00" int32 (byte*) "\x00" e_list "\x00"
+     * -- value -> int32 "\x02" "" "\x00" int32=6 "?????" "\x00" e_list "\x00"
+     ** Above, the value is set. The int32 before the value is the size of the **
+     ** value in bytes, plus one for the the null char. **
+     * -- rule2 -> int32=17 "\x02" "" "\x00" int32=6 "?????" "\x00" "" "\x00"
+     *
+     * Finally, we have the byte sequence:
+     *    "11000000 02 "" 00 06000000 "?????" 00 00"
+     *
+     * Note, the hexcode for '?' is '3F'. Grouping the sequence by byte for
+     * readability, more precisely we have:
+     *    "11 00 00 00 02 00 06 00 00 00 3F 3F 3F 3F 3F 00 00"
+     *
+     * with the value, including its length and null terminator being:
+     *    "06 00 00 00 3F 3F 3F 3F 3F 00".
+     * This is what we will store.
+     */
+
+    bson_t wrapper = BSON_INITIALIZER;
+    bson_value_t out;
+
+    BSON_ASSERT(assert_excess_bytes_removed("str_key",
+                                            "11 00 00 00 02 00 06 00 00 00 3F 3F 3F 3F 3F 00 00",
+                                            /** no prefix **/ "06 00 00 00 3F 3F 3F 3F 3F 00",
+                                            0x02, /* string type */
+                                            &out));
+
+    BSON_ASSERT(out.value_type == BSON_TYPE_UTF8);
+    BSON_ASSERT(0 == strcmp(TEST_STRING, out.value.v_utf8.str));
+    BSON_ASSERT(5 == out.value.v_utf8.len);
+    bson_value_destroy(&out);
+
+    BSON_ASSERT(assert_excess_bytes_removed("int_key",
+                                            "0B 00 00 00 10 00 63 C5 54 00 00",
+                                            /** no prefix **/ "63 C5 54 00",
+                                            0x10, /* int type */
+                                            &out));
+
+    BSON_ASSERT(out.value_type == BSON_TYPE_INT32);
+    BSON_ASSERT(TEST_INT == out.value.v_int32);
+
+    BSON_ASSERT(!assert_excess_bytes_removed("int_key",
                                              "0B 00 00 00 10 00 63 C5 54 00 00",
                                              /** no prefix **/ "63 C5 54 00",
-                                             0x10, /* int type */
+                                             0x99, /* invalid type */
                                              &out));
-
-   BSON_ASSERT (out.value_type == BSON_TYPE_INT32);
-   BSON_ASSERT (TEST_INT == out.value.v_int32);
-
-   BSON_ASSERT (
-      !assert_excess_bytes_removed ("int_key",
-                                    "0B 00 00 00 10 00 63 C5 54 00 00",
-                                    /** no prefix **/ "63 C5 54 00",
-                                    0x99, /* invalid type */
-                                    &out));
-   bson_destroy (&wrapper);
+    bson_destroy(&wrapper);
 }
 
-static void
-_test_mongocrypt_buffer_copy_from_data_and_size (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_buffer_t buf;
-   const uint8_t data[] = {0, 1, 2};
+static void _test_mongocrypt_buffer_copy_from_data_and_size(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t buf;
+    const uint8_t data[] = {0, 1, 2};
 
-   ASSERT (_mongocrypt_buffer_copy_from_data_and_size (&buf, data, 3));
-   ASSERT_CMPBYTES (data, sizeof (data), buf.data, buf.len);
-   _mongocrypt_buffer_cleanup (&buf);
+    ASSERT(_mongocrypt_buffer_copy_from_data_and_size(&buf, data, 3));
+    ASSERT_CMPBYTES(data, sizeof(data), buf.data, buf.len);
+    _mongocrypt_buffer_cleanup(&buf);
 }
 
-static void
-_test_mongocrypt_buffer_steal_from_data_and_size (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_buffer_t buf;
-   uint8_t *data = bson_malloc0 (3);
-
-   data[0] = 0;
-   data[1] = 1;
-   data[2] = 2;
-   ASSERT (_mongocrypt_buffer_steal_from_data_and_size (&buf, data, 3));
-   ASSERT_CMPBYTES (data, 3, buf.data, buf.len);
-   _mongocrypt_buffer_cleanup (&buf);
+static void _test_mongocrypt_buffer_steal_from_data_and_size(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t buf;
+    uint8_t *data = bson_malloc0(3);
+
+    data[0] = 0;
+    data[1] = 1;
+    data[2] = 2;
+    ASSERT(_mongocrypt_buffer_steal_from_data_and_size(&buf, data, 3));
+    ASSERT_CMPBYTES(data, 3, buf.data, buf.len);
+    _mongocrypt_buffer_cleanup(&buf);
 }
 
-static void
-_test_mongocrypt_buffer_steal_from_string (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_buffer_t buf;
-   char *str = bson_strdup ("foo");
+static void _test_mongocrypt_buffer_steal_from_string(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t buf;
+    char *str = bson_strdup("foo");
 
-   ASSERT (_mongocrypt_buffer_steal_from_string (&buf, str));
-   ASSERT_STREQUAL ((const char *) buf.data, str);
-   _mongocrypt_buffer_cleanup (&buf);
+    ASSERT(_mongocrypt_buffer_steal_from_string(&buf, str));
+    ASSERT_STREQUAL((const char *)buf.data, str);
+    _mongocrypt_buffer_cleanup(&buf);
 }
 
-static void
-_test_mongocrypt_buffer_copy_from_uint64_le (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_buffer_t expect;
-   _mongocrypt_buffer_t got;
-
-   _mongocrypt_buffer_copy_from_hex (&expect, "0100000000000000");
-   _mongocrypt_buffer_copy_from_uint64_le (
-      &got, 0x0000000000000001ULL);
-   ASSERT_CMPBYTES (expect.data, expect.len, got.data, got.len);
-   _mongocrypt_buffer_cleanup (&expect);
-   _mongocrypt_buffer_cleanup (&got);
-
-   _mongocrypt_buffer_copy_from_hex (&expect, "1122334455667788");
-   _mongocrypt_buffer_copy_from_uint64_le (
-      &got, 0x8877665544332211ULL);
-   ASSERT_CMPBYTES (expect.data, expect.len, got.data, got.len);
-   _mongocrypt_buffer_cleanup (&expect);
-   _mongocrypt_buffer_cleanup (&got);
+static void _test_mongocrypt_buffer_copy_from_uint64_le(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t expect;
+    _mongocrypt_buffer_t got;
+
+    _mongocrypt_buffer_copy_from_hex(&expect, "0100000000000000");
+    _mongocrypt_buffer_copy_from_uint64_le(&got, 0x0000000000000001ULL);
+    ASSERT_CMPBYTES(expect.data, expect.len, got.data, got.len);
+    _mongocrypt_buffer_cleanup(&expect);
+    _mongocrypt_buffer_cleanup(&got);
+
+    _mongocrypt_buffer_copy_from_hex(&expect, "1122334455667788");
+    _mongocrypt_buffer_copy_from_uint64_le(&got, 0x8877665544332211ULL);
+    ASSERT_CMPBYTES(expect.data, expect.len, got.data, got.len);
+    _mongocrypt_buffer_cleanup(&expect);
+    _mongocrypt_buffer_cleanup(&got);
 }
 
-static void
-_test_mongocrypt_buffer_from_subrange (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_buffer_t input;
-   _mongocrypt_buffer_t expect;
-   _mongocrypt_buffer_t got;
-
-   _mongocrypt_buffer_copy_from_hex (&input, "010203");
-   _mongocrypt_buffer_copy_from_hex (&expect, "01");
-   ASSERT (_mongocrypt_buffer_from_subrange (&got, &input, 0, 1));
-   ASSERT_CMPBYTES (expect.data, expect.len, got.data, got.len);
-   _mongocrypt_buffer_cleanup (&expect);
-   _mongocrypt_buffer_cleanup (&input);
-
-   _mongocrypt_buffer_copy_from_hex (&input, "010203");
-   _mongocrypt_buffer_copy_from_hex (&expect, "010203");
-   ASSERT (_mongocrypt_buffer_from_subrange (&got, &input, 0, 3));
-   ASSERT_CMPBYTES (expect.data, expect.len, got.data, got.len);
-   _mongocrypt_buffer_cleanup (&expect);
-   _mongocrypt_buffer_cleanup (&input);
-
-   _mongocrypt_buffer_copy_from_hex (&input, "010203");
-   _mongocrypt_buffer_copy_from_hex (&expect, "0203");
-   ASSERT (_mongocrypt_buffer_from_subrange (&got, &input, 1, 2));
-   ASSERT_CMPBYTES (expect.data, expect.len, got.data, got.len);
-   _mongocrypt_buffer_cleanup (&expect);
-   _mongocrypt_buffer_cleanup (&input);
-
-   _mongocrypt_buffer_copy_from_hex (&input, "010203");
-   ASSERT (!_mongocrypt_buffer_from_subrange (&got, &input, 0, 4));
-   _mongocrypt_buffer_cleanup (&input);
+static void _test_mongocrypt_buffer_from_subrange(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t input;
+    _mongocrypt_buffer_t expect;
+    _mongocrypt_buffer_t got;
+
+    _mongocrypt_buffer_copy_from_hex(&input, "010203");
+    _mongocrypt_buffer_copy_from_hex(&expect, "01");
+    ASSERT(_mongocrypt_buffer_from_subrange(&got, &input, 0, 1));
+    ASSERT_CMPBYTES(expect.data, expect.len, got.data, got.len);
+    _mongocrypt_buffer_cleanup(&expect);
+    _mongocrypt_buffer_cleanup(&input);
+
+    _mongocrypt_buffer_copy_from_hex(&input, "010203");
+    _mongocrypt_buffer_copy_from_hex(&expect, "010203");
+    ASSERT(_mongocrypt_buffer_from_subrange(&got, &input, 0, 3));
+    ASSERT_CMPBYTES(expect.data, expect.len, got.data, got.len);
+    _mongocrypt_buffer_cleanup(&expect);
+    _mongocrypt_buffer_cleanup(&input);
+
+    _mongocrypt_buffer_copy_from_hex(&input, "010203");
+    _mongocrypt_buffer_copy_from_hex(&expect, "0203");
+    ASSERT(_mongocrypt_buffer_from_subrange(&got, &input, 1, 2));
+    ASSERT_CMPBYTES(expect.data, expect.len, got.data, got.len);
+    _mongocrypt_buffer_cleanup(&expect);
+    _mongocrypt_buffer_cleanup(&input);
+
+    _mongocrypt_buffer_copy_from_hex(&input, "010203");
+    ASSERT(!_mongocrypt_buffer_from_subrange(&got, &input, 0, 4));
+    _mongocrypt_buffer_cleanup(&input);
 }
 
-void
-_mongocrypt_tester_install_buffer (_mongocrypt_tester_t *tester)
-{
-   INSTALL_TEST (_test_mongocrypt_buffer_from_iter);
-   INSTALL_TEST (_test_mongocrypt_buffer_copy_from_data_and_size);
-   INSTALL_TEST (_test_mongocrypt_buffer_steal_from_data_and_size);
-   INSTALL_TEST (_test_mongocrypt_buffer_steal_from_string);
-   INSTALL_TEST (_test_mongocrypt_buffer_copy_from_uint64_le);
-   INSTALL_TEST (_test_mongocrypt_buffer_from_subrange);
+void _mongocrypt_tester_install_buffer(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(_test_mongocrypt_buffer_from_iter);
+    INSTALL_TEST(_test_mongocrypt_buffer_copy_from_data_and_size);
+    INSTALL_TEST(_test_mongocrypt_buffer_steal_from_data_and_size);
+    INSTALL_TEST(_test_mongocrypt_buffer_steal_from_string);
+    INSTALL_TEST(_test_mongocrypt_buffer_copy_from_uint64_le);
+    INSTALL_TEST(_test_mongocrypt_buffer_from_subrange);
 }

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

@@ -14,44 +14,125 @@
  * limitations under the License.
  */
 
-#include "test-mongocrypt.h"
 #include "mongocrypt-cache-oauth-private.h"
+#include "test-mongocrypt.h"
+
+static void _test_cache_oauth_expiration(_mongocrypt_tester_t *tester) {
+    mc_mapof_kmsid_to_token_t *cache;
+    char *token;
+    bool ret;
+    mongocrypt_status_t *status;
+
+    cache = mc_mapof_kmsid_to_token_new();
+    token = mc_mapof_kmsid_to_token_get_token(cache, "aws");
+    BSON_ASSERT(!token);
+
+    status = mongocrypt_status_new();
+    ret = mc_mapof_kmsid_to_token_add_response(cache,
+                                               "aws",
+                                               TMP_BSON("{'expires_in': 0, 'access_token': 'foo'}"),
+                                               status);
+    ASSERT_OR_PRINT(ret, status);
+    /* Does not return expired token. */
+    token = mc_mapof_kmsid_to_token_get_token(cache, "aws");
+    BSON_ASSERT(!token);
+
+    /* Attempt to get again, to ensure MONGOCRYPT-321 is fixed. */
+    token = mc_mapof_kmsid_to_token_get_token(cache, "aws");
+    BSON_ASSERT(!token);
+
+    /* Add an unexpired token. */
+    ret = mc_mapof_kmsid_to_token_add_response(cache,
+                                               "aws",
+                                               TMP_BSON("{'expires_in': 1000, 'access_token': 'bar'}"),
+                                               status);
+    ASSERT_OR_PRINT(ret, status);
+
+    token = mc_mapof_kmsid_to_token_get_token(cache, "aws");
+    ASSERT_STREQUAL(token, "bar");
+    bson_free(token);
+
+    mc_mapof_kmsid_to_token_destroy(cache);
+    mongocrypt_status_destroy(status);
+}
+
+#define BSON_STR(...) #__VA_ARGS__
 
-static void _test_cache_oauth_expiration (_mongocrypt_tester_t *tester) {
-   _mongocrypt_cache_oauth_t* cache;
-   char *token;
-   bool ret;
-   mongocrypt_status_t* status;
-   
-   cache = _mongocrypt_cache_oauth_new ();
-   token = _mongocrypt_cache_oauth_get (cache);
-   BSON_ASSERT (!token);
-
-   status = mongocrypt_status_new ();
-   ret = _mongocrypt_cache_oauth_add (cache, TMP_BSON ("{'expires_in': 0, 'access_token': 'foo'}"), status);
-   ASSERT_OR_PRINT (ret, status);
-   /* Attempting to get the token will purge the new token from the cache. */
-   token = _mongocrypt_cache_oauth_get (cache);
-   BSON_ASSERT (!token);
-
-   /* Attempt to get again, to ensure MONGOCRYPT-321 is fixed. */
-   token = _mongocrypt_cache_oauth_get (cache);
-   BSON_ASSERT (!token);
-
-   /* Add an unexpired token. */
-   ret = _mongocrypt_cache_oauth_add (cache, TMP_BSON ("{'expires_in': 1000, 'access_token': 'bar'}"), status);
-   ASSERT_OR_PRINT (ret, status);
-   
-   token = _mongocrypt_cache_oauth_get (cache);
-   ASSERT_STREQUAL (token, "bar");
-   bson_free (token);
-
-   _mongocrypt_cache_oauth_destroy (cache);
-   mongocrypt_status_destroy (status);
+static void test_mc_mapof_kmsid_to_token(_mongocrypt_tester_t *tester) {
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    bson_t *response1 = TMP_BSON(BSON_STR({"access_token" : "foo", "expires_in" : 1234}));
+    bson_t *response2 = TMP_BSON(BSON_STR({"access_token" : "bar", "expires_in" : 4567}));
+
+    // Test inserting one entry.
+    {
+        mc_mapof_kmsid_to_token_t *k2t = mc_mapof_kmsid_to_token_new();
+        ASSERT(NULL == mc_mapof_kmsid_to_token_get_token(k2t, "local:1"));
+        ASSERT_OK_STATUS(mc_mapof_kmsid_to_token_add_response(k2t, "local:1", response1, status), status);
+        char *got = mc_mapof_kmsid_to_token_get_token(k2t, "local:1");
+        ASSERT_STREQUAL(got, "foo");
+        bson_free(got);
+        mc_mapof_kmsid_to_token_destroy(k2t);
+    }
+
+    // Test inserting two entries.
+    {
+        mc_mapof_kmsid_to_token_t *k2t = mc_mapof_kmsid_to_token_new();
+
+        // Insert first.
+        {
+            ASSERT(NULL == mc_mapof_kmsid_to_token_get_token(k2t, "local:1"));
+            ASSERT_OK_STATUS(mc_mapof_kmsid_to_token_add_response(k2t, "local:1", response1, status), status);
+            char *got = mc_mapof_kmsid_to_token_get_token(k2t, "local:1");
+            ASSERT_STREQUAL(got, "foo");
+            bson_free(got);
+        }
+
+        // Insert second.
+        {
+            ASSERT(NULL == mc_mapof_kmsid_to_token_get_token(k2t, "local:2"));
+            ASSERT_OK_STATUS(mc_mapof_kmsid_to_token_add_response(k2t, "local:2", response2, status), status);
+            char *got = mc_mapof_kmsid_to_token_get_token(k2t, "local:2");
+            ASSERT_STREQUAL(got, "bar");
+            bson_free(got);
+        }
+
+        mc_mapof_kmsid_to_token_destroy(k2t);
+    }
+
+    // Test overwriting an entry.
+    {
+        mc_mapof_kmsid_to_token_t *k2t = mc_mapof_kmsid_to_token_new();
+
+        // Insert first.
+        {
+            ASSERT(NULL == mc_mapof_kmsid_to_token_get_token(k2t, "local:1"));
+            ASSERT_OK_STATUS(mc_mapof_kmsid_to_token_add_response(k2t, "local:1", response1, status), status);
+            char *got = mc_mapof_kmsid_to_token_get_token(k2t, "local:1");
+            ASSERT_STREQUAL(got, "foo");
+            bson_free(got);
+        }
+
+        // Overwrite 'local:1' with a different token.
+        {
+            ASSERT_OK_STATUS(mc_mapof_kmsid_to_token_add_response(k2t, "local:1", response2, status), status);
+            char *got = mc_mapof_kmsid_to_token_get_token(k2t, "local:1");
+            ASSERT_STREQUAL(got, "bar");
+            bson_free(got);
+        }
+
+        mc_mapof_kmsid_to_token_destroy(k2t);
+    }
+    // Test getting a missing entry.
+    {
+        mc_mapof_kmsid_to_token_t *k2t = mc_mapof_kmsid_to_token_new();
+        ASSERT(NULL == mc_mapof_kmsid_to_token_get_token(k2t, "local:1"));
+        mc_mapof_kmsid_to_token_destroy(k2t);
+    }
+
+    mongocrypt_status_destroy(status);
 }
 
-void
-_mongocrypt_tester_install_cache_oauth (_mongocrypt_tester_t *tester)
-{
-   INSTALL_TEST (_test_cache_oauth_expiration);
-}
+void _mongocrypt_tester_install_cache_oauth(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(_test_cache_oauth_expiration);
+    INSTALL_TEST(test_mc_mapof_kmsid_to_token);
+}