Method TestASTFollowUp

core/integration/module_python_test.go:1595–1788

TestASTFollowUp exercises Python patterns the AST analyzer used to drop silently or mishandle. Each subtest invokes “dagger call“ end-to-end so the AST analyzer's schema, the engine's validation, and the runtime's dispatch all have to agree — anything that survives an integration run here matches wh

(ctx context.Context, t *testctx.T)

// dispatch all have to agree — anything that survives an integration run
// here matches what a real user would see.
func (PythonSuite) TestASTFollowUp(ctx context.Context, t *testctx.T) {
	t.Run("aliased dagger module and decorators", func(ctx context.Context, t *testctx.T) {
		c := connect(ctx, t)

		// ``import dagger as d`` plus ``from dagger import object_type as ot,
		// function as fn`` — the decorator name allow-list used to miss
		// every aliased form.
		modGen := pythonModInit(t, c, `
import dagger as d
from dagger import object_type as ot, function as fn, field as fld

@ot
class Test:
    name: str = fld(default="aliased")

    @fn
    def hello(self, msg: str = "world") -> str:
        return self.name + ":" + msg

    @d.function
    def echo(self, msg: str) -> str:
        return msg
`)
		out, err := modGen.With(daggerCall("hello")).Stdout(ctx)
		require.NoError(t, err)
		require.Equal(t, "aliased:world", out)

		out, err = modGen.With(daggerCall("echo", "--msg=hi")).Stdout(ctx)
		require.NoError(t, err)
		require.Equal(t, "hi", out)
	})

	t.Run("inherited @function across MRO", func(ctx context.Context, t *testctx.T) {
		c := connect(ctx, t)

		// ``@function`` methods on an undecorated base flow through to
		// ``Test`` via Python MRO. Fields on the same base do *not*
		// (the runtime's ``dataclasses.fields(cls)`` only walks
		// dataclass parents) — that's why ``Base`` here doesn't
		// declare a field.
		modGen := pythonModInit(t, c, `
from typing import Self

import dagger
from dagger import function, object_type

class Base:
    @function
    def shout(self, msg: str) -> str:
        return msg.upper()

@object_type
class Test(Base):
    @function
    def whisper(self, msg: str) -> str:
        return msg.lower()
`)
		// Inherited from Base.