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

package/dist/test/dataclassdeclarations.test.js

@@ -1,11 +1,32 @@
 import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
-import { Prose, namekey, refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { Prose, namekey, refkey, render } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { dataclassesModule } from "../src/builtins/python.js";
 import * as py from "../src/index.js";
-import { assertFileContents, toSourceText, toSourceTextMultiple } from "./utils.js";
+import { TestOutput, TestOutputDirectory } from "./utils.js";
 describe("DataclassDeclaration", () => {
+  it("stacks user decorators above @dataclass", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "user.py",
+      externals: [dataclassesModule],
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          frozen: true,
+          decorators: ["@final"]
+        });
+      }
+    })).toRenderTo(`
+        from dataclasses import dataclass
+
+
+        @final
+        @dataclass(frozen=True)
+        class User:
+            pass
+
+      `);
+  });
   it("Creates a dataclass with a class doc", () => {
     const doc = _$createComponent(py.ClassDoc, {
       get description() {
@@ -14,18 +35,16 @@ describe("DataclassDeclaration", () => {
         })];
       }
     });
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
           doc: doc
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -37,12 +56,12 @@ describe("DataclassDeclaration", () => {
 
             pass
 
-
       `);
   });
   it("Creates a dataclass with fields and defaults", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -72,10 +91,7 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
         from typing import TYPE_CHECKING
 
@@ -89,12 +105,12 @@ describe("DataclassDeclaration", () => {
             _: KW_ONLY
             name: str = "Anonymous"
 
-
       `);
   });
   it("Creates a dataclass with keyword arguments", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -111,10 +127,7 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -122,12 +135,12 @@ describe("DataclassDeclaration", () => {
         class User:
             id: int
 
-
       `);
   });
   it("Creates a dataclass with all keyword arguments", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -143,10 +156,7 @@ describe("DataclassDeclaration", () => {
           weakrefSlot: false
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -154,25 +164,24 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `);
   });
   it("Throws error when weakref_slot=True without slots=True", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
           weakrefSlot: true
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/weakref_slot=True requires slots=True in @dataclass decorator/);
+    }))).toThrowError(/weakref_slot=True requires slots=True in @dataclass decorator/);
   });
   it("Allows weakref_slot=True when slots=True", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -180,10 +189,7 @@ describe("DataclassDeclaration", () => {
           weakrefSlot: true
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -191,12 +197,12 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `);
   });
   it("Throws error when order=True and eq=False", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -204,23 +210,19 @@ describe("DataclassDeclaration", () => {
           eq: false
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/order=True requires eq=True/);
+    }))).toThrowError(/order=True requires eq=True/);
   });
   it("Creates a dataclass with order=True and no conflicting methods", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
           order: true
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -228,12 +230,12 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `);
   });
   it("Throws error when order=True and class defines __lt__", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -245,13 +247,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Cannot specify order=True when the class already defines __lt__\(\)/);
+    }))).toThrowError(/Cannot specify order=True when the class already defines __lt__\(\)/);
   });
   it("Throws error when order=True and class defines __le__", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -263,13 +264,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Cannot specify order=True when the class already defines __le__\(\)/);
+    }))).toThrowError(/Cannot specify order=True when the class already defines __le__\(\)/);
   });
   it("Throws error when order=True and class defines __gt__", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -281,13 +281,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Cannot specify order=True when the class already defines __gt__\(\)/);
+    }))).toThrowError(/Cannot specify order=True when the class already defines __gt__\(\)/);
   });
   it("Throws error when order=True and class defines __ge__", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -299,9 +298,7 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Cannot specify order=True when the class already defines __ge__\(\)/);
+    }))).toThrowError(/Cannot specify order=True when the class already defines __ge__\(\)/);
   });
   it("Throws error when order=True and a wrapper defines __lt__", () => {
     function Wrapper() {
@@ -309,8 +306,9 @@ describe("DataclassDeclaration", () => {
         name: "__lt__"
       });
     }
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -320,13 +318,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Cannot specify order=True when the class already defines __lt__\(\)/);
+    }))).toThrowError(/Cannot specify order=True when the class already defines __lt__\(\)/);
   });
   it("Throws error when unsafe_hash=True and class defines __hash__", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -338,13 +335,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Cannot specify unsafe_hash=True when the class already defines __hash__\(\)/);
+    }))).toThrowError(/Cannot specify unsafe_hash=True when the class already defines __hash__\(\)/);
   });
   it("Throws error when frozen=True and class defines __setattr__", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -356,13 +352,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Cannot specify frozen=True when the class already defines __setattr__\(\)/);
+    }))).toThrowError(/Cannot specify frozen=True when the class already defines __setattr__\(\)/);
   });
   it("Throws errorwhen frozen=True and class defines __delattr__", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -374,13 +369,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Cannot specify frozen=True when the class already defines __delattr__\(\)/);
+    }))).toThrowError(/Cannot specify frozen=True when the class already defines __delattr__\(\)/);
   });
   it("Throws error when slots=True and class defines __slots__", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -392,13 +386,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Cannot specify slots=True when the class already defines __slots__\(\)/);
