@goast/typescript 0.4.4 → 0.5.1-k6.1

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

@@ -1,64 +0,0 @@
-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.9/bdd.js';
-import { restore, stub } from '../deps/jsr.io/@std/testing/1.0.9/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

@@ -1,239 +0,0 @@
-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();