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

package/test/decoratorlist.test.tsx

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest";
+import { DecoratorList } from "../src/components/DecoratorList.jsx";
+import { TestOutput } from "./utils.js";
+
+/**
+ * Direct contract tests for `DecoratorList`. The component is exercised
+ * transitively by every method/property test, but pinning the three core
+ * behaviors here makes regressions caught at the helper's own boundary —
+ * not after they propagate through every consumer.
+ */
+describe("DecoratorList", () => {
+  it("renders nothing when decorators is undefined", () => {
+    expect(
+      <TestOutput>
+        {[
+          <>
+            <DecoratorList />
+            pass
+          </>,
+        ]}
+      </TestOutput>,
+    ).toRenderTo("pass");
+  });
+
+  it("renders nothing when decorators is an empty array", () => {
+    expect(
+      <TestOutput>
+        {[
+          <>
+            <DecoratorList decorators={[]} />
+            pass
+          </>,
+        ]}
+      </TestOutput>,
+    ).toRenderTo("pass");
+  });
+
+  it("renders a single decorator followed by exactly one hardline", () => {
+    expect(
+      <TestOutput>
+        {[
+          <>
+            <DecoratorList decorators={["@one"]} />
+            pass
+          </>,
+        ]}
+      </TestOutput>,
+    ).toRenderTo(
+      `
+        @one
+        pass
+      `,
+    );
+  });
+
+  it("renders multiple decorators with no blank lines between adjacent entries", () => {
+    expect(
+      <TestOutput>
+        {[
+          <>
+            <DecoratorList decorators={["@one", "@two", "@three"]} />
+            pass
+          </>,
+        ]}
+      </TestOutput>,
+    ).toRenderTo(
+      `
+        @one
+        @two
+        @three
+        pass
+      `,
+    );
+  });
+
+  it("preserves source order: first entry is topmost (= applied last)", () => {
+    expect(
+      <TestOutput>
+        {[
+          <>
+            <DecoratorList decorators={["@outer", "@middle", "@inner"]} />
+            pass
+          </>,
+        ]}
+      </TestOutput>,
+    ).toRenderTo(
+      `
+        @outer
+        @middle
+        @inner
+        pass
+      `,
+    );
+  });
+
+  it("skips falsy entries without emitting blank lines", () => {
+    expect(
+      <TestOutput>
+        {[
+          <>
+            <DecoratorList decorators={["@one", false, undefined, "@two"]} />
+            pass
+          </>,
+        ]}
+      </TestOutput>,
+    ).toRenderTo(
+      `
+        @one
+        @two
+        pass
+      `,
+    );
+  });
+});

