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

package/dist/test/classdeclarations.test.js

@@ -1,93 +1,105 @@
 import { createComponent as _$createComponent, memo as _$memo } from "@alloy-js/core/jsx-runtime";
 import { memberRefkey, 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 { assertFileContents, toSourceText, toSourceTextMultiple } from "./utils.js";
+import { TestOutput, TestOutputDirectory } from "./utils.js";
 describe("Python Class", () => {
   it("renders class-level decorators above `class`", () => {
-    const result = toSourceText([_$createComponent(py.ClassDeclaration, {
-      name: "Foo",
-      decorators: ["@final", "@deprecated('use Bar')"]
-    })]);
-    expect(result).toRenderTo(d`
+    expect(_$createComponent(TestOutput, {
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "Foo",
+          decorators: ["@final", "@deprecated('use Bar')"]
+        });
+      }
+    })).toRenderTo(`
       @final
       @deprecated('use Bar')
       class Foo:
           pass
 
-
     `);
   });
   it("renders nothing extra when decorators is undefined", () => {
-    const result = toSourceText([_$createComponent(py.ClassDeclaration, {
-      name: "Foo"
-    })]);
-    expect(result).toRenderTo(d`
+    expect(_$createComponent(TestOutput, {
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "Foo"
+        });
+      }
+    })).toRenderTo(`
       class Foo:
           pass
 
-
     `);
   });
   it("renders a class with no body as 'pass'", () => {
-    const result = toSourceText([_$createComponent(py.ClassDeclaration, {
-      name: "Foo"
-    })]);
-    expect(result).toRenderTo(d`
+    expect(_$createComponent(TestOutput, {
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "Foo"
+        });
+      }
+    })).toRenderTo(`
       class Foo:
           pass
 
-
     `);
   });
   it("takes a namekey", () => {
-    const result = toSourceText([_$createComponent(py.ClassDeclaration, {
-      get name() {
-        return namekey("Foo");
+    expect(_$createComponent(TestOutput, {
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          get name() {
+            return namekey("Foo");
+          }
+        });
       }
-    })]);
-    expect(result).toRenderTo(d`
+    })).toRenderTo(`
       class Foo:
           pass
 
-
     `);
   });
   it("renders a class with a body", () => {
-    const result = toSourceText([_$createComponent(py.ClassDeclaration, {
-      name: "Bar",
-      children: "print('hi')"
-    })]);
-    expect(result).toRenderTo(d`
+    expect(_$createComponent(TestOutput, {
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "Bar",
+          children: "print('hi')"
+        });
+      }
+    })).toRenderTo(`
       class Bar:
           print('hi')
 
-
     `);
   });
   it("renders a class with base classes", () => {
-    const result = toSourceText([_$createComponent(py.StatementList, {
+    expect(_$createComponent(TestOutput, {
       get children() {
-        return [_$createComponent(py.ClassDeclaration, {
-          name: "Base1",
-          get refkey() {
-            return refkey("Base1");
-          }
-        }), _$createComponent(py.ClassDeclaration, {
-          name: "Base2",
-          get refkey() {
-            return refkey("Base2");
-          }
-        }), _$createComponent(py.ClassDeclaration, {
-          name: "Baz",
-          get bases() {
-            return [refkey("Base1"), refkey("Base2")];
+        return _$createComponent(py.StatementList, {
+          get children() {
+            return [_$createComponent(py.ClassDeclaration, {
+              name: "Base1",
+              get refkey() {
+                return refkey("Base1");
+              }
+            }), _$createComponent(py.ClassDeclaration, {
+              name: "Base2",
+              get refkey() {
+                return refkey("Base2");
+              }
+            }), _$createComponent(py.ClassDeclaration, {
+              name: "Baz",
+              get bases() {
+                return [refkey("Base1"), refkey("Base2")];
+              }
+            })];
           }
-        })];
+        });
       }
-    })]);
-    const expected = d`
+    })).toRenderTo(`
       class Base1:
           pass
 
@@ -97,123 +109,119 @@ describe("Python Class", () => {
       class Baz(Base1, Base2):
           pass
 
-        
-    `;
-    expect(result).toRenderTo(expected);
+    `);
   });
   it("renders a class with base classes and body", () => {
-    const result = toSourceText([_$createComponent(py.ClassDeclaration, {
-      name: "Qux",
-      bases: ["Base"],
-      children: "print('hello')"
-    })]);
-    expect(result).toRenderTo(d`
+    expect(_$createComponent(TestOutput, {
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "Qux",
+          bases: ["Base"],
+          children: "print('hello')"
+        });
+      }
+    })).toRenderTo(`
       class Qux(Base):
           print('hello')
 
-
     `);
   });
   it("renders classes across modules with inheritance", () => {
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "mod1.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "A",
-          get refkey() {
-            return refkey("A");
+        return [_$createComponent(py.SourceFile, {
+          path: "mod1.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "A",
+              get refkey() {
+                return refkey("A");
+              }
+            });
           }
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "folder/mod2.py",
-      get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "B",
-          get refkey() {
-            return refkey("B");
-          },
-          get bases() {
-            return [refkey("A")];
+        }), _$createComponent(py.SourceFile, {
+          path: "folder/mod2.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "B",
+              get refkey() {
+                return refkey("B");
+              },
+              get bases() {
+                return [refkey("A")];
+              }
+            });
           }
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "mod3.py",
-      get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "C",
-          get bases() {
-            return [refkey("B")];
+        }), _$createComponent(py.SourceFile, {
+          path: "mod3.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "C",
+              get bases() {
+                return [refkey("B")];
+              }
+            });
           }
