@alloy-js/python 0.5.0-dev.1 → 0.5.0

package/test/pydanticclassdeclarations.test.tsx

@@ -1,5 +1,4 @@
 import { Prose, code, refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import {
   pydanticModule,
@@ -7,35 +6,26 @@ import {
   typingModule,
 } from "../src/builtins/python.js";
 import * as py from "../src/index.js";
-import {
-  assertFileContents,
-  toSourceText,
-  toSourceTextMultiple,
-} from "./utils.jsx";
+import { TestOutput, TestOutputDirectory } from "./utils.js";
 
 describe("PydanticClassDeclaration", () => {
   it("forwards class-level decorators above `class`", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration
-            name="User"
-            decorators={[code`@${typingModule["."].final}`]}
-          >
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="id"
-              type="int"
-            />
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule, typingModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule, typingModule]}>
+        <py.PydanticClassDeclaration
+          name="User"
+          decorators={[code`@${typingModule["."].final}`]}
+        >
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="id"
+            type="int"
+          />
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from typing import final
 
@@ -44,36 +34,30 @@ describe("PydanticClassDeclaration", () => {
         class User(BaseModel):
             id: int
 
-
       `,
     );
   });
 
   it("emits a pydantic model with BaseModel, fields, and Field import", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration name="User">
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="id"
-              type="int"
-            />
-            <py.VariableDeclaration
-              instanceVariable
-              name="name"
-              type="str"
-              initializer={code`${pydanticModule["."].Field}(default="anon")`}
-            />
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration name="User">
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="id"
+            type="int"
+          />
+          <py.VariableDeclaration
+            instanceVariable
+            name="name"
+            type="str"
+            initializer={code`${pydanticModule["."].Field}(default="anon")`}
+          />
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import Field
 
@@ -82,41 +66,35 @@ describe("PydanticClassDeclaration", () => {
             id: int
             name: str = Field(default="anon")
 
-
       `,
     );
   });
 
   it("inherits from another pydantic model via bases", () => {
     const baseRef = refkey();
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.StatementList>
-            <py.PydanticClassDeclaration name="User" refkey={baseRef}>
-              <py.VariableDeclaration
-                instanceVariable
-                omitNone
-                name="id"
-                type="int"
-              />
-            </py.PydanticClassDeclaration>
-            <py.PydanticClassDeclaration name="Admin" bases={[baseRef]}>
-              <py.VariableDeclaration
-                instanceVariable
-                omitNone
-                name="role"
-                type="str"
-              />
-            </py.PydanticClassDeclaration>
-          </py.StatementList>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.StatementList>
+          <py.PydanticClassDeclaration name="User" refkey={baseRef}>
+            <py.VariableDeclaration
+              instanceVariable
+              omitNone
+              name="id"
+              type="int"
+            />
+          </py.PydanticClassDeclaration>
+          <py.PydanticClassDeclaration name="Admin" bases={[baseRef]}>
+            <py.VariableDeclaration
+              instanceVariable
+              omitNone
+              name="role"
+              type="str"
+            />
+          </py.PydanticClassDeclaration>
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
 
 
@@ -126,47 +104,41 @@ describe("PydanticClassDeclaration", () => {
         class Admin(User):
             role: str
 
-
       `,
     );
   });
 
   it("supports required, optional, Field default, and plain default", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration name="Item">
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="sku"
-              type="str"
-            />
-            <py.VariableDeclaration
-              instanceVariable
-              name="notes"
-              type={<py.UnionTypeExpression children={["str", "None"]} />}
-            />
-            <py.VariableDeclaration
-              instanceVariable
-              name="label"
-              type="str"
-              initializer={code`${pydanticModule["."].Field}(default="untitled")`}
-            />
-            <py.VariableDeclaration
-              instanceVariable
-              name="qty"
-              type="int"
-              initializer={1}
-            />
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration name="Item">
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="sku"
+            type="str"
+          />
+          <py.VariableDeclaration
+            instanceVariable
+            name="notes"
+            type={<py.UnionTypeExpression children={["str", "None"]} />}
+          />
+          <py.VariableDeclaration
+            instanceVariable
+            name="label"
+            type="str"
+            initializer={code`${pydanticModule["."].Field}(default="untitled")`}
+          />
+          <py.VariableDeclaration
+            instanceVariable
+            name="qty"
+            type="int"
+            initializer={1}
+          />
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import Field
 
@@ -177,7 +149,6 @@ describe("PydanticClassDeclaration", () => {
             label: str = Field(default="untitled")
             qty: int = 1
 
-
       `,
     );
   });
@@ -186,24 +157,19 @@ describe("PydanticClassDeclaration", () => {
     const doc = (
       <py.ClassDoc description={[<Prose>Payload for an API request.</Prose>]} />
     );
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration name="RequestBody" doc={doc}>
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="value"
-              type="str"
-            />
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration name="RequestBody" doc={doc}>
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="value"
+            type="str"
+          />
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
 
 
@@ -214,15 +180,14 @@ describe("PydanticClassDeclaration", () => {
 
             value: str
 
-
       `,
     );
   });
 
   it("resolves refkey across files with pydantic imports", () => {
     const modelRef = refkey();
-    const res = toSourceTextMultiple(
-      [
+    expect(
+      <TestOutputDirectory externals={[pydanticModule]}>
         <py.SourceFile path="models.py">
           <py.PydanticClassDeclaration name="User" refkey={modelRef}>
             <py.VariableDeclaration
@@ -232,7 +197,7 @@ describe("PydanticClassDeclaration", () => {
               type="int"
             />
           </py.PydanticClassDeclaration>
-        </py.SourceFile>,
+        </py.SourceFile>
         <py.SourceFile path="service.py">
           <py.FunctionDeclaration
             name="load_user"
@@ -241,58 +206,50 @@ describe("PydanticClassDeclaration", () => {
           >
             {"return User(id=user_id)"}
           </py.FunctionDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    assertFileContents(res, {
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "models.py": `
-        from pydantic import BaseModel
+          from pydantic import BaseModel
 
 
-        class User(BaseModel):
-            id: int
+          class User(BaseModel):
+              id: int
 
-        `,
+          `,
       "service.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from models import User
+          if TYPE_CHECKING:
+              from models import User
 
 
-        def load_user(user_id: int) -> User:
-            return User(id=user_id)
+          def load_user(user_id: int) -> User:
+              return User(id=user_id)
 
-        `,
+          `,
     });
   });
 
   it("emits model_config = ConfigDict(...) from top-level config props", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration
-            name="User"
-            frozen
-            extra="forbid"
-            validateAssignment
-          >
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="id"
-              type="int"
-            />
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration
+          name="User"
+          frozen
+          extra="forbid"
+          validateAssignment
+        >
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="id"
+            type="int"
+          />
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import ConfigDict
 
@@ -301,37 +258,31 @@ describe("PydanticClassDeclaration", () => {
             model_config = ConfigDict(frozen=True, extra="forbid", validate_assignment=True)
             id: int
 
-
       `,
     );
   });
 
   it("emits model_config = ConfigDict(...) from modelConfig", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration
-            name="User"
-            modelConfig={{
-              frozen: true,
-              extra: "forbid",
-              validateAssignment: true,
-            }}
-          >
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="id"
-              type="int"
-            />
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration
+          name="User"
+          modelConfig={{
+            frozen: true,
+            extra: "forbid",
+            validateAssignment: true,
+          }}
+        >
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="id"
+            type="int"
+          />
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import ConfigDict
 
@@ -340,28 +291,22 @@ describe("PydanticClassDeclaration", () => {
             model_config = ConfigDict(frozen=True, extra="forbid", validate_assignment=True)
             id: int
 
-
       `,
     );
   });
 
   it("gives precedence to top-level config props over modelConfig", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration
-            name="User"
-            modelConfig={{ frozen: false, extra: "allow" }}
-            frozen
-            extra="forbid"
-          />
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration
+          name="User"
+          modelConfig={{ frozen: false, extra: "allow" }}
+          frozen
+          extra="forbid"
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import ConfigDict
 
@@ -369,32 +314,26 @@ describe("PydanticClassDeclaration", () => {
         class User(BaseModel):
             model_config = ConfigDict(frozen=True, extra="forbid")
 
-
       `,
     );
   });
 
   it("supports additional typed ConfigDict props", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration
-            name="User"
-            useEnumValues
-            coerceNumbersToStr
-            validateReturn
-            strMinLength={1}
-            strMaxLength={128}
-            serJsonBytes="base64"
-            valJsonBytes="hex"
-          />
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration
+          name="User"
+          useEnumValues
+          coerceNumbersToStr
+          validateReturn
+          strMinLength={1}
+          strMaxLength={128}
+          serJsonBytes="base64"
+          valJsonBytes="hex"
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import ConfigDict
 
@@ -402,30 +341,24 @@ describe("PydanticClassDeclaration", () => {
         class User(BaseModel):
             model_config = ConfigDict(coerce_numbers_to_str=True, ser_json_bytes="base64", str_min_length=1, str_max_length=128, use_enum_values=True, val_json_bytes="hex", validate_return=True)
 
-
       `,
     );
   });
 
   it("imports SecretStr when used as a field type", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration name="Credentials">
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="token"
-              type={pydanticModule["."].SecretStr}
-            />
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration name="Credentials">
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="token"
+            type={pydanticModule["."].SecretStr}
+          />
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from typing import TYPE_CHECKING
 
@@ -436,26 +369,20 @@ describe("PydanticClassDeclaration", () => {
         class Credentials(BaseModel):
             token: SecretStr
 
-
       `,
     );
   });
 
   it("emits arbitrary model_config via modelConfigExpression", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration
-            name="M"
-            modelConfigExpression={code`${pydanticModule["."].ConfigDict}(frozen=True, extra="allow")`}
-          />
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration
+          name="M"
+          modelConfigExpression={code`${pydanticModule["."].ConfigDict}(frozen=True, extra="allow")`}
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import ConfigDict
 
@@ -463,66 +390,54 @@ describe("PydanticClassDeclaration", () => {
         class M(BaseModel):
             model_config = ConfigDict(frozen=True, extra="allow")
 
-
       `,
     );
   });
 
   it("supports RootModel as explicit bases entry", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration
-            name="Tags"
-            bases={[code`${pydanticModule["."].RootModel}[list[str]]`]}
-          />
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration
+          name="Tags"
+          bases={[code`${pydanticModule["."].RootModel}[list[str]]`]}
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import RootModel
 
 
         class Tags(RootModel[list[str]]):
             pass
 
-
       `,
     );
   });
 
   it("places Pydantic validators above classmethod", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration name="User">
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="name"
-              type="str"
-            />
-            <py.ClassMethodDeclaration
-              name="strip_name"
-              decorators={[
-                code`@${pydanticModule["."].field_validator}("name", mode="before")`,
-              ]}
-              parameters={[{ name: "value", type: "str" }]}
-              returnType="str"
-            >
-              {"return value.strip()"}
-            </py.ClassMethodDeclaration>
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration name="User">
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="name"
+            type="str"
+          />
+          <py.ClassMethodDeclaration
+            name="strip_name"
+            decorators={[
+              code`@${pydanticModule["."].field_validator}("name", mode="before")`,
+            ]}
+            parameters={[{ name: "value", type: "str" }]}
+            returnType="str"
+          >
+            {"return value.strip()"}
+          </py.ClassMethodDeclaration>
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import field_validator
 
@@ -535,7 +450,6 @@ describe("PydanticClassDeclaration", () => {
                 return value.strip()
 
 
-      
       `,
     );
   });
@@ -543,23 +457,18 @@ describe("PydanticClassDeclaration", () => {
 
 describe("Pydantic ecosystem emitters", () => {
   it("typing module resolves Any and similar annotations", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.FunctionDeclaration
-            name="identity"
-            parameters={[{ name: "x", type: typingModule["."].Any }]}
-            returnType={typingModule["."].Any}
-          >
-            {"return x"}
-          </py.FunctionDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [typingModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[typingModule]}>
+        <py.FunctionDeclaration
+          name="identity"
+          parameters={[{ name: "x", type: typingModule["."].Any }]}
+          returnType={typingModule["."].Any}
+        >
+          {"return x"}
+        </py.FunctionDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from typing import TYPE_CHECKING
 
         if TYPE_CHECKING:
@@ -569,30 +478,24 @@ describe("Pydantic ecosystem emitters", () => {
         def identity(x: Any) -> Any:
             return x
 
-
       `,
     );
   });
 
   it("pydantic.types constrains field annotations", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration name="Score">
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="points"
-              type={pydanticModule.types.PositiveInt}
-            />
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration name="Score">
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="points"
+            type={pydanticModule.types.PositiveInt}
+          />
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from typing import TYPE_CHECKING
 
@@ -603,14 +506,13 @@ describe("Pydantic ecosystem emitters", () => {
         class Score(BaseModel):
             points: PositiveInt
 
-
       `,
     );
   });
 
   it("postponed annotations support forward references in fields", () => {
-    const res = toSourceText(
-      [
+    expect(
+      <TestOutputDirectory externals={[pydanticModule]}>
         <py.SourceFile
           path="models.py"
           futureImports={[<py.FutureStatement feature="annotations" />]}
@@ -628,42 +530,33 @@ describe("Pydantic ecosystem emitters", () => {
               type={code`"Node" | None`}
             />
           </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
-        from __future__ import annotations
-
-        from pydantic import BaseModel
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
+      "models.py": `
+          from __future__ import annotations
 
+          from pydantic import BaseModel
 
-        class Node(BaseModel):
-            label: str
-            child: "Node" | None = None
 
+          class Node(BaseModel):
+              label: str
+              child: "Node" | None = None
 
-      `,
-    );
+        `,
+    });
   });
 
   it("model_config can use pydantic.alias_generators", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration
-            name="M"
-            modelConfigExpression={code`${pydanticModule["."].ConfigDict}(alias_generator=${pydanticModule.alias_generators.to_camel})`}
-          />
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration
+          name="M"
+          modelConfigExpression={code`${pydanticModule["."].ConfigDict}(alias_generator=${pydanticModule.alias_generators.to_camel})`}
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import ConfigDict
         from pydantic.alias_generators import to_camel
@@ -672,63 +565,51 @@ describe("Pydantic ecosystem emitters", () => {
         class M(BaseModel):
             model_config = ConfigDict(alias_generator=to_camel)
 
-
       `,
     );
   });
 
   it("pydantic_settings exposes BaseSettings", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="config.py">
-          <py.ClassDeclaration
-            name="AppSettings"
-            bases={[pydanticSettingsModule["."].BaseSettings]}
-          />
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticSettingsModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="config.py" externals={[pydanticSettingsModule]}>
+        <py.ClassDeclaration
+          name="AppSettings"
+          bases={[pydanticSettingsModule["."].BaseSettings]}
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic_settings import BaseSettings
 
 
         class AppSettings(BaseSettings):
             pass
 
-
       `,
     );
   });
 
   it("emits @computed_field above @property via PropertyDeclaration", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration name="Square">
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="width"
-              type="float"
-            />
-            <py.PropertyDeclaration
-              name="area"
-              type="float"
-              decorators={[code`@${pydanticModule["."].computed_field}`]}
-            >
-              {"return self.width ** 2"}
-            </py.PropertyDeclaration>
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration name="Square">
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="width"
+            type="float"
+          />
+          <py.PropertyDeclaration
+            name="area"
+            type="float"
+            decorators={[code`@${pydanticModule["."].computed_field}`]}
+          >
+            {"return self.width ** 2"}
+          </py.PropertyDeclaration>
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import computed_field
 
@@ -741,37 +622,31 @@ describe("Pydantic ecosystem emitters", () => {
                 return self.width ** 2
 
 
-      
       `,
     );
   });
 
   it("emits computed_field on an instance method", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration name="Square">
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="width"
-              type="float"
-            />
-            <py.MethodDeclaration
-              name="area"
-              decorators={[code`@${pydanticModule["."].computed_field}`]}
-              returnType="float"
-            >
-              {"return self.width ** 2"}
-            </py.MethodDeclaration>
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration name="Square">
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="width"
+            type="float"
+          />
+          <py.MethodDeclaration
+            name="area"
+            decorators={[code`@${pydanticModule["."].computed_field}`]}
+            returnType="float"
+          >
+            {"return self.width ** 2"}
+          </py.MethodDeclaration>
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import computed_field
 
@@ -783,40 +658,34 @@ describe("Pydantic ecosystem emitters", () => {
                 return self.width ** 2
 
 
-      
       `,
     );
   });
 
   it("emits model_validator above classmethod", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="models.py">
-          <py.PydanticClassDeclaration name="Bag">
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="items"
-              type="list"
-            />
-            <py.ClassMethodDeclaration
-              name="ensure_items"
-              decorators={[
-                code`@${pydanticModule["."].model_validator}(mode="before")`,
-              ]}
-              parameters={[{ name: "data", type: "dict" }]}
-              returnType="dict"
-            >
-              {"return data"}
-            </py.ClassMethodDeclaration>
-          </py.PydanticClassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [pydanticModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="models.py" externals={[pydanticModule]}>
+        <py.PydanticClassDeclaration name="Bag">
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="items"
+            type="list"
+          />
+          <py.ClassMethodDeclaration
+            name="ensure_items"
+            decorators={[
+              code`@${pydanticModule["."].model_validator}(mode="before")`,
+            ]}
+            parameters={[{ name: "data", type: "dict" }]}
+            returnType="dict"
+          >
+            {"return data"}
+          </py.ClassMethodDeclaration>
+        </py.PydanticClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from pydantic import BaseModel
         from pydantic import model_validator
 
@@ -829,7 +698,6 @@ describe("Pydantic ecosystem emitters", () => {
                 return data
 
 
-      
       `,
     );
   });