Fix MultiTransformIterator not destroying transformers on close

This was discovered in comunica/comunica#950

This may also be the root-cause of comunica/comunica#989

asynciterator.ts

@@ -1506,6 +1506,16 @@ export class MultiTransformIterator<S, D = S> extends TransformIterator<S, D> {
     if (!this._transformerQueue.length)
       this.close();
   }
+
+  protected _end(destroy: boolean) {
+    super._end(destroy);
+
+    // Also destroy the open transformers left in the queue
+    if (this._destroySource) {
+      for (const item of this._transformerQueue)
+        item.transformer.destroy();
+    }
+  }
 }
 
 /**

test/MultiTransformIterator-test.js

@@ -386,4 +386,108 @@ describe('MultiTransformIterator', () => {
       });
     });
   });
+
+  describe('A MultiTransformIterator with transformers that never end', () => {
+    let iterator, source, multiTransform;
+    beforeEach(() => {
+      source = new ArrayIterator(['a', 'b', 'c', 'd', 'e', 'f']);
+      multiTransform = sinon.spy(item => {
+        const transformer = new BufferedIterator();
+        scheduleTask(() => {
+          transformer._push(`${item}1`);
+          transformer._push(`${item}2`);
+          transformer._push(`${item}3`);
+        });
+        return transformer;
+      });
+    });
+
+    describe('with autoStart and with destroySource', () => {
+      beforeEach(() => {
+        iterator = new MultiTransformIterator(source, { multiTransform, autoStart: true, destroySource: true });
+      });
+
+      it('should destroy the transformers in the queue when closing', async () => {
+        // Wait until the iterator has produced one result
+        await new Promise(resolve => iterator.on('data', resolve));
+
+        // Immediately close the iterator
+        iterator.close();
+
+        // Wait until the iterator has ended
+        await new Promise(resolve => iterator.on('end', resolve));
+
+        // All transformers in the queue must have been closed
+        iterator._transformerQueue.length.should.equal(4);
+        for (const item of iterator._transformerQueue)
+          item.transformer.closed.should.be.true;
+      });
+    });
+
+    describe('without autoStart and with destroySource', () => {
+      beforeEach(() => {
+        iterator = new MultiTransformIterator(source, { multiTransform, autoStart: false, destroySource: true });
+      });
+
+      it('should destroy the transformers in the queue when closing', async () => {
+        // Wait until the iterator has produced one result
+        await new Promise(resolve => iterator.on('data', resolve));
+
+        // Immediately close the iterator
+        iterator.close();
+
+        // Wait until the iterator has ended
+        await new Promise(resolve => iterator.on('end', resolve));
+
+        // All transformers in the queue must have been closed
+        iterator._transformerQueue.length.should.equal(4);
+        for (const item of iterator._transformerQueue)
+          item.transformer.closed.should.be.true;
+      });
+    });
+
+    describe('with autoStart and without destroySource', () => {
+      beforeEach(() => {
+        iterator = new MultiTransformIterator(source, { multiTransform, autoStart: true, destroySource: false });
+      });
+
+      it('should destroy the transformers in the queue when closing', async () => {
+        // Wait until the iterator has produced one result
+        await new Promise(resolve => iterator.on('data', resolve));
+
+        // Immediately close the iterator
+        iterator.close();
+
+        // Wait until the iterator has ended
+        await new Promise(resolve => iterator.on('end', resolve));
+
+        // All transformers in the queue must not have been closed
+        iterator._transformerQueue.length.should.equal(4);
+        for (const item of iterator._transformerQueue)
+          item.transformer.closed.should.be.false;
+      });
+    });
+
+    describe('without autoStart and without destroySource', () => {
+      beforeEach(() => {
+        iterator = new MultiTransformIterator(source, { multiTransform, autoStart: false, destroySource: false });
+      });
+
+      it('should destroy the transformers in the queue when closing', async () => {
+        // Wait until the iterator has produced one result
+        await new Promise(resolve => iterator.on('data', resolve));
+
+        // Immediately close the iterator
+        iterator.close();
+
+        // Wait until the iterator has ended
+        await new Promise(resolve => iterator.on('end', resolve));
+
+        // All transformers in the queue must not have been closed
+        iterator._transformerQueue.length.should.equal(4);
+        for (const item of iterator._transformerQueue)
+          item.transformer.closed.should.be.false;
+      });
+    });
+  });
 });