test: generate schemas in different paths (#78)

* test: import fixture path * test: remove importFresh utility
toomuchdesign · Sep 18, 2023 · 3798318 · 3798318
1 parent 9e0a222
commit 3798318
Show file tree

Hide file tree

Showing 21 changed files with 128 additions and 129 deletions.
diff --git a/README.md b/README.md
@@ -62,7 +62,7 @@ type MyModel = FromSchema<typeof myModelSchema>;
 
 Generated JSON schema path names get escaped in order to be valid file system names.
 
-Circular `$ref`s can be technically resolved with "import" `refHandling` option. But TS will stop the type recursion and type the schema as `any`. See [relevant tests](https://github.com/toomuchdesign/openapi-ts-json-schema/blob/master/test/circularReference.test.ts).
+Circular `$ref`s can be technically resolved with "import" `refHandling` option. But TS will stop the type recursion and type the schema as `any` (error `ts(7022)`). See [relevant tests](https://github.com/toomuchdesign/openapi-ts-json-schema/blob/master/test/circularReference.test.ts).
 
 Take a look at the [Developer's notes](./docs/developer-notes.md) for a few more in-depth explanations.
 

diff --git a/test/circularReference.test.ts b/test/circularReference.test.ts
@@ -1,21 +1,20 @@
 import path from 'path';
 import { describe, it, expect } from 'vitest';
-import { importFresh } from './test-utils';
+import { fixtures, makeTestOutputPath } from './test-utils';
 import { openapiToTsJsonSchema } from '../src';
 
-const fixtures = path.resolve(__dirname, 'fixtures');
-
 describe('Circular reference', () => {
-  it('Works', async () => {
+  it("Doesn't break", async () => {
     const { outputPath } = await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'circular-reference/specs.yaml'),
+      outputPath: makeTestOutputPath('circular'),
       definitionPathsToGenerateFrom: ['components.schemas'],
       refHandling: 'import',
       silent: true,
     });
 
-    const januarySchema = await importFresh(
-      path.resolve(outputPath, 'components/schemas/January'),
+    const januarySchema = await import(
+      path.resolve(outputPath, 'components/schemas/January')
     );
 
     expect(januarySchema.default).toEqual({
@@ -26,12 +25,8 @@ describe('Circular reference', () => {
           description: 'February description',
           type: 'object',
           properties: {
-            previousMonth: {
-              description: 'January description',
-              type: 'object',
-              // @NOTE JS engine seems to stop recursion
-              properties: { nextMonth: undefined },
-            },
+            // Node stops recursion
+            previousMonth: undefined,
           },
         },
       },

diff --git a/test/dereferencing.test.ts b/test/dereferencing.test.ts
@@ -1,20 +1,19 @@
 import path from 'path';
 import { describe, it, expect } from 'vitest';
-import { importFresh } from './test-utils';
+import { fixtures, makeTestOutputPath } from './test-utils';
 import { openapiToTsJsonSchema } from '../src';
 
-const fixtures = path.resolve(__dirname, 'fixtures');
-
-describe('Deferencing', () => {
+describe('Dereferencing', () => {
   it('Dereferences and transforms even from paths not marked for generation', async () => {
     const { outputPath } = await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'mini-referenced/specs.yaml'),
+      outputPath: makeTestOutputPath('dereferencing'),
       definitionPathsToGenerateFrom: ['components.months'],
       silent: true,
     });
 
-    const januarySchema = await importFresh(
-      path.resolve(outputPath, 'components/months/January'),
+    const januarySchema = await import(
+      path.resolve(outputPath, 'components/months/January')
     );
 
     expect(januarySchema.default).toEqual({
@@ -30,12 +29,13 @@ describe('Deferencing', () => {
   it('Transforms deeply nested schemas', async () => {
     const { outputPath } = await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'complex/specs.yaml'),
+      outputPath: makeTestOutputPath('dereferencing'),
       definitionPathsToGenerateFrom: ['paths'],
       silent: true,
     });
 
-    const pathsSchema = await importFresh(
-      path.resolve(outputPath, 'paths/v1|path-1'),
+    const pathsSchema = await import(
+      path.resolve(outputPath, 'paths/v1|path-1')
     );
 
     expect(

diff --git a/test/externalRefs.test.ts b/test/externalRefs.test.ts
@@ -1,20 +1,19 @@
 import path from 'path';
 import { describe, it, expect } from 'vitest';
-import { importFresh } from './test-utils';
+import { fixtures, makeTestOutputPath } from './test-utils';
 import { openapiToTsJsonSchema } from '../src';
 
-const fixtures = path.resolve(__dirname, 'fixtures');
-
 describe('External $ref', () => {
   it('Resolve external refs', async () => {
     const { outputPath } = await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'external-ref/specs.yaml'),
+      outputPath: makeTestOutputPath('external-refs'),
       definitionPathsToGenerateFrom: ['components.schemas'],
       silent: true,
     });
 
-    const externalDefinitionSchema = await importFresh(
-      path.resolve(outputPath, 'components/schemas/ExternalDefinition'),
+    const externalDefinitionSchema = await import(
+      path.resolve(outputPath, 'components/schemas/ExternalDefinition')
     );
 
     expect(externalDefinitionSchema.default).toEqual({
@@ -23,11 +22,11 @@ describe('External $ref', () => {
       enum: ['yes', 'no', null],
     });
 
-    const localDefinitionReferencingExternalSchema = await importFresh(
+    const localDefinitionReferencingExternalSchema = await import(
       path.resolve(
         outputPath,
         'components/schemas/LocalDefinitionReferencingExternal',
-      ),
+      )
     );
 
     expect(localDefinitionReferencingExternalSchema.default).toEqual({

diff --git a/test/idExport.test.ts b/test/idExport.test.ts
@@ -1,23 +1,22 @@
 import path from 'path';
 import { describe, it, expect } from 'vitest';
 import { openapiToTsJsonSchema } from '../src';
-import { importFresh } from './test-utils';
-
-const fixtures = path.resolve(__dirname, 'fixtures');
+import { fixtures, makeTestOutputPath } from './test-utils';
 
 describe('$id export', async () => {
   it('exposes schema id as $id named export', async () => {
     const { outputPath } = await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'complex/specs.yaml'),
+      outputPath: makeTestOutputPath('id-export'),
       definitionPathsToGenerateFrom: ['components.months'],
       silent: true,
     });
 
-    const januarySchema = await importFresh(
-      path.resolve(outputPath, 'components/months/January'),
+    const januarySchema = await import(
+      path.resolve(outputPath, 'components/months/January')
     );
-    const februarySchema = await importFresh(
-      path.resolve(outputPath, 'components/months/February'),
+    const februarySchema = await import(
+      path.resolve(outputPath, 'components/months/February')
     );
 
     expect(januarySchema['$id']).toBe('#/components/months/January');

diff --git a/test/index.test.ts b/test/index.test.ts
@@ -1,34 +1,27 @@
 import path from 'path';
 import { existsSync } from 'fs';
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { importFresh } from './test-utils';
+import { fixtures, makeTestOutputPath } from './test-utils';
 import { openapiToTsJsonSchema } from '../src';
 
-const fixtures = path.resolve(__dirname, 'fixtures');
-
 describe('openapiToTsJsonSchema', () => {
   it('Generates expected JSON schemas', async () => {
     const { outputPath } = await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'complex/specs.yaml'),
+      outputPath: makeTestOutputPath('index'),
       definitionPathsToGenerateFrom: ['paths', 'components.months'],
       silent: true,
     });
 
-    expect(outputPath).toBe(
-      path.resolve(fixtures, 'complex/schemas-autogenerated'),
-    );
-
-    const januarySchema = await importFresh(
-      path.resolve(outputPath, 'components/months/January'),
+    const januarySchema = await import(
+      path.resolve(outputPath, 'components/months/January')
     );
-    const februarySchema = await importFresh(
-      path.resolve(outputPath, 'components/months/February'),
+    const februarySchema = await import(
+      path.resolve(outputPath, 'components/months/February')
     );
 
     // definition paths get escaped
-    const path1 = await importFresh(
-      path.resolve(outputPath, 'paths/v1|path-1'),
-    );
+    const path1 = await import(path.resolve(outputPath, 'paths/v1|path-1'));
 
     expect(januarySchema.default).toEqual({
       description: 'January description',
@@ -90,8 +83,11 @@ describe('openapiToTsJsonSchema', () => {
   });
 
   it('deletes previously generated schemas', async () => {
-    const { outputPath } = await openapiToTsJsonSchema({
+    const outputPath = makeTestOutputPath('index');
+
+    await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'mini-referenced/specs.yaml'),
+      outputPath,
       definitionPathsToGenerateFrom: ['components.schemas'],
       silent: true,
     });
@@ -106,6 +102,7 @@ describe('openapiToTsJsonSchema', () => {
 
     await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'mini-referenced/specs.yaml'),
+      outputPath,
       definitionPathsToGenerateFrom: ['components.months'],
       silent: true,
     });
@@ -116,6 +113,7 @@ describe('openapiToTsJsonSchema', () => {
       await expect(() =>
         openapiToTsJsonSchema({
           openApiSchema: path.resolve(fixtures, 'does-not-exist.yaml'),
+          outputPath: makeTestOutputPath('index'),
           definitionPathsToGenerateFrom: ['components'],
           silent: true,
         }),
@@ -134,6 +132,7 @@ describe('openapiToTsJsonSchema', () => {
       it('logs expected message', async () => {
         await openapiToTsJsonSchema({
           openApiSchema: path.resolve(fixtures, 'mini-referenced/specs.yaml'),
+          outputPath: makeTestOutputPath('index'),
           definitionPathsToGenerateFrom: [],
         });
 
@@ -148,6 +147,7 @@ describe('openapiToTsJsonSchema', () => {
         await expect(
           openapiToTsJsonSchema({
             openApiSchema: path.resolve(fixtures, 'mini-referenced/specs.yaml'),
+            outputPath: makeTestOutputPath('index'),
             definitionPathsToGenerateFrom: ['paths', '/components.schema'],
           }),
         ).rejects.toThrow(

diff --git a/test/jsonOpenAPI.test.ts b/test/jsonOpenAPI.test.ts
@@ -1,20 +1,19 @@
 import path from 'path';
 import { describe, it, expect } from 'vitest';
-import { importFresh } from './test-utils';
+import { fixtures, makeTestOutputPath } from './test-utils';
 import { openapiToTsJsonSchema } from '../src';
 
-const fixtures = path.resolve(__dirname, 'fixtures');
-
 describe('JSON OpenAPI input', async () => {
   it('generates expected schemas', async () => {
     const { outputPath } = await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'json/specs.json'),
+      outputPath: makeTestOutputPath('json'),
       definitionPathsToGenerateFrom: ['components.months'],
       silent: true,
     });
 
-    const januarySchema = await importFresh(
-      path.resolve(outputPath, 'components/months/January'),
+    const januarySchema = await import(
+      path.resolve(outputPath, 'components/months/January')
     );
 
     expect(januarySchema.default).toEqual({

diff --git a/test/metaData.test.ts b/test/metaData.test.ts
@@ -2,13 +2,13 @@ import path from 'path';
 import fs from 'fs';
 import { describe, it, expect } from 'vitest';
 import { openapiToTsJsonSchema } from '../src';
-
-const fixtures = path.resolve(__dirname, 'fixtures');
+import { fixtures, makeTestOutputPath } from './test-utils';
 
 describe('Returned "metaData"', async () => {
   it('returns expected data', async () => {
     const { metaData } = await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'mini-referenced/specs.yaml'),
+      outputPath: makeTestOutputPath('meta-data'),
       definitionPathsToGenerateFrom: ['components.months'],
       refHandling: 'import',
       silent: true,

diff --git a/test/outputPath.test.ts b/test/outputPath.test.ts
@@ -1,11 +1,10 @@
 import path from 'path';
 import fs from 'fs';
 import { describe, it, expect } from 'vitest';
+import { fixtures } from './test-utils';
 import { openapiToTsJsonSchema } from '../src';
 
-const fixtures = path.resolve(__dirname, 'fixtures');
-
-describe('"outputPath" option', async () => {
+describe('"outputPath" option', () => {
   it('saves generated schemas to provided path', async () => {
     const customOutputPath = path.resolve(
       fixtures,
@@ -29,4 +28,27 @@ describe('"outputPath" option', async () => {
     );
     expect(fs.existsSync(expectedGeneratedSchemaPath)).toBe(true);
   });
+
+  describe('no value provided', () => {
+    it('saves generated schemas in a "schemas-autogenerated" folder next to open api schema', async () => {
+      const { outputPath } = await openapiToTsJsonSchema({
+        openApiSchema: path.resolve(fixtures, 'mini-referenced/specs.yaml'),
+        definitionPathsToGenerateFrom: ['components.schemas'],
+        silent: true,
+      });
+
+      const expectedOutputPath = path.resolve(
+        fixtures,
+        'mini-referenced/schemas-autogenerated',
+      );
+      expect(outputPath).toBe(expectedOutputPath);
+
+      const expectedGeneratedSchemaPath = path.resolve(
+        expectedOutputPath,
+        'components/schemas',
+        'Answer.ts',
+      );
+      expect(fs.existsSync(expectedGeneratedSchemaPath)).toBe(true);
+    });
+  });
 });
diff --git a/test/parameters.test.ts b/test/parameters.test.ts
@@ -1,20 +1,19 @@
 import path from 'path';
 import { describe, it, expect } from 'vitest';
-import { importFresh } from './test-utils';
+import { fixtures, makeTestOutputPath } from './test-utils';
 import { openapiToTsJsonSchema } from '../src';
 
-const fixtures = path.resolve(__dirname, 'fixtures');
-
 describe('OpenAPI parameters', () => {
   it('Transforms parameters array into a JSON schema record', async () => {
     const { outputPath } = await openapiToTsJsonSchema({
       openApiSchema: path.resolve(fixtures, 'parameters/specs.yaml'),
+      outputPath: makeTestOutputPath('parameters'),
       definitionPathsToGenerateFrom: ['paths'],
       silent: true,
     });
 
-    const pathSchema = await importFresh(
-      path.resolve(outputPath, 'paths/v1|path-1'),
+    const pathSchema = await import(
+      path.resolve(outputPath, 'paths/v1|path-1')
     );
 
     expect(pathSchema.default).toEqual({