@alloy-js/python 0.5.0-dev.0 → 0.5.0-dev.2

package/test/dataclassdeclarations.test.tsx

@@ -1,30 +1,39 @@
-import { Prose, namekey, refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { Prose, namekey, refkey, render } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { dataclassesModule } 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("DataclassDeclaration", () => {
+  it("stacks user decorators above @dataclass", () => {
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" frozen decorators={["@final"]} />
+      </TestOutput>,
+    ).toRenderTo(
+      `
+        from dataclasses import dataclass
+
+
+        @final
+        @dataclass(frozen=True)
+        class User:
+            pass
+
+      `,
+    );
+  });
+
   it("Creates a dataclass with a class doc", () => {
     const doc = (
       <py.ClassDoc description={[<Prose>Represents a user.</Prose>]} />
     );
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User" doc={doc} />
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" doc={doc} />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -36,42 +45,36 @@ describe("DataclassDeclaration", () => {
 
             pass
 
-
       `,
     );
   });
 
   it("Creates a dataclass with fields and defaults", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User">
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="id"
-              type="int"
-            />
-            <py.VariableDeclaration
-              instanceVariable
-              name={namekey("_", { ignoreNamePolicy: true })}
-              type={dataclassesModule["."].KW_ONLY}
-              omitNone
-            />
-            <py.VariableDeclaration
-              instanceVariable
-              name="name"
-              type="str"
-              initializer={"Anonymous"}
-            />
-          </py.DataclassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User">
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="id"
+            type="int"
+          />
+          <py.VariableDeclaration
+            instanceVariable
+            name={namekey("_", { ignoreNamePolicy: true })}
+            type={dataclassesModule["."].KW_ONLY}
+            omitNone
+          />
+          <py.VariableDeclaration
+            instanceVariable
+            name="name"
+            type="str"
+            initializer={"Anonymous"}
+          />
+        </py.DataclassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
         from typing import TYPE_CHECKING
 
@@ -85,30 +88,24 @@ describe("DataclassDeclaration", () => {
             _: KW_ONLY
             name: str = "Anonymous"
 
-
       `,
     );
   });
 
   it("Creates a dataclass with keyword arguments", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User" frozen slots kwOnly>
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="id"
-              type="int"
-            />
-          </py.DataclassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" frozen slots kwOnly>
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="id"
+            type="int"
+          />
+        </py.DataclassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -116,35 +113,29 @@ describe("DataclassDeclaration", () => {
         class User:
             id: int
 
-
       `,
     );
   });
 
   it("Creates a dataclass with all keyword arguments", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration
-            name="User"
-            init
-            repr={false}
-            eq
-            order={false}
-            unsafeHash
-            frozen
-            matchArgs={false}
-            kwOnly
-            slots
-            weakrefSlot={false}
-          />
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration
+          name="User"
+          init
+          repr={false}
+          eq
+          order={false}
+          unsafeHash
+          frozen
+          matchArgs={false}
+          kwOnly
+          slots
+          weakrefSlot={false}
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -152,20 +143,16 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `,
     );
   });
 
   it("Throws error when weakref_slot=True without slots=True", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" weakrefSlot />
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" weakrefSlot />
+        </TestOutput>,
       ),
     ).toThrowError(
       /weakref_slot=True requires slots=True in @dataclass decorator/,
@@ -173,16 +160,12 @@ describe("DataclassDeclaration", () => {
   });
 
   it("Allows weakref_slot=True when slots=True", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User" slots weakrefSlot />
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" slots weakrefSlot />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -190,35 +173,27 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `,
     );
   });
 
   it("Throws error when order=True and eq=False", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" order eq={false} />
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" order eq={false} />
+        </TestOutput>,
       ),
     ).toThrowError(/order=True requires eq=True/);
   });
 
   it("Creates a dataclass with order=True and no conflicting methods", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User" order />
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" order />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -226,22 +201,18 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `,
     );
   });
 
   it("Throws error when order=True and class defines __lt__", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" order>
-              <py.DunderMethodDeclaration name="__lt__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" order>
+            <py.DunderMethodDeclaration name="__lt__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(
       /Cannot specify order=True when the class already defines __lt__\(\)/,
@@ -250,15 +221,12 @@ describe("DataclassDeclaration", () => {
 
   it("Throws error when order=True and class defines __le__", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" order>
-              <py.DunderMethodDeclaration name="__le__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" order>
+            <py.DunderMethodDeclaration name="__le__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(
       /Cannot specify order=True when the class already defines __le__\(\)/,
@@ -267,15 +235,12 @@ describe("DataclassDeclaration", () => {
 
   it("Throws error when order=True and class defines __gt__", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" order>
-              <py.DunderMethodDeclaration name="__gt__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" order>
+            <py.DunderMethodDeclaration name="__gt__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(
       /Cannot specify order=True when the class already defines __gt__\(\)/,
@@ -284,15 +249,12 @@ describe("DataclassDeclaration", () => {
 
   it("Throws error when order=True and class defines __ge__", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" order>
-              <py.DunderMethodDeclaration name="__ge__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" order>
+            <py.DunderMethodDeclaration name="__ge__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(
       /Cannot specify order=True when the class already defines __ge__\(\)/,
@@ -304,15 +266,12 @@ describe("DataclassDeclaration", () => {
       return <py.DunderMethodDeclaration name="__lt__" />;
     }
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" order>
-              <Wrapper />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" order>
+            <Wrapper />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(
       /Cannot specify order=True when the class already defines __lt__\(\)/,
@@ -321,15 +280,12 @@ describe("DataclassDeclaration", () => {
 
   it("Throws error when unsafe_hash=True and class defines __hash__", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" unsafeHash>
-              <py.DunderMethodDeclaration name="__hash__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" unsafeHash>
+            <py.DunderMethodDeclaration name="__hash__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(
       /Cannot specify unsafe_hash=True when the class already defines __hash__\(\)/,
@@ -338,15 +294,12 @@ describe("DataclassDeclaration", () => {
 
   it("Throws error when frozen=True and class defines __setattr__", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" frozen>
-              <py.DunderMethodDeclaration name="__setattr__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" frozen>
+            <py.DunderMethodDeclaration name="__setattr__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(
       /Cannot specify frozen=True when the class already defines __setattr__\(\)/,
@@ -355,15 +308,12 @@ describe("DataclassDeclaration", () => {
 
   it("Throws errorwhen frozen=True and class defines __delattr__", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" frozen>
-              <py.DunderMethodDeclaration name="__delattr__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" frozen>
+            <py.DunderMethodDeclaration name="__delattr__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(
       /Cannot specify frozen=True when the class already defines __delattr__\(\)/,
@@ -372,15 +322,12 @@ describe("DataclassDeclaration", () => {
 
   it("Throws error when slots=True and class defines __slots__", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" slots>
-              <py.DunderMethodDeclaration name="__slots__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" slots>
+            <py.DunderMethodDeclaration name="__slots__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(
       /Cannot specify slots=True when the class already defines __slots__\(\)/,
@@ -388,23 +335,19 @@ describe("DataclassDeclaration", () => {
   });
 
   it("Creates a dataclass with kw_only=True on decorator (sentinel not used)", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User" kwOnly>
-            <py.VariableDeclaration
-              instanceVariable
-              omitNone
-              name="id"
-              type="int"
-            />
-          </py.DataclassDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" kwOnly>
+          <py.VariableDeclaration
+            instanceVariable
+            omitNone
+            name="id"
+            type="int"
+          />
+        </py.DataclassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -412,23 +355,17 @@ describe("DataclassDeclaration", () => {
         class User:
             id: int
 
-
       `,
     );
   });
 
   it("Creates a dataclass with base classes", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User" bases={["Base"]} />
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" bases={["Base"]} />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -436,82 +373,68 @@ describe("DataclassDeclaration", () => {
         class User(Base):
             pass
 
-
       `,
     );
   });
 
   it("Throws error when more than one KW_ONLY sentinel is present", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User">
-              <py.VariableDeclaration
-                instanceVariable
-                name={namekey("_", { ignoreNamePolicy: true })}
-                type={dataclassesModule["."].KW_ONLY}
-                omitNone
-              />
-              <py.VariableDeclaration
-                instanceVariable
-                name={namekey("_", { ignoreNamePolicy: true })}
-                type={dataclassesModule["."].KW_ONLY}
-                omitNone
-              />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User">
+            <py.VariableDeclaration
+              instanceVariable
+              name={namekey("_", { ignoreNamePolicy: true })}
+              type={dataclassesModule["."].KW_ONLY}
+              omitNone
+            />
+            <py.VariableDeclaration
+              instanceVariable
+              name={namekey("_", { ignoreNamePolicy: true })}
+              type={dataclassesModule["."].KW_ONLY}
+              omitNone
+            />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
   });
 
   it("Will raise arg validation errors first over member conflicts", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User" order eq={false}>
-              <py.DunderMethodDeclaration name="__lt__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User" order eq={false}>
+            <py.DunderMethodDeclaration name="__lt__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(/order=True requires eq=True/);
   });
 
   it("Does not raise errors for member conflict checks without the equivalent kwargs", () => {
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User">
-              <py.DunderMethodDeclaration name="__lt__" />
-              <py.DunderMethodDeclaration name="__slots__" />
-              <py.DunderMethodDeclaration name="__hash__" />
-              <py.DunderMethodDeclaration name="__setattr__" />
-              <py.DunderMethodDeclaration name="__delattr__" />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User">
+            <py.DunderMethodDeclaration name="__lt__" />
+            <py.DunderMethodDeclaration name="__slots__" />
+            <py.DunderMethodDeclaration name="__hash__" />
+            <py.DunderMethodDeclaration name="__setattr__" />
+            <py.DunderMethodDeclaration name="__delattr__" />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).not.toThrow();
   });
 
   it("Allows unsafe_hash=True when no __hash__ is defined", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User" unsafeHash />
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" unsafeHash />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -519,7 +442,6 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `,
     );
   });
@@ -536,36 +458,29 @@ describe("DataclassDeclaration", () => {
       );
     }
     expect(() =>
-      toSourceText(
-        [
-          <py.SourceFile path="user.py">
-            <py.DataclassDeclaration name="User">
-              <py.VariableDeclaration
-                instanceVariable
-                name={namekey("_", { ignoreNamePolicy: true })}
-                type={dataclassesModule["."].KW_ONLY}
-                omitNone
-              />
-              <Wrapper />
-            </py.DataclassDeclaration>
-          </py.SourceFile>,
-        ],
-        { externals: [dataclassesModule] },
+      render(
+        <TestOutput path="user.py" externals={[dataclassesModule]}>
+          <py.DataclassDeclaration name="User">
+            <py.VariableDeclaration
+              instanceVariable
+              name={namekey("_", { ignoreNamePolicy: true })}
+              type={dataclassesModule["."].KW_ONLY}
+              omitNone
+            />
+            <Wrapper />
+          </py.DataclassDeclaration>
+        </TestOutput>,
       ),
     ).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
   });
 
   it("Allows frozen=True when no conflicting dunders exist", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User" frozen />
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" frozen />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -573,22 +488,17 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `,
     );
   });
 
   it("Allows slots=True when no __slots__ is defined", () => {
-    const res = toSourceText(
-      [
-        <py.SourceFile path="user.py">
-          <py.DataclassDeclaration name="User" slots />
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-    expect(res).toRenderTo(
-      d`
+    expect(
+      <TestOutput path="user.py" externals={[dataclassesModule]}>
+        <py.DataclassDeclaration name="User" slots />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         from dataclasses import dataclass
 
 
@@ -596,15 +506,14 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `,
     );
   });
 
   it("Forwards refkey prop for symbol resolution in type references", () => {
     const userRefkey = refkey();
-    const res = toSourceTextMultiple(
-      [
+    expect(
+      <TestOutputDirectory externals={[dataclassesModule]}>
         <py.SourceFile path="models.py">
           <py.DataclassDeclaration name="User" refkey={userRefkey}>
             <py.VariableDeclaration
@@ -620,7 +529,7 @@ describe("DataclassDeclaration", () => {
               type="str"
             />
           </py.DataclassDeclaration>
-        </py.SourceFile>,
+        </py.SourceFile>
         <py.SourceFile path="services.py">
           <py.FunctionDeclaration name="get_user" returnType={userRefkey}>
             <py.VariableDeclaration
@@ -636,30 +545,28 @@ describe("DataclassDeclaration", () => {
             <hbr />
             {"return user"}
           </py.FunctionDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [dataclassesModule] },
-    );
-    assertFileContents(res, {
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "models.py": `
-        from dataclasses import dataclass
+          from dataclasses import dataclass
 
 
-        @dataclass
-        class User:
-            id: int
-            name: str
+          @dataclass
+          class User:
+              id: int
+              name: str
 
-        `,
+          `,
       "services.py": `
-        from models import User
+          from models import User
 
 
-        def get_user() -> User:
-            user: User = User(1, "Alice")
-            return user
+          def get_user() -> User:
+              user: User = User(1, "Alice")
+              return user
 
-        `,
+          `,
     });
   });
 });