@tsed/cli-plugin-jest 6.6.3 → 7.0.0-alpha.10

package/lib/esm/CliPluginJestModule.js

@@ -1,4 +1,6 @@
 import { __decorate, __metadata } from "tslib";
+// Import templates to register them with the DI container
+import "./templates/index.js";
 import { RuntimesModule } from "@tsed/cli";
 import { inject, Module, OnAdd, ProjectPackageJson } from "@tsed/cli-core";
 import { JestGenerateHook } from "./hooks/JestGenerateHook.js";

package/lib/esm/hooks/JestGenerateHook.js

@@ -1,60 +1,41 @@
-import { __decorate, __metadata } from "tslib";
-import { SrcRendererService } from "@tsed/cli";
-import { inject, Injectable, OnExec } from "@tsed/cli-core";
-import { normalizePath } from "@tsed/normalize-path";
-import { TEMPLATE_DIR } from "../utils/templateDir.js";
-let JestGenerateHook = class JestGenerateHook {
+import { CliProjectService, render } from "@tsed/cli";
+import { inject } from "@tsed/cli-core";
+import { injectable } from "@tsed/di";
+export class JestGenerateHook {
     constructor() {
-        this.srcRenderService = inject(SrcRendererService);
+        this.projectService = inject(CliProjectService);
     }
-    onGenerateExec(ctx) {
-        const { symbolPath } = ctx;
-        const { specTemplate, integrationTemplate, relativeSrcPath } = this.mapOptions(ctx);
+    $alterGenerateTasks(tasks, data) {
+        const { symbolPath } = data;
         return [
+            ...tasks,
             {
-                title: `Generate ${ctx.type} spec file to '${symbolPath}.spec.ts'`,
+                title: `Generate ${data.type} spec file to '${symbolPath}.spec.ts'`,
                 enabled() {
-                    return !(ctx.type === "server" || ctx.type.includes(":dataSource") || ctx.type.includes(":connection"));
+                    return !(data.type === "server" || data.type.includes(":dataSource") || data.type.includes(":connection"));
                 },
-                task: () => this.srcRenderService.render(specTemplate, { ...ctx, relativeSrcPath }, {
-                    output: `${symbolPath}.spec.ts`,
-                    templateDir: TEMPLATE_DIR
-                })
+                task: () => {
+                    let specTemplateType = [data.type, data.templateType, "spec"].filter(Boolean).join(".");
+                    specTemplateType = this.projectService.templates.get(specTemplateType) ? specTemplateType : "generic.spec";
+                    render(specTemplateType, {
+                        ...data,
+                        symbolPath: data.symbolPath + ".spec"
+                    });
+                }
             },
             {
-                title: `Generate ${ctx.type} integration file '${symbolPath}.integration.spec.ts'`,
+                title: `Generate ${data.type} integration file '${symbolPath}.integration.spec.ts'`,
                 enabled() {
-                    return ["controller", "server"].includes(ctx.type);
+                    return ["controller", "server"].includes(data.type);
                 },
-                task: () => this.srcRenderService.render(integrationTemplate, { ...ctx, relativeSrcPath }, {
-                    output: `${symbolPath}.integration.spec.ts`,
-                    templateDir: TEMPLATE_DIR
-                })
+                task: () => {
+                    render(data.type + ".integration", {
+                        ...data,
+                        symbolPath: data.symbolPath + ".integration.spec"
+                    });
+                }
             }
         ];
     }
-    mapOptions(options) {
-        const type = [options.type, options.templateType].filter(Boolean).join(".");
-        const specTemplate = this.srcRenderService.templateExists(`generate/${type}.spec.hbs`, { templateDir: TEMPLATE_DIR })
-            ? `generate/${type}.spec.hbs`
-            : "generate/generic.spec.hbs";
-        const integrationTemplate = this.srcRenderService.templateExists(`generate/${type}.integration.hbs`, { templateDir: TEMPLATE_DIR })
-            ? `generate/${type}.integration.hbs`
-            : "generate/generic.integration.hbs";
-        return {
-            specTemplate,
-            integrationTemplate,
-            relativeSrcPath: normalizePath(this.srcRenderService.relativeFrom(`${options.symbolPath}.integration.spec.ts`))
-        };
-    }
-};
-__decorate([
-    OnExec("generate"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Array)
-], JestGenerateHook.prototype, "onGenerateExec", null);
-JestGenerateHook = __decorate([
-    Injectable()
-], JestGenerateHook);
-export { JestGenerateHook };
+}
+injectable(JestGenerateHook);

package/lib/esm/hooks/JestInitHook.js

@@ -1,32 +1,19 @@
-import { __decorate, __metadata } from "tslib";
-import { RootRendererService } from "@tsed/cli";
-import { inject, Injectable, OnExec, ProjectPackageJson } from "@tsed/cli-core";
-import { TEMPLATE_DIR } from "../utils/templateDir.js";
-let JestInitHook = class JestInitHook {
-    constructor() {
-        this.packageJson = inject(ProjectPackageJson);
-        this.rootRenderer = inject(RootRendererService);
-    }
-    onInitExec() {
+import { render } from "@tsed/cli";
+import { injectable } from "@tsed/di";
+export class JestInitHook {
+    $alterInitSubTasks(tasks, data) {
         return [
+            ...tasks,
             {
-                title: "Generate files for jest",
-                task: (ctx) => {
-                    return this.rootRenderer.renderAll(["jest.config.ts.hbs"], ctx, {
-                        templateDir: `${TEMPLATE_DIR}/init`
+                title: "Create jest configuration",
+                enabled: () => !!data.jest,
+                task: () => {
+                    render("jest.config", {
+                        symbolName: "jest.config"
                     });
                 }
             }
         ];
     }
-};
-__decorate([
-    OnExec("init"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], JestInitHook.prototype, "onInitExec", null);
-JestInitHook = __decorate([
-    Injectable()
-], JestInitHook);
-export { JestInitHook };
+}
+injectable(JestInitHook);

package/lib/esm/index.js

@@ -1,3 +1,3 @@
 import { CliPluginJestModule } from "./CliPluginJestModule.js";
-export * from "./utils/templateDir.js";
+export * from "./templates/index.js";
 export default CliPluginJestModule;

package/lib/esm/templates/controller.integration.template.js

@@ -0,0 +1,35 @@
+import { CliProjectService, defineTemplate } from "@tsed/cli";
+import { inject } from "@tsed/cli-core";
+export default defineTemplate({
+    id: "controller.integration",
+    label: "Generic Integration Test",
+    fileName: "{{symbolName}}.spec",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        const projectService = inject(CliProjectService);
+        const relativePath = projectService.getRelativePath(`${data.symbolPath}.integration.spec.ts`);
+        const serverName = projectService.getServerFileName();
+        return `import { PlatformTest } from "@tsed/platform-http/testing";
+import SuperTest from "supertest";
+import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+import { Server } from "${relativePath}/${serverName}.js";
+
+describe("${symbolName}", () => {
+  beforeAll(PlatformTest.bootstrap(Server, {
+    mount: {
+      "/": [${symbolName}]
+    }
+  }));
+  afterAll(PlatformTest.reset);
+
+  it("should call GET ${data.route}", async () => {
+     const request = SuperTest(PlatformTest.callback());
+     const response = await request.get("${data.route}").expect(200);
+
+     expect(response.text).toEqual("hello");
+  });
+});
+`;
+    }
+});

package/lib/esm/templates/decorator.class.spec.template.js

@@ -0,0 +1,22 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "decorator.class.spec",
+    label: "Class Decorator Test",
+    fileName: "{{symbolName}}.spec",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        return `import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+
+describe("${symbolName}", () => {
+  it("should do something", () => {
+    @${symbolName}({})
+    class Test {
+    }
+
+    expect(typeof ${symbolName}).toBe("function")
+  });
+});
+`;
+    }
+});

package/lib/esm/templates/decorator.endpoint.spec.template.js

@@ -0,0 +1,26 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "decorator.endpoint.spec",
+    label: "Endpoint Decorator Test",
+    fileName: "{{symbolName}}.spec",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        return `import { Store } from "@tsed/core";
+import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+
+describe("${symbolName}", () => {
+  it("should store options", () => {
+    class Test {
+      @${symbolName}({options: "options"})
+      method(param: string) {}
+    }
+
+    const store = Store.fromMethod(Test, "method");
+
+    expect(store.get(${symbolName})).toEqual({options: "options"});
+  });
+});
+`;
+    }
+});

