fix(NODE-3777): update metadata in prose test

Author: durran

test/integration/client-side-encryption/client_side_encryption.prose.test.js

@@ -99,8 +99,8 @@ describe('Client Side Encryption Prose Tests', function () {
       await client.close();
     });
 
-    context('when encrypting with kmip', function () {
-      context('when not providing an endpoint in the master key', function () {
+    context('when encrypting with kmip', metadata, function () {
+      context('when not providing an endpoint in the master key', metadata, function () {
         const masterKey = { keyId: '1' };
         let dataKey;
         let encrypted;
@@ -121,15 +121,15 @@ describe('Client Side Encryption Prose Tests', function () {
           decrypted = await clientEncryption.decrypt(encrypted);
         });
 
-        it('must create a data key', function () {
+        it('must create a data key', metadata, function () {
           expect(dataKey).to.have.property('sub_type', 4);
         });
 
-        it('properly encrypts and decrypts', function () {
+        it('properly encrypts and decrypts', metadata, function () {
           expect(decrypted).to.equal('test');
         });
 
-        it('fails with invalid provider host', async function () {
+        it('fails with invalid provider host', metadata, async function () {
           try {
             await clientEncryptionInvalid.createDataKey('kmip', { masterKey });
           } catch (e) {
@@ -138,8 +138,8 @@ describe('Client Side Encryption Prose Tests', function () {
         });
       });
 
-      context('when providing an endpoint in the master key', function () {
-        context('when the endpoint is valid', function () {
+      context('when providing an endpoint in the master key', metadata, function () {
+        context('when the endpoint is valid', metadata, function () {
           const masterKey = { keyId: '1', endpoint: 'localhost:5698' };
           let dataKey;
           let encrypted;
@@ -160,16 +160,16 @@ describe('Client Side Encryption Prose Tests', function () {
             decrypted = await clientEncryption.decrypt(encrypted);
           });
 
-          it('must create a data key', function () {
+          it('must create a data key', metadata, function () {
             expect(dataKey).to.have.property('sub_type', 4);
           });
 
-          it('properly encrypts and decrypts', function () {
+          it('properly encrypts and decrypts', metadata, function () {
             expect(decrypted).to.equal('test');
           });
         });
 
-        context('when the endpoint is invalid', function () {
+        context('when the endpoint is invalid', metadata, function () {
           const masterKey = { keyId: '1', endpoint: 'doesnotexist.localhost:5698' };
 
           /**
@@ -178,7 +178,7 @@ describe('Client Side Encryption Prose Tests', function () {
            *      { keyId: 1, endpoint: 'doesnotexist.localhost:5698 '}
            *  - Expect failure.
            */
-          it('fails with invalid provider host', async function () {
+          it('fails with invalid provider host', metadata, async function () {
             try {
               await clientEncryption.createDataKey('kmip', { masterKey });
             } catch (e) {
@@ -302,7 +302,7 @@ describe('Client Side Encryption Prose Tests', function () {
     });
 
     // Case 1.
-    context('when using aws', function () {
+    context('when using aws', metadata, function () {
       const masterKey = {
         region: 'us-east-1',
         key: 'arn:aws:kms:us-east-1:579766882180:key/89fcc2c4-08b0-4bd9-9f25-e30687b580d0',
@@ -311,31 +311,31 @@ describe('Client Side Encryption Prose Tests', function () {
       const masterKeyExpired = { ...masterKey, endpoint: '127.0.0.1:8000' };
       const masterKeyInvalidHostname = { ...masterKey, endpoint: '127.0.0.1:8001' };
 
-      it('fails with no tls', async function () {
+      it('fails with no tls', metadata, async function () {
         try {
           await clientEncryptionNoTls.createDataKey('aws', { masterKey });
         } catch (e) {
           expect(e.originalError.message).to.include('certificate required');
         }
       });
 
-      it('passes with tls but fails to parse', async function () {
+      it('passes with tls but fails to parse', metadata, async function () {
         try {
           await clientEncryptionWithTls.createDataKey('aws', { masterKey });
         } catch (e) {
           expect(e.message).to.include('parse error');
         }
       });
 
-      it('fails with expired certificates', async function () {
+      it('fails with expired certificates', metadata, async function () {
         try {
           await clientEncryptionWithTlsExpired.createDataKey('aws', { masterKeyExpired });
         } catch (e) {
           expect(e.message).to.include('expected UTF-8 key');
         }
       });
 
-      it('fails with invalid hostnames', async function () {
+      it('fails with invalid hostnames', metadata, async function () {
         try {
           await clientEncryptionWithInvalidHostname.createDataKey('aws', {
             masterKeyInvalidHostname
@@ -347,37 +347,37 @@ describe('Client Side Encryption Prose Tests', function () {
     });
 
     // Case 2.
-    context('when using azure', function () {
+    context('when using azure', metadata, function () {
       const masterKey = {
         keyVaultEndpoint: 'doesnotexist.local',
         keyName: 'foo'
       };
 
-      it('fails with no tls', async function () {
+      it('fails with no tls', metadata, async function () {
         try {
           await clientEncryptionNoTls.createDataKey('azure', { masterKey });
         } catch (e) {
           expect(e.originalError.message).to.include('certificate required');
         }
       });
 
-      it('fails with invalid host', async function () {
+      it('fails with invalid host', metadata, async function () {
         try {
           await clientEncryptionWithTls.createDataKey('azure', { masterKey });
         } catch (e) {
           expect(e.message).to.include('HTTP status=404');
         }
       });
 
-      it('fails with expired certificates', async function () {
+      it('fails with expired certificates', metadata, async function () {
         try {
           await clientEncryptionWithTlsExpired.createDataKey('azure', { masterKey });
         } catch (e) {
           expect(e.originalError.message).to.include('certificate has expired');
         }
       });
 
-      it('fails with invalid hostnames', async function () {
+      it('fails with invalid hostnames', metadata, async function () {
         try {
           await clientEncryptionWithInvalidHostname.createDataKey('azure', { masterKey });
         } catch (e) {
@@ -387,39 +387,39 @@ describe('Client Side Encryption Prose Tests', function () {
     });
 
     // Case 3.
-    context('when using gcp', function () {
+    context('when using gcp', metadata, function () {
       const masterKey = {
         projectId: 'foo',
         location: 'bar',
         keyRing: 'baz',
         keyName: 'foo'
       };
 
-      it('fails with no tls', async function () {
+      it('fails with no tls', metadata, async function () {
         try {
           await clientEncryptionNoTls.createDataKey('gcp', { masterKey });
         } catch (e) {
           expect(e.originalError.message).to.include('certificate required');
         }
       });
 
-      it('fails with invalid host', async function () {
+      it('fails with invalid host', metadata, async function () {
         try {
           await clientEncryptionWithTls.createDataKey('gcp', { masterKey });
         } catch (e) {
           expect(e.message).to.include('HTTP status=404');
         }
       });
 
-      it('fails with expired certificates', async function () {
+      it('fails with expired certificates', metadata, async function () {
         try {
           await clientEncryptionWithTlsExpired.createDataKey('gcp', { masterKey });
         } catch (e) {
           expect(e.originalError.message).to.include('certificate has expired');
         }
       });
 
-      it('fails with invalid hostnames', async function () {
+      it('fails with invalid hostnames', metadata, async function () {
         try {
           await clientEncryptionWithInvalidHostname.createDataKey('gcp', { masterKey });
         } catch (e) {
@@ -429,31 +429,31 @@ describe('Client Side Encryption Prose Tests', function () {
     });
 
     // Case 4.
-    context('when using kmip', function () {
+    context('when using kmip', metadata, function () {
       it('passes with tls', async function () {
         const dataKey = await clientEncryptionWithTls.createDataKey('kmip');
         // TODO: NODE-3927
         await clientWithTls.close();
         expect(dataKey).to.have.property('sub_type', 4);
       });
 
-      it('fails with no tls', async function () {
+      it('fails with no tls', metadata, async function () {
         try {
           await clientEncryptionNoTls.createDataKey('kmip');
         } catch (e) {
           expect(e.originalError.message).to.include('before secure TLS connection');
         }
       });
 
-      it('fails with expired certificates', async function () {
+      it('fails with expired certificates', metadata, async function () {
         try {
           await clientEncryptionWithTlsExpired.createDataKey('kmip');
         } catch (e) {
           expect(e.originalError.message).to.include('certificate has expired');
         }
       });
 
-      it('fails with invalid hostnames', async function () {
+      it('fails with invalid hostnames', metadata, async function () {
         try {
           await clientEncryptionWithInvalidHostname.createDataKey('kmip');
         } catch (e) {