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

package/test/methoddeclaration.test.tsx

@@ -1,24 +1,101 @@
-import { d } from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
 import { abcModule } from "../src/index.js";
-import { toSourceText } from "./utils.js";
+import { TestOutput } from "./utils.js";
 
 describe("Method-like Declarations", () => {
+  it("renders decorators above def", () => {
+    expect(
+      <TestOutput>
+        <py.ClassDeclaration name="MyClass">
+          <py.MethodDeclaration
+            name="with_decorator"
+            decorators={["@some_decorator"]}
+          >
+            pass
+          </py.MethodDeclaration>
+        </py.ClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
+      class MyClass:
+          @some_decorator
+          def with_decorator(self):
+              pass
+
+
+    `,
+    );
+  });
+
+  it("renders multiple decorators above def without blank lines", () => {
+    expect(
+      <TestOutput>
+        <py.ClassDeclaration name="MyClass">
+          <py.MethodDeclaration
+            name="with_decorators"
+            decorators={["@outer", "@middle", "@inner"]}
+          >
+            pass
+          </py.MethodDeclaration>
+        </py.ClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
+      class MyClass:
+          @outer
+          @middle
+          @inner
+          def with_decorators(self):
+              pass
+
+
+    `,
+    );
+  });
+
+  it("renders multiple decorators above @classmethod without blank lines", () => {
+    expect(
+      <TestOutput>
+        <py.ClassDeclaration name="MyClass">
+          <py.ClassMethodDeclaration
+            name="with_decorators"
+            decorators={["@outer", "@inner"]}
+          >
+            pass
+          </py.ClassMethodDeclaration>
+        </py.ClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
+      class MyClass:
+          @outer
+          @inner
+          @classmethod
+          def with_decorators(cls):
+              pass
+
+
+    `,
+    );
+  });
+
   it("renders an instance function with a body", () => {
-    const result = toSourceText([
-      <py.ClassDeclaration name="MyClass">
-        <py.MethodDeclaration name="bar">print('hi')</py.MethodDeclaration>
-      </py.ClassDeclaration>,
-    ]);
-    expect(result).toRenderTo(d`
+    expect(
+      <TestOutput>
+        <py.ClassDeclaration name="MyClass">
+          <py.MethodDeclaration name="bar">print('hi')</py.MethodDeclaration>
+        </py.ClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       class MyClass:
           def bar(self):
               print('hi')
 
 
-              
-    `);
+    `,
+    );
   });
 
   it("can be an async method", () => {
@@ -34,13 +111,15 @@ describe("Method-like Declarations", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           async def my_method(self) -> str:
               return "async result"
 
 
-    `);
+    `,
+    );
   });
 
   it("can be an async class method", () => {
@@ -60,14 +139,16 @@ describe("Method-like Declarations", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           @classmethod
           async def create_async(cls) -> MyClass:
               return cls()
 
 
-    `);
+    `,
+    );
   });
 
   it("can be an async static method", () => {
@@ -83,14 +164,16 @@ describe("Method-like Declarations", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           @staticmethod
           async def utility() -> str:
               return "utility result"
 
 
-    `);
+    `,
+    );
   });
 
   it("renders method with parameters", () => {
@@ -103,13 +186,15 @@ describe("Method-like Declarations", () => {
       </py.ClassDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           def foo(self, x: int):
               self.attribute = "value"
 
 
-    `);
+    `,
+    );
   });
 
   it("renders class method with parameters", () => {
@@ -122,14 +207,16 @@ describe("Method-like Declarations", () => {
       </py.ClassDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           @classmethod
           def foo(cls, x: int):
               self.attribute = "value"
 
 
-    `);
+    `,
+    );
   });
 
   it("renders static method with parameters", () => {
@@ -142,14 +229,16 @@ describe("Method-like Declarations", () => {
       </py.ClassDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           @staticmethod
           def foo(x: int):
               attribute = "value"
 
 
-    `);
+    `,
+    );
   });
 
   it("renders abstract methods", () => {
@@ -178,7 +267,8 @@ describe("Method-like Declarations", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(
+      `
       from abc import abstractmethod
 
 
@@ -198,6 +288,7 @@ describe("Method-like Declarations", () => {
               pass
 
 
-    `);
+    `,
+    );
   });
 });

package/test/namepolicies.test.tsx

@@ -1,25 +1,25 @@
-import { d } from "@alloy-js/core/testing";
 import { 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";
 
 it("correct formatting of class name", () => {
-  const result = toSourceText([
-    <py.ClassDeclaration name="a-really-WeirdClass-name" />,
-  ]);
-  const expected = d`
+  expect(
+    <TestOutput>
+      <py.ClassDeclaration name="a-really-WeirdClass-name" />
+    </TestOutput>,
+  ).toRenderTo(
+    `
     class AReallyWeirdClassName:
         pass
 
-      
-  `;
-  expect(result).toRenderTo(expected);
+  `,
+  );
 });
 
 it("correct formatting of Enum name and EnumMember names", () => {
-  const result = toSourceText(
-    [
+  expect(
+    <TestOutput externals={[enumModule]}>
       <py.FunctionalEnumDeclaration
         name="priority"
         members={[
@@ -27,83 +27,83 @@ it("correct formatting of Enum name and EnumMember names", () => {
           { name: "Medium", value: 2 },
           { name: "lowValue", value: 3 },
         ]}
-      />,
-    ],
-    { externals: [enumModule] },
-  );
-  const expected = d`
+      />
+    </TestOutput>,
+  ).toRenderTo(
+    `
     from enum import Enum
 
 
     Priority = Enum('Priority', {'HIGH' : 1, 'MEDIUM' : 2, 'LOW_VALUE' : 3})
-  `;
-  expect(result).toRenderTo(expected);
+  `,
+  );
 });
 
 it("renders a function with parameters", () => {
-  const result = toSourceText([
-    <py.FunctionDeclaration
-      name="quirklyNamed-Function"
-      parameters={[{ name: "a-parameter", type: "int" }]}
-      args={true}
-      kwargs={true}
-    >
-      print(x, y)
-    </py.FunctionDeclaration>,
-  ]);
-  expect(result).toRenderTo(
-    d`
+  expect(
+    <TestOutput>
+      <py.FunctionDeclaration
+        name="quirklyNamed-Function"
+        parameters={[{ name: "a-parameter", type: "int" }]}
+        args={true}
+        kwargs={true}
+      >
+        print(x, y)
+      </py.FunctionDeclaration>
+    </TestOutput>,
+  ).toRenderTo(
+    `
       def quirkly_named_function(a_parameter: int, *args, **kwargs):
           print(x, y)
 
-        
     `,
   );
 });
 
 it("correct formatting of call signature parameters names", () => {
-  const result = toSourceText([
-    <py.CallSignatureParameters
-      parameters={[
-        { name: "this-is-a-number", type: "int" },
-        {
-          name: "andThisIsADict",
-          type: "dict",
-        },
-      ]}
-    />,
-  ]);
-  expect(result).toRenderTo(`this_is_a_number: int, and_this_is_a_dict: dict`);
+  expect(
+    <TestOutput>
+      <py.CallSignatureParameters
+        parameters={[
+          { name: "this-is-a-number", type: "int" },
+          {
+            name: "andThisIsADict",
+            type: "dict",
+          },
+        ]}
+      />
+    </TestOutput>,
+  ).toRenderTo(`this_is_a_number: int, and_this_is_a_dict: dict`);
 });
 
 it("correct formatting of call statement vars", () => {
-  const result = toSourceText([
-    <py.StatementList>
-      <py.ClassInstantiation
-        target={"test"}
-        args={[
-          <py.VariableDeclaration
-            name="this-is-a-long-name"
-            initializer={<py.Atom jsValue={"A name"} />}
-            callStatementVar
-          />,
-          <py.VariableDeclaration
-            name="andThisIsANumber"
-            initializer={<py.Atom jsValue={42} />}
-            callStatementVar
-          />,
-        ]}
-      />
-    </py.StatementList>,
-  ]);
-  expect(result).toRenderTo(
-    `test(this_is_a_long_name="A name", and_this_is_a_number=42)`,
-  );
+  expect(
+    <TestOutput>
+      <py.StatementList>
+        <py.ClassInstantiation
+          target={"test"}
+          args={[
+            <py.VariableDeclaration
+              name="this-is-a-long-name"
+              initializer={<py.Atom jsValue={"A name"} />}
+              callStatementVar
+            />,
+            <py.VariableDeclaration
+              name="andThisIsANumber"
+              initializer={<py.Atom jsValue={42} />}
+              callStatementVar
+            />,
+          ]}
+        />
+      </py.StatementList>
+    </TestOutput>,
+  ).toRenderTo(`test(this_is_a_long_name="A name", and_this_is_a_number=42)`);
 });
 
 it("correct formatting of variable name", () => {
-  const res = toSourceText([
-    <py.VariableDeclaration name="myVar" type="int" initializer={42} />,
-  ]);
-  expect(res).toBe(`my_var: int = 42`);
+  expect(
+    <TestOutput>
+      <py.VariableDeclaration name="myVar" type="int" initializer={42} />
+    </TestOutput>,
+  ).toRenderTo("my_var: int = 42");
 });

package/test/propertydeclaration.test.tsx

@@ -1,9 +1,8 @@
-import { Prose } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { Prose, code } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
 import { abcModule } from "../src/index.js";
-import { toSourceText } from "./utils.js";
+import { TestOutput } from "./utils.js";
 
 describe("PropertyDeclaration", () => {
   it("renders empty property, setter, deleter", () => {
@@ -20,7 +19,7 @@ describe("PropertyDeclaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(`
       class MyClass:
           @property
           def x(self):
@@ -57,7 +56,7 @@ describe("PropertyDeclaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(`
       class MyClass:
           @property
           def x(self) -> int:
@@ -121,7 +120,7 @@ describe("PropertyDeclaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(`
       class MyClass:
           @property
           def x(self) -> int:
@@ -148,6 +147,71 @@ describe("PropertyDeclaration", () => {
     `);
   });
 
+  it("renders decorators above @property in source order", () => {
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.PropertyDeclaration
+              name="area"
+              type="float"
+              decorators={[
+                code`@computed_field`,
+                code`@deprecated("use width**2")`,
+              ]}
+            >
+              return self.width ** 2
+            </py.PropertyDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(`
+      class MyClass:
+          @computed_field
+          @deprecated("use width**2")
+          @property
+          def area(self) -> float:
+              return self.width ** 2
+
+
+    `);
+  });
+
+  it("stacks decorators above @property and @abstractmethod below it", () => {
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.PropertyDeclaration
+              name="area"
+              type="float"
+              abstract
+              decorators={[code`@computed_field`]}
+            >
+              return self.width ** 2
+            </py.PropertyDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(`
+      from abc import abstractmethod
+
+
+      class MyClass:
+          @computed_field
+          @property
+          @abstractmethod
+          def area(self) -> float:
+              return self.width ** 2
+
+
+    `);
+  });
+
   it("renders abstract property with getter, setter, deleter", () => {
     const decl = (
       <py.StatementList>
@@ -167,7 +231,7 @@ describe("PropertyDeclaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(`
       from abc import abstractmethod