package/lib/esm/templates/decorator.method.spec.template.js

@@ -0,0 +1,24 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "decorator.method.spec",
+    label: "Method Decorator Test",
+    fileName: "{{symbolName}}.spec",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        return `import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+
+describe("${symbolName}", () => {
+  it("should do something", () => {
+    class Test {
+      @${symbolName}({})
+      method(){}
+    }
+
+    expect(typeof ${symbolName}).toBe("function")
+    expect(typeof ${symbolName}()).toBe("function")
+  });
+});
+`;
+    }
+});

package/lib/esm/templates/decorator.param.spec.template.js

@@ -0,0 +1,25 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "decorator.param.spec",
+    label: "Parameter Decorator Test",
+    fileName: "{{symbolName}}.spec",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        return `import { Store } from "@tsed/core";
+import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+
+describe("${symbolName}", () => {
+  it("should store options", () => {
+    class Test {
+      method(@${symbolName}({options: "options"}) param: string){}
+    }
+
+    const store = Store.from(Test, "method", 0)
+
+    expect(store.get(${symbolName})).toEqual({options: "options"});
+  });
+});
+`;
+    }
+});

package/lib/esm/templates/decorator.parameter.spec.template.js

@@ -0,0 +1,23 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "decorator.parameter.spec",
+    label: "Parameters Decorator Test",
+    fileName: "{{symbolName}}.spec",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        return `import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+
+describe("${symbolName}", () => {
+  it("should do something", () => {
+    class Test {
+      method(@${symbolName}({}) param: string){}
+    }
+
+    expect(typeof ${symbolName}).toBe("function")
+    expect(typeof ${symbolName}()).toBe("function")
+  });
+});
+`;
+    }
+});

