@goast/typescript 0.4.1-beta1 → 0.4.1

package/src/tests/openapi-models.test.ts

@@ -0,0 +1,64 @@
+import "../_dnt.test_polyfills.js";
+import { join } from 'node:path';
+
+
+import fs from 'fs-extra';
+
+import { OpenApiGenerator, toCustomCase } from '@goast/core';
+import {
+  MultipartData,
+  openApiV2FilesDir,
+  openApiV3_1FilesDir,
+  openApiV3FilesDir,
+  type OpenApiVersion,
+  verify,
+} from '@goast/test-utils';
+
+import { afterEach, describe, test } from '../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { restore, stub } from '../deps/jsr.io/@std/testing/1.0.3/mock.js';
+
+import { TypeScriptModelsGenerator } from '../src/generators/models/models-generator.js';
+
+const filePaths: { [P in OpenApiVersion]: string } = {
+  '2.0': openApiV2FilesDir,
+  '3.0': openApiV3FilesDir,
+  '3.1': openApiV3_1FilesDir,
+};
+
+const testFilesAllVersions: string[] = ['simple-schemas.yml', 'detailed-schemas.yml', 'object-schemas.yml'];
+const testFilesV3x: string[] = ['oneof-schemas.yml', 'discriminated-schemas.yml'];
+
+for (const [version, path] of Object.entries(filePaths)) {
+  describe(`OpenAPI V${version}`, () => {
+    afterEach(() => {
+      restore();
+    });
+
+    const testFiles = version.startsWith('3') ? testFilesAllVersions.concat(testFilesV3x) : testFilesAllVersions;
+    for (const file of testFiles) {
+      const fileWithoutExt = file.replace(/\.[^/.]+$/, '');
+      test(toCustomCase(fileWithoutExt, { wordCasing: 'all-lower', wordSeparator: ' ' }), async (t) => {
+        const filePath = join(path, file);
+
+        const result = new MultipartData();
+        stub(fs, 'ensureDirSync');
+        stub(fs, 'writeFileSync', (path: fs.PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView) => {
+          result.push([path.toString(), data.toString()]);
+        });
+
+        const generatorOptions = {
+          outputDir: 'out',
+          newLine: '\n',
+        };
+        const state = await new OpenApiGenerator(generatorOptions)
+          // deno-lint-ignore no-explicit-any
+          .useType(TypeScriptModelsGenerator, { __test__: true } as any)
+          .parseAndGenerate(filePath);
+        result.splice(0, 0, ['state', state]);
+
+        restore();
+        await verify(t, result);
+      });
+    }
+  });
+}

package/test_runner.js

