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

package/dist/test/type-checking-imports.test.js

@@ -1,377 +1,390 @@
 import { createComponent as _$createComponent, memo as _$memo } from "@alloy-js/core/jsx-runtime";
 import { refkey } from "@alloy-js/core";
-import { describe, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import { createModule } from "../src/create-module.js";
 import * as py from "../src/index.js";
-import { assertFileContents, toSourceTextMultiple } from "./utils.js";
+import { TestOutputDirectory } from "./utils.js";
 describe("TYPE_CHECKING imports", () => {
   it("imports type-only references inside TYPE_CHECKING block", () => {
     const userClassRef = refkey();
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "models.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "User",
-          refkey: userClassRef
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "service.py",
-      get children() {
-        return _$createComponent(py.FunctionDeclaration, {
-          name: "process_user",
-          parameters: [{
-            name: "user",
-            type: userClassRef
-          }],
-          returnType: "None",
-          children: "pass"
-        });
+        return [_$createComponent(py.SourceFile, {
+          path: "models.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "User",
+              refkey: userClassRef
+            });
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "service.py",
+          get children() {
+            return _$createComponent(py.FunctionDeclaration, {
+              name: "process_user",
+              parameters: [{
+                name: "user",
+                type: userClassRef
+              }],
+              returnType: "None",
+              children: "pass"
+            });
+          }
+        })];
       }
-    })]);
-    assertFileContents(result, {
+    })).toRenderTo({
       "models.py": `
-        class User:
-            pass
+          class User:
+              pass
 
-        `,
+          `,
       "service.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from models import User
+          if TYPE_CHECKING:
+              from models import User
 
 
-        def process_user(user: User) -> None:
-            pass
+          def process_user(user: User) -> None:
+              pass
 
-        `
+          `
     });
   });
   it("imports value references outside TYPE_CHECKING block", () => {
     const userClassRef = refkey();
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "models.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "User",
-          refkey: userClassRef
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "service.py",
-      get children() {
-        return _$createComponent(py.FunctionDeclaration, {
-          name: "create_user",
-          returnType: "None",
+        return [_$createComponent(py.SourceFile, {
+          path: "models.py",
           get children() {
-            return _$createComponent(py.VariableDeclaration, {
-              name: "user",
-              get initializer() {
-                return _$createComponent(py.ClassInstantiation, {
-                  target: userClassRef
+            return _$createComponent(py.ClassDeclaration, {
+              name: "User",
+              refkey: userClassRef
+            });
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "service.py",
+          get children() {
+            return _$createComponent(py.FunctionDeclaration, {
+              name: "create_user",
+              returnType: "None",
+              get children() {
+                return _$createComponent(py.VariableDeclaration, {
+                  name: "user",
+                  get initializer() {
+                    return _$createComponent(py.ClassInstantiation, {
+                      target: userClassRef
+                    });
+                  }
                 });
               }
             });
           }
-        });
+        })];
       }
-    })]);
-    assertFileContents(result, {
+    })).toRenderTo({
       "models.py": `
-        class User:
-            pass
+          class User:
+              pass
 
-        `,
+          `,
       "service.py": `
-        from models import User
+          from models import User
 
 
-        def create_user() -> None:
-            user = User()
+          def create_user() -> None:
+              user = User()
 
-        `
+          `
     });
   });
   it("upgrades type-only import to regular import when also used as value", () => {
     const userClassRef = refkey();
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "models.py",
-      get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "User",
-          refkey: userClassRef
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "service.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return _$createComponent(py.FunctionDeclaration, {
-          name: "create_user",
-          parameters: [{
-            name: "existing",
-            type: userClassRef
-          }],
-          returnType: userClassRef,
+        return [_$createComponent(py.SourceFile, {
+          path: "models.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "User",
+              refkey: userClassRef
+            });
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "service.py",
           get children() {
-            return _$createComponent(py.StatementList, {
+            return _$createComponent(py.FunctionDeclaration, {
+              name: "create_user",
+              parameters: [{
+                name: "existing",
+                type: userClassRef
+              }],
+              returnType: userClassRef,
               get children() {
-                return [_$createComponent(py.VariableDeclaration, {
-                  name: "user",
-                  get initializer() {
-                    return _$createComponent(py.ClassInstantiation, {
-                      target: userClassRef
-                    });
+                return _$createComponent(py.StatementList, {
+                  get children() {
+                    return [_$createComponent(py.VariableDeclaration, {
+                      name: "user",
+                      get initializer() {
+                        return _$createComponent(py.ClassInstantiation, {
+                          target: userClassRef
+                        });
+                      }
+                    }), ["return user"]];
                   }
-                }), ["return user"]];
+                });
               }
             });
           }
-        });
+        })];
       }
-    })]);
-
-    // Since User is used both as a type (parameter type, return type) and
-    // as a value (ClassInstantiation), it should be a regular import
-    assertFileContents(result, {
+    })).toRenderTo({
       "models.py": `
-        class User:
-            pass
+          class User:
+              pass
 
-        `,
+          `,
       "service.py": `
-        from models import User
+          from models import User
 
 
-        def create_user(existing: User) -> User:
-            user = User()
-            return user
+          def create_user(existing: User) -> User:
+              user = User()
+              return user
 
-        `
+          `
     });
   });
   it("handles mixed type-only and regular imports from same module", () => {
     const userClassRef = refkey();
     const helperFuncRef = refkey();
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "models.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return [_$createComponent(py.ClassDeclaration, {
-          name: "User",
-          refkey: userClassRef
-        }), _$createComponent(py.FunctionDeclaration, {
-          name: "helper",
-          refkey: helperFuncRef,
-          children: "pass"
-        })];
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "service.py",
-      get children() {
-        return _$createComponent(py.FunctionDeclaration, {
-          name: "process",
-          parameters: [{
-            name: "user",
-            type: userClassRef
-          }],
-          returnType: "None",
+        return [_$createComponent(py.SourceFile, {
+          path: "models.py",
           get children() {
-            return _$createComponent(py.FunctionCallExpression, {
-              target: helperFuncRef
+            return [_$createComponent(py.ClassDeclaration, {
+              name: "User",
+              refkey: userClassRef
+            }), _$createComponent(py.FunctionDeclaration, {
+              name: "helper",
+              refkey: helperFuncRef,
+              children: "pass"
+            })];
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "service.py",
+          get children() {
+            return _$createComponent(py.FunctionDeclaration, {
+              name: "process",
+              parameters: [{
+                name: "user",
+                type: userClassRef
+              }],
+              returnType: "None",
+              get children() {
+                return _$createComponent(py.FunctionCallExpression, {
+                  target: helperFuncRef
+                });
+              }
             });
           }
-        });
+        })];
       }
-    })]);
-
-    // helper is used as a value (function call), User is only used as type
-    assertFileContents(result, {
+    })).toRenderTo({
       "models.py": `
-        class User:
-            pass
+          class User:
+              pass
 
 
-        def helper():
-            pass
+          def helper():
+              pass
 
-        `,
+          `,
       "service.py": `
-        from models import helper
-        from typing import TYPE_CHECKING
+          from models import helper
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from models import User
+          if TYPE_CHECKING:
+              from models import User
 
 
-        def process(user: User) -> None:
-            helper()
+          def process(user: User) -> None:
+              helper()
 
-        `
+          `
     });
   });
   it("handles return type as type-only import", () => {
     const resultTypeRef = refkey();
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "types.py",
-      get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "Result",
-          refkey: resultTypeRef
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "main.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return _$createComponent(py.FunctionDeclaration, {
-          name: "get_result",
-          returnType: resultTypeRef,
-          children: "pass"
-        });
+        return [_$createComponent(py.SourceFile, {
+          path: "types.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "Result",
+              refkey: resultTypeRef
+            });
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "main.py",
+          get children() {
+            return _$createComponent(py.FunctionDeclaration, {
+              name: "get_result",
+              returnType: resultTypeRef,
+              children: "pass"
+            });
+          }
+        })];
       }
-    })]);
-    assertFileContents(result, {
+    })).toRenderTo({
       "types.py": `
-        class Result:
-            pass
+          class Result:
+              pass
 
-        `,
+          `,
       "main.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from types import Result
+          if TYPE_CHECKING:
+              from types import Result
 
 
-        def get_result() -> Result:
-            pass
+          def get_result() -> Result:
+              pass
 
-        `
+          `
     });
   });
   it("handles variable type annotation as type-only import", () => {
     const configTypeRef = refkey();
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "types.py",
-      get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "Config",
-          refkey: configTypeRef
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "main.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return _$createComponent(py.VariableDeclaration, {
-          name: "config",
-          type: configTypeRef,
-          omitNone: true
-        });
+        return [_$createComponent(py.SourceFile, {
+          path: "types.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "Config",
+              refkey: configTypeRef
+            });
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "main.py",
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              name: "config",
+              type: configTypeRef,
+              omitNone: true
+            });
+          }
+        })];
       }
