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

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)',
     );

package/test/functioncallexpressions.test.tsx

@@ -1,145 +1,159 @@
 import { 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("FunctionCallExpression", () => {
   it("renders", () => {
-    const result = toSourceText([<py.FunctionCallExpression target="foo" />]);
-    expect(result).toRenderTo(d`
+    expect(
+      <TestOutput>
+        <py.FunctionCallExpression target="foo" />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       foo()
-    `);
+    `,
+    );
   });
+
   it("renders with args", () => {
-    const result = toSourceText([
-      <py.FunctionCallExpression target="foo" args={["a", "b"]} />,
-    ]);
-    expect(result).toRenderTo(d`
+    expect(
+      <TestOutput>
+        <py.FunctionCallExpression target="foo" args={["a", "b"]} />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       foo(a, b)
-    `);
+    `,
+    );
   });
 
   it("function call with variables", () => {
-    // Creating the reference separately so the naming policy doesn't interfere
     const methodRef = refkey();
-    const result = toSourceText([
-      <py.StatementList>
-        <py.FunctionDeclaration name="runFunc" refkey={methodRef} />
-        <py.FunctionCallExpression
-          target={methodRef}
-          args={[
-            <py.Atom jsValue={"A name"} />,
-            <py.Atom jsValue={42} />,
-            <py.Atom jsValue={true} />,
-          ]}
-        />
-      </py.StatementList>,
-    ]);
-    const expected = d`
+    expect(
+      <TestOutput>
+        <py.StatementList>
+          <py.FunctionDeclaration name="runFunc" refkey={methodRef} />
+          <py.FunctionCallExpression
+            target={methodRef}
+            args={[
+              <py.Atom jsValue={"A name"} />,
+              <py.Atom jsValue={42} />,
+              <py.Atom jsValue={true} />,
+            ]}
+          />
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       def run_func():
           pass
       
       run_func("A name", 42, True)
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 
   it("function call with variables and assignment", () => {
-    // Creating the reference separately so the naming policy doesn't interfere
     const methodRef = refkey();
-    const result = toSourceText([
-      <py.StatementList>
-        <py.FunctionDeclaration
-          name="runFunc"
-          returnType="str"
-          refkey={methodRef}
-          parameters={[
-            { name: "name", type: "str" },
-            { name: "number", type: "int" },
-            { name: "flag", type: "bool" },
-          ]}
-        />
-        <py.VariableDeclaration
-          name="result"
-          type="str"
-          initializer={
-            <py.FunctionCallExpression
-              target={methodRef}
-              args={[
-                <py.Atom jsValue={"A name"} />,
-                <py.Atom jsValue={42} />,
-                <py.Atom jsValue={true} />,
-              ]}
-            />
-          }
-        />
-      </py.StatementList>,
-    ]);
-    const expected = d`
+    expect(
+      <TestOutput>
+        <py.StatementList>
+          <py.FunctionDeclaration
+            name="runFunc"
+            returnType="str"
+            refkey={methodRef}
+            parameters={[
+              { name: "name", type: "str" },
+              { name: "number", type: "int" },
+              { name: "flag", type: "bool" },
+            ]}
+          />
+          <py.VariableDeclaration
+            name="result"
+            type="str"
+            initializer={
+              <py.FunctionCallExpression
+                target={methodRef}
+                args={[
+                  <py.Atom jsValue={"A name"} />,
+                  <py.Atom jsValue={42} />,
+                  <py.Atom jsValue={true} />,
+                ]}
+              />
+            }
+          />
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       def run_func(name: str, number: int, flag: bool) -> str:
           pass
       
       result: str = run_func("A name", 42, True)
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 
   it("Method call without a reference and with call statement vars", () => {
-    const result = toSourceText([
-      <py.StatementList>
-        <py.FunctionCallExpression
-          target={"example_method"}
-          args={[
-            <py.VariableDeclaration
-              name="name"
-              initializer={"A name"}
-              callStatementVar
-            />,
-            <py.VariableDeclaration
-              name="number"
-              initializer={42}
-              callStatementVar
-            />,
-            <py.VariableDeclaration
-              name="flag"
-              initializer={true}
-              callStatementVar
-            />,
-          ]}
-        />
-      </py.StatementList>,
-    ]);
-    const expected = d`
+    expect(
+      <TestOutput>
+        <py.StatementList>
+          <py.FunctionCallExpression
+            target={"example_method"}
+            args={[
+              <py.VariableDeclaration
+                name="name"
+                initializer={"A name"}
+                callStatementVar
+              />,
+              <py.VariableDeclaration
+                name="number"
+                initializer={42}
+                callStatementVar
+              />,
+              <py.VariableDeclaration
+                name="flag"
+                initializer={true}
+                callStatementVar
+              />,
+            ]}
+          />
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       example_method(name="A name", number=42, flag=True)
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 
   it("Method call without a reference mixing unnamed and named vars", () => {
-    const result = toSourceText([
-      <py.StatementList>
-        <py.FunctionCallExpression
-          target={"example_method"}
-          args={[
-            <py.Atom jsValue={"A name"} />,
-            <py.VariableDeclaration
-              name="number"
-              initializer={42}
-              callStatementVar
-            />,
-            <py.VariableDeclaration
-              name="flag"
-              initializer={true}
-              callStatementVar
-            />,
-          ]}
-        />
-      </py.StatementList>,
-    ]);
-    const expected = d`
+    expect(
+      <TestOutput>
+        <py.StatementList>
+          <py.FunctionCallExpression
+            target={"example_method"}
+            args={[
+              <py.Atom jsValue={"A name"} />,
+              <py.VariableDeclaration
+                name="number"
+                initializer={42}
+                callStatementVar
+              />,
+              <py.VariableDeclaration
+                name="flag"
+                initializer={true}
+                callStatementVar
+              />,
+            ]}
+          />
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       example_method("A name", number=42, flag=True)
-    `;
-    expect(result).toRenderTo(expected);
+    `,
+    );
   });
 });