@apollo-annotation/cli 1.1.0 → 1.1.2

package/dist/test/test.js

@@ -16,12 +16,13 @@
  * yarn tsx --test-name-pattern='Print help|Feature get' src/test/test.ts
  */
 import assert from 'node:assert';
+import { spawn as spawnChildProcess } from 'node:child_process';
 import * as crypto from 'node:crypto';
 import fs from 'node:fs';
 import { after, afterEach, before, beforeEach, describe } from 'node:test';
 import { MongoClient } from 'mongodb';
 import { Shell, deleteAllChecks } from './utils.js';
-const apollo = 'yarn dev';
+const apollo = process.env.APOLLO_BIN ?? 'yarn dev';
 const P = '--profile testAdmin';
 // let client = MongoClient
 let client;
@@ -85,6 +86,82 @@ void describe('Test CLI', () => {
         const p = new Shell(`${apollo} config ${P} accessType google`);
         assert.strictEqual('', p.stdout.trim());
     });
+    void globalThis.itName('Interactive login type select shows names, not raw objects', async () => {
+        // Regression test: /auth/types returns an array of
+        // {name, needsPopup, message} objects, but selectAccessType() in
+        // config.ts used to push those objects directly as a choice's `name`,
+        // so the interactive select rendered "[object Object]" instead of the
+        // login type name.
+        const serverScript = 'test_data/tmp_auth_types_server.mjs';
+        fs.writeFileSync(serverScript, `
+import http from 'node:http'
+const server = http.createServer((req, res) => {
+  if (req.url === '/auth/types') {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    res.end(JSON.stringify([{ name: 'guest', needsPopup: false, message: 'Continue as Guest' }]))
+    return
+  }
+  res.writeHead(404)
+  res.end()
+})
+server.listen(0, () => {
+  console.log(server.address().port)
+})
+`);
+        const authServer = spawnChildProcess('node', [serverScript]);
+        const authPort = await new Promise((resolve) => {
+            authServer.stdout.once('data', (data) => {
+                resolve(data.toString().trim());
+            });
+        });
+        const child = spawnChildProcess(`${apollo} config ${P}`, {
+            shell: '/bin/bash',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        const waitFor = (pattern, timeoutMs = 15_000) => new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                clearInterval(interval);
+                reject(new Error(`Timed out waiting for "${pattern}". Stdout so far:\n${stdout}\nStderr so far:\n${stderr}`));
+            }, timeoutMs);
+            const interval = setInterval(() => {
+                if (stdout.includes(pattern)) {
+                    clearInterval(interval);
+                    clearTimeout(timer);
+                    resolve();
+                }
+            }, 50);
+        });
+        try {
+            await waitFor('Server address and port');
+            child.stdin.write(`http://localhost:${authPort}\r`);
+            await waitFor('Select login type');
+            // Move the selection down from the default "root" choice onto the
+            // mock server's "guest" login type, then confirm it.
+            child.stdin.write('\u001B[B');
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            child.stdin.write('\r');
+            const exitCode = await new Promise((resolve) => {
+                child.on('exit', resolve);
+            });
+            assert.strictEqual(exitCode, 0, `Expected "apollo config" to exit cleanly. Stdout:\n${stdout}\nStderr:\n${stderr}`);
+            assert.ok(!stdout.includes('[object Object]'), `Select choices rendered a raw object instead of its name:\n${stdout}`);
+            assert.ok(stdout.includes('guest'));
+        }
+        finally {
+            child.kill();
+            authServer.kill();
+            fs.unlinkSync(serverScript);
+        }
+        const p = new Shell(`${apollo} config ${P} accessType`);
+        assert.strictEqual(p.stdout.trim(), 'guest');
+    });
     void globalThis.itName('Apollo status', () => {
         let p = new Shell(`${apollo} status ${P}`);
         assert.strictEqual(p.stdout.trim(), 'testAdmin: Logged in');
@@ -319,7 +396,7 @@ void describe('Test CLI', () => {
         p = new Shell(`${apollo} assembly get ${P} -a vv1`);
         assert.ok(p.stdout.includes('vv1'));
         p = new Shell(`${apollo} assembly sequence ${P} -a vv1 -r ctgA -s 1 -e 10`);
-        const seq = p.stdout.trim().split('\n');
+        const seq = p.stdout.split(' ');
         assert.strictEqual(seq[1], 'cattgttgcg');
         p = new Shell(`${apollo} assembly add-from-fasta ${P} -a vv1 -f https://x.fa.gz --fai https://x.fa.gz.fai --gzi https://x.fa.gz.gzi`, false);
         assert.ok(p.returncode != 0);
@@ -327,7 +404,7 @@ void describe('Test CLI', () => {
     void globalThis.itName('Detect missing external index', () => {
         const p = new Shell(`${apollo} assembly add-from-fasta ${P} -a vv1 -f http://localhost:3131/tiny.fasta`, false);
         assert.ok(p.returncode != 0);
-        assert.ok(p.stderr.includes('Index file') && p.stderr.includes('does not exist'));
+        assert.ok(p.stderr.includes('Index file does not exist'));
     });
     void globalThis.itName('Editable sequence not allowed with external source', () => {
         const cmd = `${apollo} assembly add-from-fasta ${P} -a vv1 -f http://localhost:3131/tiny.fasta.gz`;
@@ -811,9 +888,9 @@ EOF`);
         assert.ok(p.stderr.includes('returned 0 assemblies'));
         p = new Shell(`${apollo} assembly sequence ${P} -a v1 -s 0`, false);
         assert.ok(p.returncode != 0);
-        assert.ok(p.stderr.includes('must be greater than 0'));
+        assert.match(p.stderr, /must be greater than 0/);
         p = new Shell(`${apollo} assembly sequence ${P} -a v1`);
-        let seq = p.stdout.trim().split('\n');
+        let seq = p.stdout.split(' ');
         assert.strictEqual(seq.length, 25);
         assert.deepStrictEqual(seq.at(0), '>ctgA:1..420');
         assert.deepStrictEqual(seq.at(1), 'cattgttgcggagttgaacaACGGCATTAGGAACACTTCCGTCTCtcacttttatacgattatgattggttctttagcct');
@@ -821,11 +898,11 @@ EOF`);
         assert.deepStrictEqual(seq.at(7), '>ctgB:1..800');
         assert.deepStrictEqual(seq.at(-1), 'ttggtcgctccgttgtaccc');
         p = new Shell(`${apollo} assembly sequence ${P} -a v1 -r ctgB -s 1 -e 1`);
-        seq = p.stdout.split('\n');
+        seq = p.stdout.split(' ');
         assert.deepStrictEqual(seq.at(0), '>ctgB:1..1');
         assert.deepStrictEqual(seq.at(1), 'A');
         p = new Shell(`${apollo} assembly sequence ${P} -a v1 -r ctgB -s 2 -e 4`);
-        seq = p.stdout.split('\n');
+        seq = p.stdout.split(' ');
         assert.deepStrictEqual(seq.at(0), '>ctgB:2..4');
         assert.deepStrictEqual(seq.at(1), 'CAT');
         p = new Shell(`${apollo} assembly sequence ${P} -r ctgB`, false);
@@ -1165,15 +1242,15 @@ EOF`);
         new Shell(`${apollo} feature import ${P} test_data/tiny.fasta.gff3 -a vv1`);
         let p = new Shell(`${apollo} export gff3 ${P} vv1 --include-fasta`);
         let gff = p.stdout;
-        assert.ok(gff.startsWith('##gff-version 3'));
-        assert.ok(gff.includes('multivalue=val1,val2,val3'));
-        assert.ok(gff.includes('##FASTA\n'));
-        assert.deepStrictEqual(gff.slice(-6), 'taccc\n');
+        assert.match(gff, /^##gff-version 3/);
+        assert.match(gff, /multivalue=val1,val2,val3/);
+        assert.match(gff, /##FASTA/);
+        assert.match(gff, /taccc$/);
         p = new Shell(`${apollo} export gff3 ${P} vv1`);
         gff = p.stdout;
-        assert.ok(gff.startsWith('##gff-version 3'));
-        assert.ok(gff.includes('multivalue=val1,val2,val3'));
-        assert.ok(!gff.includes('##FASTA\n'));
+        assert.match(gff, /^##gff-version 3/);
+        assert.match(gff, /multivalue=val1,val2,val3/);
+        assert.doesNotMatch(gff, /##FASTA/);
         // Invalid assembly
         p = new Shell(`${apollo} export gff3 ${P} foobar`, false);
         assert.ok(p.returncode != 0);
@@ -1184,32 +1261,30 @@ EOF`);
         new Shell(`${apollo} feature import ${P} test_data/tiny.fasta.gff3 -a vv1`);
         let p = new Shell(`${apollo} export gff3 ${P} vv1 --include-fasta`);
         let gff = p.stdout;
-        assert.ok(gff.startsWith('##gff-version 3'));
-        assert.ok(gff.includes('multivalue=val1,val2,val3'));
-        assert.ok(gff.includes('##FASTA\n'));
-        // We end with two newlines because the test data does have an extra newline at the end.
-        assert.deepStrictEqual(gff.slice(-7), 'taccc\n\n');
+        assert.match(gff, /^##gff-version 3/);
+        assert.match(gff, /multivalue=val1,val2,val3/);
+        assert.match(gff, /##FASTA/);
+        assert.match(gff, /taccc$/);
         p = new Shell(`${apollo} export gff3 ${P} vv1`);
         gff = p.stdout;
-        assert.ok(gff.startsWith('##gff-version 3'));
-        assert.ok(gff.includes('multivalue=val1,val2,val3'));
-        assert.ok(!gff.includes('##FASTA\n'));
+        assert.match(gff, /^##gff-version 3/);
+        assert.match(gff, /multivalue=val1,val2,val3/);
+        assert.doesNotMatch(gff, /##FASTA/);
     });
     void globalThis.itName('Export gff3 from external assembly', () => {
         new Shell(`${apollo} assembly add-from-fasta ${P} http://localhost:3131/tiny.fasta.gz -a vv1 -f`);
         new Shell(`${apollo} feature import ${P} test_data/tiny.fasta.gff3 -a vv1`);
         let p = new Shell(`${apollo} export gff3 ${P} vv1 --include-fasta`);
         let gff = p.stdout;
-        assert.ok(gff.startsWith('##gff-version 3'));
-        assert.ok(gff.includes('multivalue=val1,val2,val3'));
-        assert.ok(gff.includes('##FASTA\n'));
-        // We end with two newlines because the test data does have an extra newline at the end.
-        assert.deepStrictEqual(gff.slice(-7), 'taccc\n\n');
+        assert.match(gff, /^##gff-version 3/);
+        assert.match(gff, /multivalue=val1,val2,val3/);
+        assert.match(gff, /##FASTA/);
+        assert.match(gff, /taccc$/);
         p = new Shell(`${apollo} export gff3 ${P} vv1`);
         gff = p.stdout;
-        assert.ok(gff.startsWith('##gff-version 3'));
-        assert.ok(gff.includes('multivalue=val1,val2,val3'));
-        assert.ok(!gff.includes('##FASTA\n'));
+        assert.match(gff, /^##gff-version 3/);
+        assert.match(gff, /multivalue=val1,val2,val3/);
+        assert.doesNotMatch(gff, /##FASTA/);
     });
     void globalThis.itName('Position of internal stop codon warning in forward', () => {
         new Shell(`${apollo} assembly add-from-gff ${P} test_data/warningPositionForward.gff -a vv1 -f`);
@@ -1341,5 +1416,54 @@ EOF`);
         chk = out.filter((x) => x.cause === 'NonCanonicalSpliceSiteAtFivePrime' && x.start === 37);
         assert.strictEqual(chk.length, 1);
     });
+    void globalThis.itName('Timeout option', async () => {
+        // Every CLI request to the real server is preceded by two lightweight
+        // access-token checks (see BaseCommand.getURL/getHeaders), so only the
+        // 3rd request is the one actually governed by --timeout. Delay only
+        // that one so the two checks don't slow the test down.
+        const serverScript = 'test_data/tmp_timeout_server.mjs';
+        fs.writeFileSync(serverScript, `
+import http from 'node:http'
+let requestCount = 0
+const server = http.createServer((req, res) => {
+  requestCount++
+  const respond = () => {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    res.end('[]')
+  }
+  if (requestCount % 3 === 0) {
+    setTimeout(respond, 3000)
+  } else {
+    respond()
+  }
+})
+server.listen(0, () => {
+  console.log(server.address().port)
+})
+`);
+        const server = spawnChildProcess('node', [serverScript]);
+        const port = await new Promise((resolve) => {
+            server.stdout.once('data', (data) => {
+                resolve(data.toString().trim());
+            });
+        });
+        new Shell(`${apollo} config --profile fakeTimeout address http://localhost:${port}`);
+        new Shell(`${apollo} config --profile fakeTimeout accessToken dummytoken`);
+        try {
+            // Timeout shorter than the server's response delay: the request
+            // should fail with a headers timeout error.
+            let p = new Shell(`${apollo} assembly get --profile fakeTimeout --timeout 1s`, false);
+            assert.notStrictEqual(p.returncode, 0);
+            assert.ok(p.stderr.includes('UND_ERR_HEADERS_TIMEOUT'));
+            // Timeout longer than the server's response delay: the request
+            // should succeed.
+            p = new Shell(`${apollo} assembly get --profile fakeTimeout --timeout 10s`);
+            assert.strictEqual(p.stdout.trim(), '[]');
+        }
+        finally {
+            server.kill();
+            fs.unlinkSync(serverScript);
+        }
+    });
 });
 //# sourceMappingURL=test.js.map