Method TestErrors

core/integration/module_python_test.go:2035–2114

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

}

func (PythonSuite) TestErrors(ctx context.Context, t *testctx.T) {
	c := connect(ctx, t)
	ctr := goGitBase(t, c).
		WithWorkdir("/work/dep").
		With(daggerInitPython("--name=dep")).
		With(fileContents("src/dep/__init__.py", fmt.Sprintf(`
            import dagger
            from dagger import dag

            @dagger.object_type
            class Dep:
                @dagger.function
                async def exec_(self) -> str:
                    return await (
                        dag.container()
                        .from_("%s")
                        .with_exec(["sh", "-c", ">&2 echo 'oh noes'; exit 5"])
                        .stdout()
                    )
        `, alpineImage))).
		WithWorkdir("/work/test").
		With(daggerInitPython()).
		With(daggerExec("install", "../dep")).
		With(pythonSource(`
			import dagger
			from dagger import dag

			@dagger.object_type
			class Test:
				@dagger.function
				async def error_extensions(self) -> str:
					try:
						return await dag.dep().exec()
					except dagger.ExecError as e:
						# If the SDK didn't properly propagate the error
						# extensions this would be a dagger.QueryError instead,
						# so not caught.
						assert e.exit_code == 5
						return f"error: {e.stderr}"

				@dagger.function
				def coro(self) -> str:
					# Should fail because dag.version() returns a coroutine
					# and this isn't an async function
					return dag.version()

				@dagger.function
				async def nowait(self) -> str:
					# Should fail because of missing await
					return dag.version()

				@dagger.function
				def unhandled(self) -> str:
					raise ValueError("a foo bubbles up to bar")
		`))

	t.Run("error extensions", func(ctx context.Context, t *testctx.T) {
		out, err := ctr.With(daggerCall("error-extensions")).Stdout(ctx)