@@ -0,0 +1,239 @@
+const pc = require("picocolors");
+const process = require("process");
+const { pathToFileURL } = require("url");
+const { testDefinitions } = require("@deno/shim-deno-test");
+const filePaths = [
+    "src/ast/nodes/argument.test.js",
+    "src/ast/nodes/array-type.test.js",
+    "src/ast/nodes/arrow-function.test.js",
+    "src/ast/nodes/class.test.js",
+    "src/ast/nodes/constructor-parameter.test.js",
+    "src/ast/nodes/constructor.test.js",
+    "src/ast/nodes/decorator.test.js",
+    "src/ast/nodes/doc-tag.test.js",
+    "src/ast/nodes/doc.test.js",
+    "src/ast/nodes/enum-value.test.js",
+    "src/ast/nodes/enum.test.js",
+    "src/ast/nodes/export.test.js",
+    "src/ast/nodes/function-type.test.js",
+    "src/ast/nodes/function.test.js",
+    "src/ast/nodes/generic-parameter.test.js",
+    "src/ast/nodes/indexer.test.js",
+    "src/ast/nodes/interface.test.js",
+    "src/ast/nodes/intersection-type.test.js",
+    "src/ast/nodes/method.test.js",
+    "src/ast/nodes/object-type.test.js",
+    "src/ast/nodes/object.test.js",
+    "src/ast/nodes/parameter.test.js",
+    "src/ast/nodes/property-accessor.test.js",
+    "src/ast/nodes/property.test.js",
+    "src/ast/nodes/reference.test.js",
+    "src/ast/nodes/string.test.js",
+    "src/ast/nodes/tuple.test.js",
+    "src/ast/nodes/type-alias.test.js",
+    "src/ast/nodes/union-type.test.js",
+    "src/ast/nodes/variable.test.js",
+    "src/import-collection.test.js",
+    "tests/openapi-models.test.js",
+];
+async function main() {
+    const testContext = {
+        process,
+        pc,
+    };
+    for (const [i, filePath] of filePaths.entries()) {
+        if (i > 0) {
+            console.log("");
+        }
+        const scriptPath = "./script/" + filePath;
+        console.log("Running tests in " + pc.underline(scriptPath) + "...\n");
+        process.chdir(__dirname + "/script");
+        const scriptTestContext = {
+            origin: pathToFileURL(filePath).toString(),
+            ...testContext,
+        };
+        try {
+            require(scriptPath);
+        }
+        catch (err) {
+            console.error(err);
+            process.exit(1);
+        }
+        await runTestDefinitions(testDefinitions.splice(0, testDefinitions.length), scriptTestContext);
+        const esmPath = "./esm/" + filePath;
+        console.log("\nRunning tests in " + pc.underline(esmPath) + "...\n");
+        process.chdir(__dirname + "/esm");
+        const esmTestContext = {
+            origin: pathToFileURL(filePath).toString(),
+            ...testContext,
+        };
+        await import(esmPath);
+        await runTestDefinitions(testDefinitions.splice(0, testDefinitions.length), esmTestContext);
+    }
+}
+async function runTestDefinitions(testDefinitions, options) {
+    var _a, _b;
+    const testFailures = [];
+    const hasOnly = testDefinitions.some((d) => d.only);
+    if (hasOnly) {
+        testDefinitions = testDefinitions.filter((d) => d.only);
+    }
+    for (const definition of testDefinitions) {
+        options.process.stdout.write("test " + definition.name + " ...");
+        if (definition.ignore) {
+            options.process.stdout.write(` ${options.pc.gray("ignored")}\n`);
+            continue;
+        }
+        const context = getTestContext(definition, undefined);
+        let pass = false;
+        try {
+            await definition.fn(context);
+            if (context.hasFailingChild) {
+                testFailures.push({
+                    name: definition.name,
+                    err: new Error("Had failing test step.")
+                });
+            }
+            else {
+                pass = true;
+            }
+        }
+        catch (err) {
+            testFailures.push({
+                name: definition.name,
+                err
+            });
+        }
+        const testStepOutput = context.getOutput();
+        if (testStepOutput.length > 0) {
+            options.process.stdout.write(testStepOutput);
+        }
+        else {
+            options.process.stdout.write(" ");
+        }
+        options.process.stdout.write(getStatusText(pass ? "ok" : "fail"));
+        options.process.stdout.write("\n");
+    }
+    if (testFailures.length > 0) {
+        options.process.stdout.write("\nFAILURES");
+        for (const failure of testFailures) {
+            options.process.stdout.write("\n\n");
+            options.process.stdout.write(failure.name + "\n");
+            options.process.stdout.write(indentText(((_b = (_a = failure.err) === null || _a === void 0 ? void 0 : _a.stack) !== null && _b !== void 0 ? _b : failure.err).toString(), 1));
+        }
+        options.process.exit(1);
+    }
+    else if (hasOnly) {
+        options.process.stdout.write('error: Test failed because the "only" option was used.\n');
+        options.process.exit(1);
+    }
+    function getTestContext(definition, parent) {
+        return {
+            name: definition.name,
+            parent,
+            origin: options.origin,
+            /** @type {any} */ err: undefined,
+            status: "ok",
+            children: [],
+            get hasFailingChild() {
+                return this.children.some((c) => c.status === "fail" || c.status === "pending");
+            },
+            getOutput() {
+                var _a;
+                let output = "";
+                if (this.parent) {
+                    output += "test " + this.name + " ...";
+                }
+                if (this.children.length > 0) {
+                    output += "\n" + this.children.map((c) => indentText(c.getOutput(), 1)).join("\n") + "\n";
+                }
+                else if (!this.err) {
+                    output += " ";
+                }
+                if (this.parent && this.err) {
+                    output += "\n";
+                }
+                if (this.err) {
+                    output += indentText(((_a = this.err.stack) !== null && _a !== void 0 ? _a : this.err).toString(), 1);
+                    if (this.parent) {
+                        output += "\n";
+                    }
+                }
+                if (this.parent) {
+                    output += getStatusText(this.status);
+                }
+                return output;
+            },
+            async step(nameOrTestDefinition, fn) {
+                const definition = getDefinition();
+                const context = getTestContext(definition, this);
+                context.status = "pending";
+                this.children.push(context);
+                if (definition.ignore) {
+                    context.status = "ignored";
+                    return false;
+                }
+                try {
+                    await definition.fn(context);
+                    context.status = "ok";
+                    if (context.hasFailingChild) {
+                        context.status = "fail";
+                        return false;
+                    }
+                    return true;
+                }
+                catch (err) {
+                    context.status = "fail";
+                    context.err = err;
+                    return false;
+                }
+                /** @returns {TestDefinition} */ function getDefinition() {
+                    if (typeof nameOrTestDefinition === "string") {
+                        if (!(fn instanceof Function)) {
+                            throw new TypeError("Expected function for second argument.");
+                        }
+                        return {
+                            name: nameOrTestDefinition,
+                            fn
+                        };
+                    }
+                    else if (typeof nameOrTestDefinition === "object") {
+                        return nameOrTestDefinition;
+                    }
+                    else {
+                        throw new TypeError("Expected a test definition or name and function.");
+                    }
+                }
+            }
+        };
+    }
+    function getStatusText(status) {
+        switch (status) {
+            case "ok":
+                return options.pc.green(status);
+            case "fail":
+            case "pending":
+                return options.pc.red(status);
+            case "ignored":
+                return options.pc.gray(status);
+            default:
+                {
+                    const _assertNever = status;
+                    return status;
+                }
+        }
+    }
+    function indentText(text, indentLevel) {
+        if (text === undefined) {
+            text = "[undefined]";
+        }
+        else if (text === null) {
+            text = "[null]";
+        }
+        else {
+            text = text.toString();
+        }
+        return text.split(/\r?\n/).map((line) => "  ".repeat(indentLevel) + line).join("\n");
+    }
+}
+main();