-    })]);
-    assertFileContents(result, {
+    })).toRenderTo({
       "types.py": `
-        class Config:
-            pass
+          class Config:
+              pass
 
-        `,
+          `,
       "main.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from types import Config
+          if TYPE_CHECKING:
+              from types import Config
 
-        config: Config
-        `
+          config: Config
+          `
     });
   });
   it("handles TypeReference component as type-only import", () => {
     const myTypeRef = refkey();
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "types.py",
-      get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "MyType",
-          refkey: myTypeRef
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "main.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return _$createComponent(py.VariableDeclaration, {
-          name: "value",
-          get type() {
-            return _$createComponent(py.TypeReference, {
+        return [_$createComponent(py.SourceFile, {
+          path: "types.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "MyType",
               refkey: myTypeRef
             });
-          },
-          omitNone: true
-        });
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "main.py",
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              name: "value",
+              get type() {
+                return _$createComponent(py.TypeReference, {
+                  refkey: myTypeRef
+                });
+              },
+              omitNone: true
+            });
+          }
+        })];
       }
-    })]);
-    assertFileContents(result, {
+    })).toRenderTo({
       "types.py": `
-        class MyType:
-            pass
+          class MyType:
+              pass
 
-        `,
+          `,
       "main.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from types import MyType
+          if TYPE_CHECKING:
+              from types import MyType
 
-        value: MyType
-        `
+          value: MyType
+          `
     });
   });
   it("handles class bases as regular import (runtime requirement)", () => {
     const baseClassRef = refkey();
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "base.py",
+    expect(_$createComponent(TestOutputDirectory, {
       get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "BaseClass",
-          refkey: baseClassRef
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "derived.py",
-      get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "DerivedClass",
-          bases: [baseClassRef]
-        });
+        return [_$createComponent(py.SourceFile, {
+          path: "base.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "BaseClass",
+              refkey: baseClassRef
+            });
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "derived.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "DerivedClass",
+              bases: [baseClassRef]
+            });
+          }
+        })];
       }
