From 39cff855d009ebad23dc18e85258b5e455ea8c9a Mon Sep 17 00:00:00 2001
From: larabr <7375870+larabr@users.noreply.github.com>
Date: Fri, 26 Jan 2024 14:54:58 +0100
Subject: [PATCH] CI: fix memory benchmark tests

Move to away from Node native streams.
---
 .github/workflows/benchmark.yml |  2 ++
 test/benchmarks/memory_usage.js | 56 +++++++++++++--------------------
 2 files changed, 23 insertions(+), 35 deletions(-)

diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index 7f3482e3..70eff19f 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -20,6 +20,8 @@ jobs:
           ref: main
           path: main
       - uses: actions/setup-node@v3
+        with:
+          node-version: '>=20.6.0'
 
       - name: Run pull request time benchmark
         run: cd pr && npm install && npm run --silent benchmark-time > benchmarks.txt && cat benchmarks.txt
diff --git a/test/benchmarks/memory_usage.js b/test/benchmarks/memory_usage.js
index 323ae475..50673b67 100644
--- a/test/benchmarks/memory_usage.js
+++ b/test/benchmarks/memory_usage.js
@@ -173,7 +173,7 @@ class MemoryBenchamrkSuite {
 
     const passwords = 'password';
     const config = { aeadProtect: false, preferredCompressionAlgorithm: openpgp.enums.compression.uncompressed };
-    const inputStream = require('stream').Readable.from(largeDataGenerator({ chunk: new Uint8Array(ONE_MEGABYTE), numberOfChunks: 1 }));
+    const inputStream = require('stream/web').ReadableStream.from(largeDataGenerator({ chunk: new Uint8Array(ONE_MEGABYTE), numberOfChunks: 1 }));
     const plaintextMessage = await openpgp.createMessage({ binary: inputStream });
     assert(plaintextMessage.fromStream);
 
@@ -183,10 +183,8 @@ class MemoryBenchamrkSuite {
     assert.ok(encryptedMessage.packets[1].version === 1);
     const { data: decryptedData } = await openpgp.decrypt({ message: encryptedMessage, passwords, config });
     // read out output stream to trigger decryption
-    await new Promise(resolve => {
-      decryptedData.pipe(require('fs').createWriteStream('/dev/null'));
-      decryptedData.on('end', resolve);
-    });
+    const sink = require('stream').Writable.toWeb(require('fs').createWriteStream('/dev/null'));
+    await decryptedData.pipeTo(sink);
   });
 
   suite.add('openpgp.encrypt/decrypt (CFB, text, with streaming)', async () => {
@@ -199,7 +197,7 @@ class MemoryBenchamrkSuite {
 
     const passwords = 'password';
     const config = { aeadProtect: false, preferredCompressionAlgorithm: openpgp.enums.compression.uncompressed };
-    const inputStream = require('stream').Readable.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 1 }));
+    const inputStream = require('stream/web').ReadableStream.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 1 }));
     const plaintextMessage = await openpgp.createMessage({ text: inputStream });
     assert(plaintextMessage.fromStream);
 
@@ -209,10 +207,8 @@ class MemoryBenchamrkSuite {
     assert.ok(encryptedMessage.packets[1].version === 1);
     const { data: decryptedData } = await openpgp.decrypt({ message: encryptedMessage, passwords, config });
     // read out output stream to trigger decryption
-    await new Promise(resolve => {
-      decryptedData.pipe(require('fs').createWriteStream('/dev/null'));
-      decryptedData.on('end', resolve);
-    });
+    const sink = require('stream').Writable.toWeb(require('fs').createWriteStream('/dev/null'));
+    await decryptedData.pipeTo(sink);
   });
 
   suite.add('openpgp.encrypt/decrypt (AEAD, binary, with streaming)', async () => {
@@ -225,7 +221,7 @@ class MemoryBenchamrkSuite {
 
     const passwords = 'password';
     const config = { aeadProtect: true, preferredCompressionAlgorithm: openpgp.enums.compression.uncompressed };
-    const inputStream = require('stream').Readable.from(largeDataGenerator({ chunk: new Uint8Array(ONE_MEGABYTE), numberOfChunks: 1 }));
+    const inputStream = require('stream/web').ReadableStream.from(largeDataGenerator({ chunk: new Uint8Array(ONE_MEGABYTE), numberOfChunks: 1 }));
     const plaintextMessage = await openpgp.createMessage({ binary:inputStream });
     assert(plaintextMessage.fromStream);
 
@@ -235,10 +231,8 @@ class MemoryBenchamrkSuite {
     assert.ok(encryptedMessage.packets[1].version === 2);
     const { data: decryptedData } = await openpgp.decrypt({ message: encryptedMessage, passwords, config });
     // read out output stream to trigger decryption
-    await new Promise(resolve => {
-      decryptedData.pipe(require('fs').createWriteStream('/dev/null'));
-      decryptedData.on('end', resolve);
-    });
+    const sink = require('stream').Writable.toWeb(require('fs').createWriteStream('/dev/null'));
+    await decryptedData.pipeTo(sink);
   });
 
   suite.add('openpgp.encrypt/decrypt (AEAD, text, with streaming)', async () => {
@@ -251,7 +245,7 @@ class MemoryBenchamrkSuite {
 
     const passwords = 'password';
     const config = { aeadProtect: true, preferredCompressionAlgorithm: openpgp.enums.compression.uncompressed };
-    const inputStream = require('stream').Readable.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 1 }));
+    const inputStream = require('stream/web').ReadableStream.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 1 }));
     const plaintextMessage = await openpgp.createMessage({ text: inputStream });
     assert(plaintextMessage.fromStream);
 
