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

package/test/classdeclarations.test.tsx

@@ -9,6 +9,33 @@ import {
 } from "./utils.jsx";
 
 describe("Python Class", () => {
+  it("renders class-level decorators above `class`", () => {
+    const result = toSourceText([
+      <py.ClassDeclaration
+        name="Foo"
+        decorators={["@final", "@deprecated('use Bar')"]}
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      @final
+      @deprecated('use Bar')
+      class Foo:
+          pass
+
+
+    `);
+  });
+
+  it("renders nothing extra when decorators is undefined", () => {
+    const result = toSourceText([<py.ClassDeclaration name="Foo" />]);
+    expect(result).toRenderTo(d`
+      class Foo:
+          pass
+
+
+    `);
+  });
+
   it("renders a class with no body as 'pass'", () => {
     const result = toSourceText([<py.ClassDeclaration name="Foo" />]);
     expect(result).toRenderTo(d`

package/test/dataclassdeclarations.test.tsx

@@ -10,6 +10,31 @@ import {
 } from "./utils.jsx";
 
 describe("DataclassDeclaration", () => {
+  it("stacks user decorators above @dataclass", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" frozen decorators={["@final"]} />
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+
+    expect(res).toRenderTo(
+      d`
+        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>]} />

package/test/decoratorlist.test.tsx

@@ -0,0 +1,95 @@
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import { DecoratorList } from "../src/components/DecoratorList.jsx";
+import { toSourceText } 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(
+      toSourceText([
+        <>
+          <DecoratorList />
+          pass
+        </>,
+      ]),
+    ).toRenderTo("pass");
+  });
+
+  it("renders nothing when decorators is an empty array", () => {
+    expect(
+      toSourceText([
+        <>
+          <DecoratorList decorators={[]} />
+          pass
+        </>,
+      ]),
+    ).toRenderTo("pass");
+  });
+
+  it("renders a single decorator followed by exactly one hardline", () => {
+    expect(
+      toSourceText([
+        <>
+          <DecoratorList decorators={["@one"]} />
+          pass
+        </>,
+      ]),
+    ).toRenderTo(d`
+      @one
+      pass
+    `);
+  });
+
+  it("renders multiple decorators with no blank lines between adjacent entries", () => {
+    expect(
+      toSourceText([
+        <>
+          <DecoratorList decorators={["@one", "@two", "@three"]} />
+          pass
+        </>,
+      ]),
+    ).toRenderTo(d`
+      @one
+      @two
+      @three
+      pass
+    `);
+  });
+
+  it("preserves source order: first entry is topmost (= applied last)", () => {
+    expect(
+      toSourceText([
+        <>
+          <DecoratorList decorators={["@outer", "@middle", "@inner"]} />
+          pass
+        </>,
+      ]),
+    ).toRenderTo(d`
+      @outer
+      @middle
+      @inner
+      pass
+    `);
+  });
+
+  it("skips falsy entries without emitting blank lines", () => {
+    expect(
+      toSourceText([
+        <>
+          <DecoratorList decorators={["@one", false, undefined, "@two"]} />
+          pass
+        </>,
+      ]),
+    ).toRenderTo(d`
+      @one
+      @two
+      pass
+    `);
+  });
+});

package/test/enums.test.tsx

@@ -6,6 +6,35 @@ import * as py from "../src/index.js";
 import { toSourceText } from "./utils.jsx";
 
 describe("Python Enum", () => {
+  it("renders class-level decorators above ClassEnumDeclaration", () => {
+    const result = toSourceText(
+      [
+        <py.ClassEnumDeclaration
+          name="Color"
+          baseType="IntEnum"
+          decorators={["@final"]}
+          members={[
+            { name: "RED", value: 1 },
+            { name: "GREEN", value: 2 },
+          ]}
+        />,
+      ],
+      { externals: [enumModule] },
+    );
+
+    expect(result).toRenderTo(d`
+      from enum import IntEnum
+
+
+      @final
+      class Color(IntEnum):
+          RED = 1
+          GREEN = 2
+
+
+    `);
+  });
+
   it("class enum with explicit values", () => {
     const result = toSourceText(
       [

package/test/functiondeclaration.test.tsx

@@ -10,6 +10,23 @@ import {
 } from "./utils.js";
 
 describe("Function Declaration", () => {
+  it("renders multiple decorators above def without blank lines", () => {
+    const result = toSourceText([
+      <py.FunctionDeclaration name="f" decorators={["@a", "@b", "@c"]}>
+        pass
+      </py.FunctionDeclaration>,
+    ]);
+    expect(result).toRenderTo(d`
+      @a
+      @b
+      @c
+      def f():
+          pass
+
+        
+    `);
+  });
+
   it("renders a function with no body as 'pass'", () => {
     const result = toSourceText([<py.FunctionDeclaration name="foo" />]);
     expect(result).toRenderTo(d`

package/test/methoddeclaration.test.tsx

@@ -5,6 +5,76 @@ import { abcModule } from "../src/index.js";
 import { toSourceText } from "./utils.js";
 
 describe("Method-like Declarations", () => {
+  it("renders decorators above def", () => {
+    const result = toSourceText([
+      <py.ClassDeclaration name="MyClass">
+        <py.MethodDeclaration
+          name="with_decorator"
+          decorators={["@some_decorator"]}
+        >
+          pass
+        </py.MethodDeclaration>
+      </py.ClassDeclaration>,
+    ]);
+    expect(result).toRenderTo(d`
+      class MyClass:
+          @some_decorator
+          def with_decorator(self):
+              pass
+
+
+              
+    `);
+  });
+
+  it("renders multiple decorators above def without blank lines", () => {
+    const result = toSourceText([
+      <py.ClassDeclaration name="MyClass">
+        <py.MethodDeclaration
+          name="with_decorators"
+          decorators={["@outer", "@middle", "@inner"]}
+        >
+          pass
+        </py.MethodDeclaration>
+      </py.ClassDeclaration>,
+    ]);
+    expect(result).toRenderTo(d`
+      class MyClass:
+          @outer
+          @middle
+          @inner
+          def with_decorators(self):
+              pass
+
+
+              
+    `);
+  });
+
+  it("renders multiple decorators above @classmethod without blank lines", () => {
+    const result = toSourceText([
+      <py.ClassDeclaration name="MyClass">
+        <py.ClassMethodDeclaration
+          name="with_decorators"
+          decorators={["@outer", "@inner"]}
+        >
+          pass
+        </py.ClassMethodDeclaration>
+      </py.ClassDeclaration>,
+    ]);
+    expect(result).toRenderTo(d`
+      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">

package/test/propertydeclaration.test.tsx

@@ -1,4 +1,4 @@
-import { Prose } from "@alloy-js/core";
+import { Prose, code } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
@@ -148,6 +148,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(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+      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(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+      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>