@workos/oagen-emitters 0.2.1 → 0.4.0

package/test/python/tests.test.ts

@@ -0,0 +1,202 @@
+import { describe, it, expect } from 'vitest';
+import { generateTests } from '../../src/python/tests.js';
+import type { EmitterContext, ApiSpec, Service, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+const models: Model[] = [
+  {
+    name: 'Organization',
+    fields: [
+      { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+    ],
+  },
+];
+
+const services: Service[] = [
+  {
+    name: 'Organizations',
+    operations: [
+      {
+        name: 'getOrganization',
+        httpMethod: 'get',
+        path: '/organizations/{id}',
+        pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model', name: 'Organization' },
+        errors: [],
+        injectIdempotencyKey: false,
+      },
+      {
+        name: 'deleteOrganization',
+        httpMethod: 'delete',
+        path: '/organizations/{id}',
+        pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'primitive', type: 'unknown' },
+        errors: [],
+        injectIdempotencyKey: false,
+      },
+    ],
+  },
+];
+
+const spec: ApiSpec = {
+  name: 'TestAPI',
+  version: '1.0.0',
+  baseUrl: 'https://api.workos.com',
+  services,
+  models,
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec,
+};
+
+describe('generateTests', () => {
+  it('does not generate conftest, helpers, client tests, or pagination tests (now @oagen-ignore-file)', () => {
+    const files = generateTests(spec, ctx);
+    expect(files.find((f) => f.path === 'tests/generated_helpers.py')).toBeUndefined();
+    expect(files.find((f) => f.path === 'tests/conftest.py')).toBeUndefined();
+    expect(files.find((f) => f.path === 'tests/test_generated_client.py')).toBeUndefined();
+    expect(files.find((f) => f.path === 'tests/test_pagination.py')).toBeUndefined();
+  });
+
+  it('generates per-service test file', () => {
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path === 'tests/test_organizations.py');
+    expect(testFile).toBeDefined();
+
+    const content = testFile!.content;
+    expect(content).toContain('class TestOrganizations:');
+    expect(content).toContain('def test_get_organization(');
+    expect(content).toContain('def test_delete_organization(');
+    expect(content).toContain('assert result is None');
+    expect(content).toContain('isinstance(result, Organization)');
+  });
+
+  it('generates error test', () => {
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path === 'tests/test_organizations.py');
+    expect(testFile!.content).toContain('def test_get_organization_unauthorized(');
+    expect(testFile!.content).toContain('def test_get_organization_not_found(');
+    expect(testFile!.content).toContain('def test_get_organization_rate_limited(');
+    expect(testFile!.content).toContain('def test_get_organization_server_error(');
+    expect(testFile!.content).toContain('pytest.raises(AuthenticationError)');
+  });
+
+  it('still generates per-service and model round-trip tests', () => {
+    const files = generateTests(spec, ctx);
+    expect(files.find((f) => f.path === 'tests/test_organizations.py')).toBeDefined();
+  });
+
+  it('generates fixture JSON files', () => {
+    const files = generateTests(spec, ctx);
+    const fixture = files.find((f) => f.path === 'tests/fixtures/organization.json');
+    expect(fixture).toBeDefined();
+    expect(fixture!.headerPlacement).toBe('skip');
+
+    const data = JSON.parse(fixture!.content);
+    expect(data).toHaveProperty('id');
+    expect(data).toHaveProperty('name');
+  });
+
+  it('generates model edge-case and query/pagination regression tests', () => {
+    const edgeModels: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'status', type: { kind: 'enum', name: 'OrganizationStatus' }, required: true },
+          { name: 'nickname', type: { kind: 'primitive', type: 'string' }, required: false },
+          {
+            name: 'external_id',
+            type: { kind: 'nullable', inner: { kind: 'primitive', type: 'string' } },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'OrganizationList',
+        fields: [
+          { name: 'data', type: { kind: 'array', items: { kind: 'model', name: 'Organization' } }, required: true },
+          { name: 'list_metadata', type: { kind: 'model', name: 'ListMetadata' }, required: true },
+        ],
+      },
+      {
+        name: 'ListMetadata',
+        fields: [
+          { name: 'before', type: { kind: 'primitive', type: 'string' }, required: false },
+          { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+        ],
+      },
+    ];
+
+    const edgeSpec: ApiSpec = {
+      ...spec,
+      models: edgeModels,
+      enums: [
+        {
+          name: 'OrganizationStatus',
+          values: [
+            { name: 'ACTIVE', value: 'active' },
+            { name: 'INACTIVE', value: 'inactive' },
+          ],
+        },
+      ],
+      services: [
+        {
+          name: 'Organizations',
+          operations: [
+            {
+              name: 'listOrganizations',
+              httpMethod: 'get',
+              path: '/organizations',
+              pathParams: [],
+              queryParams: [
+                { name: 'status', type: { kind: 'enum', name: 'OrganizationStatus' }, required: false },
+                { name: 'email', type: { kind: 'primitive', type: 'string' }, required: false },
+                { name: 'limit', type: { kind: 'primitive', type: 'integer' }, required: false },
+                { name: 'before', type: { kind: 'primitive', type: 'string' }, required: false },
+                { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+              ],
+              headerParams: [],
+              response: { kind: 'model', name: 'OrganizationList' },
+              errors: [],
+              injectIdempotencyKey: false,
+              pagination: {
+                strategy: 'cursor',
+                param: 'after',
+                dataPath: 'data',
+                itemType: { kind: 'model', name: 'Organization' },
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    const files = generateTests(edgeSpec, { ...ctx, spec: edgeSpec });
+    const serviceTest = files.find((f) => f.path === 'tests/test_organizations.py');
+    const roundTripTest = files.find((f) => f.path === 'tests/test_models_round_trip.py');
+
+    expect(serviceTest).toBeDefined();
+    expect(serviceTest!.content).toContain('def test_list_organizations_empty_page(');
+    expect(serviceTest!.content).toContain('def test_list_organizations_encodes_query_params(');
+    expect(serviceTest!.content).toContain('assert request.url.params["email"] == "value email/test"');
+    expect(serviceTest!.content).toContain('assert request.url.params["limit"] == "10"');
+
+    expect(roundTripTest).toBeDefined();
+    expect(roundTripTest!.content).toContain('def test_organization_minimal_payload(');
+    expect(roundTripTest!.content).toContain('def test_organization_omits_absent_optional_non_nullable_fields(');
+    expect(roundTripTest!.content).toContain('def test_organization_preserves_nullable_fields(');
+    expect(roundTripTest!.content).toContain('def test_organization_round_trips_unknown_enum_values(');
+  });
+});

package/src/node/common.ts

@@ -1,273 +0,0 @@
-import type { GeneratedFile } from '@workos/oagen';
-
-export function generateCommon(): GeneratedFile[] {
-  return [
-    {
-      path: 'src/common/utils/pagination.ts',
-      content: paginationContent(),
-      skipIfExists: true,
-      integrateTarget: false,
-    },
-    {
-      path: 'src/common/utils/fetch-and-deserialize.ts',
-      content: fetchAndDeserializeContent(),
-      skipIfExists: true,
-      integrateTarget: true,
-    },
-    {
-      path: 'src/common/serializers/list.serializer.ts',
-      content: listSerializerContent(),
-      skipIfExists: true,
-      integrateTarget: false,
-    },
-    {
-      path: 'src/common/utils/test-utils.ts',
-      content: testUtilsContent(),
-      skipIfExists: true,
-      integrateTarget: true,
-    },
-  ];
-}
-
-function paginationContent(): string {
-  return `import type { PaginationOptions } from '../interfaces/pagination-options.interface';
-
-export interface ListMetadata {
-  before: string | null;
-  after: string | null;
-}
-
-export interface List<T> {
-  object: 'list';
-  data: T[];
-  listMetadata: ListMetadata;
-}
-
-export interface ListResponse<T> {
-  object: 'list';
-  data: T[];
-  list_metadata: {
-    before: string | null;
-    after: string | null;
-  };
-}
-
-export class AutoPaginatable<
-  ResourceType,
-  ParametersType extends PaginationOptions = PaginationOptions,
-> {
-  readonly object = 'list' as const;
-  readonly options: ParametersType;
-
-  constructor(
-    protected list: List<ResourceType>,
-    private apiCall: (params: PaginationOptions) => Promise<List<ResourceType>>,
-    options?: ParametersType,
-  ) {
-    this.options = options ?? ({} as ParametersType);
-  }
-
-  get data(): ResourceType[] {
-    return this.list.data;
-  }
-
-  get listMetadata() {
-    return this.list.listMetadata;
-  }
-
-  private async *generatePages(
-    params: PaginationOptions,
-  ): AsyncGenerator<ResourceType[]> {
-    const result = await this.apiCall({
-      ...this.options,
-      limit: 100,
-      after: params.after,
-    });
-    yield result.data;
-    if (result.listMetadata.after) {
-      await new Promise((resolve) => setTimeout(resolve, 350));
-      yield* this.generatePages({ after: result.listMetadata.after });
-    }
-  }
-
-  async autoPagination(): Promise<ResourceType[]> {
-    if (this.options.limit) {
-      return this.data;
-    }
-    const results: ResourceType[] = [];
-    for await (const page of this.generatePages({
-      after: this.options.after,
-    })) {
-      results.push(...page);
-    }
-    return results;
-  }
-}`;
-}
-
-function fetchAndDeserializeContent(): string {
-  return `import type { WorkOS } from '../../workos';
-import type { PaginationOptions } from '../interfaces/pagination-options.interface';
-import { AutoPaginatable, type List, type ListResponse } from './pagination';
-
-function setDefaultOptions(
-  options?: PaginationOptions,
-): Record<string, any> {
-  return {
-    order: 'desc',
-    ...options,
-  };
-}
-
-function deserializeList<T, U>(
-  data: ListResponse<T>,
-  deserializeFn: (item: T) => U,
-): List<U> {
-  return {
-    data: data.data.map(deserializeFn),
-    listMetadata: {
-      before: data.list_metadata.before,
-      after: data.list_metadata.after,
-    },
-  };
-}
-
-export const fetchAndDeserialize = async <T, U>(
-  workos: WorkOS,
-  endpoint: string,
-  deserializeFn: (data: T) => U,
-  options?: PaginationOptions,
-): Promise<List<U>> => {
-  const { data } = await workos.get<ListResponse<T>>(endpoint, {
-    query: setDefaultOptions(options),
-  });
-  return deserializeList(data, deserializeFn);
-};
-
-export async function createPaginatedList<TResponse, TModel, TOptions extends PaginationOptions>(
-  workos: WorkOS,
-  endpoint: string,
-  deserializeFn: (r: TResponse) => TModel,
-  options?: TOptions,
-): Promise<AutoPaginatable<TModel, TOptions>> {
-  return new AutoPaginatable(
-    await fetchAndDeserialize<TResponse, TModel>(workos, endpoint, deserializeFn, options),
-    (params) => fetchAndDeserialize<TResponse, TModel>(workos, endpoint, deserializeFn, params),
-    options,
-  );
-}`;
-}
-
-function listSerializerContent(): string {
-  return `import type { ListMetadata, ListResponse } from '../utils/pagination';
-
-export function deserializeListMetadata(
-  metadata: ListResponse<any>['list_metadata'],
-): ListMetadata {
-  return {
-    before: metadata.before,
-    after: metadata.after,
-  };
-}`;
-}
-
-function testUtilsContent(): string {
-  return `import fetch from 'jest-fetch-mock';
-
-interface MockParams {
-  status?: number;
-  headers?: Record<string, string>;
-  [key: string]: any;
-}
-
-export function fetchOnce(
-  response: any = {},
-  { status = 200, headers, ...rest }: MockParams = {},
-) {
-  return fetch.once(JSON.stringify(response), {
-    status,
-    headers: {
-      'content-type': 'application/json;charset=UTF-8',
-      ...headers,
-    },
-    ...rest,
-  });
-}
-
-export function fetchURL(): string {
-  return String(fetch.mock.calls[0][0]);
-}
-
-export function fetchMethod(): string {
-  return String(fetch.mock.calls[0][1]?.method ?? 'GET');
-}
-
-export function fetchSearchParams(): Record<string, string> {
-  return Object.fromEntries(new URL(fetchURL()).searchParams);
-}
-
-export function fetchHeaders(): Record<string, string> {
-  const headers = fetch.mock.calls[0][1]?.headers ?? {};
-  return headers as Record<string, string>;
-}
-
-export function fetchBody({ raw = false } = {}): any {
-  const body = fetch.mock.calls[0][1]?.body;
-  if (body instanceof URLSearchParams) return body.toString();
-  if (raw) return body;
-  return JSON.parse(String(body));
-}
-
-/**
- * Shared test helper: asserts that the given async function throws when the
- * server responds with 401 Unauthorized.
- */
-export function testUnauthorized(fn: () => Promise<any>) {
-  it('throws on unauthorized', async () => {
-    fetchOnce({ message: 'Unauthorized' }, { status: 401 });
-    await expect(fn()).rejects.toThrow('Could not authorize the request');
-  });
-}
-
-/**
- * Shared test helper: asserts that a paginated list call returns the expected
- * shape (data array + listMetadata) and hits the correct endpoint.
- */
-export function testPaginatedList(
-  fn: () => Promise<any>,
-  pathContains: string,
-) {
-  it('returns paginated results', async () => {
-    // Caller must have called fetchOnce with the list fixture before invoking fn
-    const { data, listMetadata } = await fn();
-    expect(fetchURL()).toContain(pathContains);
-    expect(fetchSearchParams()).toHaveProperty('order');
-    expect(Array.isArray(data)).toBe(true);
-    expect(listMetadata).toBeDefined();
-  });
-}
-
-/**
- * Shared test helper: asserts that a paginated list call returns empty data
- * when the server responds with an empty list.
- */
-export function testEmptyResults(fn: () => Promise<any>) {
-  it('handles empty results', async () => {
-    fetchOnce({ data: [], list_metadata: { before: null, after: null } });
-    const { data } = await fn();
-    expect(data).toEqual([]);
-  });
-}
-
-/**
- * Shared test helper: asserts that pagination params are forwarded correctly.
- */
-export function testPaginationParams(fn: (opts: any) => Promise<any>, fixture: any) {
-  it('forwards pagination params', async () => {
-    fetchOnce(fixture);
-    await fn({ limit: 10, after: 'cursor_abc' });
-    expect(fetchSearchParams()['limit']).toBe('10');
-    expect(fetchSearchParams()['after']).toBe('cursor_abc');
-  });
-}`;
-}

package/src/node/config.ts

@@ -1,71 +0,0 @@
-import type { GeneratedFile } from '@workos/oagen';
-
-export function generateConfig(): GeneratedFile[] {
-  return [
-    {
-      path: 'src/common/interfaces/workos-options.interface.ts',
-      content: `export interface WorkOSOptions {
-  apiKey?: string;
-  apiHostname?: string;
-  https?: boolean;
-  port?: number;
-  config?: RequestInit;
-  fetchFn?: typeof fetch;
-  clientId?: string;
-  timeout?: number;
-}
-
-export interface AppInfo {
-  name: string;
-  version?: string;
-}`,
-      skipIfExists: true,
-      integrateTarget: false,
-    },
-    {
-      path: 'src/common/interfaces/post-options.interface.ts',
-      content: `export interface PostOptions {
-  query?: Record<string, any>;
-  idempotencyKey?: string;
-  warrantToken?: string;
-  skipApiKeyCheck?: boolean;
-  encoding?: 'json' | 'form-data' | 'form-urlencoded' | 'binary' | 'text';
-}`,
-      skipIfExists: true,
-      integrateTarget: false,
-    },
-    {
-      path: 'src/common/interfaces/get-options.interface.ts',
-      content: `export interface GetOptions {
-  query?: Record<string, any>;
-  accessToken?: string;
-  warrantToken?: string;
-  skipApiKeyCheck?: boolean;
-}`,
-      skipIfExists: true,
-      integrateTarget: false,
-    },
-    {
-      path: 'src/common/interfaces/pagination-options.interface.ts',
-      content: `export interface PaginationOptions {
-  limit?: number;
-  before?: string | null;
-  after?: string | null;
-  order?: 'asc' | 'desc';
-}`,
-      skipIfExists: true,
-      integrateTarget: false,
-    },
-    {
-      path: 'src/common/interfaces/request-exception.interface.ts',
-      content: `export interface RequestException {
-  readonly status: number;
-  readonly name: string;
-  readonly requestID: string;
-  readonly code?: string;
-}`,
-      skipIfExists: true,
-      integrateTarget: false,
-    },
-  ];
-}