@positronic/cli 0.0.2

package/dist/src/commands/test-utils.js

@@ -0,0 +1,737 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+import React from 'react';
+import { render } from 'ink-testing-library';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { fileURLToPath } from 'url';
+import process from 'process';
+import { TestDevServer } from '../test/test-dev-server.js';
+import { buildCli } from '../cli.js';
+import caz from 'caz';
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+// Singleton cache for the template to avoid repeated npm installs
+// This is shared across all tests in a test run and should NOT be deleted
+// by individual test cleanup. It's cleaned up automatically when the process exits.
+var cachedTemplatePath = null;
+function getCachedTemplate() {
+    return _async_to_generator(function() {
+        var devPath, originalTemplate, tempCopyDir, cazOptions, originalStdoutWrite, originalStderrWrite, originalConsoleLog, originalConsoleError;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    // Check if cached template exists and is valid
+                    if (cachedTemplatePath && fs.existsSync(cachedTemplatePath)) {
+                        return [
+                            2,
+                            cachedTemplatePath
+                        ];
+                    }
+                    // Create cache only once per test run
+                    devPath = path.resolve(__dirname, '../../../');
+                    originalTemplate = path.resolve(devPath, 'template-new-project');
+                    // First, copy template to temp location so caz can mess with that copy
+                    tempCopyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-template-copy-'));
+                    fs.cpSync(originalTemplate, tempCopyDir, {
+                        recursive: true
+                    });
+                    // Now generate the actual cached template in another temp directory
+                    cachedTemplatePath = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-cached-template-'));
+                    // Run caz once to generate a clean template
+                    cazOptions = {
+                        name: 'test-project',
+                        backend: 'none',
+                        install: false,
+                        claudemd: false,
+                        force: true
+                    };
+                    // Temporarily hijack all output streams to suppress caz output
+                    originalStdoutWrite = process.stdout.write;
+                    originalStderrWrite = process.stderr.write;
+                    originalConsoleLog = console.log;
+                    originalConsoleError = console.error;
+                    process.stdout.write = function() {
+                        return true;
+                    };
+                    process.stderr.write = function() {
+                        return true;
+                    };
+                    console.log = function() {};
+                    console.error = function() {};
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        ,
+                        3,
+                        4
+                    ]);
+                    return [
+                        4,
+                        caz.default(tempCopyDir, cachedTemplatePath, cazOptions)
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    // Restore original output streams
+                    process.stdout.write = originalStdoutWrite;
+                    process.stderr.write = originalStderrWrite;
+                    console.log = originalConsoleLog;
+                    console.error = originalConsoleError;
+                    return [
+                        7
+                    ];
+                case 4:
+                    // Clean up the temp copy directory
+                    fs.rmSync(tempCopyDir, {
+                        recursive: true,
+                        force: true
+                    });
+                    return [
+                        2,
+                        cachedTemplatePath
+                    ];
+            }
+        });
+    })();
+}
+// Helper function to copy test resources from test data directory
+function copyTestResources(targetDir) {
+    var testDataPath = path.join(__dirname, '../test/data/resources');
+    var targetResourcesPath = path.join(targetDir, 'resources');
+    // Remove existing resources directory if it exists
+    if (fs.existsSync(targetResourcesPath)) {
+        fs.rmSync(targetResourcesPath, {
+            recursive: true,
+            force: true
+        });
+    }
+    // Copy the test data resources
+    fs.cpSync(testDataPath, targetResourcesPath, {
+        recursive: true
+    });
+}
+// Helper function to create a minimal Positronic project structure
+export function createMinimalProject(dir) {
+    return _async_to_generator(function() {
+        var cachedTemplate, configPath, config;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        getCachedTemplate()
+                    ];
+                case 1:
+                    cachedTemplate = _state.sent();
+                    // Copy the cached template to the target directory
+                    fs.cpSync(cachedTemplate, dir, {
+                        recursive: true
+                    });
+                    copyTestResources(dir);
+                    // Update positronic.config.json with the correct project name if it exists
+                    configPath = path.join(dir, 'positronic.config.json');
+                    if (fs.existsSync(configPath)) {
+                        config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                        config.name = 'test-project';
+                        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+                    }
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+export var TestEnv = /*#__PURE__*/ function() {
+    "use strict";
+    function TestEnv(server) {
+        _class_call_check(this, TestEnv);
+        _define_property(this, "server", void 0);
+        _define_property(this, "serverHandle", void 0);
+        this.server = server;
+        this.serverHandle = null;
+    }
+    _create_class(TestEnv, [
+        {
+            key: "projectRootDir",
+            get: function get() {
+                return this.server.projectRootDir;
+            }
+        },
+        {
+            key: "setup",
+            value: function setup(setup) {
+                setup(this.projectRootDir);
+                return this;
+            }
+        },
+        {
+            key: "start",
+            value: function start() {
+                return _async_to_generator(function() {
+                    var _this, _;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this;
+                                if (this.serverHandle) {
+                                    throw new Error('Server already started');
+                                }
+                                _ = this;
+                                return [
+                                    4,
+                                    this.server.start()
+                                ];
+                            case 1:
+                                _.serverHandle = _state.sent();
+                                return [
+                                    2,
+                                    function(argv) {
+                                        return _async_to_generator(function() {
+                                            return _ts_generator(this, function(_state) {
+                                                if (!this.serverHandle) {
+                                                    throw new Error('Server not started');
+                                                }
+                                                return [
+                                                    2,
+                                                    px(argv, {
+                                                        server: this.server,
+                                                        projectRootDir: this.projectRootDir
+                                                    })
+                                                ];
+                                            });
+                                        }).call(_this);
+                                    }
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "cleanup",
+            value: function cleanup() {
+                fs.rmSync(this.projectRootDir, {
+                    recursive: true,
+                    force: true
+                });
+            }
+        },
+        {
+            key: "stop",
+            value: function stop() {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!this.serverHandle) {
+                                    throw new Error('Server not started');
+                                }
+                                this.serverHandle.kill();
+                                this.serverHandle = null;
+                                return [
+                                    4,
+                                    this.server.stop()
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "stopAndCleanup",
+            value: function stopAndCleanup() {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.stop()
+                                ];
+                            case 1:
+                                _state.sent();
+                                this.cleanup();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return TestEnv;
+}();
+export function createTestEnv() {
+    return _async_to_generator(function() {
+        var tempDir, devServer;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-server-test-'));
+                    return [
+                        4,
+                        createMinimalProject(tempDir)
+                    ];
+                case 1:
+                    _state.sent();
+                    // Create test dev server instance
+                    devServer = new TestDevServer(tempDir);
+                    return [
+                        2,
+                        new TestEnv(devServer)
+                    ];
+            }
+        });
+    })();
+}
+// Helper function to wait for types file to contain specific content
+export function waitForTypesFile(typesPath, expectedContent) {
+    var maxWaitMs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 5000;
+    return _async_to_generator(function() {
+        var _loop, startTime, contentToCheck, _ret;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _loop = function() {
+                        var content;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    if (fs.existsSync(typesPath)) {
+                                        content = fs.readFileSync(typesPath, 'utf-8');
+                                        // Check if all expected content is present
+                                        if (contentToCheck.every(function(expected) {
+                                            return content.includes(expected);
+                                        })) {
+                                            return [
+                                                2,
+                                                {
+                                                    v: content
+                                                }
+                                            ];
+                                        }
+                                    }
+                                    return [
+                                        4,
+                                        new Promise(function(resolve) {
+                                            return setTimeout(resolve, 100);
+                                        })
+                                    ];
+                                case 1:
+                                    _state.sent();
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    };
+                    startTime = Date.now();
+                    contentToCheck = Array.isArray(expectedContent) ? expectedContent : [
+                        expectedContent
+                    ];
+                    _state.label = 1;
+                case 1:
+                    if (!(Date.now() - startTime < maxWaitMs)) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        5,
+                        _ts_values(_loop())
+                    ];
+                case 2:
+                    _ret = _state.sent();
+                    if (_type_of(_ret) === "object") return [
+                        2,
+                        _ret.v
+                    ];
+                    return [
+                        3,
+                        1
+                    ];
+                case 3:
+                    return [
+                        2,
+                        ''
+                    ];
+            }
+        });
+    })();
+}
+export function px(_0) {
+    return _async_to_generator(function(argv) {
+        var options, server, projectRootDir, configDir, instance;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                    server = options.server, projectRootDir = options.projectRootDir, configDir = options.configDir;
+                    instance = null;
+                    return [
+                        4,
+                        runCli(argv, {
+                            server: server,
+                            configDir: configDir
+                        })
+                    ];
+                case 1:
+                    instance = _state.sent();
+                    // const { lastFrame, rerender, unmount, frames, stdin, stdout, stderr } = instance!;
+                    return [
+                        2,
+                        {
+                            waitForOutput: function(regex) {
+                                var maxTries = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 10;
+                                return _async_to_generator(function() {
+                                    var tries, _instance_lastFrame, lastFrame;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                if (!instance && !regex) {
+                                                    return [
+                                                        2,
+                                                        true
+                                                    ];
+                                                }
+                                                if (!instance && regex) {
+                                                    console.error('waitForOutput failed, instance is null');
+                                                    return [
+                                                        2,
+                                                        false
+                                                    ];
+                                                }
+                                                tries = 0;
+                                                _state.label = 1;
+                                            case 1:
+                                                if (!(tries < maxTries)) return [
+                                                    3,
+                                                    3
+                                                ];
+                                                lastFrame = (_instance_lastFrame = instance.lastFrame()) !== null && _instance_lastFrame !== void 0 ? _instance_lastFrame : '';
+                                                if (regex.test(lastFrame)) {
+                                                    return [
+                                                        2,
+                                                        true
+                                                    ];
+                                                }
+                                                return [
+                                                    4,
+                                                    new Promise(function(resolve) {
+                                                        return setTimeout(resolve, 10);
+                                                    })
+                                                ];
+                                            case 2:
+                                                _state.sent();
+                                                tries++;
+                                                return [
+                                                    3,
+                                                    1
+                                                ];
+                                            case 3:
+                                                console.error('waitForOutput failed, last frame:', instance.lastFrame());
+                                                return [
+                                                    2,
+                                                    false
+                                                ];
+                                        }
+                                    });
+                                })();
+                            },
+                            waitForTypesFile: function(types) {
+                                return _async_to_generator(function() {
+                                    var typesPath;
+                                    return _ts_generator(this, function(_state) {
+                                        if (projectRootDir) {
+                                            typesPath = path.join(projectRootDir, 'resources.d.ts');
+                                            return [
+                                                2,
+                                                waitForTypesFile(typesPath, types, 1000)
+                                            ];
+                                        }
+                                        console.warn("waitForTypesFile didn't wait for anything, projectRootDir is not set");
+                                        return [
+                                            2,
+                                            ''
+                                        ];
+                                    });
+                                })();
+                            },
+                            instance: instance ? {
+                                lastFrame: instance.lastFrame,
+                                rerender: instance.rerender,
+                                unmount: instance.unmount,
+                                frames: instance.frames,
+                                stdin: instance.stdin,
+                                stdout: instance.stdout,
+                                stderr: instance.stderr
+                            } : {
+                                lastFrame: function() {
+                                    return undefined;
+                                },
+                                rerender: function() {},
+                                unmount: function() {},
+                                frames: [],
+                                stdin: {
+                                    write: function() {}
+                                },
+                                stdout: {
+                                    lastFrame: function() {
+                                        return undefined;
+                                    },
+                                    frames: []
+                                },
+                                stderr: {
+                                    lastFrame: function() {
+                                        return undefined;
+                                    },
+                                    frames: []
+                                }
+                            }
+                        }
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+// Helper function to test CLI commands with ink-testing-library
+function runCli(_0) {
+    return _async_to_generator(function(argv) {
+        var options, capturedElement, configDir, server, mockRenderFn, testCli;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                    capturedElement = null;
+                    configDir = options.configDir, server = options.server;
+                    mockRenderFn = function(element) {
+                        capturedElement = render(element);
+                        return capturedElement;
+                    };
+                    // Setup project-specific environment if configDir is provided
+                    if (configDir) {
+                        process.env.POSITRONIC_CONFIG_DIR = configDir;
+                    }
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        ,
+                        3,
+                        4
+                    ]);
+                    testCli = buildCli({
+                        argv: argv,
+                        server: server,
+                        exitProcess: false,
+                        render: mockRenderFn
+                    });
+                    return [
+                        4,
+                        testCli.parse()
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        2,
+                        capturedElement
+                    ];
+                case 3:
+                    // Cleanup project-specific environment if configDir was provided
+                    if (configDir) {
+                        delete process.env.POSITRONIC_CONFIG_DIR;
+                    }
+                    return [
+                        7
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}