add passing tests

Author: baileympearson

.eslintignore

@@ -2,3 +2,6 @@
 lib
 test/disabled
 !etc/docs
+
+
+test/explicit-resource-management

src/resource_management.ts

@@ -11,6 +11,29 @@ export interface AsyncDisposable {
   [Symbol.asyncDispose]: () => Promise<void>;
 }
 
+/**
+ * @public
+ * @beta
+ *
+ * Attaches `Symbol.asyncDispose` methods to the MongoClient, Cursors, sessions and change streams
+ * if Symbol.asyncDispose is defined.
+ *
+ * It's usually not necessary to call this method - the driver attempts to attach these methods
+ * itself when its loaded.  However, sometimes the driver may be loaded before `Symbol.asyncDispose`
+ * is defined, in which case it is necessary to call this method directly.  This can happen if the
+ * application is polyfilling `Symbol.asyncDispose`.
+ *
+ * Example:
+ *
+ * ```typescript
+ * import { load, MongoClient } from 'mongodb/beta';
+ *
+ * Symbol.asyncDispose ??= Symbol('dispose');
+ * load();
+ *
+ * await using client = new MongoClient(...);
+ * ```
+ */
 export function load() {
   Symbol.asyncDispose &&
     (MongoClient.prototype[Symbol.asyncDispose] = async function () {

test/explicit-resource-management/.gitignore

@@ -0,0 +1 @@
+*.js

test/explicit-resource-management/.mocharc.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://raw.githubusercontent.com/SchemaStore/schemastore/master/src/schemas/json/mocharc.json",
+  "extension": [
+    "js"
+  ],
+  "reporter": "../tools/reporter/mongodb_reporter.js",
+  "recursive": true,
+  "timeout": 60000,
+  "failZero": true,
+  "sort": true,
+  "color": true
+}

test/explicit-resource-management/main.test.ts

@@ -0,0 +1,123 @@
+
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import { AbstractCursor, ChangeStream, ClientSession, GridFSBucket, MongoClient } from 'mongodb/lib/beta';
+import * as sinon from 'sinon';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { setTimeout } from 'timers/promises';
+
+// @ts-expect-error Assigning readonly property.
+Symbol.asyncDispose ??= Symbol('dispose');
+
+async function setUpCollection(client: MongoClient) {
+	const collection = client.db('foo').collection<{ name: string }>('bar');
+	const documents: Array<{ name: string }> = Array.from({ length: 5 }).map(i => ({
+		name: String(i)
+	}));
+	await collection.insertMany(documents)
+	return collection;
+}
+
+describe('explicit resource management smoke tests', function () {
+	const clientSpy = sinon.spy(MongoClient.prototype, Symbol.asyncDispose);
+	const cursorSpy = sinon.spy(AbstractCursor.prototype, Symbol.asyncDispose);
+	const endSessionSpy = sinon.spy(ClientSession.prototype, Symbol.asyncDispose);
+	const changeStreamSpy = sinon.spy(ChangeStream.prototype, Symbol.asyncDispose);
+	const readableSpy = sinon.spy(Readable.prototype, Symbol.asyncDispose);
+
+	afterEach(function () {
+		clientSpy.resetHistory();
+		cursorSpy.resetHistory();
+		endSessionSpy.resetHistory();
+		changeStreamSpy.resetHistory();
+		readableSpy.resetHistory();
+	});
+
+	describe('MongoClient', function () {
+		it('can be used with await-using syntax', async function () {
+			{
+				await using client = new MongoClient(process.env.MONGODB_URI!);
+				await client.connect();
+			}
+			expect(clientSpy.called).to.be.true;
+			expect(clientSpy.callCount).to.equal(1);
+		})
+	})
+
+	describe('Cursors', function () {
+		it('can be used with await-using syntax', async function () {
+			{
+				await using client = new MongoClient(process.env.MONGODB_URI!);
+				await client.connect();
+
+				const collection = await setUpCollection(client);
+
+				await using cursor = collection.find();
+				await cursor.next();
+				await cursor.next();
+				await cursor.next();
+			}
+			expect(cursorSpy.callCount).to.equal(1);
+		})
+
+		describe('cursor streams', function() {
+			it('can be used with await-using syntax', async function() {
+				{
+					await using client = new MongoClient(process.env.MONGODB_URI!);
+					await client.connect();
+
+					const collection = await setUpCollection(client);
+
+					await using readable = collection.find().stream();
+				}
+				expect(readableSpy.callCount).to.equal(1);
+			})
+		})
+	})
+
+	describe('Sessions', function () {
+		it('can be used with await-using syntax', async function () {
+			{
+				await using client = new MongoClient(process.env.MONGODB_URI!);
+				await client.connect();
+
+				await using session = client.startSession();
+			}
+			expect(endSessionSpy.callCount).to.equal(1);
+		})
+	})
+
+	describe('ChangeStreams', function () {
+		it('can be used with await-using syntax', async function () {
+			{
+				await using client = new MongoClient(process.env.MONGODB_URI!);
+				await client.connect();
+
+				const collection = await setUpCollection(client);
+				await using cs = collection.watch();
+
+				setTimeout(1000).then(() => collection.insertOne({ name: 'bailey' }));
+				await cs.next();
+			}
+			expect(changeStreamSpy.callCount).to.equal(1);
+		})
+	});
+
+	describe('GridFSDownloadStream', function () {
+		it('can be used with await-using syntax', async function () {
+			{
+				await using client = new MongoClient(process.env.MONGODB_URI!);
+				await client.connect();
+
+				const bucket = new GridFSBucket(client.db('foo'));
+				const uploadStream = bucket.openUploadStream('foo.txt')
+				await pipeline(Readable.from("AAAAAAA".split('')), uploadStream);
+
+				await using downloadStream = bucket.openDownloadStreamByName('foo.txt');
+
+			}
+			expect(readableSpy.callCount).to.equal(1);
+		})
+	});
+})