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

package/test/functiondeclaration.test.tsx

@@ -1,182 +1,201 @@
-import { code, namekey, refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { code, namekey, refkey, render } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
 import { abcModule } from "../src/index.js";
-import {
-  assertFileContents,
-  toSourceText,
-  toSourceTextMultiple,
-} from "./utils.js";
+import { TestOutput, TestOutputDirectory } 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`
+    expect(
+      <TestOutput>
+        <py.FunctionDeclaration name="f" decorators={["@a", "@b", "@c"]}>
+          pass
+        </py.FunctionDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       @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`
+    expect(
+      <TestOutput>
+        <py.FunctionDeclaration name="foo" />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       def foo():
           pass
 
-        
-    `);
+    `,
+    );
   });
 
   it("takes a namekey", () => {
-    const result = toSourceText([
-      <py.FunctionDeclaration name={namekey("foo-bar")} />,
-    ]);
-    expect(result).toRenderTo(d`
+    expect(
+      <TestOutput>
+        <py.FunctionDeclaration name={namekey("foo-bar")} />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       def foo_bar():
           pass
 
-
-    `);
+    `,
+    );
   });
 
   it("renders a function with no body as 'pass' with return type", () => {
-    const result = toSourceText([
-      <py.FunctionDeclaration name="foo" returnType="int" />,
-    ]);
-    expect(result).toRenderTo(d`
+    expect(
+      <TestOutput>
+        <py.FunctionDeclaration name="foo" returnType="int" />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       def foo() -> int:
           pass
 
-
-    `);
+    `,
+    );
   });
 
   it("renders a function that calls another function", () => {
     const refkeyFoo = refkey();
-    const result = toSourceText([
-      <py.StatementList>
-        <py.FunctionDeclaration
-          name="foo"
-          returnType="int"
-          refkey={refkeyFoo}
-        />
-        <py.FunctionDeclaration name="bar" returnType="int">
-          <py.VariableDeclaration
-            name="result"
-            type="int"
-            initializer={
-              <py.FunctionCallExpression target={refkeyFoo} args={[]} />
-            }
+    expect(
+      <TestOutput>
+        <py.StatementList>
+          <py.FunctionDeclaration
+            name="foo"
+            returnType="int"
+            refkey={refkeyFoo}
           />
-        </py.FunctionDeclaration>
-      </py.StatementList>,
-    ]);
-    expect(result).toRenderTo(d`
+          <py.FunctionDeclaration name="bar" returnType="int">
+            <py.VariableDeclaration
+              name="result"
+              type="int"
+              initializer={
+                <py.FunctionCallExpression target={refkeyFoo} args={[]} />
+              }
+            />
+          </py.FunctionDeclaration>
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       def foo() -> int:
           pass
 
       def bar() -> int:
           result: int = foo()
 
-
-    `);
+    `,
+    );
   });
 
   it("renders a function with parameters", () => {
-    const result = toSourceText([
-      <py.FunctionDeclaration
-        name="baz"
-        parameters={[
-          { name: "x", type: "int" },
-          { name: "y", default: 0 },
-          { name: "z", type: "int", default: 42 },
-        ]}
-        args={true}
-        kwargs={true}
-      >
-        print(x, y)
-      </py.FunctionDeclaration>,
-    ]);
-    expect(result).toRenderTo(
-      d`
+    expect(
+      <TestOutput>
+        <py.FunctionDeclaration
+          name="baz"
+          parameters={[
+            { name: "x", type: "int" },
+            { name: "y", default: 0 },
+            { name: "z", type: "int", default: 42 },
+          ]}
+          args={true}
+          kwargs={true}
+        >
+          print(x, y)
+        </py.FunctionDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         def baz(x: int, y=0, z: int = 42, *args, **kwargs):
             print(x, y)
 
-
       `,
     );
   });
 
   it("renders an __init__ function with no body as 'pass'", () => {
-    const result = toSourceText([
-      <py.ClassDeclaration name="MyClass">
-        <py.DunderMethodDeclaration
-          name="__init__"
-          parameters={[{ name: "x" }]}
-        />
-      </py.ClassDeclaration>,
-    ]);
-    expect(result).toRenderTo(d`
+    expect(
+      <TestOutput>
+        <py.ClassDeclaration name="MyClass">
+          <py.DunderMethodDeclaration
+            name="__init__"
+            parameters={[{ name: "x" }]}
+          />
+        </py.ClassDeclaration>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       class MyClass:
           def __init__(self, x):
               pass
 
-      
-      
-    `);
+
+    `,
+    );
   });
 
   it("can be an async function", () => {
-    expect(toSourceText([<py.FunctionDeclaration async name="foo" />])).toBe(d`
+    expect(
+      <TestOutput>
+        <py.FunctionDeclaration async name="foo" />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       async def foo():
           pass
 
-    `);
+    `,
+    );
   });
 
   it("can be an async function with returnType", () => {
     expect(
-      toSourceText([
-        <py.FunctionDeclaration async name="foo" returnType={"Foo"} />,
-      ]),
-    ).toBe(d`
+      <TestOutput>
+        <py.FunctionDeclaration async name="foo" returnType={"Foo"} />
+      </TestOutput>,
+    ).toRenderTo(
+      `
       async def foo() -> Foo:
           pass
 
-    `);
+    `,
+    );
   });
 
   it("can be an async function with returnType element with Reference", () => {
     expect(
-      toSourceText([
+      <TestOutput>
         <py.StatementList>
           <py.ClassDeclaration name="Foo" refkey={refkey("Foo")} />
           <py.FunctionDeclaration async name="foo" returnType={refkey("Foo")} />
-        </py.StatementList>,
-      ]),
-    ).toBe(d`
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       class Foo:
           pass
 
       async def foo() -> Foo:
           pass
 
-    `);
+    `,
+    );
   });
 
   it("can be an async function with returnType element with list of References", () => {
     expect(
-      toSourceText([
+      <TestOutput>
         <py.StatementList>
           <py.ClassDeclaration name="Foo" refkey={refkey("Foo")} />
           <py.FunctionDeclaration
@@ -184,16 +203,18 @@ describe("Function Declaration", () => {
             name="foo"
             returnType={code`list[${refkey("Foo")}]`}
           />
-        </py.StatementList>,
-      ]),
-    ).toBe(d`
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       class Foo:
           pass
 
       async def foo() -> list[Foo]:
           pass
 
-    `);
+    `,
+    );
   });
 
   it("can be an async dunder method", () => {
@@ -213,13 +234,15 @@ describe("Function Declaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           async def __aenter__(self) -> MyClass:
               return self
 
 
-    `);
+    `,
+    );
   });
 
   it("can be an async constructor", () => {
@@ -235,13 +258,15 @@ describe("Function Declaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           async def __new__(cls) -> MyClass:
               return super().__new__(cls)
 
 
-    `);
+    `,
+    );
   });
 
   it("supports parameters", () => {
@@ -254,12 +279,15 @@ describe("Function Declaration", () => {
       </py.FunctionDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       def foo(a, b):
           return a + b
 
-    `);
+    `,
+    );
   });
+
   it("supports type parameters", () => {
     const decl = (
       <py.FunctionDeclaration
@@ -271,12 +299,15 @@ describe("Function Declaration", () => {
       </py.FunctionDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       def foo[T, U](a, b):
           return a + b
 
-    `);
+    `,
+    );
   });
+
   it("renders abstract methods", () => {
     const parameters = [{ name: "x", type: "int" }];
     const decl = (
@@ -303,7 +334,8 @@ describe("Function Declaration", () => {
       </py.StatementList>
     );
 
-    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+    expect(<TestOutput externals={[abcModule]}>{decl}</TestOutput>).toRenderTo(
+      `
       from abc import abstractmethod
 
 
