@contractkit/plugin-python 0.9.1

package/tests/codegen-client.test.ts

@@ -0,0 +1,361 @@
+import { describe, it, expect } from 'vitest';
+import { generatePythonClient, deriveClientClassName, deriveClientModuleName, hasPublicOperations } from '../src/codegen-client.js';
+import {
+    scalarType, arrayType, refType, enumType,
+    opParam, paramNodes, paramRef, paramType, opRequest, opResponse, opOperation, opRoute, opRoot,
+} from './helpers.js';
+
+// ─── deriveClientClassName ────────────────────────────────────────────────
+
+describe('deriveClientClassName', () => {
+    it('derives class name from file', () => {
+        expect(deriveClientClassName('payments.op.ck')).toBe('PaymentsClient');
+        expect(deriveClientClassName('ledger.categories.op.ck')).toBe('LedgerCategoriesClient');
+        expect(deriveClientClassName('/path/to/users.op.ck')).toBe('UsersClient');
+    });
+});
+
+describe('deriveClientModuleName', () => {
+    it('derives module name from file', () => {
+        expect(deriveClientModuleName('payments.op.ck')).toBe('_client_payments');
+        expect(deriveClientModuleName('ledger.categories.op.ck')).toBe('_client_ledger_categories');
+    });
+});
+
+// ─── hasPublicOperations ──────────────────────────────────────────────────
+
+describe('hasPublicOperations', () => {
+    it('returns false for all-internal ops', () => {
+        const root = opRoot([
+            opRoute('/internal', [opOperation('get')], undefined, ['internal']),
+        ]);
+        expect(hasPublicOperations(root)).toBe(false);
+    });
+
+    it('returns true when at least one public op exists', () => {
+        const root = opRoot([
+            opRoute('/public', [opOperation('get')]),
+        ]);
+        expect(hasPublicOperations(root)).toBe(true);
+    });
+});
+
+// ─── generatePythonClient ─────────────────────────────────────────────────
+
+describe('generatePythonClient', () => {
+    it('generates a class with the right name', () => {
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('get', { responses: [opResponse(200, 'Payment')] }),
+            ]),
+        ], 'payments.op.ck');
+        const output = generatePythonClient(root);
+        expect(output).toContain('class PaymentsClient(BaseClient):');
+    });
+
+    it('skips internal operations', () => {
+        const root = opRoot([
+            opRoute('/internal', [opOperation('get', { responses: [opResponse(200, 'User')] })], undefined, ['internal']),
+            opRoute('/public', [opOperation('get', { responses: [opResponse(200, 'User')] })]),
+        ]);
+        const output = generatePythonClient(root);
+        const methodCount = (output.match(/async def /g) || []).length;
+        expect(methodCount).toBe(1);
+    });
+
+    it('infers method names from path and method', () => {
+        const root = opRoot([
+            opRoute('/payments', [opOperation('get', { responses: [opResponse(200, 'array(Payment)')] })]),
+            opRoute('/payments/{id}', [opOperation('get', { responses: [opResponse(200, 'Payment')] })],
+                paramNodes([opParam('id', scalarType('uuid'))])),
+            opRoute('/payments', [opOperation('post', { request: opRequest('PaymentInput'), responses: [opResponse(201, 'Payment')] })]),
+        ], 'payments.op.ck');
+        const output = generatePythonClient(root);
+        expect(output).toContain('async def get_payments(self)');
+        expect(output).toContain('async def get_payments_by_id(self, id: UUID)');
+        expect(output).toContain('async def post_payments(self, body: PaymentInput)');
+    });
+
+    it('uses op.sdk name when provided (converted to snake_case)', () => {
+        const root = opRoot([
+            opRoute('/payments/{id}', [
+                opOperation('get', { sdk: 'getPayment', responses: [opResponse(200, 'Payment')] }),
+            ], paramNodes([opParam('id', scalarType('uuid'))])),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('async def get_payment(self, id: UUID)');
+    });
+
+    it('uses op.name as method name when op.sdk is not set', () => {
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('post', { name: 'Create a Payment', responses: [opResponse(201, 'Payment')] }),
+            ]),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('async def create_a_payment(self)');
+    });
+
+    it('prefers op.sdk over op.name as method name', () => {
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('post', { sdk: 'makePayment', name: 'Create a Payment', responses: [opResponse(201, 'Payment')] }),
+            ]),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('async def make_payment(self)');
+        expect(output).not.toContain('create_a_payment');
+    });
+
+    it('generates void return for operations with no body', () => {
+        const root = opRoot([
+            opRoute('/payments/{id}', [
+                opOperation('delete', { responses: [opResponse(204)] }),
+            ], paramNodes([opParam('id', scalarType('uuid'))])),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('-> None:');
+        expect(output).toContain('return None');
+    });
+
+    it('generates model_validate for model responses', () => {
+        const root = opRoot([
+            opRoute('/payments/{id}', [
+                opOperation('get', { responses: [opResponse(200, 'Payment')] }),
+            ], paramNodes([opParam('id', scalarType('uuid'))])),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('Payment.model_validate(result)');
+    });
+
+    it('generates list comprehension for array model responses', () => {
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('get', { responses: [opResponse(200, 'array(Payment)')] }),
+            ]),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('[Payment.model_validate(item) for item in result]');
+    });
+
+    it('generates query parameter', () => {
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('get', {
+                    query: [opParam('page', scalarType('int')), opParam('limit', scalarType('int'))],
+                    responses: [opResponse(200, 'array(Payment)')],
+                }),
+            ]),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('query: dict | None = None');
+        expect(output).toContain('params=query');
+    });
+
+    it('generates body parameter for POST', () => {
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('post', {
+                    request: opRequest('PaymentInput'),
+                    responses: [opResponse(201, 'Payment')],
+                }),
+            ]),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('body: PaymentInput');
+        expect(output).toContain('body=body.model_dump(mode="json")');
+    });
+
+    it('generates path param interpolation in f-string', () => {
+        const root = opRoot([
+            opRoute('/payments/{id}', [
+                opOperation('get', { responses: [opResponse(200, 'Payment')] }),
+            ], paramNodes([opParam('id', scalarType('uuid'))])),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('f"/payments/{id}"');
+    });
+
+    it('imports model types from their modules', () => {
+        const modelModulePaths = new Map([['Payment', '._models_payment'], ['PaymentInput', '._models_payment']]);
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('post', {
+                    request: opRequest('PaymentInput'),
+                    responses: [opResponse(201, 'Payment')],
+                }),
+            ]),
+        ]);
+        const output = generatePythonClient(root, { modelModulePaths });
+        expect(output).toContain('from ._models_payment import Payment, PaymentInput');
+    });
+
+    it('imports UUID when uuid scalar is used', () => {
+        const root = opRoot([
+            opRoute('/payments/{id}', [
+                opOperation('get', { responses: [opResponse(204)] }),
+            ], paramNodes([opParam('id', scalarType('uuid'))])),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('from uuid import UUID');
+    });
+
+    it('adds deprecated comment for deprecated operations', () => {
+        const root = opRoot([
+            opRoute('/old', [
+                opOperation('get', { responses: [opResponse(200, 'User')] }),
+            ], undefined, ['deprecated']),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('# @deprecated');
+    });
+
+    it('forwards a vendor JSON content_type kwarg to _fetch', () => {
+        const root = opRoot([
+            opRoute('/users', [
+                opOperation('post', {
+                    sdk: 'createUser',
+                    request: opRequest('User', 'application/vnd.api+json'),
+                    responses: [opResponse(201, 'User', 'application/vnd.api+json')],
+                }),
+            ]),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).toContain('content_type="application/vnd.api+json"');
+    });
+
+    it('omits internal operations by default and includes them when includeInternal is true', () => {
+        const root = opRoot([
+            opRoute('/public', [opOperation('get', { sdk: 'getPublic', responses: [opResponse(200, 'User')] })]),
+            opRoute('/secret', [opOperation('get', { sdk: 'getSecret', responses: [opResponse(200, 'User')] })], undefined, ['internal']),
+        ]);
+        const defaultOut = generatePythonClient(root);
+        expect(defaultOut).toContain('async def get_public(');
+        expect(defaultOut).not.toContain('async def get_secret(');
+
+        const inclusiveOut = generatePythonClient(root, { includeInternal: true });
+        expect(inclusiveOut).toContain('async def get_public(');
+        expect(inclusiveOut).toContain('async def get_secret(');
+    });
+
+    it('typed body and response as str/bytes for text and binary content types', () => {
+        const textRoot = opRoot([
+            opRoute('/notes', [
+                opOperation('post', {
+                    sdk: 'putNote',
+                    request: opRequest('Note', 'text/plain'),
+                    responses: [opResponse(200, 'Note', 'text/plain')],
+                }),
+            ]),
+        ]);
+        const textOut = generatePythonClient(textRoot);
+        expect(textOut).toContain('body: str');
+        expect(textOut).toContain('-> str:');
+        expect(textOut).toContain('body_kind="text"');
+        expect(textOut).toContain('response_kind="text"');
+
+        const binaryRoot = opRoot([
+            opRoute('/files', [
+                opOperation('get', {
+                    sdk: 'downloadFile',
+                    responses: [opResponse(200, 'File', 'application/octet-stream')],
+                }),
+            ]),
+        ]);
+        const binaryOut = generatePythonClient(binaryRoot);
+        expect(binaryOut).toContain('-> bytes:');
+        expect(binaryOut).toContain('response_kind="binary"');
+    });
+
+    it('omits content_type kwarg when the request is plain application/json', () => {
+        const root = opRoot([
+            opRoute('/users', [
+                opOperation('post', {
+                    sdk: 'createUser',
+                    request: opRequest('User'),
+                    responses: [opResponse(201, 'User')],
+                }),
+            ]),
+        ]);
+        const output = generatePythonClient(root);
+        expect(output).not.toContain('content_type=');
+    });
+
+    it('uses model_dump for Input variant body when modelsWithInput is set', () => {
+        const modelsWithInput = new Set(['Payment']);
+        const root = opRoot([
+            opRoute('/payments', [
+                opOperation('post', {
+                    request: opRequest('Payment'),
+                    responses: [opResponse(201, 'Payment')],
+                }),
+            ]),
+        ]);
+        const output = generatePythonClient(root, { modelsWithInput });
+        expect(output).toContain('body: PaymentInput');
+        expect(output).toContain('body=body.model_dump(mode="json")');
+    });
+
+    describe('response headers', () => {
+        it('emits a TypedDict and tuple return type when response declares headers', () => {
+            const root = opRoot([
+                opRoute('/transfers/{id}', [
+                    opOperation('get', {
+                        sdk: 'getTransfer',
+                        responses: [
+                            {
+                                statusCode: 200,
+                                contentType: 'application/json',
+                                bodyType: { kind: 'ref', name: 'Transfer' },
+                                headers: [
+                                    { name: 'preference-applied', optional: true, type: scalarType('string') },
+                                    { name: 'etag', optional: false, type: scalarType('string') },
+                                ],
+                            },
+                        ],
+                    }),
+                ], paramNodes([opParam('id', scalarType('uuid'))])),
+            ]);
+            const output = generatePythonClient(root);
+            expect(output).toContain('from typing import TypedDict');
+            expect(output).toContain('class GetTransferHeaders(TypedDict, total=False):');
+            expect(output).toContain('    preference_applied: str  # preference-applied (optional)');
+            expect(output).toContain('    etag: str  # etag (required)');
+            expect(output).toContain('-> tuple[Transfer, GetTransferHeaders]:');
+            expect(output).toContain('await self._fetch_with_headers(');
+            expect(output).toContain('"preference-applied" in _response_headers');
+            expect(output).toContain('headers["preference_applied"] = _response_headers["preference-applied"]');
+            expect(output).toContain('return Transfer.model_validate(result), headers');
+        });
+
+        it('returns just headers TypedDict for void ops with declared response headers', () => {
+            const root = opRoot([
+                opRoute('/resources/{id}', [
+                    opOperation('delete', {
+                        sdk: 'deleteResource',
+                        responses: [
+                            {
+                                statusCode: 204,
+                                headers: [{ name: 'x-deleted-at', optional: false, type: scalarType('string') }],
+                            },
+                        ],
+                    }),
+                ], paramNodes([opParam('id', scalarType('uuid'))])),
+            ]);
+            const output = generatePythonClient(root);
+            expect(output).toContain('class DeleteResourceHeaders(TypedDict, total=False):');
+            expect(output).toContain('-> DeleteResourceHeaders:');
+            expect(output).toContain('return headers');
+        });
+
+        it('keeps plain return type when no response headers are declared', () => {
+            const root = opRoot([
+                opRoute('/users/{id}', [opOperation('get', { sdk: 'getUser', responses: [opResponse(200, 'User')] })], paramNodes([opParam('id', scalarType('uuid'))])),
+            ]);
+            const output = generatePythonClient(root);
+            expect(output).toContain('-> User:');
+            expect(output).not.toContain('TypedDict');
+            expect(output).not.toContain('_fetch_with_headers');
+        });
+    });
+});

package/tests/codegen-models.test.ts

@@ -0,0 +1,295 @@
+import { describe, it, expect } from 'vitest';
+import { generatePydanticModels, renderPyType, toPythonFieldName, deriveModelsModuleName } from '../src/codegen-models.js';
+import {
+    scalarType, arrayType, tupleType, recordType, enumType, literalType,
+    unionType, refType, inlineObjectType, lazyType,
+    field, model, contractRoot,
+} from './helpers.js';
+
+// ─── renderPyType ─────────────────────────────────────────────────────────
+
+describe('renderPyType', () => {
+    it('renders scalar types', () => {
+        expect(renderPyType(scalarType('string'))).toBe('str');
+        expect(renderPyType(scalarType('number'))).toBe('float');
+        expect(renderPyType(scalarType('int'))).toBe('int');
+        expect(renderPyType(scalarType('bigint'))).toBe('int');
+        expect(renderPyType(scalarType('boolean'))).toBe('bool');
+        expect(renderPyType(scalarType('date'))).toBe('date');
+        expect(renderPyType(scalarType('time'))).toBe('time');
+        expect(renderPyType(scalarType('datetime'))).toBe('datetime');
+        expect(renderPyType(scalarType('duration'))).toBe('timedelta');
+        expect(renderPyType(scalarType('uuid'))).toBe('UUID');
+        expect(renderPyType(scalarType('email'))).toBe('str');
+        expect(renderPyType(scalarType('url'))).toBe('str');
+        expect(renderPyType(scalarType('null'))).toBe('None');
+        expect(renderPyType(scalarType('binary'))).toBe('bytes');
+        expect(renderPyType(scalarType('unknown'))).toBe('Any');
+        expect(renderPyType(scalarType('json'))).toBe('Any');
+        expect(renderPyType(scalarType('object'))).toBe('Any');
+    });
+
+    it('renders enum', () => {
+        expect(renderPyType(enumType('pending', 'completed', 'failed')))
+            .toBe('Literal["pending", "completed", "failed"]');
+    });
+
+    it('renders literal', () => {
+        expect(renderPyType(literalType('hello'))).toBe('"hello"');
+        expect(renderPyType(literalType(42))).toBe('42');
+        expect(renderPyType(literalType(true))).toBe('true');
+    });
+
+    it('renders array', () => {
+        expect(renderPyType(arrayType(scalarType('string')))).toBe('list[str]');
+        expect(renderPyType(arrayType(refType('Payment')))).toBe('list[Payment]');
+    });
+
+    it('renders tuple', () => {
+        expect(renderPyType(tupleType(scalarType('string'), scalarType('int')))).toBe('tuple[str, int]');
+        expect(renderPyType({ kind: 'tuple', items: [] })).toBe('tuple[()]');
+    });
+
+    it('renders record', () => {
+        expect(renderPyType(recordType(scalarType('string'), scalarType('number')))).toBe('dict[str, float]');
+    });
+
+    it('renders union', () => {
+        expect(renderPyType(unionType(scalarType('string'), scalarType('int')))).toBe('str | int');
+    });
+
+    it('renders model ref', () => {
+        expect(renderPyType(refType('Payment'))).toBe('Payment');
+    });
+
+    it('renders model ref as Input variant when forInput=true and in modelsWithInput', () => {
+        const modelsWithInput = new Set(['Payment']);
+        expect(renderPyType(refType('Payment'), modelsWithInput, true)).toBe('PaymentInput');
+        expect(renderPyType(refType('Payment'), modelsWithInput, false)).toBe('Payment');
+    });
+
+    it('renders inline object as dict', () => {
+        expect(renderPyType(inlineObjectType([]))).toBe('dict[str, Any]');
+    });
+
+    it('renders lazy unwrapped', () => {
+        expect(renderPyType(lazyType(scalarType('string')))).toBe('str');
+    });
+
+    it('renders intersection as dict', () => {
+        expect(renderPyType({ kind: 'intersection', members: [refType('A'), refType('B')] })).toBe('dict[str, Any]');
+    });
+});
+
+// ─── toPythonFieldName ────────────────────────────────────────────────────
+
+describe('toPythonFieldName', () => {
+    it('leaves valid snake_case unchanged', () => {
+        expect(toPythonFieldName('name')).toBe('name');
+        expect(toPythonFieldName('first_name')).toBe('first_name');
+    });
+
+    it('converts camelCase to snake_case', () => {
+        expect(toPythonFieldName('createdAt')).toBe('created_at');
+        expect(toPythonFieldName('firstName')).toBe('first_name');
+        expect(toPythonFieldName('myHTTPClient')).toBe('my_httpclient');
+    });
+
+    it('replaces hyphens with underscores', () => {
+        expect(toPythonFieldName('x-event-id')).toBe('x_event_id');
+        expect(toPythonFieldName('x-topic')).toBe('x_topic');
+    });
+
+    it('handles mixed separators', () => {
+        expect(toPythonFieldName('my.field-name')).toBe('my_field_name');
+    });
+});
+
+// ─── deriveModelsModuleName ───────────────────────────────────────────────
+
+describe('deriveModelsModuleName', () => {
+    it('converts file paths to Python module names', () => {
+        expect(deriveModelsModuleName('payment.ck')).toBe('_models_payment');
+        expect(deriveModelsModuleName('ledger.categories.ck')).toBe('_models_ledger_categories');
+        expect(deriveModelsModuleName('/path/to/user.profile.ck')).toBe('_models_user_profile');
+    });
+});
+
+// ─── generatePydanticModels ───────────────────────────────────────────────
+
+describe('generatePydanticModels', () => {
+    it('generates a simple model', () => {
+        const root = contractRoot([
+            model('Payment', [
+                field('id', scalarType('uuid')),
+                field('amount', scalarType('number')),
+                field('status', enumType('pending', 'completed', 'failed')),
+            ]),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('class Payment(BaseModel):');
+        expect(output).toContain('id: UUID');
+        expect(output).toContain('amount: float');
+        expect(output).toContain('status: Literal["pending", "completed", "failed"]');
+        expect(output).toContain('from pydantic import BaseModel');
+        expect(output).toContain('from uuid import UUID');
+        expect(output).toContain('from typing import Literal');
+    });
+
+    it('generates optional fields', () => {
+        const root = contractRoot([
+            model('User', [
+                field('id', scalarType('uuid')),
+                field('bio', scalarType('string'), { optional: true }),
+            ]),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('bio: str | None = None');
+    });
+
+    it('generates fields with defaults', () => {
+        const root = contractRoot([
+            model('Config', [
+                field('status', enumType('active', 'inactive'), { default: 'active' }),
+            ]),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('default="active"');
+    });
+
+    it('generates nullable fields', () => {
+        const root = contractRoot([
+            model('Item', [
+                field('description', scalarType('string'), { nullable: true }),
+            ]),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('description: str | None');
+    });
+
+    it('generates Field(alias=...) for fields with hyphens', () => {
+        const root = contractRoot([
+            model('WebhookHeaders', [
+                field('x-topic', scalarType('string')),
+                field('x-event-id', scalarType('uuid')),
+            ]),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('x_topic: str = Field(alias="x-topic")');
+        expect(output).toContain('x_event_id: UUID = Field(alias="x-event-id")');
+        expect(output).toContain('model_config = ConfigDict(populate_by_name=True)');
+        expect(output).toContain('from pydantic import BaseModel, ConfigDict, Field');
+    });
+
+    it('generates Input/Read split for readonly fields', () => {
+        const root = contractRoot([
+            model('Payment', [
+                field('id', scalarType('uuid'), { visibility: 'readonly' }),
+                field('amount', scalarType('number')),
+                field('createdAt', scalarType('datetime'), { visibility: 'readonly' }),
+            ]),
+        ]);
+        const output = generatePydanticModels(root);
+        // Read model has id and createdAt
+        expect(output).toContain('class Payment(BaseModel):');
+        expect(output).toContain('class PaymentInput(BaseModel):');
+        // Input omits readonly fields
+        const inputStart = output.indexOf('class PaymentInput');
+        const inputSection = output.slice(inputStart);
+        expect(inputSection).not.toContain('id: UUID');
+        expect(inputSection).not.toContain('created_at: datetime');
+        expect(inputSection).toContain('amount: float');
+    });
+
+    it('generates Input/Read split for writeonly fields', () => {
+        const root = contractRoot([
+            model('UserCreate', [
+                field('username', scalarType('string')),
+                field('password', scalarType('string'), { visibility: 'writeonly' }),
+            ]),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('class UserCreate(BaseModel):');
+        expect(output).toContain('class UserCreateInput(BaseModel):');
+        // Read model omits writeonly
+        const readStart = output.indexOf('class UserCreate(BaseModel):');
+        const readEnd = output.indexOf('class UserCreateInput');
+        const readSection = output.slice(readStart, readEnd);
+        expect(readSection).not.toContain('password: str');
+        expect(readSection).toContain('username: str');
+    });
+
+    it('generates a type alias', () => {
+        const root = contractRoot([
+            model('UserId', [], { type: scalarType('uuid') }),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('UserId = UUID');
+    });
+
+    it('generates datetime imports when needed', () => {
+        const root = contractRoot([
+            model('Event', [
+                field('createdAt', scalarType('datetime')),
+                field('date', scalarType('date')),
+                field('time', scalarType('time')),
+            ]),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('from datetime import date, datetime, time');
+    });
+
+    it('generates timedelta import for duration fields', () => {
+        const root = contractRoot([model('Task', [field('timeout', scalarType('duration'))])]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('from datetime import timedelta');
+        expect(output).toContain('timeout: timedelta');
+    });
+
+    it('includes deprecation comment', () => {
+        const root = contractRoot([
+            model('OldModel', [field('id', scalarType('uuid'))], { deprecated: true }),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('# @deprecated');
+    });
+
+    it('includes description comment', () => {
+        const root = contractRoot([
+            model('Payment', [field('id', scalarType('uuid'))], { description: 'A payment record' }),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('# A payment record');
+    });
+
+    it('handles model extending another model', () => {
+        const root = contractRoot([
+            model('BaseEntity', [field('id', scalarType('uuid'))]),
+            model('Payment', [field('amount', scalarType('number'))], { bases: ['BaseEntity'] }),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('class Payment(BaseEntity):');
+    });
+
+    it('emits a comma-separated parent list for multi-base inheritance', () => {
+        const root = contractRoot([
+            model('A', [field('a', scalarType('string'))]),
+            model('B', [field('b', scalarType('int'))]),
+            model('Test5', [field('e', scalarType('string'))], { bases: ['A', 'B'] }),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('class Test5(A, B):');
+    });
+
+    it('generates array and record types', () => {
+        const root = contractRoot([
+            model('Container', [
+                field('items', arrayType(refType('Payment'))),
+                field('meta', recordType(scalarType('string'), scalarType('string'))),
+            ]),
+        ]);
+        const output = generatePydanticModels(root);
+        expect(output).toContain('items: list[Payment]');
+        expect(output).toContain('meta: dict[str, str]');
+    });
+});