@tsed/cli-testing 6.6.2 → 7.0.0-alpha.1

package/lib/esm/CliPlatformTest.js

@@ -1,13 +1,22 @@
 import "@tsed/logger-std";
 import { CliCore, CliExeca, CliFs, CliHttpClient, CliService, configuration, createInjector, DITest, Env, getCommandMetadata, injector, InjectorService, logger, ProjectPackageJson, resolveConfiguration } from "@tsed/cli-core";
 import { Type } from "@tsed/core";
-import { DIContext, runInContext } from "@tsed/di";
+import { DIContext, inject, runInContext } from "@tsed/di";
 import { $asyncEmit } from "@tsed/hooks";
 import { v4 } from "uuid";
 import { FakeCliExeca } from "./FakeCliExeca.js";
 import { FakeCliFs } from "./FakeCliFs.js";
 import { FakeCliHttpClient } from "./FakeCliHttpClient.js";
 export class CliPlatformTest extends DITest {
+    static async reset() {
+        // Explicitly clear FakeCliFs static collections to prevent memory leaks
+        FakeCliFs.files.clear();
+        FakeCliFs.directories.clear();
+        FakeCliExeca.entries.clear();
+        FakeCliHttpClient.entries.clear();
+        // Call parent reset method
+        return super.reset();
+    }
     static async bootstrap(options = {}) {
         options = resolveConfiguration({
             name: "tsed",
@@ -17,6 +26,7 @@ export class CliPlatformTest extends DITest {
                 scriptsDir: "scripts",
                 ...(options.project || {})
             },
+            disableReadUpPkg: true,
             ...options
         });
         CliPlatformTest.createInjector(options);
@@ -36,10 +46,30 @@ export class CliPlatformTest extends DITest {
         await $asyncEmit("$loadPackageJson");
         CliPlatformTest.get(CliService).load();
     }
+    static async initProject(options) {
+        CliPlatformTest.setPackageJson({
+            name: "",
+            version: "1.0.0",
+            description: "",
+            scripts: {},
+            dependencies: {},
+            devDependencies: {}
+        });
+        return CliPlatformTest.exec("init", {
+            platform: "express",
+            rootDir: "./project-data",
+            projectName: "project-data",
+            tsedVersion: "5.58.1",
+            packageManager: "yarn",
+            runtime: "node",
+            ...options
+        });
+    }
     static async create(options = {}, rootModule = CliCore) {
         options = resolveConfiguration({
             name: "tsed",
-            ...options
+            ...options,
+            disableReadUpPkg: true
         });
         CliPlatformTest.createInjector(options);
         injector().addProvider(CliCore, {
@@ -70,13 +100,14 @@ export class CliPlatformTest extends DITest {
     static setPackageJson(pkg) {
         const projectPackageJson = CliPlatformTest.get(ProjectPackageJson);
         projectPackageJson.setRaw(pkg);
+        inject(CliFs).writeJsonSync(projectPackageJson.path, pkg);
     }
     /**
      * Invoke command with a new context without running prompts
      * @param cmdName
      * @param initialData
      */
-    static exec(cmdName, initialData) {
+    static async exec(cmdName, initialData) {
         const $ctx = new DIContext({
             id: v4(),
             injector: injector(),
@@ -86,8 +117,12 @@ export class CliPlatformTest extends DITest {
             .get("commands")
             .map((token) => getCommandMetadata(token))
             .find((commandOpts) => cmdName === commandOpts.name);
+        if (cmdName !== "init") {
+            initialData.platform ||= "express";
+            initialData = inject(ProjectPackageJson).fillWithPreferences(initialData);
+        }
         $ctx.set("data", initialData);
         $ctx.set("command", metadata);
-        return runInContext($ctx, () => this.injector.get(CliService).exec(cmdName, initialData, $ctx));
+        await runInContext($ctx, () => this.injector.get(CliService).exec(cmdName, initialData, $ctx));
     }
 }

package/lib/esm/FakeCliExeca.js

@@ -1,10 +1,16 @@
 import { CliExeca } from "@tsed/cli-core";
+import { $emit } from "@tsed/hooks";
 import { Observable } from "rxjs";
 export class FakeCliExeca extends CliExeca {
     static { this.entries = new Map(); }
     run(cmd, args, opts) {
-        const result = FakeCliExeca.entries.get(cmd + " " + args.join(" "));
+        const key = cmd + " " + args.join(" ");
+        const result = FakeCliExeca.entries.get(key);
+        if (!result) {
+            FakeCliExeca.entries.set(key, "executed");
+        }
         return new Observable((observer) => {
+            $emit(key);
             observer.next(result);
             observer.complete();
         });
@@ -17,7 +23,9 @@ export class FakeCliExeca extends CliExeca {
                 }
             }));
         }
-        return Promise.resolve(FakeCliExeca.entries.get(cmd + " " + args.join(" ")));
+        const key = cmd + " " + args.join(" ");
+        $emit(key);
+        return Promise.resolve(FakeCliExeca.entries.get(key));
     }
     runSync(cmd, args, opts) {
         return {

package/lib/esm/FakeCliFs.js

@@ -1,29 +1,52 @@
 import * as fs from "node:fs";
+import { dirname, join } from "node:path";
+import { errors, matchGlobs } from "@ts-morph/common";
 import { isString } from "@tsed/core";
+import {} from "fs-extra";
 import { normalizePath } from "./normalizePath.js";
 export class FakeCliFs {
-    static { this.entries = new Map(); }
+    static { this.files = new Map(); }
+    static { this.directories = new Set(); }
     static getKeys() {
-        return normalizePath(Array.from(FakeCliFs.entries.keys()).sort((a, b) => (a < b ? -1 : 1)));
+        return normalizePath(Array.from(FakeCliFs.files.keys()).sort((a, b) => (a < b ? -1 : 1)));
     }
     // @ts-ignore
     findUpFile() {
         return null;
     }
     exists(path) {
-        return FakeCliFs.entries.has(normalizePath(path));
+        path = this.normalizePath(path);
+        if (path.includes("templates")) {
+            return fs.existsSync(join("/", path));
+        }
+        return FakeCliFs.files.has(path) || FakeCliFs.files.has(path);
     }
     readFile(file, encoding) {
-        return Promise.resolve(FakeCliFs.entries.get(normalizePath(file)));
+        return Promise.resolve(this.readFileSync(file, encoding));
     }
     readFileSync(file, encoding) {
         try {
-            if (isString(file) && file.match(/_partials/)) {
-                return fs.readFileSync(file, encoding);
+            if (isString(file)) {
+                if (file.includes("templates")) {
+                    return fs.readFileSync(join("/", file), encoding);
+                }
+                if (file.match(/_partials/) || file.includes("packages/cli")) {
+                    return fs.readFileSync(file, encoding);
+                }
             }
         }
         catch (er) { }
-        return FakeCliFs.entries.get(normalizePath(file));
+        const standardizedFilePath = this.normalizePath(file);
+        const parentDir = this.normalizePath(dirname(standardizedFilePath));
+        const hasParentDir = FakeCliFs.directories.has(parentDir);
+        if (!hasParentDir) {
+            throw new errors.FileNotFoundError(standardizedFilePath);
+        }
+        const fileText = FakeCliFs.files.get(standardizedFilePath);
+        if (fileText === undefined) {
+            throw new errors.FileNotFoundError(standardizedFilePath);
+        }
+        return fileText;
     }
     async readJson(file, encoding) {
         const content = await this.readFile(file, encoding);
@@ -33,20 +56,188 @@ export class FakeCliFs {
         const content = this.readFileSync(file, encoding);
         return content ? JSON.parse(content) : {};
     }
+    async writeJson(file, data, options) {
+        await this.writeFile(file, JSON.stringify(data, null, 2), options || { encoding: "utf8" });
+    }
+    writeJsonSync(file, data, options) {
+        this.writeFileSync(file, JSON.stringify(data, null, 2), options || { encoding: "utf8" });
+    }
     writeFileSync(path, data, options) {
-        FakeCliFs.entries.set(normalizePath(path), data);
+        path = this.normalizePath(path);
+        this.mkdirSync(dirname(path));
+        FakeCliFs.files.set(path, data);
     }
     writeFile(file, data, options) {
-        FakeCliFs.entries.set(normalizePath(file), data);
+        this.writeFileSync(file, data, options);
+        return Promise.resolve();
     }
     ensureDir(path, options) {
-        FakeCliFs.entries.set(normalizePath(path), path);
+        this.ensureDirSync(path, options);
         return Promise.resolve();
     }
     ensureDirSync(path, options) {
-        FakeCliFs.entries.set(normalizePath(path), path);
+        this.mkdirSync(this.normalizePath(path));
+        FakeCliFs.files.set(this.normalizePath(path), path);
+    }
+    isCaseSensitive() {
+        return true;
+    }
+    delete(path) {
+        this.deleteSync(path);
+        return Promise.resolve();
+    }
+    /** @inheritdoc */
+    deleteSync(path) {
+        FakeCliFs.files.delete(this.normalizePath(path));
+    }
+    /** @inheritdoc */
+    readDirSync(dirPath) {
+        const standardizedDirPath = this.normalizePath(dirPath);
+        const dir = FakeCliFs.directories.has(standardizedDirPath);
+        if (!dir) {
+            throw new errors.DirectoryNotFoundError(standardizedDirPath);
+        }
+        const files = [
+            ...[...FakeCliFs.directories.keys()]
+                .filter((file) => this.normalizePath(file).startsWith(standardizedDirPath + "/"))
+                .map((file) => ({
+                name: `/${this.normalizePath(file)}`,
+                isFile: false,
+                isDirectory: true,
+                isSymlink: false
+            })),
+            ...[...FakeCliFs.files.keys()]
+                .filter((file) => !FakeCliFs.directories.has(this.normalizePath(file)))
+                .filter((file) => {
+                return (this.normalizePath(file).startsWith(standardizedDirPath + "/") &&
+                    this.normalizePath(file)
+                        .replace(standardizedDirPath + "/", "")
+                        .split("/").length == 1);
+            })
+                .map((file) => {
+                return {
+                    name: `/${this.normalizePath(file)}`,
+                    isFile: true,
+                    isDirectory: false,
+                    isSymlink: false
+                };
+            })
+        ];
+        return files;
+    }
+    mkdir(dirPath) {
+        this.mkdirSync(dirPath);
+        return Promise.resolve();
+    }
+    // #writeFileSync(filePath: string, fileText: string) {
+    //   // private method to avoid calling a method in the constructor that could be overwritten (virtual method)
+    //   const standardizedFilePath = FileUtils.getStandardizedAbsolutePath(this, filePath);
+    //   const dirPath = FileUtils.getDirPath(standardizedFilePath);
+    //   this.#getOrCreateDir(dirPath).files.set(standardizedFilePath, fileText);
+    // }
+    mkdirSync(dirPath) {
+        this.normalizePath(dirPath)
+            .split("/")
+            .reduce((currentPath, dirName) => {
+            const nextPath = join(currentPath, dirName);
+            FakeCliFs.directories.add(nextPath);
+            return nextPath;
+        }, "");
+    }
+    move(srcPath, destPath) {
+        this.moveSync(srcPath, destPath);
+        return Promise.resolve();
+    }
+    moveSync(srcPath, destPath) {
+        const standardizedSrcPath = this.normalizePath(srcPath);
+        const standardizedDestPath = this.normalizePath(destPath);
+        if (this.fileExistsSync(standardizedSrcPath)) {
+            const fileText = this.readFileSync(standardizedSrcPath);
+            this.deleteSync(standardizedSrcPath);
+            this.writeFileSync(standardizedDestPath, fileText);
+        }
+        else if (FakeCliFs.directories.has(standardizedSrcPath)) {
+            const impactedDirs = [...FakeCliFs.directories.keys()].filter((dir) => {
+                return dir.startsWith(standardizedSrcPath);
+            });
+            const impactedFiles = [...FakeCliFs.files.entries()].filter(([file]) => {
+                return file.startsWith(standardizedSrcPath);
+            });
+            // delete all impacted dirs
+            for (const dir of impactedDirs) {
+                FakeCliFs.directories.delete(dir);
+            }
+            this.mkdirSync(standardizedDestPath);
+            // delete all impacted files
+            for (const [filePath, fileText] of impactedFiles) {
+                FakeCliFs.files.delete(filePath);
+                FakeCliFs.files.set(filePath.replace(standardizedSrcPath, standardizedDestPath), fileText);
+            }
+        }
+        else {
+            throw new errors.PathNotFoundError(standardizedSrcPath);
+        }
+    }
+    copy(srcPath, destPath) {
+        this.copySync(srcPath, destPath);
+        return Promise.resolve();
+    }
+    copySync(srcPath, destPath) {
+        const standardizedSrcPath = this.normalizePath(srcPath);
+        const standardizedDestPath = this.normalizePath(destPath);
+        if (this.fileExistsSync(standardizedSrcPath)) {
+            this.writeFileSync(standardizedDestPath, this.readFileSync(standardizedSrcPath));
+        }
+        else if (FakeCliFs.directories.has(standardizedSrcPath)) {
+            const impactedFiles = [...FakeCliFs.files.entries()].filter(([file]) => {
+                return file.startsWith(standardizedSrcPath);
+            });
+            this.mkdirSync(standardizedDestPath);
+            // delete all impacted files
+            for (const [filePath, fileText] of impactedFiles) {
+                FakeCliFs.files.set(filePath.replace(standardizedSrcPath, standardizedDestPath), fileText);
+            }
+        }
+        else {
+            throw new errors.PathNotFoundError(standardizedSrcPath);
+        }
+    }
+    fileExists(filePath) {
+        return Promise.resolve(this.fileExistsSync(filePath));
+    }
+    fileExistsSync(filePath) {
+        return this.exists(filePath);
+    }
+    directoryExists(dirPath) {
+        return Promise.resolve(this.directoryExistsSync(dirPath));
+    }
+    directoryExistsSync(dirPath) {
+        return FakeCliFs.directories.has(this.normalizePath(dirPath));
+    }
+    realpathSync(path) {
+        return path;
+    }
+    getCurrentDirectory() {
+        return "/";
+    }
+    glob(patterns) {
+        try {
+            return Promise.resolve(this.globSync(patterns));
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    /** @inheritdoc */
+    globSync(patterns) {
+        const allFilePaths = [...FakeCliFs.directories.keys(), ...FakeCliFs.files.keys()]
+            .map((file) => {
+            return "/" + this.normalizePath(file);
+        })
+            .sort((a, b) => a.localeCompare(b));
+        return matchGlobs(allFilePaths, patterns, this.getCurrentDirectory());
     }
-    $onDestroy() {
-        FakeCliFs.entries.clear();
+    normalizePath(path) {
+        return normalizePath(path).replace(/^\//, "");
     }
 }

package/lib/esm/FakeCliHttpClient.js

@@ -15,7 +15,4 @@ export class FakeCliHttpClient extends CliHttpClient {
         }
         return FakeCliHttpClient.entries.get(key)?.(endpoint, options);
     }
-    $onDestroy() {
-        FakeCliHttpClient.entries.clear();
-    }
 }

package/lib/esm/index.js

@@ -1,4 +1,5 @@
 export * from "./CliPlatformTest.js";
+export * from "./FakeCliExeca.js";
 export * from "./FakeCliFs.js";
 export * from "./FakeCliHttpClient.js";
 export * from "./normalizePath.js";

package/lib/types/CliPlatformTest.d.ts

@@ -2,7 +2,9 @@ import "@tsed/logger-std";
 import { DITest, InjectorService } from "@tsed/cli-core";
 import { Type } from "@tsed/core";
 export declare class CliPlatformTest extends DITest {
+    static reset(): Promise<void>;
     static bootstrap(options?: Partial<TsED.Configuration>): Promise<void>;
+    static initProject(options?: any): Promise<void>;
     static create(options?: Partial<TsED.Configuration>, rootModule?: Type): Promise<void>;
     /**
      * Create a new injector with the right default services
@@ -14,5 +16,5 @@ export declare class CliPlatformTest extends DITest {
      * @param cmdName
      * @param initialData
      */
-    static exec(cmdName: string, initialData: any): Promise<Promise<any>>;
+    static exec(cmdName: string, initialData: any): Promise<void>;
 }

package/lib/types/FakeCliFs.d.ts

@@ -1,7 +1,9 @@
 import type { PathLike } from "node:fs";
-import type { EnsureDirOptions, WriteFileOptions } from "fs-extra";
-export declare class FakeCliFs {
-    static entries: Map<any, string>;
+import { type FileSystemHost, type RuntimeDirEntry } from "@ts-morph/common";
+import { type EnsureDirOptions, type WriteFileOptions } from "fs-extra";
+export declare class FakeCliFs implements FileSystemHost {
+    static files: Map<any, string>;
+    static directories: Set<string>;
     static getKeys(): any;
     findUpFile(): null;
     exists(path: string): boolean;
@@ -9,9 +11,32 @@ export declare class FakeCliFs {
     readFileSync(file: string | Buffer | number, encoding?: any): string;
     readJson(file: string | Buffer | number, encoding?: any): Promise<string>;
     readJsonSync(file: string | Buffer | number, encoding?: any): Promise<string>;
+    writeJson(file: string | Buffer | number, data: any, options?: WriteFileOptions | string): Promise<any>;
+    writeJsonSync(file: string | Buffer | number, data: any, options?: WriteFileOptions | string): void;
     writeFileSync(path: PathLike | number, data: any, options?: WriteFileOptions): void;
-    writeFile(file: string | Buffer | number, data: any, options?: WriteFileOptions | string): void;
+    writeFile(file: string | Buffer | number, data: any, options?: WriteFileOptions | string): Promise<void>;
     ensureDir(path: string, options?: EnsureDirOptions | number): Promise<void>;
     ensureDirSync(path: string, options?: EnsureDirOptions | number): void;
-    $onDestroy(): void;
+    isCaseSensitive(): boolean;
+    delete(path: string): Promise<void>;
+    /** @inheritdoc */
+    deleteSync(path: string): void;
+    /** @inheritdoc */
+    readDirSync(dirPath: string): RuntimeDirEntry[];
+    mkdir(dirPath: string): Promise<void>;
+    mkdirSync(dirPath: string): void;
+    move(srcPath: string, destPath: string): Promise<void>;
+    moveSync(srcPath: string, destPath: string): void;
+    copy(srcPath: string, destPath: string): Promise<void>;
+    copySync(srcPath: string, destPath: string): void;
+    fileExists(filePath: string): Promise<boolean>;
+    fileExistsSync(filePath: string): boolean;
+    directoryExists(dirPath: string): Promise<boolean>;
+    directoryExistsSync(dirPath: string): boolean;
+    realpathSync(path: string): string;
+    getCurrentDirectory(): string;
+    glob(patterns: ReadonlyArray<string>): Promise<string[]>;
+    /** @inheritdoc */
+    globSync(patterns: ReadonlyArray<string>): string[];
+    private normalizePath;
 }

package/lib/types/FakeCliHttpClient.d.ts

@@ -1,7 +1,5 @@
 import { CliHttpClient, type CliHttpClientOptions } from "@tsed/cli-core";
-import type { OnDestroy } from "@tsed/di";
-export declare class FakeCliHttpClient extends CliHttpClient implements OnDestroy {
-    static entries: Map<string, any>;
+export declare class FakeCliHttpClient extends CliHttpClient {
+    static entries: Map<string, (endpoint: string, options: CliHttpClientOptions) => any>;
     get(endpoint: string, options?: CliHttpClientOptions): Promise<any>;
-    $onDestroy(): void;
 }

package/lib/types/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./CliPlatformTest.js";
+export * from "./FakeCliExeca.js";
 export * from "./FakeCliFs.js";
 export * from "./FakeCliHttpClient.js";
 export * from "./normalizePath.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tsed/cli-testing",
   "description": "Utils to test you CLI based on Ts.ED CLI",
-  "version": "6.6.2",
+  "version": "7.0.0-alpha.1",
   "type": "module",
   "main": "./lib/esm/index.js",
   "source": "./src/index.ts",
@@ -30,11 +30,11 @@
     "decorators"
   ],
   "dependencies": {
-    "@tsed/cli-core": "6.6.2",
+    "@tsed/cli-core": "7.0.0-alpha.1",
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/typescript": "6.6.2",
+    "@tsed/typescript": "7.0.0-alpha.1",
     "cross-env": "7.0.3",
     "typescript": "5.6.2",
     "vitest": "3.2.4"
@@ -46,5 +46,8 @@
   },
   "homepage": "https://github.com/tsedio/tsed-cli/tree/master/packages/cli-testing",
   "author": "Romain Lenzotti",
-  "license": "MIT"
+  "license": "MIT",
+  "publishConfig": {
+    "tag": "alpha"
+  }
 }