@@ -323,8 +355,10 @@ describe("Function Declaration", () => {
               pass
 
 
-    `);
+    `,
+    );
   });
+
   it("renders dunder methods with parameters", () => {
     const parameters = [{ name: "x", type: "int" }];
     const decl = (
@@ -340,7 +374,8 @@ describe("Function Declaration", () => {
       </py.ClassDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           def __init__(self, x: int):
               self.attribute = "value"
@@ -349,7 +384,8 @@ describe("Function Declaration", () => {
               return "MyClass"
 
 
-    `);
+    `,
+    );
   });
 
   it("renders dunder methods __new__", () => {
@@ -363,13 +399,15 @@ describe("Function Declaration", () => {
       </py.ClassDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       class MyClass:
           def __new__(cls, *args, **kwargs):
               pass
 
 
-    `);
+    `,
+    );
   });
 
   it("renders nested functions", () => {
@@ -411,7 +449,8 @@ describe("Function Declaration", () => {
       </py.FunctionDeclaration>
     );
 
-    expect(toSourceText([decl])).toBe(d`
+    expect(<TestOutput>{decl}</TestOutput>).toRenderTo(
+      `
       def foo(x: int):
           def bar(y: int):
               def foobar(z: int):
@@ -419,39 +458,41 @@ describe("Function Declaration", () => {
               return foobar(2)
           return bar(3)
 
-    `);
+    `,
+    );
   });
-  it("renders complex typing structure", () => {
-    const res = toSourceTextMultiple([
-      <py.SourceFile path="mod1.py">
-        <py.ClassDeclaration name="Foo" refkey={refkey("Foo")} />
-      </py.SourceFile>,
-      <py.SourceFile path="mod2.py">
-        <py.ClassDeclaration name="A" refkey={refkey("A")} />
-        <py.ClassDeclaration name="B" refkey={refkey("B")} />
-      </py.SourceFile>,
-      <py.SourceFile path="usage.py">
-        <py.FunctionDeclaration
-          async
-          name="foo"
-          parameters={[
-            {
-              name: "x",
-              type: refkey("A"),
-            },
-            {
-              name: "y",
-              type: refkey("B"),
-            },
-          ]}
-          args={true}
-          kwargs={true}
-          returnType={refkey("Foo")}
-        />
-      </py.SourceFile>,
-    ]);
 
-    assertFileContents(res, {
+  it("renders complex typing structure", () => {
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="mod1.py">
+          <py.ClassDeclaration name="Foo" refkey={refkey("Foo")} />
+        </py.SourceFile>
+        <py.SourceFile path="mod2.py">
+          <py.ClassDeclaration name="A" refkey={refkey("A")} />
+          <py.ClassDeclaration name="B" refkey={refkey("B")} />
+        </py.SourceFile>
+        <py.SourceFile path="usage.py">
+          <py.FunctionDeclaration
+            async
+            name="foo"
+            parameters={[
+              {
+                name: "x",
+                type: refkey("A"),
+              },
+              {
+                name: "y",
+                type: refkey("B"),
+              },
+            ]}
+            args={true}
+            kwargs={true}
+            returnType={refkey("Foo")}
+          />
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "mod1.py": `
             class Foo:
                 pass
@@ -484,13 +525,21 @@ describe("Function Declaration", () => {
 
   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)',
     );
@@ -498,7 +547,11 @@ describe("Function Declaration", () => {
 
   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)',
     );
@@ -506,7 +559,11 @@ describe("Function Declaration", () => {
 
   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)',
     );
@@ -514,7 +571,11 @@ describe("Function Declaration", () => {
 
   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)',
     );