@alloy-js/python 0.4.0-dev.3 → 0.4.0-dev.6

package/dist/dev/test/functiondeclaration.test.js

@@ -0,0 +1,817 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { code, namekey, 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 { abcModule } from "../src/index.js";
+import { assertFileContents, toSourceText, toSourceTextMultiple } from "./utils.js";
+describe("Function Declaration", () => {
+  it("renders a function with no body as 'pass'", () => {
+    const result = toSourceText([_$createComponent(py.FunctionDeclaration, {
+      name: "foo"
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 14,
+      columnNumber: 34
+    })]);
+    expect(result).toRenderTo(d`
+      def foo():
+          pass
+
+        
+    `);
+  });
+  it("takes a namekey", () => {
+    const result = toSourceText([_$createComponent(py.FunctionDeclaration, {
+      get name() {
+        return namekey("foo-bar");
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 25,
+      columnNumber: 7
+    })]);
+    expect(result).toRenderTo(d`
+      def foo_bar():
+          pass
+
+
+    `);
+  });
+  it("renders a function with no body as 'pass' with return type", () => {
+    const result = toSourceText([_$createComponent(py.FunctionDeclaration, {
+      name: "foo",
+      returnType: "int"
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 37,
+      columnNumber: 7
+    })]);
+    expect(result).toRenderTo(d`
+      def foo() -> int:
+          pass
+
+
+    `);
+  });
+  it("renders a function that calls another function", () => {
+    const refkeyFoo = refkey();
+    const result = toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.FunctionDeclaration, {
+          name: "foo",
+          returnType: "int",
+          refkey: refkeyFoo
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 51,
+          columnNumber: 9
+        }), _$createComponent(py.FunctionDeclaration, {
+          name: "bar",
+          returnType: "int",
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              name: "result",
+              type: "int",
+              get initializer() {
+                return _$createComponent(py.FunctionCallExpression, {
+                  target: refkeyFoo,
+                  args: []
+                }, {
+                  fileName: import.meta.url,
+                  lineNumber: 61,
+                  columnNumber: 15
+                });
+              }
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 57,
+              columnNumber: 11
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 56,
+          columnNumber: 9
+        })];
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 50,
+      columnNumber: 7
+    })]);
+    expect(result).toRenderTo(d`
+      def foo() -> int:
+          pass
+
+      def bar() -> int:
+          result: int = foo()
+
+
+    `);
+  });
+  it("renders a function with parameters", () => {
+    const result = toSourceText([_$createComponent(py.FunctionDeclaration, {
+      name: "baz",
+      parameters: [{
+        name: "x",
+        type: "int"
+      }, {
+        name: "y",
+        default: 0
+      }, {
+        name: "z",
+        type: "int",
+        default: 42
+      }],
+      args: true,
+      kwargs: true,
+      children: "print(x, y)"
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 80,
+      columnNumber: 7
+    })]);
+    expect(result).toRenderTo(d`
+        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([_$createComponent(py.ClassDeclaration, {
+      name: "MyClass",
+      get children() {
+        return _$createComponent(py.DunderMethodDeclaration, {
+          name: "__init__",
+          parameters: [{
+            name: "x"
+          }]
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 106,
+          columnNumber: 9
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 105,
+      columnNumber: 7
+    })]);
+    expect(result).toRenderTo(d`
+      class MyClass:
+          def __init__(self, x):
+              pass
+
+      
+      
+    `);
+  });
+  it("can be an async function", () => {
+    expect(toSourceText([_$createComponent(py.FunctionDeclaration, {
+      async: true,
+      name: "foo"
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 123,
+      columnNumber: 26
+    })])).toBe(d`
+      async def foo():
+          pass
+
+    `);
+  });
+  it("can be an async function with returnType", () => {
+    expect(toSourceText([_$createComponent(py.FunctionDeclaration, {
+      async: true,
+      name: "foo",
+      returnType: "Foo"
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 133,
+      columnNumber: 9
+    })])).toBe(d`
+      async def foo() -> Foo:
+          pass
+
+    `);
+  });
+  it("can be an async function with returnType element with Reference", () => {
+    expect(toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "Foo",
+          get refkey() {
+            return refkey("Foo");
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 146,
+          columnNumber: 11
+        }), _$createComponent(py.FunctionDeclaration, {
+          async: true,
+          name: "foo",
+          get returnType() {
+            return refkey("Foo");
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 147,
+          columnNumber: 11
+        })];
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 145,
+      columnNumber: 9
+    })])).toBe(d`
+      class Foo:
+          pass
+
+      async def foo() -> Foo:
+          pass
+
+    `);
+  });
+  it("can be an async function with returnType element with list of References", () => {
+    expect(toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "Foo",
+          get refkey() {
+            return refkey("Foo");
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 164,
+          columnNumber: 11
+        }), _$createComponent(py.FunctionDeclaration, {
+          async: true,
+          name: "foo",
+          get returnType() {
+            return code`list[${refkey("Foo")}]`;
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 165,
+          columnNumber: 11
+        })];
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 163,
+      columnNumber: 9
+    })])).toBe(d`
+      class Foo:
+          pass
+
+      async def foo() -> list[Foo]:
+          pass
+
+    `);
+  });
+  it("can be an async dunder method", () => {
+    const decl = _$createComponent(py.StatementList, {
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "MyClass",
+          get children() {
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return _$createComponent(py.DunderMethodDeclaration, {
+                  async: true,
+                  name: "__aenter__",
+                  returnType: "MyClass",
+                  children: "return self"
+                }, {
+                  fileName: import.meta.url,
+                  lineNumber: 187,
+                  columnNumber: 13
+                });
+              }
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 186,
+              columnNumber: 11
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 185,
+          columnNumber: 9
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 184,
+      columnNumber: 7
+    });
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          async def __aenter__(self) -> MyClass:
+              return self
+
+
+    `);
+  });
+  it("can be an async constructor", () => {
+    const decl = _$createComponent(py.StatementList, {
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "MyClass",
+          get children() {
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return _$createComponent(py.ConstructorDeclaration, {
+                  async: true,
+                  returnType: "MyClass",
+                  children: "return super().__new__(cls)"
+                }, {
+                  fileName: import.meta.url,
+                  lineNumber: 213,
+                  columnNumber: 13
+                });
+              }
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 212,
+              columnNumber: 11
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 211,
+          columnNumber: 9
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 210,
+      columnNumber: 7
+    });
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          async def __new__(cls) -> MyClass:
+              return super().__new__(cls)
+
+
+    `);
+  });
+  it("supports parameters", () => {
+    const decl = _$createComponent(py.FunctionDeclaration, {
+      name: "foo",
+      parameters: [{
+        name: "a"
+      }, {
+        name: "b"
+      }],
+      children: "return a + b"
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 232,
+      columnNumber: 7
+    });
+    expect(toSourceText([decl])).toBe(d`
+      def foo(a, b):
+          return a + b
+
+    `);
+  });
+  it("supports type parameters", () => {
+    const decl = _$createComponent(py.FunctionDeclaration, {
+      name: "foo",
+      parameters: [{
+        name: "a"
+      }, {
+        name: "b"
+      }],
+      typeParameters: ["T", "U"],
+      children: "return a + b"
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 248,
+      columnNumber: 7
+    });
+    expect(toSourceText([decl])).toBe(d`
+      def foo[T, U](a, b):
+          return a + b
+
+    `);
+  });
+  it("renders abstract methods", () => {
+    const parameters = [{
+      name: "x",
+      type: "int"
+    }];
+    const decl = _$createComponent(py.StatementList, {
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "MyClass",
+          get children() {
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return [_$createComponent(py.MethodDeclaration, {
+                  name: "methoddef",
+                  parameters: parameters,
+                  abstract: true
+                }, {
+                  fileName: import.meta.url,
+                  lineNumber: 269,
+                  columnNumber: 13
+                }), _$createComponent(py.ClassMethodDeclaration, {
+                  name: "classdef",
+                  parameters: parameters,
+                  abstract: true
+                }, {
+                  fileName: import.meta.url,
+                  lineNumber: 274,
+                  columnNumber: 13
+                }), _$createComponent(py.StaticMethodDeclaration, {
+                  name: "staticdef",
+                  parameters: parameters,
+                  abstract: true
+                }, {
+                  fileName: import.meta.url,
+                  lineNumber: 279,
+                  columnNumber: 13
+                })];
+              }
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 268,
+              columnNumber: 11
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 267,
+          columnNumber: 9
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 266,
+      columnNumber: 7
+    });
+    expect(toSourceText([decl], {
+      externals: [abcModule]
+    })).toBe(d`
+      from abc import abstractmethod
+
+
+      class MyClass:
+          @abstractmethod
+          def methoddef(self, x: int):
+              pass
+
+          @classmethod
+          @abstractmethod
+          def classdef(cls, x: int):
+              pass
+
+          @staticmethod
+          @abstractmethod
+          def staticdef(x: int):
+              pass
+
+
+    `);
+  });
+  it("renders dunder methods with parameters", () => {
+    const parameters = [{
+      name: "x",
+      type: "int"
+    }];
+    const decl = _$createComponent(py.ClassDeclaration, {
+      name: "MyClass",
+      get children() {
+        return _$createComponent(py.StatementList, {
+          get children() {
+            return [_$createComponent(py.DunderMethodDeclaration, {
+              name: "__init__",
+              parameters: parameters,
+              children: "self.attribute = \"value\""
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 316,
+              columnNumber: 11
+            }), _$createComponent(py.DunderMethodDeclaration, {
+              name: "__repr__",
+              parameters: parameters,
+              children: "return \"MyClass\""
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 319,
+              columnNumber: 11
+            })];
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 315,
+          columnNumber: 9
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 314,
+      columnNumber: 7
+    });
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          def __init__(self, x: int):
+              self.attribute = "value"
+
+          def __repr__(self, x: int):
+              return "MyClass"
+
+
+    `);
+  });
+  it("renders dunder methods __new__", () => {
+    const decl = _$createComponent(py.ClassDeclaration, {
+      name: "MyClass",
+      get children() {
+        return _$createComponent(py.StatementList, {
+          get children() {
+            return _$createComponent(py.ConstructorDeclaration, {
+              args: true,
+              kwargs: true,
+              children: "pass"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 342,
+              columnNumber: 11
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 341,
+          columnNumber: 9
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 340,
+      columnNumber: 7
+    });
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          def __new__(cls, *args, **kwargs):
+              pass
+
+
+    `);
+  });
+  it("renders nested functions", () => {
+    const parameters = [{
+      name: "x",
+      type: "int"
+    }];
+    const parameters_nested = [{
+      name: "y",
+      type: "int"
+    }];
+    const parameters_nested_nested = [{
+      name: "z",
+      type: "int"
+    }];
+    const fooRef = refkey();
+    const barRef = refkey();
+    const foobarRef = refkey();
+    const decl = _$createComponent(py.FunctionDeclaration, {
+      name: "foo",
+      parameters: parameters,
+      refkey: fooRef,
+      get children() {
+        return [_$createComponent(py.FunctionDeclaration, {
+          name: "bar",
+          parameters: parameters_nested,
+          refkey: barRef,
+          get children() {
+            return [_$createComponent(py.FunctionDeclaration, {
+              name: "foobar",
+              parameters: parameters_nested_nested,
+              refkey: foobarRef,
+              children: "return z * 2"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 376,
+              columnNumber: 11
+            }), "return", " ", _$createComponent(py.FunctionCallExpression, {
+              target: foobarRef,
+              get args() {
+                return [_$createComponent(py.Atom, {
+                  jsValue: 2
+                }, {
+                  fileName: import.meta.url,
+                  lineNumber: 386,
+                  columnNumber: 20
+                })];
+              }
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 384,
+              columnNumber: 11
+            })];
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 371,
+          columnNumber: 9
+        }), "return", " ", _$createComponent(py.FunctionCallExpression, {
+          target: barRef,
+          get args() {
+            return [_$createComponent(py.Atom, {
+              jsValue: 3
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 392,
+              columnNumber: 18
+            })];
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 390,
+          columnNumber: 9
+        })];
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 366,
+      columnNumber: 7
+    });
+    expect(toSourceText([decl])).toBe(d`
+      def foo(x: int):
+          def bar(y: int):
+              def foobar(z: int):
+                  return z * 2
+              return foobar(2)
+          return bar(3)
+
+    `);
+  });
+  it("renders complex typing structure", () => {
+    const res = toSourceTextMultiple([_$createComponent(py.SourceFile, {
+      path: "mod1.py",
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "Foo",
+          get refkey() {
+            return refkey("Foo");
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 410,
+          columnNumber: 9
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 409,
+      columnNumber: 7
+    }), _$createComponent(py.SourceFile, {
+      path: "mod2.py",
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "A",
+          get refkey() {
+            return refkey("A");
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 413,
+          columnNumber: 9
+        }), _$createComponent(py.ClassDeclaration, {
+          name: "B",
+          get refkey() {
+            return refkey("B");
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 414,
+          columnNumber: 9
+        })];
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 412,
+      columnNumber: 7
+    }), _$createComponent(py.SourceFile, {
+      path: "usage.py",
+      get children() {
+        return _$createComponent(py.FunctionDeclaration, {
+          async: true,
+          name: "foo",
+          get parameters() {
+            return [{
+              name: "x",
+              type: refkey("A")
+            }, {
+              name: "y",
+              type: refkey("B")
+            }];
+          },
+          args: true,
+          kwargs: true,
+          get returnType() {
+            return refkey("Foo");
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 417,
+          columnNumber: 9
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 416,
+      columnNumber: 7
+    })]);
+    assertFileContents(res, {
+      "mod1.py": `
+            class Foo:
+                pass
+
+            `,
+      "mod2.py": `
+            class A:
+                pass
+
+
+            class B:
+                pass
+
+            `,
+      "usage.py": `
+            from typing import TYPE_CHECKING
+
+            if TYPE_CHECKING:
+                from mod1 import Foo
+                from mod2 import A
+                from mod2 import B
+
+
+            async def foo(x: A, y: B, *args, **kwargs) -> Foo:
+                pass
+
+            `
+    });
+  });
+  it("throws error when PropertyDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([_$createComponent(py.PropertyDeclaration, {
+        name: "x"
+      }, {
+        fileName: import.meta.url,
+        lineNumber: 470,
+        columnNumber: 21
+      })]);
+    }).toThrow('Method "x" must be declared inside a class (member scope)');
+  });
+  it("throws error when MethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([_$createComponent(py.MethodDeclaration, {
+        name: "my_method"
+      }, {
+        fileName: import.meta.url,
+        lineNumber: 476,
+        columnNumber: 21
+      })]);
+    }).toThrow('Method "my_method" must be declared inside a class (member scope)');
+  });
+  it("throws error when ClassMethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([_$createComponent(py.ClassMethodDeclaration, {
+        name: "my_class_method"
+      }, {
+        fileName: import.meta.url,
+        lineNumber: 484,
+        columnNumber: 21
+      })]);
+    }).toThrow('Method "my_class_method" must be declared inside a class (member scope)');
+  });
+  it("throws error when StaticMethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([_$createComponent(py.StaticMethodDeclaration, {
+        name: "my_static_method"
+      }, {
+        fileName: import.meta.url,
+        lineNumber: 492,
+        columnNumber: 21
+      })]);
+    }).toThrow('Method "my_static_method" must be declared inside a class (member scope)');
+  });
+  it("throws error when DunderMethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([_$createComponent(py.DunderMethodDeclaration, {
+        name: "__init__"
+      }, {
+        fileName: import.meta.url,
+        lineNumber: 500,
+        columnNumber: 21
+      })]);
+    }).toThrow('Method "__init__" must be declared inside a class (member scope)');
+  });
+});
+//# sourceMappingURL=functiondeclaration.test.js.map