@goast/core 0.4.1 → 0.4.2

package/src/tests/openapi.test.ts

@@ -1,50 +0,0 @@
-import "../_dnt.test_polyfills.js";
-import { join } from 'node:path';
-
-import {
-  declutterApiData,
-  openApiV2FilesDir,
-  openApiV3_1FilesDir,
-  openApiV3FilesDir,
-  type OpenApiVersion,
-  verify,
-} from '@goast/test-utils';
-
-import { describe, it } from '../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-import { OpenApiParser, toCustomCase } from '../mod.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}`, () => {
-    const testFiles = version.startsWith('3') ? testFilesAllVersions.concat(testFilesV3x) : testFilesAllVersions;
-    for (const file of testFiles) {
-      const fileWithoutExt = file.replace(/\.[^/.]+$/, '');
-      it(
-        toCustomCase(fileWithoutExt, {
-          wordCasing: 'all-lower',
-          wordSeparator: ' ',
-        }),
-        async (t) => {
-          const filePath = join(path, file);
-          const data = await new OpenApiParser().parseApisAndTransform(filePath);
-
-          // Remove properties that do not need to be verified
-          for (const schema of Object.values(data.schemas)) {
-            delete (schema.$src as Record<string, unknown>).document;
-          }
-
-          declutterApiData(data);
-          await verify(t, data);
-        },
-      );
-    }
-  });
-}

package/src/tests/schema-factory.ts

@@ -1,185 +0,0 @@
-import type { ApiSchema, ApiSchemaBase, ApiSchemaComponent, ApiSchemaExtensions, ApiSchemaProperty } from '../mod.js';
-
-export type TestSchema =
-  & Partial<Omit<ApiSchemaBase, 'required'>>
-  & Partial<ApiSchemaComponent>
-  & {
-    required?: string[];
-  };
-export type TestOneofSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'oneOf'>, 'kind'>>;
-export type TestMultiTypeSchema =
-  & TestSchema
-  & Partial<Omit<ApiSchemaExtensions<'multi-type'>, 'kind' | 'properties'>>
-  & {
-    properties?: ApiSchemaProperty[];
-  };
-export type TestStringSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'string'>, 'kind' | 'type'>>;
-export type TestBooleanSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'boolean'>, 'kind' | 'type'>>;
-export type TestNullSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'null'>, 'kind' | 'type'>>;
-export type TestNumberSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'number'>, 'kind' | 'type'>>;
-export type TestIntegerSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'integer'>, 'kind' | 'type'>>;
-export type TestArraySchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'array'>, 'kind' | 'type'>>;
-export type TestObjectSchema =
-  & TestSchema
-  & Partial<Omit<ApiSchemaExtensions<'object'>, 'kind' | 'type' | 'properties'>>
-  & {
-    properties?: ApiSchemaProperty[];
-  };
-export type TestCombinedSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'combined'>, 'kind'>>;
-export type TestUnknownSchema = TestSchema & Partial<Omit<ApiSchemaExtensions<'unknown'>, 'kind'>>;
-
-let nextId = 0;
-
-function createSchemaBase<T extends TestSchema>(schema: T) {
-  const name = schema.name ?? `schema-${nextId++}`;
-  return {
-    ...schema,
-    name,
-    $src: schema.$src,
-    id: schema.id ?? name,
-    isNameGenerated: schema.isNameGenerated ?? schema.id !== undefined,
-    deprecated: schema.deprecated ?? false,
-    accessibility: schema.accessibility ?? 'all',
-    required: new Set(schema.required ?? []),
-    custom: {},
-  } as ApiSchemaBase & Omit<T, keyof ApiSchemaBase>;
-}
-
-export function createOneOfSchema(schema: TestOneofSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'oneOf',
-    oneOf: schema.oneOf ?? [],
-  } as ApiSchema<'oneOf'>;
-}
-
-export function createMultiTypeSchema(schema: TestMultiTypeSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'multi-type',
-    type: schema.type ?? [],
-    properties: new Map<string, ApiSchemaProperty>((schema.properties ?? []).map((p) => [p.name, p])),
-    allOf: schema.allOf ?? [],
-    anyOf: schema.anyOf ?? [],
-  } as ApiSchema<'multi-type'>;
-}
-
-export function createStringSchema(schema: TestStringSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'string',
-    type: 'string',
-  } as ApiSchema<'string'>;
-}
-
-export function createBooleanSchema(schema: TestBooleanSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'boolean',
-    type: 'boolean',
-  } as ApiSchema<'boolean'>;
-}
-
-export function createNullSchema(schema: TestNullSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'null',
-    type: 'null',
-  } as ApiSchema<'null'>;
-}
-
-export function createNumberSchema(schema: TestNumberSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'number',
-    type: 'number',
-  } as ApiSchema<'number'>;
-}
-
-export function createIntegerSchema(schema: TestIntegerSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'integer',
-    type: 'integer',
-  } as ApiSchema<'integer'>;
-}
-
-export function createArraySchema(schema: TestArraySchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'array',
-    type: 'array',
-    items: schema.items ?? undefined,
-  } as ApiSchema<'array'>;
-}
-
-export function createObjectSchema(schema: TestObjectSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'object',
-    type: 'object',
-    properties: new Map<string, ApiSchemaProperty>((schema.properties ?? []).map((p) => [p.name, p])),
-    allOf: schema.allOf ?? [],
-    anyOf: schema.anyOf ?? [],
-  } as ApiSchema<'object'>;
-}
-
-export function createCombinedSchema(schema: TestCombinedSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'combined',
-    allOf: schema.allOf ?? [],
-    anyOf: schema.anyOf ?? [],
-  } as ApiSchema<'combined'>;
-}
-
-export function createUnknownSchema(schema: TestUnknownSchema = {}) {
-  return {
-    ...createSchemaBase(schema),
-    kind: 'unknown',
-  } as ApiSchema<'unknown'>;
-}
-
-export function createOneOfProperty(name: string, schema: TestOneofSchema = {}): ApiSchemaProperty {
-  return { name, schema: createOneOfSchema(schema) };
-}
-
-export function createMultiTypeProperty(name: string, schema: TestMultiTypeSchema = {}): ApiSchemaProperty {
-  return { name, schema: createMultiTypeSchema(schema) };
-}
-
-export function createStringProperty(name: string, schema: TestStringSchema = {}): ApiSchemaProperty {
-  return { name, schema: createStringSchema(schema) };
-}
-
-export function createBooleanProperty(name: string, schema: TestBooleanSchema = {}): ApiSchemaProperty {
-  return { name, schema: createBooleanSchema(schema) };
-}
-
-export function createNullProperty(name: string, schema: TestNullSchema = {}): ApiSchemaProperty {
-  return { name, schema: createNullSchema(schema) };
-}
-
-export function createNumberProperty(name: string, schema: TestNumberSchema = {}): ApiSchemaProperty {
-  return { name, schema: createNumberSchema(schema) };
-}
-
-export function createIntegerProperty(name: string, schema: TestIntegerSchema = {}): ApiSchemaProperty {
-  return { name, schema: createIntegerSchema(schema) };
-}
-
-export function createArrayProperty(name: string, schema: TestArraySchema = {}): ApiSchemaProperty {
-  return { name, schema: createArraySchema(schema) };
-}
-
-export function createObjectProperty(name: string, schema: TestObjectSchema = {}): ApiSchemaProperty {
-  return { name, schema: createObjectSchema(schema) };
-}
-
-export function createCombinedProperty(name: string, schema: TestCombinedSchema = {}): ApiSchemaProperty {
-  return { name, schema: createCombinedSchema(schema) };
-}
-
-export function createUnknownProperty(name: string, schema: TestUnknownSchema = {}): ApiSchemaProperty {
-  return { name, schema: createUnknownSchema(schema) };
-}

package/test_runner.js

@@ -1,221 +0,0 @@
-const pc = require("picocolors");
-const process = require("process");
-const { pathToFileURL } = require("url");
-const { testDefinitions } = require("@deno/shim-deno-test");
-const filePaths = [
-    "src/collect/helpers.test.js",
-    "src/transform/helpers.test.js",
-    "src/utils/action-provider.test.js",
-    "src/utils/common.utils.test.js",
-    "src/utils/condition.test.js",
-    "src/utils/endpoint.utils.test.js",
-    "src/utils/factory.test.js",
-    "src/utils/generator.utils.test.js",
-    "src/utils/object.utils.test.js",
-    "src/utils/schema.utils.test.js",
-    "src/utils/source-builder.test.js",
-    "src/utils/string-builder/string-builder.test.js",
-    "src/utils/string.utils.test.js",
-    "tests/openapi.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();