+    }))).toThrowError(/Cannot specify slots=True when the class already defines __slots__\(\)/);
   });
   it("Creates a dataclass with kw_only=True on decorator (sentinel not used)", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -413,10 +406,7 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -424,22 +414,19 @@ describe("DataclassDeclaration", () => {
         class User:
             id: int
 
-
       `);
   });
   it("Creates a dataclass with base classes", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
           bases: ["Base"]
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -447,12 +434,12 @@ describe("DataclassDeclaration", () => {
         class User(Base):
             pass
 
-
       `);
   });
   it("Throws error when more than one KW_ONLY sentinel is present", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -483,13 +470,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
+    }))).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
   });
   it("Will raise arg validation errors first over member conflicts", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -502,13 +488,12 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/order=True requires eq=True/);
+    }))).toThrowError(/order=True requires eq=True/);
   });
   it("Does not raise errors for member conflict checks without the equivalent kwargs", () => {
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -527,23 +512,19 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).not.toThrow();
+    }))).not.toThrow();
   });
   it("Allows unsafe_hash=True when no __hash__ is defined", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
           unsafeHash: true
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -551,7 +532,6 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `);
   });
   it("Counts KW_ONLY sentinels through wrappers (symbol-level)", () => {
@@ -569,8 +549,9 @@ describe("DataclassDeclaration", () => {
         omitNone: true
       });
     }
-    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+    expect(() => render(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
@@ -590,23 +571,19 @@ describe("DataclassDeclaration", () => {
           }
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    })).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
+    }))).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
   });
   it("Allows frozen=True when no conflicting dunders exist", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
           frozen: true
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -614,22 +591,19 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `);
   });
   it("Allows slots=True when no __slots__ is defined", () => {
-    const res = toSourceText([_$createComponent(py.SourceFile, {
+    expect(_$createComponent(TestOutput, {
       path: "user.py",
+      externals: [dataclassesModule],
       get children() {
         return _$createComponent(py.DataclassDeclaration, {
           name: "User",
           slots: true
         });
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    expect(res).toRenderTo(d`
+    })).toRenderTo(`
         from dataclasses import dataclass
 
 
@@ -637,75 +611,76 @@ describe("DataclassDeclaration", () => {
         class User:
             pass
 
-
       `);
   });
   it("Forwards refkey prop for symbol resolution in type references", () => {
     const userRefkey = refkey();
-    const res = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "models.py",
+    expect(_$createComponent(TestOutputDirectory, {
+      externals: [dataclassesModule],
       get children() {
-        return _$createComponent(py.DataclassDeclaration, {
-          name: "User",
-          refkey: userRefkey,
+        return [_$createComponent(py.SourceFile, {
+          path: "models.py",
           get children() {
-            return [_$createComponent(py.VariableDeclaration, {
-              instanceVariable: true,
-              omitNone: true,
-              name: "id",
-              type: "int"
-            }), _$createComponent(py.VariableDeclaration, {
-              instanceVariable: true,
-              omitNone: true,
-              name: "name",
-              type: "str"
-            })];
+            return _$createComponent(py.DataclassDeclaration, {
+              name: "User",
+              refkey: userRefkey,
+              get children() {
+                return [_$createComponent(py.VariableDeclaration, {
+                  instanceVariable: true,
+                  omitNone: true,
+                  name: "id",
+                  type: "int"
+                }), _$createComponent(py.VariableDeclaration, {
+                  instanceVariable: true,
+                  omitNone: true,
+                  name: "name",
+                  type: "str"
+                })];
+              }
+            });
           }
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "services.py",
-      get children() {
-        return _$createComponent(py.FunctionDeclaration, {
-          name: "get_user",
-          returnType: userRefkey,
+        }), _$createComponent(py.SourceFile, {
+          path: "services.py",
           get children() {
-            return [_$createComponent(py.VariableDeclaration, {
-              name: "user",
-              type: userRefkey,
-              get initializer() {
-                return _$createComponent(py.ClassInstantiation, {
-                  target: userRefkey,
-                  args: ["1", '"Alice"']
-                });
+            return _$createComponent(py.FunctionDeclaration, {
+              name: "get_user",
+              returnType: userRefkey,
+              get children() {
+                return [_$createComponent(py.VariableDeclaration, {
+                  name: "user",
+                  type: userRefkey,
+                  get initializer() {
+                    return _$createComponent(py.ClassInstantiation, {
+                      target: userRefkey,
+                      args: ["1", '"Alice"']
+                    });
+                  }
+                }), _$createIntrinsic("hbr", {}), "return user"];
               }
-            }), _$createIntrinsic("hbr", {}), "return user"];
+            });
           }
-        });
+        })];
       }
-    })], {
-      externals: [dataclassesModule]
-    });
-    assertFileContents(res, {
+    })).toRenderTo({
       "models.py": `
-        from dataclasses import dataclass
+          from dataclasses import dataclass
 
 
-        @dataclass
-        class User:
-            id: int
-            name: str
+          @dataclass
+          class User:
+              id: int
+              name: str
 
-        `,
+          `,
       "services.py": `
-        from models import User
+          from models import User
 
 
-        def get_user() -> User:
-            user: User = User(1, "Alice")
-            return user
+          def get_user() -> User:
+              user: User = User(1, "Alice")
+              return user
 
-        `
+          `
     });
   });
 });