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

package/test/uniontypeexpression.test.tsx

@@ -1,27 +1,28 @@
 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 {
-  assertFileContents,
-  toSourceText,
-  toSourceTextMultiple,
-} from "./utils.jsx";
+import { TestOutput, TestOutputDirectory } from "./utils.js";
 
 describe("UnionTypeExpression", () => {
   it("renders a Python union expression - 1 item", () => {
     expect(
-      toSourceText([<py.UnionTypeExpression children={["int"]} />]),
+      <TestOutput>
+        <py.UnionTypeExpression children={["int"]} />
+      </TestOutput>,
     ).toRenderTo("int");
   });
+
   it("renders a Python union expression - 2 items", () => {
     expect(
-      toSourceText([<py.UnionTypeExpression children={["int", "str"]} />]),
+      <TestOutput>
+        <py.UnionTypeExpression children={["int", "str"]} />
+      </TestOutput>,
     ).toRenderTo("int | str");
   });
+
   it("renders a Python union expression - N items", () => {
     expect(
-      toSourceText([
+      <TestOutput>
         <py.UnionTypeExpression
           children={[
             "int",
@@ -38,9 +39,10 @@ describe("UnionTypeExpression", () => {
             "memoryview",
             "complex",
           ]}
-        />,
-      ]),
-    ).toRenderTo(d`
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         (
             int
             | str
@@ -55,31 +57,36 @@ describe("UnionTypeExpression", () => {
             | bytearray
             | memoryview
             | complex
-        )`);
+        )`,
+    );
   });
+
   it("renders a Python union expression - 2 items again", () => {
     expect(
-      toSourceText([<py.UnionTypeExpression children={["int", "str"]} />]),
+      <TestOutput>
+        <py.UnionTypeExpression children={["int", "str"]} />
+      </TestOutput>,
     ).toRenderTo("int | str");
   });
+
   it("renders a Python union expression - 2 items with None", () => {
     expect(
-      toSourceText([
-        <py.UnionTypeExpression children={["int", "str", "None"]} />,
-      ]),
+      <TestOutput>
+        <py.UnionTypeExpression children={["int", "str", "None"]} />
+      </TestOutput>,
     ).toRenderTo("int | str | None");
   });
 
   it("renders a Python union with generic types", () => {
     expect(
-      toSourceText([
+      <TestOutput>
         <py.UnionTypeExpression
           children={[
             <py.TypeReference name="list" typeArgs={["int"]} />,
             <py.TypeReference name="dict" typeArgs={["str", "int"]} />,
           ]}
-        />,
-      ]),
+        />
+      </TestOutput>,
     ).toRenderTo("list[int] | dict[str, int]");
   });
 
@@ -88,7 +95,7 @@ describe("UnionTypeExpression", () => {
     const otherClassRefkey = refkey();
 
     expect(
-      toSourceText([
+      <TestOutput>
         <py.StatementList>
           <py.ClassDeclaration
             name="Bar"
@@ -104,9 +111,10 @@ describe("UnionTypeExpression", () => {
               <py.Reference refkey={otherClassRefkey} />,
             ]}
           />
-        </py.StatementList>,
-      ]),
-    ).toRenderTo(d`
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
         class Bar:
             pass
 
@@ -114,38 +122,40 @@ describe("UnionTypeExpression", () => {
             pass
 
         Bar | Foo
-    `);
+    `,
+    );
   });
 
   it("emits import for TypeReference with refkey and typeArgs across files", () => {
     const classRefkey = refkey();
-    const res = toSourceTextMultiple([
-      <py.SourceFile path="defs.py">
-        <py.ClassDeclaration name="Bar" refkey={classRefkey} />
-      </py.SourceFile>,
-      <py.SourceFile path="use.py">
-        <py.StatementList>
-          <py.VariableDeclaration
-            name="v"
-            type={<py.TypeReference refkey={classRefkey} typeArgs={["T"]} />}
-          />
-        </py.StatementList>
-      </py.SourceFile>,
-    ]);
-    assertFileContents(res, {
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="defs.py">
+          <py.ClassDeclaration name="Bar" refkey={classRefkey} />
+        </py.SourceFile>
+        <py.SourceFile path="use.py">
+          <py.StatementList>
+            <py.VariableDeclaration
+              name="v"
+              type={<py.TypeReference refkey={classRefkey} typeArgs={["T"]} />}
+            />
+          </py.StatementList>
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "defs.py": `
-        class Bar:
-            pass
+          class Bar:
+              pass
 
-      `,
+        `,
       "use.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from defs import Bar
+          if TYPE_CHECKING:
+              from defs import Bar
 
-        v: Bar[T] = None
-      `,
+          v: Bar[T] = None
+        `,
     });
   });
 });
@@ -159,11 +169,11 @@ describe("TypeExpression in different scenarios", () => {
       />
     );
     expect(
-      toSourceText([
+      <TestOutput>
         <py.ClassDeclaration
           name="Foo"
           refkey={classRefkey}
-        ></py.ClassDeclaration>,
+        ></py.ClassDeclaration>
         <py.FunctionDeclaration
           name="fooFunction"
           parameters={[
@@ -175,9 +185,10 @@ describe("TypeExpression in different scenarios", () => {
           args={true}
           kwargs={true}
           returnType={type}
-        />,
-      ]),
-    ).toRenderTo(d`
+        />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         class Foo:
             pass
 
@@ -185,9 +196,10 @@ describe("TypeExpression in different scenarios", () => {
         def foo_function(x: int | str | Foo, *args, **kwargs) -> int | str | Foo:
             pass
 
-
-    `);
+    `,
+    );
   });
+
   it("renders an UnionTypeExpression as a variable type", () => {
     const classRefkey = refkey();
     const type = (
@@ -196,20 +208,21 @@ describe("TypeExpression in different scenarios", () => {
       />
     );
     expect(
-      toSourceText([
+      <TestOutput>
         <py.ClassDeclaration
           name="Foo"
           refkey={classRefkey}
-        ></py.ClassDeclaration>,
-        <py.VariableDeclaration name="fooVariable" type={type} />,
-      ]),
-    ).toRenderTo(d`
+        ></py.ClassDeclaration>
+        <py.VariableDeclaration name="fooVariable" type={type} />
+      </TestOutput>,
+    ).toRenderTo(
+      `
         class Foo:
             pass
 
 
         foo_variable: int | str | Foo = None
-
-    `);
+    `,
+    );
   });
 });

package/test/utils.tsx

@@ -1,133 +1,49 @@
 import {
   Binder,
   Children,
-  ContentOutputFile,
   NamePolicy,
   Output,
-  OutputDirectory,
-  OutputFile,
   OutputScope,
-  PrintTreeOptions,
   SymbolCreator,
-  render,
 } from "@alloy-js/core";
-import { dedent } from "@alloy-js/core/testing";
-import { expect } from "vitest";
 import * as py from "../src/components/index.js";
 import { pythonNameConflictResolver } from "../src/name-conflict-resolver.js";
 import { createPythonNamePolicy } from "../src/name-policy.js";
 import { PythonModuleScope } from "../src/symbols/index.js";
 
-export function findFile(
-  res: OutputDirectory,
-  path: string,
-): ContentOutputFile {
-  const result = findFileWorker(res, path);
-
-  if (!result) {
-    throw new Error("Expected to find file " + path);
-  }
-  return result as ContentOutputFile;
-
-  function findFileWorker(
-    res: OutputDirectory,
-    path: string,
-  ): OutputFile | null {
-    for (const item of res.contents) {
-      if (item.kind === "file") {
-        if (item.path === path) {
-          return item;
-        }
-        continue;
-      } else {
-        const found = findFileWorker(item, path);
-        if (found) {
-          return found;
-        }
-      }
-    }
-    return null;
-  }
-}
-
-export function assertFileContents(
-  res: OutputDirectory,
-  expectedFiles: Record<string, string>,
-) {
-  for (const [path, contents] of Object.entries(expectedFiles)) {
-    const file = findFile(res, path);
-    expect(file.contents).toBe(dedent(contents));
-  }
-}
-
-export function toSourceTextMultiple(
-  sourceFiles: Children[],
-  {
-    policy,
-    externals,
-    options,
-    printOptions,
-  }: {
-    policy?: NamePolicy<string>;
-    externals?: SymbolCreator[];
-    options?: { externals?: SymbolCreator[] };
-    printOptions?: PrintTreeOptions;
-  } = {},
-): OutputDirectory {
-  if (!policy) {
-    policy = createPythonNamePolicy();
-  }
-  const mergedExternals = options?.externals ?? externals;
-  if (printOptions === undefined) {
-    printOptions = {
-      printWidth: 80,
-      tabWidth: 4,
-      insertFinalNewLine: false,
-    };
-  } else {
-    printOptions.insertFinalNewLine = false;
-    printOptions.tabWidth = 4;
-  }
-  const content = (
+export function TestOutput(props: {
+  children?: Children;
+  externals?: SymbolCreator[];
+  namePolicy?: NamePolicy<string>;
+  path?: string;
+}) {
+  return (
     <Output
-      externals={mergedExternals}
-      namePolicy={policy}
+      externals={props.externals}
+      namePolicy={props.namePolicy ?? createPythonNamePolicy()}
       nameConflictResolver={pythonNameConflictResolver}
     >
-      {sourceFiles}
+      <py.SourceFile path={props.path ?? "test.py"} printWidth={80}>
+        {props.children}
+      </py.SourceFile>
     </Output>
   );
-  return render(content, printOptions);
 }
 
-export function toSourceText(
-  content: Children | Children[],
-  {
-    policy,
-    externals,
-    options,
-    printOptions,
-  }: {
-    policy?: NamePolicy<string>;
-    externals?: SymbolCreator[];
-    options?: { externals?: SymbolCreator[] };
-    printOptions?: PrintTreeOptions;
-  } = {},
-  path: string = "test.py",
-): string {
-  // If content is an array, wrap it in a default SourceFile
-  const sourceFile =
-    Array.isArray(content) ?
-      <py.SourceFile path={path}>{content}</py.SourceFile>
-    : content;
-
-  const res = toSourceTextMultiple([sourceFile], {
-    policy,
-    externals,
-    options,
-    printOptions,
-  });
-  return findFile(res, path).contents;
+export function TestOutputDirectory(props: {
+  children: Children;
+  externals?: SymbolCreator[];
+  namePolicy?: NamePolicy<string>;
+}) {
+  return (
+    <Output
+      externals={props.externals}
+      namePolicy={props.namePolicy ?? createPythonNamePolicy()}
+      nameConflictResolver={pythonNameConflictResolver}
+    >
+      {props.children}
+    </Output>
+  );
 }
 
 // Helper function to create a PythonModuleScope to be used in tests

package/test/values.test.tsx

@@ -1,82 +1,126 @@
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
-import { toSourceText } from "./utils.jsx";
+import { TestOutput } from "./utils.js";
 
 describe("Atom", () => {
   it("renders string value", () => {
-    expect(toSourceText([<py.Atom jsValue={"Test"} />])).toRenderTo('"Test"');
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={"Test"} />
+      </TestOutput>,
+    ).toRenderTo('"Test"');
   });
 
   it("renders null/undefined object", () => {
-    expect(toSourceText([<py.Atom jsValue={undefined} />])).toRenderTo("None");
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={undefined} />
+      </TestOutput>,
+    ).toRenderTo("None");
   });
 
   it("renders number", () => {
-    expect(toSourceText([<py.Atom jsValue={123} />])).toRenderTo("123");
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={123} />
+      </TestOutput>,
+    ).toRenderTo("123");
   });
 
   it("renders floating point number", () => {
-    expect(toSourceText([<py.Atom jsValue={123.456} />])).toRenderTo("123.456");
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={123.456} />
+      </TestOutput>,
+    ).toRenderTo("123.456");
   });
 
   it("renders floating point number when hinted", () => {
-    expect(toSourceText([<py.Atom jsValue={123.456} asFloat />])).toRenderTo(
-      "123.456",
-    );
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={123.456} asFloat />
+      </TestOutput>,
+    ).toRenderTo("123.456");
   });
 
   it("renders floating point number with decimal point zero when hinted", () => {
-    expect(toSourceText([<py.Atom jsValue={123.0} asFloat />])).toRenderTo(
-      "123.0",
-    );
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={123.0} asFloat />
+      </TestOutput>,
+    ).toRenderTo("123.0");
   });
 
   it("renders integer as float when hinted", () => {
-    expect(toSourceText([<py.Atom jsValue={123} asFloat />])).toRenderTo(
-      "123.0",
-    );
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={123} asFloat />
+      </TestOutput>,
+    ).toRenderTo("123.0");
   });
 
   it("renders small positive float when hinted", () => {
-    expect(toSourceText([<py.Atom jsValue={0.07} asFloat />])).toRenderTo(
-      "0.07",
-    );
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={0.07} asFloat />
+      </TestOutput>,
+    ).toRenderTo("0.07");
   });
 
   it("renders large positive numbers as float when hinted", () => {
-    expect(toSourceText([<py.Atom jsValue={2 ** 64} asFloat />])).toRenderTo(
-      "18446744073709551616.0",
-    );
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={2 ** 64} asFloat />
+      </TestOutput>,
+    ).toRenderTo("18446744073709551616.0");
   });
 
   it("renders boolean - True", () => {
-    expect(toSourceText([<py.Atom jsValue={true} />])).toRenderTo("True");
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={true} />
+      </TestOutput>,
+    ).toRenderTo("True");
   });
 
   it("renders boolean - False", () => {
-    expect(toSourceText([<py.Atom jsValue={false} />])).toRenderTo("False");
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={false} />
+      </TestOutput>,
+    ).toRenderTo("False");
   });
 
   it("renders array", () => {
-    expect(toSourceText([<py.Atom jsValue={[1, 2, 3]} />])).toRenderTo(
-      "[1, 2, 3]",
-    );
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={[1, 2, 3]} />
+      </TestOutput>,
+    ).toRenderTo("[1, 2, 3]");
   });
 
   it("renders object", () => {
-    expect(toSourceText([<py.Atom jsValue={{ a: 1, b: 2 }} />])).toRenderTo(
-      '{"a": 1, "b": 2}',
-    );
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={{ a: 1, b: 2 }} />
+      </TestOutput>,
+    ).toRenderTo('{"a": 1, "b": 2}');
   });
 
   it("renders more complex object", () => {
     expect(
-      toSourceText([<py.Atom jsValue={{ a: "1", b: 2, c: true }} />]),
+      <TestOutput>
+        <py.Atom jsValue={{ a: "1", b: 2, c: true }} />
+      </TestOutput>,
     ).toRenderTo('{"a": "1", "b": 2, "c": True}');
   });
 
   it("renders empty object", () => {
-    expect(toSourceText([<py.Atom jsValue={{}} />])).toRenderTo("{}");
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={{}} />
+      </TestOutput>,
+    ).toRenderTo("{}");
   });
 
   it("renders function", () => {
@@ -84,12 +128,18 @@ describe("Atom", () => {
       return <>Test</>;
     }
 
-    expect(toSourceText([<py.Atom jsValue={Test} />])).toRenderTo("Test");
+    expect(
+      <TestOutput>
+        <py.Atom jsValue={Test} />
+      </TestOutput>,
+    ).toRenderTo("Test");
   });
 
   it("renders nested object", () => {
     expect(
-      toSourceText([<py.Atom jsValue={{ a: { b: { c: 1 } }, d: 2 }} />]),
+      <TestOutput>
+        <py.Atom jsValue={{ a: { b: { c: 1 } }, d: 2 }} />
+      </TestOutput>,
     ).toRenderTo('{"a": {"b": {"c": 1}}, "d": 2}');
   });
 });