package/test/dundermethoddeclaration.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("Dunder/Constructor Declarations", () => {
   it("renders dunder methods with parameters", () => {
@@ -19,7 +18,7 @@ describe("Dunder/Constructor Declarations", () => {
       </py.ClassDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(`
       class MyClass:
           def __init__(self, x: int):
               self.attribute = "value"
@@ -42,7 +41,7 @@ describe("Dunder/Constructor Declarations", () => {
       </py.ClassDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(`
       class MyClass:
           def __new__(cls, *args, **kwargs):
               pass

package/test/enums.test.tsx

@@ -1,14 +1,40 @@
 import { refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import { enumModule } from "../src/builtins/python.js";
 import * as py from "../src/index.js";
-import { toSourceText } from "./utils.jsx";
+import { TestOutput } from "./utils.js";
 
 describe("Python Enum", () => {
+  it("renders class-level decorators above ClassEnumDeclaration", () => {
+    expect(
+      <TestOutput externals={[enumModule]}>
+        <py.ClassEnumDeclaration
+          name="Color"
+          baseType="IntEnum"
+          decorators={["@final"]}
+          members={[
+            { name: "RED", value: 1 },
+            { name: "GREEN", value: 2 },
+          ]}
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
+      from enum import IntEnum
+
+
+      @final
+      class Color(IntEnum):
+          RED = 1
+          GREEN = 2
+
+    `,
+    );
+  });
+
   it("class enum with explicit values", () => {
-    const result = toSourceText(
-      [
+    expect(
+      <TestOutput externals={[enumModule]}>
         <py.ClassEnumDeclaration
           name="Color"
           baseType="IntEnum"
@@ -17,11 +43,10 @@ describe("Python Enum", () => {
             { name: "GREEN", value: "2" },
             { name: "BLUE", value: "3" },
           ]}
-        />,
-      ],
-      { externals: [enumModule] },
-    );
-    const expected = d`
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       from enum import IntEnum
 
 
@@ -30,14 +55,13 @@ describe("Python Enum", () => {
           GREEN = 2
           BLUE = 3
 
-        
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 
   it("class enum with jsValues", () => {
-    const result = toSourceText(
-      [
+    expect(
+      <TestOutput externals={[enumModule]}>
         <py.ClassEnumDeclaration
           name="Color"
           baseType="IntEnum"
@@ -46,11 +70,10 @@ describe("Python Enum", () => {
             { name: "GREEN", jsValue: 2 },
             { name: "BLUE", jsValue: "3" },
           ]}
-        />,
-      ],
-      { externals: [enumModule] },
-    );
-    const expected = d`
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       from enum import IntEnum
 
 
@@ -59,14 +82,13 @@ describe("Python Enum", () => {
           GREEN = 2
           BLUE = "3"
 
-
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 
   it("class enum with a refkey as jsValue", () => {
-    const result = toSourceText(
-      [
+    expect(
+      <TestOutput externals={[enumModule]}>
         <py.StatementList>
           <py.ClassDeclaration name="Dog" refkey={refkey("Dog")} />
           <py.ClassDeclaration name="Cat" refkey={refkey("Cat")} />
@@ -78,11 +100,10 @@ describe("Python Enum", () => {
               { name: "CAT", value: refkey("Cat") },
             ]}
           />
-        </py.StatementList>,
-      ],
-      { externals: [enumModule] },
-    );
-    const expected = d`
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       from enum import Enum
 
 
@@ -96,23 +117,21 @@ describe("Python Enum", () => {
           DOG = Dog
           CAT = Cat
 
-
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 
   it("class enum with auto() values", () => {
-    const result = toSourceText(
-      [
+    expect(
+      <TestOutput externals={[enumModule]}>
         <py.ClassEnumDeclaration
           name="Animal"
           auto
           members={[{ name: "DOG" }, { name: "CAT" }, { name: "RABBIT" }]}
-        />,
-      ],
-      { externals: [enumModule] },
-    );
-    const expected = d`
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       from enum import auto
       from enum import Enum
 
@@ -122,14 +141,13 @@ describe("Python Enum", () => {
           CAT = auto()
           RABBIT = auto()
 
-
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 
   it("class enum with mixed manual and auto() values", () => {
-    const result = toSourceText(
-      [
+    expect(
+      <TestOutput externals={[enumModule]}>
         <py.ClassEnumDeclaration
           name="Permission"
           baseType="Flag"
@@ -139,12 +157,10 @@ describe("Python Enum", () => {
             { name: "WRITE" },
             { name: "EXECUTE" },
           ]}
-        />,
-      ],
-      { externals: [enumModule] },
-    );
-
-    const expected = d`
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       from enum import auto
       from enum import Flag
 
@@ -154,14 +170,13 @@ describe("Python Enum", () => {
           WRITE = auto()
           EXECUTE = auto()
 
-
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 
   it("functional enum with list", () => {
-    const result = toSourceText(
-      [
+    expect(
+      <TestOutput externals={[enumModule]}>
         <py.FunctionalEnumDeclaration
           name="Direction"
           members={[
@@ -170,22 +185,21 @@ describe("Python Enum", () => {
             { name: "EAST" },
             { name: "WEST" },
           ]}
-        />,
-      ],
-      { externals: [enumModule] },
-    );
-    const expected = d`
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       from enum import Enum
 
 
       Direction = Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 
   it("functional enum with mapping", () => {
-    const result = toSourceText(
-      [
+    expect(
+      <TestOutput externals={[enumModule]}>
         <py.FunctionalEnumDeclaration
           name="Priority"
           members={[
@@ -193,16 +207,15 @@ describe("Python Enum", () => {
             { name: "MEDIUM", value: 2 },
             { name: "LOW", value: 3 },
           ]}
-        />,
-      ],
-      { externals: [enumModule] },
-    );
-    const expected = d`
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       from enum import Enum
 
 
       Priority = Enum('Priority', {'HIGH' : 1, 'MEDIUM' : 2, 'LOW' : 3})
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 });

package/test/externals.test.tsx

@@ -1,9 +1,8 @@
 import { code, refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import * as py from "../src/index.js";
 import { createModule } from "../src/index.js";
-import { toSourceText } from "./utils.js";
+import { TestOutput } from "./utils.js";
 
 it("uses import from external library", () => {
   const requestsLib = createModule({
@@ -14,19 +13,18 @@ it("uses import from external library", () => {
       "models.anothermodule": ["something"],
     },
   });
-  const result = toSourceText(
-    [
+  expect(
+    <TestOutput externals={[requestsLib]}>
       <py.StatementList>
         {requestsLib["."].get}
         {requestsLib["."].post}
         {requestsLib["models"].Request}
         {requestsLib["models"].Response}
         {requestsLib["models.anothermodule"].something}
-      </py.StatementList>,
-    ],
-    { externals: [requestsLib] },
-  );
-  const expected = d`
+      </py.StatementList>
+    </TestOutput>,
+  ).toRenderTo(
+    `
     from requests import get
     from requests import post
     from requests.models import Request
@@ -38,8 +36,8 @@ it("uses import from external library", () => {
     Request
     Response
     something
-  `;
-  expect(result).toRenderTo(expected);
+  `,
+  );
 });
 
 it("uses import from external library in multiple functions", () => {
@@ -86,10 +84,12 @@ it("uses import from external library in multiple functions", () => {
     </py.FunctionDeclaration>,
   ];
 
-  const result = toSourceText(functionDeclarations, {
-    externals: [py.requestsModule],
-  });
-  const expected = d`
+  expect(
+    <TestOutput externals={[py.requestsModule]}>
+      {functionDeclarations}
+    </TestOutput>,
+  ).toRenderTo(
+    `
     from requests import get
     from requests import post
     from typing import TYPE_CHECKING
@@ -107,9 +107,8 @@ it("uses import from external library in multiple functions", () => {
         response = post(1)
         return response.json()
 
-
-  `;
-  expect(result).toRenderTo(expected);
+  `,
+  );
 });
 
 it("uses import from external library in multiple class methods", () => {
@@ -166,10 +165,12 @@ it("uses import from external library in multiple class methods", () => {
     </py.ClassDeclaration>,
   ];
 
-  const result = toSourceText(functionDeclarations, {
-    externals: [py.requestsModule],
-  });
-  const expected = d`
+  expect(
+    <TestOutput externals={[py.requestsModule]}>
+      {functionDeclarations}
+    </TestOutput>,
+  ).toRenderTo(
+    `
     from requests import get
     from requests import post
     from typing import TYPE_CHECKING
@@ -189,7 +190,6 @@ it("uses import from external library in multiple class methods", () => {
             return response.json()
 
 
-
-  `;
-  expect(result).toRenderTo(expected);
+  `,
+  );
 });

package/test/factories.test.tsx

@@ -1,46 +1,76 @@
+import { render } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
-import { toSourceText } from "./utils.js";
+import { TestOutput } from "./utils.js";
 
 describe("Symbol factories", () => {
   it("createMethodSymbol throws outside class", () => {
     expect(() => {
-      toSourceText([<py.MethodDeclaration name="m" />]);
+      render(
+        <TestOutput>
+          <py.MethodDeclaration name="m" />
+        </TestOutput>,
+      );
     }).toThrow('Method "m" must be declared inside a class (member scope)');
   });
 
   it("createMethodSymbol succeeds inside class", () => {
-    const result = toSourceText([
-      <py.ClassDeclaration name="C">
-        <py.MethodDeclaration name="m" />
-      </py.ClassDeclaration>,
-    ]);
-    expect(result).toContain("def m(self):");
+    expect(
+      <TestOutput>
+        <py.ClassDeclaration name="C">
+          <py.MethodDeclaration name="m" />
+        </py.ClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
+      class C:
+          def m(self):
+              pass
+
+
+      `,
+    );
   });
 
   it("createFunctionSymbol usable in member scope (top-level function component still works nested)", () => {
-    const result = toSourceText([
-      <py.ClassDeclaration name="C">
-        <py.StatementList>
-          <py.FunctionDeclaration name="f" />
-        </py.StatementList>
-      </py.ClassDeclaration>,
-    ]);
-    // Nested free functions render without self/cls
-    expect(result).toContain("def f():");
+    expect(
+      <TestOutput>
+        <py.ClassDeclaration name="C">
+          <py.StatementList>
+            <py.FunctionDeclaration name="f" />
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
+      class C:
+          def f():
+              pass
+
+
+      `,
+    );
   });
 });
 
 describe("Validation Errors", () => {
   it("throws error when PropertyDeclaration is used outside of a class", () => {
     expect(() => {
-      toSourceText([<py.PropertyDeclaration name="x" />]);
+      render(
+        <TestOutput>
+          <py.PropertyDeclaration name="x" />
+        </TestOutput>,
+      );
     }).toThrow('Method "x" must be declared inside a class (member scope)');
   });
 
   it("throws error when MethodDeclaration is used outside of a class", () => {
     expect(() => {
-      toSourceText([<py.MethodDeclaration name="my_method" />]);
+      render(
+        <TestOutput>
+          <py.MethodDeclaration name="my_method" />
+        </TestOutput>,
+      );
     }).toThrow(
       'Method "my_method" must be declared inside a class (member scope)',
     );
@@ -48,7 +78,11 @@ describe("Validation Errors", () => {
 
   it("throws error when ClassMethodDeclaration is used outside of a class", () => {
     expect(() => {
-      toSourceText([<py.ClassMethodDeclaration name="my_class_method" />]);
+      render(
+        <TestOutput>
+          <py.ClassMethodDeclaration name="my_class_method" />
+        </TestOutput>,
+      );
     }).toThrow(
       'Method "my_class_method" must be declared inside a class (member scope)',
     );
@@ -56,7 +90,11 @@ describe("Validation Errors", () => {
 
   it("throws error when StaticMethodDeclaration is used outside of a class", () => {
     expect(() => {
-      toSourceText([<py.StaticMethodDeclaration name="my_static_method" />]);
+      render(
+        <TestOutput>
+          <py.StaticMethodDeclaration name="my_static_method" />
+        </TestOutput>,
+      );
     }).toThrow(
       'Method "my_static_method" must be declared inside a class (member scope)',
     );
@@ -64,7 +102,11 @@ describe("Validation Errors", () => {
 
   it("throws error when DunderMethodDeclaration is used outside of a class", () => {
     expect(() => {
-      toSourceText([<py.DunderMethodDeclaration name="__init__" />]);
+      render(
+        <TestOutput>
+          <py.DunderMethodDeclaration name="__init__" />
+        </TestOutput>,
+      );
     }).toThrow(
       'Method "__init__" must be declared inside a class (member scope)',
     );