neonctl 1.32.0 → 1.33.0

package/test_utils/fixtures.js

@@ -0,0 +1,84 @@
+import { fork } from 'node:child_process';
+import { join } from 'node:path';
+import { expect, test as originalTest } from 'vitest';
+import strip from 'strip-ansi';
+import emocks from 'emocks';
+import express from 'express';
+import { log } from '../log';
+export const test = originalTest.extend({
+    // eslint-disable-next-line no-empty-pattern
+    runMockServer: async ({}, use) => {
+        let server;
+        await use(async (mockDir) => {
+            const app = express();
+            app.use(express.json());
+            app.use('/', emocks(join(process.cwd(), 'mocks', mockDir), {
+                '404': (_req, res) => res.status(404).send({ message: 'Not Found' }),
+            }));
+            await new Promise((resolve) => {
+                server = app.listen(0, () => {
+                    resolve();
+                    log.debug('Mock server listening at %d', server.address().port);
+                });
+            });
+            return server;
+        });
+        await new Promise((resolve, reject) => server.close((err) => {
+            if (err) {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+            else {
+                resolve();
+            }
+        }));
+    },
+    testCliCommand: async ({ runMockServer }, use) => {
+        await use(async (args, options = {}) => {
+            const server = await runMockServer(options.mockDir || 'main');
+            let output = '';
+            let error = '';
+            const cp = fork(join(process.cwd(), './dist/index.js'), [
+                '--api-host',
+                `http://localhost:${server.address().port}`,
+                '--output',
+                'yaml',
+                '--api-key',
+                'test-key',
+                '--no-analytics',
+                ...args,
+            ], {
+                stdio: 'pipe',
+                env: {
+                    PATH: `mocks/bin:${process.env.PATH}`,
+                },
+            });
+            return new Promise((resolve, reject) => {
+                cp.stdout?.on('data', (data) => {
+                    output += data.toString();
+                });
+                cp.stderr?.on('data', (data) => {
+                    error += data.toString();
+                    log.error(data.toString());
+                });
+                cp.on('error', (err) => {
+                    throw err;
+                });
+                cp.on('close', (code) => {
+                    try {
+                        expect(code).toBe(options?.code ?? 0);
+                        expect(output).toMatchSnapshot();
+                        if (options.stderr !== undefined) {
+                            expect(strip(error).replace(/\s+/g, ' ').trim()).toEqual(typeof options.stderr === 'string'
+                                ? options.stderr.toString().replace(/\s+/g, ' ')
+                                : options.stderr);
+                        }
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    }
+                });
+            });
+        });
+    },
+});

package/writer.js

@@ -84,7 +84,7 @@ export const writer = (props) => {
             if (props.output == 'json') {
                 return out.write(writeJson(chunks));
             }
-            return writeTable(chunks, out);
+            writeTable(chunks, out);
         },
     };
 };

package/test_utils/mock_server.js

@@ -1,16 +0,0 @@
-import emocks from 'emocks';
-import express from 'express';
-import { join } from 'node:path';
-import { log } from '../log';
-export const runMockServer = async (mockDir) => new Promise((resolve) => {
-    const app = express();
-    app.use(express.json());
-    app.use('/', emocks(join(process.cwd(), 'mocks', mockDir), {
-        '404': (req, res) => res.status(404).send({ message: 'Not Found' }),
-    }));
-    const server = app.listen(0);
-    server.on('listening', () => {
-        resolve(server);
-        log.debug('Mock server listening at %d', server.address().port);
-    });
-});

package/test_utils/test_cli_command.js

@@ -1,80 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'vitest';
-import { fork } from 'node:child_process';
-import { join } from 'node:path';
-import { log } from '../log.js';
-import strip from 'strip-ansi';
-import { runMockServer } from './mock_server.js';
-export const testCliCommand = ({ args, name, expected, before, after, mockDir = 'main', }) => {
-    let server;
-    describe(name, () => {
-        beforeAll(async () => {
-            if (before) {
-                await before();
-            }
-            server = await runMockServer(mockDir);
-        });
-        afterAll(async () => {
-            if (after) {
-                await after();
-            }
-            return new Promise((resolve) => {
-                server.close(() => {
-                    resolve();
-                });
-            });
-        });
-        test('test', async () => {
-            let output = '';
-            let error = '';
-            const cp = fork(join(process.cwd(), './dist/index.js'), [
-                '--api-host',
-                `http://localhost:${server.address().port}`,
-                '--output',
-                'yaml',
-                '--api-key',
-                'test-key',
-                '--no-analytics',
-                ...args,
-            ], {
-                stdio: 'pipe',
-                env: {
-                    PATH: `mocks/bin:${process.env.PATH}`,
-                },
-            });
-            return new Promise((resolve, reject) => {
-                cp.stdout?.on('data', (data) => {
-                    output += data.toString();
-                });
-                cp.stderr?.on('data', (data) => {
-                    error += data.toString();
-                    log.error(data.toString());
-                });
-                cp.on('error', (err) => {
-                    throw err;
-                });
-                cp.on('close', (code) => {
-                    try {
-                        expect(code).toBe(expected?.code ?? 0);
-                        if (expected) {
-                            if (expected.snapshot) {
-                                expect(output).toMatchSnapshot();
-                            }
-                            if (expected.stdout !== undefined) {
-                                expect(strip(output)).toEqual(expected.stdout);
-                            }
-                            if (expected.stderr !== undefined) {
-                                expect(strip(error).replace(/\s+/g, ' ').trim()).toEqual(typeof expected.stderr === 'string'
-                                    ? expected.stderr.toString().replace(/\s+/g, ' ')
-                                    : expected.stderr);
-                            }
-                        }
-                        resolve();
-                    }
-                    catch (err) {
-                        reject(err);
-                    }
-                });
-            });
-        });
-    });
-};