package/lib/esm/templates/decorator.prop.spec.template.js

@@ -0,0 +1,26 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "decorator.prop.spec",
+    label: "Property Decorator with @Property Test",
+    fileName: "{{symbolName}}.spec",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        return `import { Store } from "@tsed/core";
+import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+
+describe("${symbolName}", () => {
+  it("should store options", () => {
+    class Test {
+      @${symbolName}({options: "options"})
+      property: string;
+    }
+
+    const store = Store.from(Test, "property");
+
+    expect(store.get(${symbolName})).toEqual({options: "options"});
+  });
+});
+`;
+    }
+});

package/lib/esm/templates/decorator.property.spec.template.js

@@ -0,0 +1,24 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "decorator.property.spec",
+    label: "Property Decorator Test",
+    fileName: "{{symbolName}}.spec",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        return `import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+
+describe("${symbolName}", () => {
+  it("should do something", () => {
+    class Test {
+      @${symbolName}({})
+      property: string;
+    }
+
+    expect(typeof ${symbolName}).toBe("function")
+    expect(typeof ${symbolName}()).toBe("function")
+  });
+});
+`;
+    }
+});

package/lib/esm/templates/generic.spec.template.js

@@ -0,0 +1,25 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "generic.spec",
+    label: "Generic Spec",
+    fileName: "{{symbolName}}.spec",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        return `import { PlatformTest, inject } from "@tsed/platform-http/testing";
+import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+
+describe("${symbolName}", () => {
+  beforeEach(PlatformTest.create);
+  afterEach(PlatformTest.reset);
+
+  it("should do something", () => {
+    const instance = inject(${symbolName});
+    // const instance = PlatformTest.invoke<${symbolName}>(${symbolName}); // get fresh instance
+
+    expect(instance).toBeInstanceOf(${symbolName});
+  });
+});
+`;
+    }
+});

