test: remove redundant fle tests

Author: nbbeeken

test/integration/node-specific/abort_signal.test.ts

@@ -513,205 +513,6 @@ describe('AbortSignal support', () => {
           test(cursorAPI, args);
         }
       });
-
-      const fleMetadata: MongoDBMetadataUI = {
-        requires: {
-          clientSideEncryption: true,
-          mongodb: '>=7.0.0',
-          topology: '!single'
-        }
-      };
-
-      if (cursorName !== 'listCollections') {
-        describe('setup fle', fleMetadata, () => {
-          let autoEncryption: AutoEncryptionOptions;
-          let client: MongoClient;
-          let db;
-          let collection;
-          let method;
-          let filter;
-
-          before(async function () {
-            if (
-              !this.configuration.clientSideEncryption.enabled ||
-              semver.lt(this.configuration.version, '7.0.0') ||
-              this.configuration.topologyType === 'Single'
-            ) {
-              return this.skip();
-            }
-
-            autoEncryption = {
-              keyVaultNamespace: 'admin.datakeys',
-              kmsProviders: {
-                local: { key: Buffer.alloc(96) }
-              },
-              tlsOptions: {
-                kmip: {
-                  tlsCAFile: process.env.KMIP_TLS_CA_FILE,
-                  tlsCertificateKeyFile: process.env.KMIP_TLS_CERT_FILE
-                }
-              },
-              encryptedFieldsMap: {
-                'abortSignal.support': {
-                  fields: [
-                    {
-                      path: 'ssn',
-                      keyId: null,
-                      bsonType: 'string'
-                    }
-                  ]
-                }
-              }
-            };
-
-            let utilClient = this.configuration.newClient({}, {});
-
-            try {
-              await utilClient
-                .db('abortSignal')
-                .collection('support')
-                .drop({})
-                .catch(() => null);
-
-              const clientEncryption = new ClientEncryption(utilClient, {
-                ...autoEncryption,
-                encryptedFieldsMap: undefined
-              });
-
-              autoEncryption.encryptedFieldsMap['abortSignal.support'] = (
-                await clientEncryption.createEncryptedCollection(
-                  utilClient.db('abortSignal'),
-                  'support',
-                  {
-                    provider: 'local',
-                    createCollectionOptions: {
-                      encryptedFields: autoEncryption.encryptedFieldsMap['abortSignal.support']
-                    }
-                  }
-                )
-              ).encryptedFields;
-            } finally {
-              await utilClient.close();
-            }
-
-            utilClient = this.configuration.newClient({}, { autoEncryption });
-            try {
-              await utilClient
-                .db('abortSignal')
-                .collection('support')
-                .insertMany([
-                  { a: 1, ssn: '0000-00-0001' },
-                  { a: 2, ssn: '0000-00-0002' },
-                  { a: 3, ssn: '0000-00-0003' }
-                ]);
-            } finally {
-              await utilClient.close();
-            }
-          });
-
-          beforeEach(async function () {
-            client = this.configuration.newClient(
-              {},
-              {
-                autoEncryption,
-                monitorCommands: true,
-                appName: 'abortSignalClient',
-                __enableMongoLogger: true,
-                __internalLoggerConfig: { MONGODB_LOG_SERVER_SELECTION: 'debug' },
-                mongodbLogPath: { write: log => logs.push(log) },
-                serverSelectionTimeoutMS: 10_000,
-                maxPoolSize: 1
-              }
-            );
-            await client.connect();
-            db = client.db('abortSignal');
-            collection = db.collection('support');
-
-            method = collection[cursorName].bind(collection);
-            filter = cursorName === 'aggregate' ? [] : {};
-          });
-
-          afterEach(async function () {
-            await client?.close();
-          });
-
-          describe('and the signal is aborted during command encryption', fleMetadata, () => {
-            function test(cursorAPI, args) {
-              let controller: AbortController;
-              let signal: AbortSignal;
-              let cursor: AbstractCursor<{ a: number }>;
-
-              beforeEach(async function () {
-                controller = new AbortController();
-                signal = controller.signal;
-                cursor = method(filter, { signal });
-              });
-
-              afterEach(async function () {
-                sinon.restore();
-                await cursor?.close();
-              });
-
-              it(`rejects ${cursorAPI.toString()}`, fleMetadata, async () => {
-                const willBeResultBlocked = iterateUntilDocumentOrError(cursor, cursorAPI, args);
-
-                const stub = sinon
-                  .stub(client.options.autoEncrypter, 'encrypt')
-                  .callsFake(function (...args) {
-                    controller.abort();
-                    return stub.wrappedMethod.apply(this, args);
-                  });
-
-                const result = await willBeResultBlocked;
-
-                expect(result).to.be.instanceOf(DOMException);
-              });
-            }
-
-            for (const [cursorAPI, { value: args }] of getAllProps(cursorAPIs)) {
-              test(cursorAPI, args);
-            }
-          });
-
-          describe('and the signal is aborted during command decryption', fleMetadata, () => {
-            function test(cursorAPI, args) {
-              let controller: AbortController;
-              let signal: AbortSignal;
-              let cursor: AbstractCursor<{ a: number }>;
-
-              beforeEach(async function () {
-                controller = new AbortController();
-                signal = controller.signal;
-                cursor = method(filter, { signal });
-              });
-
-              afterEach(async function () {
-                sinon.restore();
-                await cursor?.close();
-              });
-
-              it(`rejects ${cursorAPI.toString()}`, fleMetadata, async () => {
-                const willBeResultBlocked = iterateUntilDocumentOrError(cursor, cursorAPI, args);
-
-                const stub = sinon
-                  .stub(client.options.autoEncrypter, 'decrypt')
-                  .callsFake(function (...args) {
-                    controller.abort();
-                    return stub.wrappedMethod.apply(this, args);
-                  });
-
-                const result = await willBeResultBlocked;
-
-                expect(result).to.be.instanceOf(DOMException);
-              });
-            }
-
-            for (const [cursorAPI, { value: args }] of getAllProps(cursorAPIs)) {
-              test(cursorAPI, args);
-            }
-          });
-        });
-      }
     });
   }