-        });
+        })];
       }
-    })]);
-    const mod1Expected = d`
-      class A:
-          pass
-
-
-    `;
-    const mod2Expected = d`
-      from mod1 import A
-
+    })).toRenderTo({
+      "mod1.py": `
+          class A:
+              pass
 
-      class B(A):
-          pass
+        `,
+      "folder/mod2.py": `
+          from mod1 import A
 
 
-    `;
-    const mod3Expected = d`
-      from folder.mod2 import B
+          class B(A):
+              pass
 
+        `,
+      "mod3.py": `
+          from folder.mod2 import B
 
-      class C(B):
-          pass
 
+          class C(B):
+              pass
 
-    `;
-    assertFileContents(result, {
-      "mod1.py": mod1Expected
-    });
-    assertFileContents(result, {
-      "folder/mod2.py": mod2Expected
-    });
-    assertFileContents(result, {
-      "mod3.py": mod3Expected
+        `
     });
   });
   it("renders a class with class variables like foo: str, and also bar: A where A is another class", () => {
-    const result = toSourceText([_$createComponent(py.StatementList, {
+    expect(_$createComponent(TestOutput, {
       get children() {
-        return [_$createComponent(py.ClassDeclaration, {
-          name: "A",
-          get refkey() {
-            return refkey("A");
-          }
-        }), _$createComponent(py.ClassDeclaration, {
-          name: "B",
+        return _$createComponent(py.StatementList, {
           get children() {
-            return _$createComponent(py.StatementList, {
+            return [_$createComponent(py.ClassDeclaration, {
+              name: "A",
+              get refkey() {
+                return refkey("A");
+              }
+            }), _$createComponent(py.ClassDeclaration, {
+              name: "B",
               get children() {
-                return [_$createComponent(py.VariableDeclaration, {
-                  name: "bar",
-                  get type() {
-                    return refkey("A");
-                  },
-                  omitNone: true
-                }), _$createComponent(py.VariableDeclaration, {
-                  name: "foo",
-                  type: "str",
-                  omitNone: true
-                })];
+                return _$createComponent(py.StatementList, {
+                  get children() {
+                    return [_$createComponent(py.VariableDeclaration, {
+                      name: "bar",
+                      get type() {
+                        return refkey("A");
+                      },
+                      omitNone: true
+                    }), _$createComponent(py.VariableDeclaration, {
+                      name: "foo",
+                      type: "str",
+                      omitNone: true
+                    })];
+                  }
+                });
               }
-            });
+            })];
           }
-        })];
+        });
       }
-    })]);
-    const expected = d`
+    })).toRenderTo(`
       class A:
           pass
 
@@ -221,47 +229,48 @@ describe("Python Class", () => {
           bar: A
           foo: str
 
-
-    `;
-    expect(result).toRenderTo(expected);
+    `);
   });
   it("renders a class with class variables like foo: str, and another identical class", () => {
     const fooKey = refkey();
     const barKey = refkey();
-    const result = toSourceText([_$createComponent(py.StatementList, {
+    expect(_$createComponent(TestOutput, {
       get children() {
-        return [_$createComponent(py.ClassDeclaration, {
-          name: "A",
+        return _$createComponent(py.StatementList, {
           get children() {
-            return _$createComponent(py.StatementList, {
+            return [_$createComponent(py.ClassDeclaration, {
+              name: "A",
               get children() {
-                return _$createComponent(py.VariableDeclaration, {
-                  name: "foo",
-                  type: "str",
-                  refkey: fooKey,
-                  omitNone: true
+                return _$createComponent(py.StatementList, {
+                  get children() {
+                    return _$createComponent(py.VariableDeclaration, {
+                      name: "foo",
+                      type: "str",
+                      refkey: fooKey,
+                      omitNone: true
+                    });
+                  }
                 });
               }
-            });
-          }
-        }), _$createComponent(py.ClassDeclaration, {
-          name: "B",
-          get children() {
-            return _$createComponent(py.StatementList, {
+            }), _$createComponent(py.ClassDeclaration, {
+              name: "B",
               get children() {
-                return _$createComponent(py.VariableDeclaration, {
-                  name: "foo",
-                  type: "str",
-                  refkey: barKey,
-                  omitNone: true
+                return _$createComponent(py.StatementList, {
+                  get children() {
+                    return _$createComponent(py.VariableDeclaration, {
+                      name: "foo",
+                      type: "str",
+                      refkey: barKey,
+                      omitNone: true
+                    });
+                  }
                 });
               }
-            });
+            }), fooKey, barKey];
           }
-        }), fooKey, barKey];
+        });
       }
-    })]);
-    const expected = d`
+    })).toRenderTo(`
       class A:
           foo: str
 
@@ -270,53 +279,55 @@ describe("Python Class", () => {
 
       A.foo
       B.foo
-    `;
-    expect(result).toRenderTo(expected);
+    `);
   });
 });
 describe("Python Class - VariableDeclaration", () => {
   it("renders a class with class fields", () => {
-    const result = toSourceText([_$createComponent(py.StatementList, {
+    expect(_$createComponent(TestOutput, {
       get children() {
-        return [_$createComponent(py.ClassDeclaration, {
-          get refkey() {
-            return refkey("Base");
-          },
-          name: "Base"
-        }), _$createComponent(py.ClassDeclaration, {
-          get refkey() {
-            return refkey("A");
-          },
-          name: "A",
+        return _$createComponent(py.StatementList, {
           get children() {
-            return _$createComponent(py.StatementList, {
+            return [_$createComponent(py.ClassDeclaration, {
+              get refkey() {
+                return refkey("Base");
+              },
+              name: "Base"
+            }), _$createComponent(py.ClassDeclaration, {
+              get refkey() {
+                return refkey("A");
+              },
+              name: "A",
               get children() {
-                return [_$createComponent(py.VariableDeclaration, {
-                  instanceVariable: true,
-                  name: "just_name"
-                }), _$createComponent(py.VariableDeclaration, {
-                  name: "name_and_type",
-                  type: "number",
-                  instanceVariable: true
-                }), _$createComponent(py.VariableDeclaration, {
-                  instanceVariable: true,
-                  name: "name_type_and_value",
-                  type: "number",
-                  initializer: 12
-                }), _$createComponent(py.VariableDeclaration, {
-                  instanceVariable: true,
-                  name: "class_based",
-                  get type() {
-                    return refkey("Base");
+                return _$createComponent(py.StatementList, {
+                  get children() {
+                    return [_$createComponent(py.VariableDeclaration, {
+                      instanceVariable: true,
+                      name: "just_name"
+                    }), _$createComponent(py.VariableDeclaration, {
+                      name: "name_and_type",
+                      type: "number",
+                      instanceVariable: true
+                    }), _$createComponent(py.VariableDeclaration, {
+                      instanceVariable: true,
+                      name: "name_type_and_value",
+                      type: "number",
+                      initializer: 12
+                    }), _$createComponent(py.VariableDeclaration, {
+                      instanceVariable: true,
+                      name: "class_based",
+                      get type() {
+                        return refkey("Base");
+                      }
+                    })];
                   }
-                })];
+                });
               }
-            });
+            })];
           }
-        })];
+        });
       }
-    })]);
-    const expected = d`
+    })).toRenderTo(`
       class Base:
           pass
 
@@ -326,74 +337,75 @@ describe("Python Class - VariableDeclaration", () => {
           name_type_and_value: number = 12
           class_based: Base = None
 
-
-    `;
-    expect(result).toRenderTo(expected);
+    `);
   });
   it("correctly access members of its type", () => {
     const classRk = refkey();
     const classMemberRk = refkey();
     const classMethodRk = refkey();
     const v1Rk = refkey();
-    const res = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "inst.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return _$createComponent(py.StatementList, {
+        return [_$createComponent(py.SourceFile, {
+          path: "inst.py",
           get children() {
-            return [_$createComponent(py.VariableDeclaration, {
-              name: "one",
-              refkey: v1Rk,
-              type: classRk,
-              get initializer() {
-                return _$createComponent(py.ClassInstantiation, {
-                  target: classRk
-                });
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return [_$createComponent(py.VariableDeclaration, {
+                  name: "one",
+                  refkey: v1Rk,
+                  type: classRk,
+                  get initializer() {
+                    return _$createComponent(py.ClassInstantiation, {
+                      target: classRk
+                    });
+                  }
+                }), [_$memo(() => memberRefkey(v1Rk, classMemberRk))], [_$memo(() => memberRefkey(v1Rk, classMethodRk)), "()"]];
               }
-            }), [_$memo(() => memberRefkey(v1Rk, classMemberRk))], [_$memo(() => memberRefkey(v1Rk, classMethodRk)), "()"]];
+            });
           }
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "decl.py",
-      get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "Bar",
-          refkey: classRk,
+        }), _$createComponent(py.SourceFile, {
+          path: "decl.py",
           get children() {
-            return _$createComponent(py.StatementList, {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "Bar",
+              refkey: classRk,
               get children() {
-                return [_$createComponent(py.VariableDeclaration, {
-                  name: "instanceProp",
-                  refkey: classMemberRk,
-                  initializer: 42,
-                  instanceVariable: true
-                }), _$createComponent(py.MethodDeclaration, {
-                  name: "instanceMethod",
-                  refkey: classMethodRk,
-                  returnType: "int"
-                })];
+                return _$createComponent(py.StatementList, {
+                  get children() {
+                    return [_$createComponent(py.VariableDeclaration, {
+                      name: "instanceProp",
+                      refkey: classMemberRk,
+                      initializer: 42,
+                      instanceVariable: true
+                    }), _$createComponent(py.MethodDeclaration, {
+                      name: "instanceMethod",
+                      refkey: classMethodRk,
+                      returnType: "int"
+                    })];
+                  }
+                });
               }
             });
           }
-        });
+        })];
       }
-    })]);
-    assertFileContents(res, {
+    })).toRenderTo({
       "inst.py": `
-        from decl import Bar
+          from decl import Bar
 
-        one: Bar = Bar()
-        one.instance_prop
-        one.instance_method()
-      `,
+          one: Bar = Bar()
+          one.instance_prop
+          one.instance_method()
+        `,
       "decl.py": `
-        class Bar:
-            instance_prop = 42
-            def instance_method(self) -> int:
-                pass
+          class Bar:
+              instance_prop = 42
+              def instance_method(self) -> int:
+                  pass
 
 
-      `
+        `
     });
   });
 });
@@ -402,52 +414,55 @@ describe("Python Class - FunctionDeclaration", () => {
     const methodRefkey = refkey();
     const classMethodRefkey = refkey();
     const staticMethodRefkey = refkey();
-    const result = toSourceText([_$createComponent(py.StatementList, {
+    expect(_$createComponent(TestOutput, {
       get children() {
-        return [_$createComponent(py.ClassDeclaration, {
-          name: "MyClass",
-          bases: ["BaseClass"],
+        return _$createComponent(py.StatementList, {
           get children() {
-            return _$createComponent(py.StatementList, {
+            return [_$createComponent(py.ClassDeclaration, {
+              name: "MyClass",
+              bases: ["BaseClass"],
               get children() {
-                return [_$createComponent(py.VariableDeclaration, {
-                  name: "a",
-                  type: "int",
-                  instanceVariable: true
-                }), _$createComponent(py.VariableDeclaration, {
-                  name: "b",
-                  type: "int",
-                  instanceVariable: true
-                }), _$createComponent(py.MethodDeclaration, {
-                  name: "my_method",
-                  parameters: [{
-                    name: "a",
-                    type: "int"
-                  }, {
-                    name: "b",
-                    type: "int"
-                  }],
-                  returnType: "int",
-                  refkey: methodRefkey,
-                  children: "return a + b"
-                }), _$createComponent(py.ClassMethodDeclaration, {
-                  name: "my_class_method",
-                  returnType: "int",
-                  refkey: classMethodRefkey,
-                  children: "pass"
-                }), _$createComponent(py.FunctionDeclaration, {
-                  name: "my_standalone_function",
-                  returnType: "int",
-                  refkey: staticMethodRefkey,
-                  children: "pass"
-                })];
+                return _$createComponent(py.StatementList, {
+                  get children() {
+                    return [_$createComponent(py.VariableDeclaration, {
+                      name: "a",
+                      type: "int",
+                      instanceVariable: true
+                    }), _$createComponent(py.VariableDeclaration, {
+                      name: "b",
+                      type: "int",
+                      instanceVariable: true
+                    }), _$createComponent(py.MethodDeclaration, {
+                      name: "my_method",
+                      parameters: [{
+                        name: "a",
+                        type: "int"
+                      }, {
+                        name: "b",
+                        type: "int"
+                      }],
+                      returnType: "int",
+                      refkey: methodRefkey,
+                      children: "return a + b"
+                    }), _$createComponent(py.ClassMethodDeclaration, {
+                      name: "my_class_method",
+                      returnType: "int",
+                      refkey: classMethodRefkey,
+                      children: "pass"
+                    }), _$createComponent(py.FunctionDeclaration, {
+                      name: "my_standalone_function",
+                      returnType: "int",
+                      refkey: staticMethodRefkey,
+                      children: "pass"
+                    })];
+                  }
+                });
               }
-            });
+            }), classMethodRefkey, staticMethodRefkey];
           }
-        }), classMethodRefkey, staticMethodRefkey];
+        });
       }
-    })]);
-    const expected = d`
+    })).toRenderTo(`
       class MyClass(BaseClass):
           a: int = None
           b: int = None
@@ -464,8 +479,7 @@ describe("Python Class - FunctionDeclaration", () => {
       
       MyClass.my_class_method
       MyClass.my_standalone_function
-    `;
-    expect(result).toRenderTo(expected);
+    `);
   });
 });
 //# sourceMappingURL=classdeclarations.test.js.map