package/lib/esm/templates/index.js

@@ -0,0 +1,12 @@
+// Import all templates to register them with the DI container
+import "./decorator.class.spec.template.js";
+import "./decorator.endpoint.spec.template.js";
+import "./decorator.method.spec.template.js";
+import "./decorator.param.spec.template.js";
+import "./decorator.parameter.spec.template.js";
+import "./decorator.prop.spec.template.js";
+import "./decorator.property.spec.template.js";
+import "./controller.integration.template.js";
+import "./generic.spec.template.js";
+import "./jest.config.template.js";
+import "./server.integration.template.js";

package/lib/esm/templates/jest.config.template.js

@@ -0,0 +1,84 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "jest.config",
+    label: "Jest Config",
+    fileName: "jest.config",
+    ext: "mjs",
+    outputDir: ".",
+    hidden: true,
+    preserveCase: true,
+    render() {
+        return `// For a detailed explanation regarding each configuration property, visit:
+// https://jestjs.io/docs/en/configuration.html
+
+/** @type {import('jest').Config} */
+export default {
+  // Automatically clear mock calls and instances between every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  coveragePathIgnorePatterns: ["index.ts", "/node_modules/"],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  coverageThreshold: {
+    global: {
+      branches: 70,
+      functions: 70,
+      lines: 70,
+      statements: 70
+    }
+  },
+
+  // An array of file extensions your modules use
+  moduleFileExtensions: ["js", "json", "jsx", "ts", "tsx", "node"],
+  extensionsToTreatAsEsm: [".ts", ".tsx"],
+  // The test environment that will be used for testing
+  testEnvironment: "node",
+
+  // The glob patterns Jest uses to detect test files
+  testMatch: ["**/src/**/__tests__/**/*.[jt]s?(x)", "**/src/**/?(*.)+(spec|test).[tj]s?(x)"],
+  // A map from regular expressions to paths to transformers
+  transform: {
+    "^.+\\\\.(j|t)sx?$": [
+      "@swc/jest",
+      {
+        jsc: {
+          parser: {
+            syntax: "typescript",
+            tsx: true,
+            decorators: true,
+            dynamicImport: true,
+            importMeta: true,
+            preserveAllComments: true
+          },
+          target: "esnext",
+          transform: {
+            useDefineForClassFields: false,
+            legacyDecorator: true,
+            decoratorMetadata: true
+          }
+        },
+        module: {
+          type: "es6"
+        }
+      }
+    ]
+  },
+  moduleNameMapper: {
+    "^(\\\\.{1,2}/.*)\\\\.js$": "$1"
+  },
+  testPathIgnorePatterns: ["/node_modules/", "/dist/"],
+  transformIgnorePatterns: ["/node_modules/(?!(module-name|another-module)/)"]
+};
+`;
+    }
+});

package/lib/esm/templates/server.integration.template.js

@@ -0,0 +1,30 @@
+import { defineTemplate } from "@tsed/cli";
+export default defineTemplate({
+    id: "server.integration",
+    label: "Server Integration Test",
+    outputDir: "{{srcDir}}",
+    hidden: true,
+    render(symbolName, data) {
+        return `import { PlatformTest } from "@tsed/platform-http/testing";
+import SuperTest from "supertest";
+import { ${symbolName} } from "./${data.symbolPathBasename}.js";
+
+describe("${symbolName}", () => {
+  beforeAll(PlatformTest.bootstrap(${symbolName}));
+  afterAll(PlatformTest.reset);
+
+  it("should call GET ${data.route}", async () => {
+     const request = SuperTest(PlatformTest.callback());
+     const response = await request.get("${data.route}").expect(404);
+
+     expect(response.body).toEqual({
+       errors: [],
+       message: 'Resource "/rest" not found',
+       name: "NOT_FOUND",
+       status: 404,
+     });
+  });
+});
+`;
+    }
+});