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

package/test/methoddeclaration.test.tsx

@@ -1,44 +1,47 @@
-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", () => {
-    const result = toSourceText([
-      <py.ClassDeclaration name="MyClass">
-        <py.MethodDeclaration
-          name="with_decorator"
-          decorators={["@some_decorator"]}
-        >
-          pass
-        </py.MethodDeclaration>
-      </py.ClassDeclaration>,
-    ]);
-    expect(result).toRenderTo(d`
+    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", () => {
-    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`
+    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
@@ -47,22 +50,24 @@ describe("Method-like Declarations", () => {
               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`
+    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
@@ -71,24 +76,26 @@ describe("Method-like Declarations", () => {
               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", () => {
@@ -104,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", () => {
@@ -130,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", () => {
@@ -153,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", () => {
@@ -173,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", () => {
@@ -192,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", () => {
@@ -212,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", () => {
@@ -248,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
 
 
@@ -268,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, 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";
 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:
@@ -168,7 +167,7 @@ describe("PropertyDeclaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(`
       class MyClass:
           @computed_field
           @deprecated("use width**2")
@@ -198,7 +197,7 @@ describe("PropertyDeclaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(`
       from abc import abstractmethod
 
 
@@ -232,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