@@ -261,10 +255,8 @@ class MemoryBenchamrkSuite {
     assert.ok(encryptedMessage.packets[1].version === 2);
     const { data: decryptedData } = await openpgp.decrypt({ message: encryptedMessage, passwords, config });
     // read out output stream to trigger decryption
-    await new Promise(resolve => {
-      decryptedData.pipe(require('fs').createWriteStream('/dev/null'));
-      decryptedData.on('end', resolve);
-    });
+    const sink = require('stream').Writable.toWeb(require('fs').createWriteStream('/dev/null'));
+    await decryptedData.pipeTo(sink);
   });
 
   suite.add('openpgp.encrypt/decrypt (CFB, text @ 10MB, with streaming)', async () => {
@@ -277,7 +269,7 @@ class MemoryBenchamrkSuite {
 
     const passwords = 'password';
     const config = { aeadProtect: false, preferredCompressionAlgorithm: openpgp.enums.compression.uncompressed };
-    const inputStream = require('stream').Readable.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 20 }));
+    const inputStream = require('stream/web').ReadableStream.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 20 }));
     const plaintextMessage = await openpgp.createMessage({ text: inputStream });
     assert(plaintextMessage.fromStream);
 
@@ -287,10 +279,8 @@ class MemoryBenchamrkSuite {
     assert.ok(encryptedMessage.packets[1].version === 1);
     const { data: decryptedData } = await openpgp.decrypt({ message: encryptedMessage, passwords, config });
     // read out output stream to trigger decryption
-    await new Promise(resolve => {
-      decryptedData.pipe(require('fs').createWriteStream('/dev/null'));
-      decryptedData.on('end', resolve);
-    });
+    const sink = require('stream').Writable.toWeb(require('fs').createWriteStream('/dev/null'));
+    await decryptedData.pipeTo(sink);
   });
 
   suite.add('openpgp.encrypt/decrypt (CFB, text @ 10MB, with unauthenticated streaming)', async () => {
@@ -303,7 +293,7 @@ class MemoryBenchamrkSuite {
 
     const passwords = 'password';
     const config = { aeadProtect: false, preferredCompressionAlgorithm: openpgp.enums.compression.uncompressed };
-    const inputStream = require('stream').Readable.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 20 }));
+    const inputStream = require('stream/web').ReadableStream.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 20 }));
     const plaintextMessage = await openpgp.createMessage({ text: inputStream });
     assert(plaintextMessage.fromStream);
 
@@ -317,10 +307,8 @@ class MemoryBenchamrkSuite {
       config: { ...config, allowUnauthenticatedStream: true }
     });
     // read out output stream to trigger decryption
-    await new Promise(resolve => {
-      decryptedData.pipe(require('fs').createWriteStream('/dev/null'));
-      decryptedData.on('end', resolve);
-    });
+    const sink = require('stream').Writable.toWeb(require('fs').createWriteStream('/dev/null'));
+    await decryptedData.pipeTo(sink);
   });
 
   suite.add('openpgp.encrypt/decrypt (AEAD, text @ 10MB, with streaming)', async () => {
@@ -333,7 +321,7 @@ class MemoryBenchamrkSuite {
 
     const passwords = 'password';
     const config = { aeadProtect: true, preferredCompressionAlgorithm: openpgp.enums.compression.uncompressed };
-    const inputStream = require('stream').Readable.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 20 }));
+    const inputStream = require('stream/web').ReadableStream.from(largeDataGenerator({ chunk: 'a'.repeat(ONE_MEGABYTE / 2), numberOfChunks: 20 }));
     const plaintextMessage = await openpgp.createMessage({ text: inputStream });
     assert(plaintextMessage.fromStream);
 
@@ -343,10 +331,8 @@ class MemoryBenchamrkSuite {
     assert.ok(encryptedMessage.packets[1].version === 2);
     const { data: decryptedData } = await openpgp.decrypt({ message: encryptedMessage, passwords, config });
     // read out output stream to trigger decryption
-    await new Promise(resolve => {
-      decryptedData.pipe(require('fs').createWriteStream('/dev/null'));
-      decryptedData.on('end', resolve);
-    });
+    const sink = require('stream').Writable.toWeb(require('fs').createWriteStream('/dev/null'));
+    await decryptedData.pipeTo(sink);
   });
 
   const stats = await suite.run();