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

package/test/staticmethoddeclaration.test.tsx

@@ -1,7 +1,6 @@
-import { d } from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
-import { toSourceText } from "./utils.js";
+import { TestOutput } from "./utils.js";
 
 describe("StaticMethodDeclaration", () => {
   it("renders async static method", () => {
@@ -17,7 +16,7 @@ describe("StaticMethodDeclaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(`
       class MyClass:
           @staticmethod
           async def util() -> str:
@@ -37,7 +36,7 @@ describe("StaticMethodDeclaration", () => {
       </py.ClassDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(`
       class MyClass:
           @staticmethod
           def foo(x: int):

package/test/type-checking-imports.test.tsx

@@ -1,123 +1,121 @@
 import { refkey } from "@alloy-js/core";
-import { describe, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import { createModule } from "../src/create-module.js";
 import * as py from "../src/index.js";
-import { assertFileContents, toSourceTextMultiple } from "./utils.jsx";
+import { TestOutputDirectory } from "./utils.js";
 
 describe("TYPE_CHECKING imports", () => {
   it("imports type-only references inside TYPE_CHECKING block", () => {
     const userClassRef = refkey();
 
-    const result = toSourceTextMultiple([
-      <py.SourceFile path="models.py">
-        <py.ClassDeclaration name="User" refkey={userClassRef} />
-      </py.SourceFile>,
-      <py.SourceFile path="service.py">
-        <py.FunctionDeclaration
-          name="process_user"
-          parameters={[{ name: "user", type: userClassRef }]}
-          returnType="None"
-        >
-          pass
-        </py.FunctionDeclaration>
-      </py.SourceFile>,
-    ]);
-
-    assertFileContents(result, {
-      "models.py": `
-        class User:
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="models.py">
+          <py.ClassDeclaration name="User" refkey={userClassRef} />
+        </py.SourceFile>
+        <py.SourceFile path="service.py">
+          <py.FunctionDeclaration
+            name="process_user"
+            parameters={[{ name: "user", type: userClassRef }]}
+            returnType="None"
+          >
             pass
+          </py.FunctionDeclaration>
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
+      "models.py": `
+          class User:
+              pass
 
-        `,
+          `,
       "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 process_user(user: User) -> None:
-            pass
+          def process_user(user: User) -> None:
+              pass
 
-        `,
+          `,
     });
   });
 
   it("imports value references outside TYPE_CHECKING block", () => {
     const userClassRef = refkey();
 
-    const result = toSourceTextMultiple([
-      <py.SourceFile path="models.py">
-        <py.ClassDeclaration name="User" refkey={userClassRef} />
-      </py.SourceFile>,
-      <py.SourceFile path="service.py">
-        <py.FunctionDeclaration name="create_user" returnType="None">
-          <py.VariableDeclaration
-            name="user"
-            initializer={<py.ClassInstantiation target={userClassRef} />}
-          />
-        </py.FunctionDeclaration>
-      </py.SourceFile>,
-    ]);
-
-    assertFileContents(result, {
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="models.py">
+          <py.ClassDeclaration name="User" refkey={userClassRef} />
+        </py.SourceFile>
+        <py.SourceFile path="service.py">
+          <py.FunctionDeclaration name="create_user" returnType="None">
+            <py.VariableDeclaration
+              name="user"
+              initializer={<py.ClassInstantiation target={userClassRef} />}
+            />
+          </py.FunctionDeclaration>
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "models.py": `
-        class User:
-            pass
+          class User:
+              pass
 
-        `,
+          `,
       "service.py": `
-        from models import User
+          from models import User
 
 
-        def create_user() -> None:
-            user = User()
+          def create_user() -> None:
+              user = User()
 
-        `,
+          `,
     });
   });
 
   it("upgrades type-only import to regular import when also used as value", () => {
     const userClassRef = refkey();
 
-    const result = toSourceTextMultiple([
-      <py.SourceFile path="models.py">
-        <py.ClassDeclaration name="User" refkey={userClassRef} />
-      </py.SourceFile>,
-      <py.SourceFile path="service.py">
-        <py.FunctionDeclaration
-          name="create_user"
-          parameters={[{ name: "existing", type: userClassRef }]}
-          returnType={userClassRef}
-        >
-          <py.StatementList>
-            <py.VariableDeclaration
-              name="user"
-              initializer={<py.ClassInstantiation target={userClassRef} />}
-            />
-            <>return user</>
-          </py.StatementList>
-        </py.FunctionDeclaration>
-      </py.SourceFile>,
-    ]);
-
-    // Since User is used both as a type (parameter type, return type) and
-    // as a value (ClassInstantiation), it should be a regular import
-    assertFileContents(result, {
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="models.py">
+          <py.ClassDeclaration name="User" refkey={userClassRef} />
+        </py.SourceFile>
+        <py.SourceFile path="service.py">
+          <py.FunctionDeclaration
+            name="create_user"
+            parameters={[{ name: "existing", type: userClassRef }]}
+            returnType={userClassRef}
+          >
+            <py.StatementList>
+              <py.VariableDeclaration
+                name="user"
+                initializer={<py.ClassInstantiation target={userClassRef} />}
+              />
+              <>return user</>
+            </py.StatementList>
+          </py.FunctionDeclaration>
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "models.py": `
-        class User:
-            pass
+          class User:
+              pass
 
-        `,
+          `,
       "service.py": `
-        from models import User
+          from models import User
 
 
-        def create_user(existing: User) -> User:
-            user = User()
-            return user
+          def create_user(existing: User) -> User:
+              user = User()
+              return user
 
-        `,
+          `,
     });
   });
 
@@ -125,179 +123,175 @@ describe("TYPE_CHECKING imports", () => {
     const userClassRef = refkey();
     const helperFuncRef = refkey();
 
-    const result = toSourceTextMultiple([
-      <py.SourceFile path="models.py">
-        <py.ClassDeclaration name="User" refkey={userClassRef} />
-        <py.FunctionDeclaration name="helper" refkey={helperFuncRef}>
-          pass
-        </py.FunctionDeclaration>
-      </py.SourceFile>,
-      <py.SourceFile path="service.py">
-        <py.FunctionDeclaration
-          name="process"
-          parameters={[{ name: "user", type: userClassRef }]}
-          returnType="None"
-        >
-          <py.FunctionCallExpression target={helperFuncRef} />
-        </py.FunctionDeclaration>
-      </py.SourceFile>,
-    ]);
-
-    // helper is used as a value (function call), User is only used as type
-    assertFileContents(result, {
-      "models.py": `
-        class User:
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="models.py">
+          <py.ClassDeclaration name="User" refkey={userClassRef} />
+          <py.FunctionDeclaration name="helper" refkey={helperFuncRef}>
             pass
+          </py.FunctionDeclaration>
+        </py.SourceFile>
+        <py.SourceFile path="service.py">
+          <py.FunctionDeclaration
+            name="process"
+            parameters={[{ name: "user", type: userClassRef }]}
+            returnType="None"
+          >
+            <py.FunctionCallExpression target={helperFuncRef} />
+          </py.FunctionDeclaration>
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
+      "models.py": `
+          class User:
+              pass
 
 
-        def helper():
-            pass
+          def helper():
+              pass
 
-        `,
+          `,
       "service.py": `
-        from models import helper
-        from typing import TYPE_CHECKING
+          from models import helper
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from models import User
+          if TYPE_CHECKING:
+              from models import User
 
 
-        def process(user: User) -> None:
-            helper()
+          def process(user: User) -> None:
+              helper()
 
-        `,
+          `,
     });
   });
 
   it("handles return type as type-only import", () => {
     const resultTypeRef = refkey();
 
-    const result = toSourceTextMultiple([
-      <py.SourceFile path="types.py">
-        <py.ClassDeclaration name="Result" refkey={resultTypeRef} />
-      </py.SourceFile>,
-      <py.SourceFile path="main.py">
-        <py.FunctionDeclaration name="get_result" returnType={resultTypeRef}>
-          pass
-        </py.FunctionDeclaration>
-      </py.SourceFile>,
-    ]);
-
-    assertFileContents(result, {
-      "types.py": `
-        class Result:
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="types.py">
+          <py.ClassDeclaration name="Result" refkey={resultTypeRef} />
+        </py.SourceFile>
+        <py.SourceFile path="main.py">
+          <py.FunctionDeclaration name="get_result" returnType={resultTypeRef}>
             pass
+          </py.FunctionDeclaration>
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
+      "types.py": `
+          class Result:
+              pass
 
-        `,
+          `,
       "main.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from types import Result
+          if TYPE_CHECKING:
+              from types import Result
 
 
-        def get_result() -> Result:
-            pass
+          def get_result() -> Result:
+              pass
 
-        `,
+          `,
     });
   });
 
   it("handles variable type annotation as type-only import", () => {
     const configTypeRef = refkey();
 
-    const result = toSourceTextMultiple([
-      <py.SourceFile path="types.py">
-        <py.ClassDeclaration name="Config" refkey={configTypeRef} />
-      </py.SourceFile>,
-      <py.SourceFile path="main.py">
-        <py.VariableDeclaration name="config" type={configTypeRef} omitNone />
-      </py.SourceFile>,
-    ]);
-
-    assertFileContents(result, {
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="types.py">
+          <py.ClassDeclaration name="Config" refkey={configTypeRef} />
+        </py.SourceFile>
+        <py.SourceFile path="main.py">
+          <py.VariableDeclaration name="config" type={configTypeRef} omitNone />
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "types.py": `
-        class Config:
-            pass
+          class Config:
+              pass
 
-        `,
+          `,
       "main.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from types import Config
+          if TYPE_CHECKING:
+              from types import Config
 
-        config: Config
-        `,
+          config: Config
+          `,
     });
   });
 
   it("handles TypeReference component as type-only import", () => {
     const myTypeRef = refkey();
 
-    const result = toSourceTextMultiple([
-      <py.SourceFile path="types.py">
-        <py.ClassDeclaration name="MyType" refkey={myTypeRef} />
-      </py.SourceFile>,
-      <py.SourceFile path="main.py">
-        <py.VariableDeclaration
-          name="value"
-          type={<py.TypeReference refkey={myTypeRef} />}
-          omitNone
-        />
-      </py.SourceFile>,
-    ]);
-
-    assertFileContents(result, {
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="types.py">
+          <py.ClassDeclaration name="MyType" refkey={myTypeRef} />
+        </py.SourceFile>
+        <py.SourceFile path="main.py">
+          <py.VariableDeclaration
+            name="value"
+            type={<py.TypeReference refkey={myTypeRef} />}
+            omitNone
+          />
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "types.py": `
-        class MyType:
-            pass
+          class MyType:
+              pass
 
-        `,
+          `,
       "main.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from types import MyType
+          if TYPE_CHECKING:
+              from types import MyType
 
-        value: MyType
-        `,
+          value: MyType
+          `,
     });
   });
 
   it("handles class bases as regular import (runtime requirement)", () => {
     const baseClassRef = refkey();
 
-    const result = toSourceTextMultiple([
-      <py.SourceFile path="base.py">
-        <py.ClassDeclaration name="BaseClass" refkey={baseClassRef} />
-      </py.SourceFile>,
-      <py.SourceFile path="derived.py">
-        <py.ClassDeclaration name="DerivedClass" bases={[baseClassRef]} />
-      </py.SourceFile>,
-    ]);
-
-    // Class bases require runtime access, so they should NOT be
-    // inside a TYPE_CHECKING block
-    assertFileContents(result, {
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="base.py">
+          <py.ClassDeclaration name="BaseClass" refkey={baseClassRef} />
+        </py.SourceFile>
+        <py.SourceFile path="derived.py">
+          <py.ClassDeclaration name="DerivedClass" bases={[baseClassRef]} />
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "base.py": `
-        class BaseClass:
-            pass
+          class BaseClass:
+              pass
 
-        `,
+          `,
       "derived.py": `
-        from base import BaseClass
+          from base import BaseClass
 
 
-        class DerivedClass(BaseClass):
-            pass
+          class DerivedClass(BaseClass):
+              pass
 
-        `,
+          `,
     });
   });
 
   it("renders regular imports before TYPE_CHECKING block", () => {
-    // Create a typing module with multiple exports
     const typingModule = createModule({
       name: "typing",
       descriptor: {
@@ -305,7 +299,6 @@ describe("TYPE_CHECKING imports", () => {
       },
     });
 
-    // Create a third-party module
     const requestsModule = createModule({
       name: "requests",
       descriptor: {
@@ -315,11 +308,11 @@ describe("TYPE_CHECKING imports", () => {
 
     const userClassRef = refkey();
 
-    const result = toSourceTextMultiple(
-      [
+    expect(
+      <TestOutputDirectory externals={[typingModule, requestsModule]}>
         <py.SourceFile path="models.py">
           <py.ClassDeclaration name="User" refkey={userClassRef} />
-        </py.SourceFile>,
+        </py.SourceFile>
         <py.SourceFile path="service.py">
           <py.FunctionDeclaration
             name="get_users"
@@ -327,37 +320,32 @@ describe("TYPE_CHECKING imports", () => {
             returnType="str"
           >
             <py.StatementList>
-              {/* Use cast as a value (function call) to make it a regular import */}
               <>response = {requestsModule["."].get}("https://example.com")</>
               <>return {typingModule["."].cast}(str, user)</>
             </py.StatementList>
           </py.FunctionDeclaration>
-        </py.SourceFile>,
-      ],
-      { externals: [typingModule, requestsModule] },
-    );
-
-    // Regular imports first (sorted alphabetically), then TYPE_CHECKING block
-    assertFileContents(result, {
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "models.py": `
-        class User:
-            pass
+          class User:
+              pass
 
-        `,
+          `,
       "service.py": `
-        from requests import get
-        from typing import cast
-        from typing import TYPE_CHECKING
+          from requests import get
+          from typing import cast
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from models import User
+          if TYPE_CHECKING:
+              from models import User
 
 
-        def get_users(user: User) -> str:
-            response = get("https://example.com")
-            return cast(str, user)
+          def get_users(user: User) -> str:
+              response = get("https://example.com")
+              return cast(str, user)
 
-        `,
+          `,
     });
   });
 });

package/test/typereference.test.tsx

@@ -1,15 +1,14 @@
 import { code, refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
-import { toSourceText } from "./utils.jsx";
+import { TestOutput } from "./utils.js";
 
 describe("TypeReference", () => {
   it("renders a Python TypeReference with a refkey and type arguments", () => {
     const classRefkey = refkey();
 
     expect(
-      toSourceText([
+      <TestOutput>
         <py.StatementList>
           <py.ClassDeclaration
             name="Bar"
@@ -17,15 +16,17 @@ describe("TypeReference", () => {
           ></py.ClassDeclaration>
           <py.TypeReference refkey={classRefkey} typeArgs={["T", "P"]} />
           <py.TypeReference name="dict" typeArgs={["str", "int"]} />
-        </py.StatementList>,
-      ]),
-    ).toRenderTo(d`
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         class Bar:
             pass
 
         Bar[T, P]
         dict[str, int]
-    `);
+    `,
+    );
   });
 
   it("renders a Python list expression with a reference", () => {
@@ -33,20 +34,22 @@ describe("TypeReference", () => {
     const type = code`list[${classRefkey}]`;
 
     expect(
-      toSourceText([
+      <TestOutput>
         <py.StatementList>
           <py.ClassDeclaration
             name="Foo"
             refkey={classRefkey}
           ></py.ClassDeclaration>
           <py.TypeReference name={type} />
-        </py.StatementList>,
-      ]),
-    ).toRenderTo(d`
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         class Foo:
             pass
 
         list[Foo]
-    `);
+    `,
+    );
   });
 });