-    })]);
-
-    // Class bases require runtime access, so they should NOT be
-    // inside a TYPE_CHECKING block
-    assertFileContents(result, {
+    })).toRenderTo({
       "base.py": `
-        class BaseClass:
-            pass
+          class BaseClass:
+              pass
 
-        `,
+          `,
       "derived.py": `
-        from base import BaseClass
+          from base import BaseClass
 
 
-        class DerivedClass(BaseClass):
-            pass
+          class DerivedClass(BaseClass):
+              pass
 
-        `
+          `
     });
   });
   it("renders regular imports before TYPE_CHECKING block", () => {
-    // Create a typing module with multiple exports
     const typingModule = createModule({
       name: "typing",
       descriptor: {
         ".": ["TYPE_CHECKING", "cast"]
       }
     });
-
-    // Create a third-party module
     const requestsModule = createModule({
       name: "requests",
       descriptor: {
@@ -379,58 +392,58 @@ describe("TYPE_CHECKING imports", () => {
       }
     });
     const userClassRef = refkey();
-    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
-      path: "models.py",
-      get children() {
-        return _$createComponent(py.ClassDeclaration, {
-          name: "User",
-          refkey: userClassRef
-        });
-      }
-    }), _$createComponent(py.SourceFile, {
-      path: "service.py",
+    expect(_$createComponent(TestOutputDirectory, {
+      externals: [typingModule, requestsModule],
       get children() {
-        return _$createComponent(py.FunctionDeclaration, {
-          name: "get_users",
-          parameters: [{
-            name: "user",
-            type: userClassRef
-          }],
-          returnType: "str",
+        return [_$createComponent(py.SourceFile, {
+          path: "models.py",
+          get children() {
+            return _$createComponent(py.ClassDeclaration, {
+              name: "User",
+              refkey: userClassRef
+            });
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "service.py",
           get children() {
-            return _$createComponent(py.StatementList, {
+            return _$createComponent(py.FunctionDeclaration, {
+              name: "get_users",
+              parameters: [{
+                name: "user",
+                type: userClassRef
+              }],
+              returnType: "str",
               get children() {
-                return [["response = ", _$memo(() => requestsModule["."].get), "(\"https://example.com\")"], ["return ", _$memo(() => typingModule["."].cast), "(str, user)"]];
+                return _$createComponent(py.StatementList, {
+                  get children() {
+                    return [["response = ", _$memo(() => requestsModule["."].get), "(\"https://example.com\")"], ["return ", _$memo(() => typingModule["."].cast), "(str, user)"]];
+                  }
+                });
               }
             });
           }
-        });
+        })];
       }
-    })], {
-      externals: [typingModule, requestsModule]
-    });
-
-    // Regular imports first (sorted alphabetically), then TYPE_CHECKING block
-    assertFileContents(result, {
+    })).toRenderTo({
       "models.py": `
-        class User:
-            pass
+          class User:
+              pass
 
-        `,
+          `,
       "service.py": `
-        from requests import get
-        from typing import cast
-        from typing import TYPE_CHECKING
+          from requests import get
+          from typing import cast
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from models import User
+          if TYPE_CHECKING:
+              from models import User
 
 
-        def get_users(user: User) -> str:
-            response = get("https://example.com")
-            return cast(str, user)
+          def get_users(user: User) -> str:
+              response = get("https://example.com")
+              return cast(str, user)
 
-        `
+          `
     });
   });
 });