test: cover default and empty Python templates

The template names are part of the init UX: omitting `template` must produce
the useful starter, while users who want a blank object must be able to ask
for `empty` explicitly.

Exercise both paths through `initModule` and assert the rendered source rather
than template-helper internals. In particular, protect the alternate
constructor shape: Python reconstructs object state between the constructor
and later function calls, so overriding `__init__` with only user-facing
inputs makes a rendered module load but fail when a function is invoked.

The check also covers the pinned base image, workspace mount, bare empty class,
and leaked Go-template placeholders.

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Author: grouville

.dagger/modules/e2e/main.dang

@@ -134,13 +134,56 @@ type E2e {
     assert(contains(defaultChanges.addedPaths, defaultPath + "/" + generatedMarkerPath) == false, "init should not produce SDK-generated files")
     assert(defaultChanges.modifiedPaths.length == 0, "init unexpectedly modified existing files")
     assert(defaultChanges.removedPaths.length == 0, "init unexpectedly removed files")
-    assertContains(defaultChanges.layer.file(defaultPath + "/src/init_default/__init__.py").contents, "class InitDefault:", "minimal template did not render the module type")
+    assertContains(defaultChanges.layer.file(defaultPath + "/src/init_default/__init__.py").contents, "class InitDefault:", "default template did not render the module type")
 
     assertContains(legacyChanges.layer.file(legacyPath + "/src/init_legacy/main.py").contents, "class InitLegacy:", "legacy template did not render the module type")
 
     null
   }
 
+  """
+  The default template should render a working module that reads source from
+  the workspace and returns a ready-to-build container. The empty template
+  should remain available as a bare object class.
+  """
+  pub templateCheck(ws: Workspace!): Void @check {
+    let defaultPath = outputRoot + "/template-default"
+    let compatibleDefaultPath = outputRoot + "/template-default-empty-value"
+    let emptyPath = outputRoot + "/template-empty"
+
+    let defaultChanges = pythonSdk.initModule(ws, name: "template-default", path: defaultPath)
+    let defaultSourcePath = defaultPath + "/src/template_default/__init__.py"
+    assertAdded(defaultChanges, defaultSourcePath)
+    assertAdded(defaultChanges, defaultPath + "/pyproject.toml")
+    let defaultSource = defaultChanges.layer.file(defaultSourcePath).contents
+    assertContains(defaultSource, "class TemplateDefault:", "default template should render the module class")
+    assertContains(defaultSource, "@classmethod", "default template should use a reconstructable alternate constructor")
+    assertContains(defaultSource, "def create(", "default template should expose the alternate constructor")
+    assertContains(defaultSource, "ws: dagger.Workspace", "default template constructor should receive the workspace")
+    assertContains(defaultSource, "base_image_address: str = \"alpine:3.21\"", "default template should expose a pinned base image")
+    assertContains(defaultSource, "return cls(", "default template constructor should return serializable object state")
+    assertNotContains(defaultSource, "def __init__", "default template should leave state reconstruction to the dataclass initializer")
+    assertContains(defaultSource, "def container(self) -> dagger.Container:", "default template should expose the container function")
+    assertContains(defaultSource, ".with_directory(\"/src\", self.source)", "default template should mount the workspace source")
+    assertNotContains(defaultSource, "{{", "default template placeholders should be fully rendered")
+
+    let compatibleDefaultChanges = pythonSdk.initModule(ws, name: "template-default-empty-value", path: compatibleDefaultPath, template: "")
+    let compatibleDefaultSource = compatibleDefaultChanges.layer.file(compatibleDefaultPath + "/src/template_default_empty_value/__init__.py").contents
+    assertContains(compatibleDefaultSource, "def container(self) -> dagger.Container:", "an explicitly empty template should retain default-template compatibility")
+
+    let emptyChanges = pythonSdk.initModule(ws, name: "template-empty", path: emptyPath, template: "empty")
+    let emptySourcePath = emptyPath + "/src/template_empty/__init__.py"
+    assertAdded(emptyChanges, emptySourcePath)
+    assertAdded(emptyChanges, emptyPath + "/pyproject.toml")
+    let emptySource = emptyChanges.layer.file(emptySourcePath).contents
+    assertContains(emptySource, "class TemplateEmpty:", "empty template should render the module class")
+    assertContains(emptySource, "    pass", "empty template should render a bare class")
+    assertNotContains(emptySource, "def container", "empty template should not include the default behavior")
+    assertNotContains(emptySource, "{{", "empty template placeholders should be fully rendered")
+
+    null
+  }
+
   """
   Generating an existing module should produce generated files rooted at that
   module without touching unrelated paths.