status
stringclasses 1
value | repo_name
stringclasses 31
values | repo_url
stringclasses 31
values | issue_id
int64 1
104k
| title
stringlengths 4
233
| body
stringlengths 0
186k
⌀ | issue_url
stringlengths 38
56
| pull_url
stringlengths 37
54
| before_fix_sha
stringlengths 40
40
| after_fix_sha
stringlengths 40
40
| report_datetime
unknown | language
stringclasses 5
values | commit_datetime
unknown | updated_file
stringlengths 7
188
| chunk_content
stringlengths 1
1.03M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.NoError(t, err)
require.Contains(t, generated, "module example.com/test")
})
})
t.Run("respects existing go.work", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithExec([]string{"go", "work", "init"}).
WithExec([]string{"go", "work", "use", "."}).
With(daggerExec("init", "--name=hasGoMod", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{hasGoMod{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasGoMod":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("go.work is edited", func(t *testing.T) {
generated, err := modGen.File("go.work").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, "\t.\n")
require.Contains(t, generated, "\t./dagger\n")
})
})
t.Run("respects existing go.work for top-level source", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithExec([]string{"go", "work", "init"}).
With(daggerExec("init", "--name=hasGoMod", "--sdk=go", "--source=."))
out, err := modGen.
With(daggerQuery(`{hasGoMod{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasGoMod":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("go.work is edited", func(t *testing.T) {
generated, err := modGen.File("go.work").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, "use .\n")
})
})
t.Run("ignores go.work for subdir", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithExec([]string{"go", "work", "init"}).
WithExec([]string{"go", "work", "use", "."}).
With(daggerExec("init", "--name=hasGoMod", "--sdk=go", "subdir"))
out, err := modGen. |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | WithWorkdir("./subdir").
With(daggerQuery(`{hasGoMod{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasGoMod":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("go.work is unedited", func(t *testing.T) {
generated, err := modGen.File("go.work").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, "use .\n")
})
})
t.Run("respects parent go.mod if root points to it", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
generated := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithNewFile("/work/foo.go", dagger.ContainerWithNewFileOpts{
Contents: "package foo\n",
}).
With(daggerExec("init", "--name=child", "--sdk=go", "./child")).
WithWorkdir("/work/child").
With(daggerExec("develop")).
Directory("/work")
parentEntries, err := generated.Entries(ctx)
require.NoError(t, err)
require.Equal(t, []string{".git", "child", "foo.go", "go.mod", "go.sum"}, parentEntries)
childEntries, err := generated.Directory("child").Entries(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.NoError(t, err)
require.NotContains(t, childEntries, "go.mod")
t.Run("preserves parent module name", func(t *testing.T) {
goMod, err := generated.File("go.mod").Contents(ctx)
require.NoError(t, err)
require.Contains(t, goMod, "module example.com/test")
})
})
t.Run("respects existing go.mod even if root points to parent that has go.mod", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
generated := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"git", "init"}).
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithNewFile("/work/foo.go", dagger.ContainerWithNewFileOpts{
Contents: "package foo\n",
}).
WithWorkdir("/work/child").
WithExec([]string{"go", "mod", "init", "my-mod"}).
WithWorkdir("/work").
With(daggerExec("init", "--source=./child", "--name=child", "--sdk=go", "./child")).
WithWorkdir("/work/child").
With(daggerExec("develop")).
Directory("/work")
parentEntries, err := generated.Entries(ctx)
require.NoError(t, err) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.Equal(t, []string{".git", "child", "foo.go", "go.mod"}, parentEntries)
childEntries, err := generated.Directory("child").Entries(ctx)
require.NoError(t, err)
require.Contains(t, childEntries, "go.mod")
require.Contains(t, childEntries, "go.sum")
})
t.Run("respects existing main.go", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `
package main
type HasMainGo struct {}
func (m *HasMainGo) Hello() string { return "Hello, world!" }
`,
}).
With(daggerExec("init", "--name=hasMainGo", "--sdk=go", "--source=."))
out, err := modGen.
With(daggerQuery(`{hasMainGo{hello}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasMainGo":{"hello":"Hello, world!"}}`, out)
})
t.Run("respects existing main.go even if it uses types not generated yet", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `
package main
type HasDaggerTypes struct {}
func (m *HasDaggerTypes) Hello() *Container {
return dag.Container().
From("` + alpineImage + `").
WithExec([]string{"echo", "Hello, world!"})
}
`,
}).
With(daggerExec("init", "--source=.", "--name=hasDaggerTypes", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{hasDaggerTypes{hello{stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasDaggerTypes":{"hello":{"stdout":"Hello, world!\n"}}}`, out)
})
t.Run("respects existing package without creating main.go", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/notmain.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type HasNotMainGo struct {}
func (m *HasNotMainGo) Hello() string { return "Hello, world!" } |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | `,
}).
With(daggerExec("init", "--source=.", "--name=hasNotMainGo", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{hasNotMainGo{hello}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasNotMainGo":{"hello":"Hello, world!"}}`, out)
})
t.Run("with source", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=bare", "--sdk=go", "--source=some/subdir"))
out, err := modGen.
With(daggerQuery(`{bare{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"bare":{"containerEcho":{"stdout":"hello\n"}}}`, out)
sourceSubdirEnts, err := modGen.Directory("/work/some/subdir").Entries(ctx)
require.NoError(t, err)
require.Contains(t, sourceSubdirEnts, "main.go")
sourceRootEnts, err := modGen.Directory("/work").Entries(ctx)
require.NoError(t, err)
require.NotContains(t, sourceRootEnts, "main.go")
})
}
func TestModuleInitLICENSE(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Run("bootstraps Apache-2.0 LICENSE file if none found", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=licensed-to-ill", "--sdk=go"))
content, err := modGen.File("LICENSE").Contents(ctx)
require.NoError(t, err)
require.Contains(t, content, "Apache License, Version 2.0")
})
t.Run("creates LICENSE file in the directory specified by arg", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=licensed-to-ill", "--sdk=go", "./mymod"))
content, err := modGen.File("mymod/LICENSE").Contents(ctx)
require.NoError(t, err)
require.Contains(t, content, "Apache License, Version 2.0")
})
t.Run("does not bootstrap LICENSE file if it exists in the parent dir", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/LICENSE", dagger.ContainerWithNewFileOpts{
Contents: "doesnt matter",
}).
WithWorkdir("/work/sub").
With(daggerExec("init", "--name=licensed-to-ill", "--sdk=go"))
_, err := modGen.File("LICENSE").Contents(ctx)
require.Error(t, err)
})
t.Run("bootstraps a LICENSE file when requested, even if it exists in the parent dir", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/LICENSE", dagger.ContainerWithNewFileOpts{
Contents: "doesnt matter",
}).
WithWorkdir("/work/sub").
With(daggerExec("init", "--name=licensed-to-ill", "--sdk=go", "--license=MIT"))
content, err := modGen.File("LICENSE").Contents(ctx)
require.NoError(t, err)
require.Contains(t, content, "MIT License")
})
}
func TestModuleGit(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
gitGeneratedFiles []string
gitIgnoredFiles []string
}
for _, tc := range []testCase{
{
sdk: "go",
gitGeneratedFiles: []string{
"/dagger.gen.go",
"/internal/dagger/**",
"/internal/querybuilder/**",
},
},
{
sdk: "python",
gitGeneratedFiles: []string{
"/sdk/**",
},
gitIgnoredFiles: []string{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | "/sdk",
},
},
{
sdk: "typescript",
gitGeneratedFiles: []string{
"/sdk/**",
},
gitIgnoredFiles: []string{
"/sdk",
},
},
} {
tc := tc
t.Run(fmt.Sprintf("module %s git", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
With(daggerExec("init", "--name=bare", "--sdk="+tc.sdk))
out, err := modGen.
With(daggerQuery(`{bare{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"bare":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("configures .gitattributes", func(t *testing.T) {
ignore, err := modGen.File("dagger/.gitattributes").Contents(ctx)
require.NoError(t, err)
for _, fileName := range tc.gitGeneratedFiles {
require.Contains(t, ignore, fmt.Sprintf("%s linguist-generated\n", fileName))
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | })
if len(tc.gitIgnoredFiles) > 0 {
t.Run("configures .gitignore", func(t *testing.T) {
ignore, err := modGen.File("dagger/.gitignore").Contents(ctx)
require.NoError(t, err)
for _, fileName := range tc.gitIgnoredFiles {
require.Contains(t, ignore, fileName)
}
})
}
})
}
}
var goSignatures string
func TestModuleGoSignatures(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: goSignatures,
})
t.Run("func Hello() string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{hello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"hello":"hello"}}`, out)
})
t.Run("func Echo(string) string", func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | out, err := modGen.With(daggerQuery(`{minimal{echo(msg: "hello")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echo":"hello...hello...hello..."}}`, out)
})
t.Run("func EchoPointer(*string) string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoPointer(msg: "hello")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoPointer":"hello...hello...hello..."}}`, out)
})
t.Run("func EchoPointerPointer(**string) string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoPointerPointer(msg: "hello")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoPointerPointer":"hello...hello...hello..."}}`, out)
})
t.Run("func EchoOptional(string) string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoOptional(msg: "hello")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptional":"hello...hello...hello..."}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{echoOptional}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptional":"default...default...default..."}}`, out)
})
t.Run("func EchoOptionalPointer(string) string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoOptionalPointer(msg: "hello")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptionalPointer":"hello...hello...hello..."}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{echoOptionalPointer}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptionalPointer":"default...default...default..."}}`, out)
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Run("func EchoOptionalSlice([]string) string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoOptionalSlice(msg: ["hello", "there"])}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptionalSlice":"hello+there...hello+there...hello+there..."}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{echoOptionalSlice}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptionalSlice":"foobar...foobar...foobar..."}}`, out)
})
t.Run("func Echoes([]string) []string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoes(msgs: ["hello"])}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoes":["hello...hello...hello..."]}}`, out)
})
t.Run("func EchoesVariadic(...string) string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoesVariadic(msgs: ["hello"])}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoesVariadic":"hello...hello...hello..."}}`, out)
})
t.Run("func HelloContext(context.Context) string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{helloContext}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"helloContext":"hello context"}}`, out)
})
t.Run("func EchoContext(context.Context, string) string", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoContext(msg: "hello")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoContext":"ctx.hello...ctx.hello...ctx.hello..."}}`, out)
})
t.Run("func HelloStringError() (string, error)", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{helloStringError}}`)).Stdout(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"helloStringError":"hello i worked"}}`, out)
})
t.Run("func HelloVoid()", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{helloVoid}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"helloVoid":null}}`, out)
})
t.Run("func HelloVoidError() error", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{helloVoidError}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"helloVoidError":null}}`, out)
})
t.Run("func EchoOpts(string, string, int) error", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoOpts(msg: "hi")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOpts":"hi"}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{echoOpts(msg: "hi", suffix: "!", times: 2)}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOpts":"hi!hi!"}}`, out)
})
t.Run("func EchoOptsInline(struct{string, string, int}) error", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoOptsInline(msg: "hi")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptsInline":"hi"}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{echoOptsInline(msg: "hi", suffix: "!", times: 2)}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptsInline":"hi!hi!"}}`, out)
})
t.Run("func EchoOptsInlinePointer(*struct{string, string, int}) error", func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | out, err := modGen.With(daggerQuery(`{minimal{echoOptsInlinePointer(msg: "hi")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptsInlinePointer":"hi"}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{echoOptsInlinePointer(msg: "hi", suffix: "!", times: 2)}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptsInlinePointer":"hi!hi!"}}`, out)
})
t.Run("func EchoOptsInlineCtx(ctx, struct{string, string, int}) error", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoOptsInlineCtx(msg: "hi")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptsInlineCtx":"hi"}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{echoOptsInlineCtx(msg: "hi", suffix: "!", times: 2)}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptsInlineCtx":"hi!hi!"}}`, out)
})
t.Run("func EchoOptsInlineTags(struct{string, string, int}) error", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoOptsInlineTags(msg: "hi")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptsInlineTags":"hi"}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{echoOptsInlineTags(msg: "hi", suffix: "!", times: 2)}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptsInlineTags":"hi!hi!"}}`, out)
})
t.Run("func EchoOptsPragmas(string, string, int) error", func(t *testing.T) {
out, err := modGen.With(daggerQuery(`{minimal{echoOptsPragmas(msg: "hi")}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"echoOptsPragmas":"hi...hi...hi..."}}`, out)
})
}
func TestModuleGoSignaturesBuiltinTypes(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=minimal", "--sdk=go")).
WithNewFile("dagger/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type Minimal struct {}
func (m *Minimal) Read(ctx context.Context, dir Directory) (string, error) {
return dir.File("foo").Contents(ctx)
}
func (m *Minimal) ReadPointer(ctx context.Context, dir *Directory) (string, error) {
return dir.File("foo").Contents(ctx)
}
func (m *Minimal) ReadSlice(ctx context.Context, dir []Directory) (string, error) {
return dir[0].File("foo").Contents(ctx)
}
func (m *Minimal) ReadVariadic(ctx context.Context, dir ...Directory) (string, error) {
return dir[0].File("foo").Contents(ctx)
}
func (m *Minimal) ReadOptional(
ctx context.Context, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | dir *Directory, // +optional
) (string, error) {
if dir != nil {
return dir.File("foo").Contents(ctx)
}
return "", nil
}
`,
})
out, err := modGen.With(daggerQuery(`{directory{withNewFile(path: "foo", contents: "bar"){id}}}`)).Stdout(ctx)
require.NoError(t, err)
dirID := gjson.Get(out, "directory.withNewFile.id").String()
t.Run("func Read(ctx, Directory) (string, error)", func(t *testing.T) {
out, err := modGen.With(daggerQuery(fmt.Sprintf(`{minimal{read(dir: "%s")}}`, dirID))).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"read":"bar"}}`, out)
})
t.Run("func ReadPointer(ctx, *Directory) (string, error)", func(t *testing.T) {
out, err := modGen.With(daggerQuery(fmt.Sprintf(`{minimal{readPointer(dir: "%s")}}`, dirID))).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"readPointer":"bar"}}`, out)
})
t.Run("func ReadSlice(ctx, []Directory) (string, error)", func(t *testing.T) {
out, err := modGen.With(daggerQuery(fmt.Sprintf(`{minimal{readSlice(dir: ["%s"])}}`, dirID))).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"readSlice":"bar"}}`, out)
})
t.Run("func ReadVariadic(ctx, ...Directory) (string, error)", func(t *testing.T) {
out, err := modGen.With(daggerQuery(fmt.Sprintf(`{minimal{readVariadic(dir: ["%s"])}}`, dirID))).Stdout(ctx)
require.NoError(t, err) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.JSONEq(t, `{"minimal":{"readVariadic":"bar"}}`, out)
})
t.Run("func ReadOptional(ctx, Optional[Directory]) (string, error)", func(t *testing.T) {
out, err := modGen.With(daggerQuery(fmt.Sprintf(`{minimal{readOptional(dir: "%s")}}`, dirID))).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"readOptional":"bar"}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{readOptional}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"readOptional":""}}`, out)
})
}
func TestModuleGoSignaturesUnexported(t *testing.T) {
t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Minimal struct {}
type Foo struct {}
type bar struct {}
func (m *Minimal) Hello(name string) string {
return name
}
func (f *Foo) Hello(name string) string {
return name
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | func (b *bar) Hello(name string) string {
return name
}
`,
})
objs := inspectModuleObjects(ctx, t, modGen)
require.Equal(t, 1, len(objs.Array()))
require.Equal(t, "Minimal", objs.Get("0.name").String())
modGen = c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Minimal struct {}
type Foo struct {}
type bar struct {}
func (m *Minimal) Hello(name string) Foo {
return Foo{}
}
func (f *Foo) Hello(name string) string {
return name
}
func (b *bar) Hello(name string) string {
return name
}
`,
})
objs = inspectModuleObjects(ctx, t, modGen)
require.Equal(t, 2, len(objs.Array())) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.Equal(t, "Minimal", objs.Get("0.name").String())
require.Equal(t, "MinimalFoo", objs.Get("1.name").String())
modGen = c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Minimal struct {}
type Foo struct {
Bar bar
}
type bar struct {}
func (m *Minimal) Hello(name string) Foo {
return Foo{}
}
func (f *Foo) Hello(name string) string {
return name
}
func (b *bar) Hello(name string) string {
return name
}
`,
})
_, err := modGen.With(moduleIntrospection).Stderr(ctx)
require.Error(t, err)
require.NoError(t, c.Close())
require.Contains(t, logs.String(), "cannot code-generate unexported type bar")
}
func TestModuleGoSignaturesMixMatch(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Minimal struct {}
func (m *Minimal) Hello(name string, opts struct{}, opts2 struct{}) string {
return name
}
`,
})
_, err := modGen.With(daggerQuery(`{minimal{hello}}`)).Stdout(ctx)
require.Error(t, err)
require.NoError(t, c.Close())
require.Contains(t, logs.String(), "nested structs are not supported")
}
func TestModuleGoSignaturesNameConflict(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Minimal struct {
Foo Foo
Bar Bar
Baz Baz
}
type Foo struct {}
type Bar struct {}
type Baz struct {}
func (m *Foo) Hello(name string) string {
return name
}
func (f *Bar) Hello(name string, name2 string) string {
return name + name2
}
func (b *Baz) Hello() (string, error) {
return "", nil
}
`,
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | objs := inspectModuleObjects(ctx, t, modGen)
require.Equal(t, 4, len(objs.Array()))
require.Equal(t, "Minimal", objs.Get("0.name").String())
require.Equal(t, "MinimalFoo", objs.Get("1.name").String())
require.Equal(t, "MinimalBar", objs.Get("2.name").String())
require.Equal(t, "MinimalBaz", objs.Get("3.name").String())
}
func TestModuleGoDocs(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: goSignatures,
})
logGen(ctx, t, modGen.Directory("."))
obj := inspectModuleObjects(ctx, t, modGen).Get("0")
require.Equal(t, "Minimal", obj.Get("name").String())
hello := obj.Get(`functions.#(name="hello")`)
require.Equal(t, "hello", hello.Get("name").String())
require.Empty(t, hello.Get("description").String())
require.Empty(t, hello.Get("args").Array())
echoOpts := obj.Get(`functions.#(name="echoOpts")`)
require.Equal(t, "echoOpts", echoOpts.Get("name").String())
require.Equal(t, "EchoOpts does some opts things", echoOpts.Get("description").String())
require.Len(t, echoOpts.Get("args").Array(), 3)
require.Equal(t, "msg", echoOpts.Get("args.0.name").String()) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.Equal(t, "the message to echo", echoOpts.Get("args.0.description").String())
require.Equal(t, "suffix", echoOpts.Get("args.1.name").String())
require.Equal(t, "String to append to the echoed message", echoOpts.Get("args.1.description").String())
require.Equal(t, "times", echoOpts.Get("args.2.name").String())
require.Equal(t, "Number of times to repeat the message", echoOpts.Get("args.2.description").String())
echoOpts = obj.Get(`functions.#(name="echoOptsInline")`)
require.Equal(t, "echoOptsInline", echoOpts.Get("name").String())
require.Equal(t, "EchoOptsInline does some opts things", echoOpts.Get("description").String())
require.Len(t, echoOpts.Get("args").Array(), 3)
require.Equal(t, "msg", echoOpts.Get("args.0.name").String())
require.Equal(t, "the message to echo", echoOpts.Get("args.0.description").String())
require.Equal(t, "suffix", echoOpts.Get("args.1.name").String())
require.Equal(t, "String to append to the echoed message", echoOpts.Get("args.1.description").String())
require.Equal(t, "times", echoOpts.Get("args.2.name").String())
require.Equal(t, "Number of times to repeat the message", echoOpts.Get("args.2.description").String())
echoOpts = obj.Get(`functions.#(name="echoOptsPragmas")`)
require.Equal(t, "echoOptsPragmas", echoOpts.Get("name").String())
require.Len(t, echoOpts.Get("args").Array(), 3)
require.Equal(t, "msg", echoOpts.Get("args.0.name").String())
require.Equal(t, "", echoOpts.Get("args.0.defaultValue").String())
require.Equal(t, "suffix", echoOpts.Get("args.1.name").String())
require.Equal(t, "String to append to the echoed message", echoOpts.Get("args.1.description").String())
require.Equal(t, "\"...\"", echoOpts.Get("args.1.defaultValue").String())
require.Equal(t, "times", echoOpts.Get("args.2.name").String())
require.Equal(t, "3", echoOpts.Get("args.2.defaultValue").String())
require.Equal(t, "Number of times to repeat the message", echoOpts.Get("args.2.description").String())
}
func TestModuleGoDocsEdgeCases(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
// Minimal is a thing
type Minimal struct {
// X is this
X, Y string // Y is not this
// +private
Z string
}
// some docs
func (m *Minimal) Hello(foo string, bar string,
// hello
baz string, qux string, x string, // lol
) string {
return foo + bar
}
func (m *Minimal) HelloMore(
// foo here
foo,
// bar here
bar string,
) string {
return foo + bar
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | func (m *Minimal) HelloMoreInline(opts struct{
// foo here
foo, bar string
}) string {
return opts.foo + opts.bar
}
func (m *Minimal) HelloAgain( // docs for helloagain
foo string,
bar string, // docs for bar
baz string,
) string {
return foo + bar
}
func (m *Minimal) HelloFinal(
foo string) string { // woops
return foo
}
`,
})
logGen(ctx, t, modGen.Directory("."))
obj := inspectModuleObjects(ctx, t, modGen).Get("0")
require.Equal(t, "Minimal", obj.Get("name").String())
require.Equal(t, "Minimal is a thing", obj.Get("description").String())
hello := obj.Get(`functions.#(name="hello")`)
require.Equal(t, "hello", hello.Get("name").String())
require.Len(t, hello.Get("args").Array(), 5)
require.Equal(t, "foo", hello.Get("args.0.name").String())
require.Equal(t, "", hello.Get("args.0.description").String())
require.Equal(t, "bar", hello.Get("args.1.name").String())
require.Equal(t, "", hello.Get("args.1.description").String()) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.Equal(t, "baz", hello.Get("args.2.name").String())
require.Equal(t, "hello", hello.Get("args.2.description").String())
require.Equal(t, "qux", hello.Get("args.3.name").String())
require.Equal(t, "", hello.Get("args.3.description").String())
require.Equal(t, "x", hello.Get("args.4.name").String())
require.Equal(t, "lol", hello.Get("args.4.description").String())
hello = obj.Get(`functions.#(name="helloMore")`)
require.Equal(t, "helloMore", hello.Get("name").String())
require.Len(t, hello.Get("args").Array(), 2)
require.Equal(t, "foo", hello.Get("args.0.name").String())
require.Equal(t, "foo here", hello.Get("args.0.description").String())
require.Equal(t, "bar", hello.Get("args.1.name").String())
require.Equal(t, "bar here", hello.Get("args.1.description").String())
hello = obj.Get(`functions.#(name="helloMoreInline")`)
require.Equal(t, "helloMoreInline", hello.Get("name").String())
require.Len(t, hello.Get("args").Array(), 2)
require.Equal(t, "foo", hello.Get("args.0.name").String())
require.Equal(t, "foo here", hello.Get("args.0.description").String())
require.Equal(t, "bar", hello.Get("args.1.name").String())
require.Equal(t, "", hello.Get("args.1.description").String())
hello = obj.Get(`functions.#(name="helloAgain")`)
require.Equal(t, "helloAgain", hello.Get("name").String())
require.Len(t, hello.Get("args").Array(), 3)
require.Equal(t, "foo", hello.Get("args.0.name").String())
require.Equal(t, "", hello.Get("args.0.description").String())
require.Equal(t, "bar", hello.Get("args.1.name").String())
require.Equal(t, "docs for bar", hello.Get("args.1.description").String())
require.Equal(t, "baz", hello.Get("args.2.name").String())
require.Equal(t, "", hello.Get("args.2.description").String())
hello = obj.Get(`functions.#(name="helloFinal")`) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.Equal(t, "helloFinal", hello.Get("name").String())
require.Len(t, hello.Get("args").Array(), 1)
require.Equal(t, "foo", hello.Get("args.0.name").String())
require.Equal(t, "", hello.Get("args.0.description").String())
require.Len(t, obj.Get(`fields`).Array(), 2)
prop := obj.Get(`fields.#(name="x")`)
require.Equal(t, "x", prop.Get("name").String())
require.Equal(t, "X is this", prop.Get("description").String())
prop = obj.Get(`fields.#(name="y")`)
require.Equal(t, "y", prop.Get("name").String())
require.Equal(t, "", prop.Get("description").String())
}
func TestModuleGoWeirdFields(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Z string
type Minimal struct {
// field with single (normal) name
W string
// field with multiple names
X, Y string
// field with no names
Z |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
func New() Minimal {
return Minimal{
W: "-",
X: "-",
Y: "-",
Z: Z("-"),
}
}
// struct with no fields
type Bar struct{}
func (m *Minimal) Say(
// field with single (normal) name
a string,
// field with multiple names
b, c string,
// field with no names (not included, mixed names not allowed)
// string
) string {
return a + " " + b + " " + c
}
func (m *Minimal) Hello(
// field with no names
string,
) string {
return "hello"
}
func (m *Minimal) SayOpts(opts struct{
// field with single (normal) name
A string |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | // field with multiple names
B, C string
// field with no names (not included because of above)
// string
}) string {
return opts.A + " " + opts.B + " " + opts.C
}
func (m *Minimal) HelloOpts(opts struct{
// field with no names
string
}) string {
return "hello"
}
`,
})
out, err := modGen.With(daggerQuery(`{minimal{w, x, y, z}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal": {"w": "-", "x": "-", "y": "-", "z": "-"}}`, out)
for _, name := range []string{"say", "sayOpts"} {
out, err := modGen.With(daggerQuery(`{minimal{%s(a: "hello", b: "world", c: "!")}}`, name)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, fmt.Sprintf(`{"minimal": {"%s": "hello world !"}}`, name), out)
}
for _, name := range []string{"hello", "helloOpts"} {
out, err := modGen.With(daggerQuery(`{minimal{%s(string: "")}}`, name)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, fmt.Sprintf(`{"minimal": {"%s": "hello"}}`, name), out)
}
}
func TestModuleGoFieldMustBeNil(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "fmt"
type Minimal struct {
Src *Directory
Name *string
}
func New() *Minimal {
return &Minimal{}
}
func (m *Minimal) IsEmpty() bool {
if m.Name != nil {
panic(fmt.Sprintf("name should be nil but is %v", m.Name))
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | if m.Src != nil {
panic(fmt.Sprintf("src should be nil but is %v", m.Src))
}
return true
}
`,
})
out, err := modGen.With(daggerQuery(`{minimal{isEmpty}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal": {"isEmpty": true}}`, out)
}
func TestModuleDescription(t *testing.T) {
t.Parallel()
type source struct {
file string
contents string
}
for _, tc := range []struct {
sdk string
sources []source
}{
{
sdk: "go",
sources: []source{
{
file: "main.go",
contents: `
// Test module, short description
//
// Long description, with full sentences. |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | package main
// Test object, short description
type Test struct {
// +default="foo"
Foo string
}
`,
},
},
},
{
sdk: "go",
sources: []source{
{
file: "a.go",
contents: `
// First, but not main
package main
type Foo struct {}
`,
},
{
file: "z.go",
contents: `
// Test module, short description
//
// Long description, with full sentences.
package main
// Test object, short description
type Test struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
func (*Test) Foo() Foo {
return Foo{}
}
`,
},
},
},
{
sdk: "python",
sources: []source{
{
file: "src/main.py",
contents: `
"""Test module, short description
Long description, with full sentences.
"""
from dagger import field, object_type
@object_type
class Test:
"""Test object, short description"""
foo: str = field(default="foo")
`,
},
},
},
{
sdk: "python",
sources: []source{
{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | file: "src/main/foo.py",
contents: `
"""Not the main file"""
from dagger import field, object_type
@object_type
class Foo:
bar: str = field(default="bar")
`,
},
{
file: "src/main/__init__.py",
contents: `
"""Test module, short description
Long description, with full sentences.
"""
from dagger import function, object_type
from .foo import Foo
@object_type
class Test:
"""Test object, short description"""
foo = function(Foo)
`,
},
},
},
{
sdk: "typescript",
sources: []source{
{
file: "src/index.ts", |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | contents: `
/**
* Test module, short description
*
* Long description, with full sentences.
*/
import { object, field } from '@dagger.io/dagger'
/**
* Test object, short description
*/
@object()
class Test {
@field()
foo: string = "foo"
}
`,
},
},
},
{
sdk: "typescript",
sources: []source{
{
file: "src/foo.ts",
contents: `
/**
* Not the main file
*/
import { object, field } from '@dagger.io/dagger'
@object() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | export class Foo {
@field()
bar = "bar"
}
`,
},
{
file: "src/index.ts",
contents: `
/**
* Test module, short description
*
* Long description, with full sentences.
*/
import { object, field } from '@dagger.io/dagger'
import { Foo } from "./foo"
/**
* Test object, short description
*/
@object()
class Test {
@func()
foo(): Foo {
return new Foo()
}
}
`,
},
},
}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | } {
tc := tc
t.Run(fmt.Sprintf("%s with %d files", tc.sdk, len(tc.sources)), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work")
for _, src := range tc.sources {
src := src
modGen = modGen.WithNewFile(src.file, dagger.ContainerWithNewFileOpts{
Contents: heredoc.Doc(src.contents),
})
}
mod := inspectModule(ctx, t,
modGen.With(daggerExec("init", "--source=.", "--name=test", "--sdk="+tc.sdk)))
require.Equal(t,
"Test module, short description\n\nLong description, with full sentences.",
mod.Get("description").String(),
)
require.Equal(t,
"Test object, short description",
mod.Get("objects.#.asObject|#(name=Test).description").String(),
)
})
}
}
func TestModulePrivateField(t *testing.T) {
t.Parallel()
for _, tc := range []struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}{
{
sdk: "go",
source: `package main
type Minimal struct {
Foo string
Bar string // +private
}
func (m *Minimal) Set(foo string, bar string) *Minimal {
m.Foo = foo
m.Bar = bar
return m
}
func (m *Minimal) Hello() string {
return m.Foo + m.Bar
}
`,
},
{
sdk: "python",
source: `from dagger import field, function, object_type
@object_type
class Minimal:
foo: str = field(default="")
bar: str = ""
@function
def set(self, foo: str, bar: str) -> "Minimal":
self.foo = foo |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | self.bar = bar
return self
@function
def hello(self) -> str:
return self.foo + self.bar
`,
},
{
sdk: "typescript",
source: `
import { object, func, field } from "@dagger.io/dagger"
@object()
class Minimal {
@field()
foo: string
bar?: string
constructor(foo?: string, bar?: string) {
this.foo = foo
this.bar = bar
}
@func()
set(foo: string, bar: string): Minimal {
this.foo = foo
this.bar = bar
return this
}
@func()
hello(): string {
return this.foo + this.bar
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=minimal", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
obj := inspectModuleObjects(ctx, t, modGen).Get("0")
require.Equal(t, "Minimal", obj.Get("name").String())
require.Len(t, obj.Get(`fields`).Array(), 1)
prop := obj.Get(`fields.#(name="foo")`)
require.Equal(t, "foo", prop.Get("name").String())
out, err := modGen.With(daggerQuery(`{minimal{set(foo: "abc", bar: "xyz"){hello}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"set":{"hello": "abcxyz"}}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{set(foo: "abc", bar: "xyz"){foo}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"set":{"foo": "abc"}}}`, out)
_, err = modGen.With(daggerQuery(`{minimal{set(foo: "abc", bar: "xyz"){bar}}}`)).Stdout(ctx)
require.ErrorContains(t, err, `Minimal has no such field: "bar"`)
})
}
}
func TestModuleGoExtendCore(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=container", "--sdk=go")).
WithNewFile("internal/dagger/more.go", dagger.ContainerWithNewFileOpts{
Contents: `package dagger
import "context"
func (c *Container) Echo(ctx context.Context, msg string) (string, error) {
return c.WithExec([]string{"echo", msg}).Stdout(ctx)
}
`,
}).
With(daggerQuery(`{container{from(address:"` + alpineImage + `"){echo(msg:"echo!"){stdout}}}}`)).
Sync(ctx)
require.Error(t, err)
require.NoError(t, c.Close())
t.Log(logs.String())
require.Contains(t, logs.String(), "cannot define methods on objects from outside this module")
}
func TestModuleGoBadCtx(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=foo", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type Foo struct {}
func (f *Foo) Echo(ctx context.Context, ctx2 context.Context) (string, error) {
return "", nil
}
`,
}).
With(daggerQuery(`{foo{echo}}`)).
Sync(ctx)
require.Error(t, err)
require.NoError(t, c.Close())
t.Log(logs.String())
require.Contains(t, logs.String(), "unexpected context type")
}
func TestModuleCustomTypes(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "strings"
type Test struct{}
func (m *Test) Repeater(msg string, times int) *Repeater {
return &Repeater{
Message: msg,
Times: times,
}
}
type Repeater struct {
Message string
Times int
}
func (t *Repeater) Render() string {
return strings.Repeat(t.Message, t.Times)
}
`,
},
{
sdk: "python",
source: `from dagger import field, function, object_type
@object_type
class Repeater:
message: str = field(default="") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | times: int = field(default=0)
@function
def render(self) -> str:
return self.message * self.times
@function
def repeater(msg: str, times: int) -> Repeater:
return Repeater(message=msg, times=times)
`,
},
{
sdk: "typescript",
source: `
import { object, func, field } from "@dagger.io/dagger"
@object()
class Repeater {
@field()
message: string
@field()
times: number
constructor(message: string, times: number) {
this.message = message
this.times = times
}
@func()
render(): string {
return this.message.repeat(this.times)
}
}
@object()
class Test { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | @func()
repeater(msg: string, times: number): Repeater {
return new Repeater(msg, times)
}
}
`,
},
} {
tc := tc
t.Run(fmt.Sprintf("custom %s types", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := modInit(ctx, t, c, tc.sdk, tc.source).
With(daggerQuery(`{test{repeater(msg:"echo!", times: 3){render}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"test":{"repeater":{"render":"echo!echo!echo!"}}}`, out)
})
}
}
func TestModuleReturnTypeDetection(t *testing.T) {
t.Parallel()
type testCase struct {
sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | type Foo struct {}
type X struct {
Message string ` + "`json:\"message\"`" + `
}
func (m *Foo) MyFunction() X {
return X{Message: "foo"}
}
`,
},
{
sdk: "python",
source: `from dagger import field, function, object_type
@object_type
class X:
message: str = field(default="")
@function
def my_function() -> X:
return X(message="foo")
`,
},
{
sdk: "typescript",
source: `
import { object, func, field } from "@dagger.io/dagger"
@object()
class X {
@field()
message: string
constructor(message: string) {
this.message = message; |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
}
@object()
class Foo {
@func()
myFunction(): X {
return new X("foo");
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{myFunction{message}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"myFunction":{"message":"foo"}}}`, out)
})
}
}
func TestModuleReturnObject(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Foo struct {}
type X struct {
Message string ` + "`json:\"message\"`" + `
When string ` + "`json:\"Timestamp\"`" + `
To string ` + "`json:\"recipient\"`" + `
From string
}
func (m *Foo) MyFunction() X {
return X{Message: "foo", When: "now", To: "user", From: "admin"}
}
`,
},
{
sdk: "python",
source: `from dagger import field, function, object_type
@object_type
class X: |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | message: str = field(default="")
when: str = field(default="", name="Timestamp")
to: str = field(default="", name="recipient")
from_: str = field(default="", name="from")
@object_type
class Foo:
@function
def my_function(self) -> X:
return X(message="foo", when="now", to="user", from_="admin")
`,
},
{
sdk: "typescript",
source: `
import { object, func, field } from "@dagger.io/dagger"
@object()
class X {
@field()
message: string
@field()
timestamp: string
@field()
recipient: string
@field()
from: string
constructor(message: string, timestamp: string, recipient: string, from: string) {
this.message = message;
this.timestamp = timestamp;
this.recipient = recipient;
this.from = from; |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
}
@object()
class Foo {
@func()
myFunction(): X {
return new X("foo", "now", "user", "admin");
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{myFunction{message, recipient, from, timestamp}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"myFunction":{"message":"foo", "recipient":"user", "from":"admin", "timestamp":"now"}}}`, out)
})
}
}
func TestModuleReturnNestedObject(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Playground struct{}
type Foo struct {
MsgContainer Bar
}
type Bar struct {
Msg string
}
func (m *Playground) MyFunction() Foo {
return Foo{MsgContainer: Bar{Msg: "hello world"}}
}
`,
},
{
sdk: "python",
source: `from dagger import field, function, object_type
@object_type |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | class Bar:
msg: str = field()
@object_type
class Foo:
msg_container: Bar = field()
@object_type
class Playground:
@function
def my_function(self) -> Foo:
return Foo(msg_container=Bar(msg="hello world"))
`,
},
{
sdk: "typescript",
source: `
import { object, func, field } from "@dagger.io/dagger"
@object()
class Bar {
@field()
msg: string;
constructor(msg: string) {
this.msg = msg;
}
}
@object()
class Foo {
@field()
msgContainer: Bar;
constructor(msgContainer: Bar) {
this.msgContainer = msgContainer; |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
}
@object()
class Playground {
@func()
myFunction(): Foo {
return new Foo(new Bar("hello world"));
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=playground", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{playground{myFunction{msgContainer{msg}}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"playground":{"myFunction":{"msgContainer":{"msg": "hello world"}}}}`, out)
})
}
}
func TestModuleReturnCompositeCore(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Playground struct{}
func (m *Playground) MySlice() []*Container {
return []*Container{dag.Container().From("` + alpineImage + `").WithExec([]string{"echo", "hello world"})}
}
type Foo struct {
Con *Container
// verify fields can remain nil w/out error too
UnsetFile *File
}
func (m *Playground) MyStruct() *Foo {
return &Foo{Con: dag.Container().From("` + alpineImage + `").WithExec([]string{"echo", "hello world"})}
}
`,
},
{
sdk: "python",
source: `import dagger
from dagger import dag, field, function, object_type
@object_type
class Foo:
con: dagger.Container = field() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | unset_file: dagger.File | None = field(default=None)
@object_type
class Playground:
@function
def my_slice(self) -> list[dagger.Container]:
return [dag.container().from_("` + alpineImage + `").with_exec(["echo", "hello world"])]
@function
def my_struct(self) -> Foo:
return Foo(con=dag.container().from_("` + alpineImage + `").with_exec(["echo", "hello world"]))
`,
},
{
sdk: "typescript",
source: `
import { dag, Container, File, object, func, field } from "@dagger.io/dagger"
@object()
class Foo {
@field()
con: Container
@field()
unsetFile?: File
constructor(con: Container, usetFile?: File) {
this.con = con
this.usetFile = usetFile
}
}
@object()
class Playground {
@func()
mySlice(): Container[] { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | return [
dag.container().from("` + alpineImage + `").withExec(["echo", "hello world"])
]
}
@func()
myStruct(): Foo {
return new Foo(
dag.container().from("` + alpineImage + `").withExec(["echo", "hello world"])
)
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=playground", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{playground{mySlice{stdout}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"playground":{"mySlice":[{"stdout":"hello world\n"}]}}`, out)
out, err = modGen.With(daggerQuery(`{playground{myStruct{con{stdout}}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"playground":{"myStruct":{"con":{"stdout":"hello world\n"}}}}`, out)
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
}
func TestModuleReturnComplexThing(t *testing.T) {
t.Parallel()
type testCase struct {
sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Playground struct{}
type ScanResult struct {
Containers []*Container ` + "`json:\"targets\"`" + `
Report ScanReport
}
type ScanReport struct {
Contents string ` + "`json:\"contents\"`" + `
Authors []string ` + "`json:\"Authors\"`" + `
}
func (m *Playground) Scan() ScanResult {
return ScanResult{
Containers: []*Container{
dag.Container().From("` + alpineImage + `").WithExec([]string{"echo", "hello world"}),
},
Report: ScanReport{
Contents: "hello world",
Authors: []string{"foo", "bar"},
}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
}
`,
},
{
sdk: "python",
source: `import dagger
from dagger import dag, field, function, object_type
@object_type
class ScanReport:
contents: str = field()
authors: list[str] = field()
@object_type
class ScanResult:
containers: list[dagger.Container] = field(name="targets")
report: ScanReport = field()
@object_type
class Playground:
@function
def scan(self) -> ScanResult:
return ScanResult(
containers=[
dag.container().from_("` + alpineImage + `").with_exec(["echo", "hello world"]),
],
report=ScanReport(
contents="hello world",
authors=["foo", "bar"],
),
)
`, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | },
{
sdk: "typescript",
source: `
import { dag, Container, object, func, field } from "@dagger.io/dagger"
@object()
class ScanReport {
@field()
contents: string
@field()
authors: string[]
constructor(contents: string, authors: string[]) {
this.contents = contents
this.authors = authors
}
}
@object()
class ScanResult {
@field("targets")
containers: Container[]
@field()
report: ScanReport
constructor(containers: Container[], report: ScanReport) {
this.containers = containers
this.report = report
}
}
@object()
class Playground {
@func() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | async scan(): Promise<ScanResult> {
return new ScanResult(
[
dag.container().from("` + alpineImage + `").withExec(["echo", "hello world"])
],
new ScanReport("hello world", ["foo", "bar"])
)
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=playground", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{playground{scan{targets{stdout},report{contents,authors}}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"playground":{"scan":{"targets":[{"stdout":"hello world\n"}],"report":{"contents":"hello world","authors":["foo","bar"]}}}}`, out)
})
}
}
func TestModuleGlobalVarDAG(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "context"
type Foo struct {}
var someDefault = dag.Container().From("` + alpineImage + `")
func (m *Foo) Fn(ctx context.Context) (string, error) {
return someDefault.WithExec([]string{"echo", "foo"}).Stdout(ctx)
}
`,
},
{
sdk: "python",
source: `from dagger import dag, function, object_type
SOME_DEFAULT = dag.container().from_("` + alpineImage + `")
@object_type
class Foo:
@function
async def fn(self) -> str:
return await SOME_DEFAULT.with_exec(["echo", "foo"]).stdout()
`,
},
{
sdk: "typescript",
source: ` |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | import { dag, object, func } from "@dagger.io/dagger"
var someDefault = dag.container().from("` + alpineImage + `")
@object()
class Foo {
@func()
async fn(): Promise<string> {
return someDefault.withExec(["echo", "foo"]).stdout()
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{fn}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"fn":"foo\n"}}`, out)
})
}
}
func TestModuleIDableType(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Foo struct {
Data string
}
func (m *Foo) Set(data string) *Foo {
m.Data = data
return m
}
func (m *Foo) Get() string {
return m.Data
}
`,
},
{
sdk: "python",
source: `from typing import Self
from dagger import field, function, object_type
@object_type
class Foo:
data: str = ""
@function |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | def set(self, data: str) -> Self:
self.data = data
return self
@function
def get(self) -> str:
return self.data
`,
},
{
sdk: "typescript",
source: `
import { object, func } from "@dagger.io/dagger"
@object()
class Foo {
data: string = ""
@func()
set(data: string): Foo {
this.data = data
return this
}
@func()
get(): string {
return this.data
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{set(data: "abc"){get}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"set":{"get": "abc"}}}`, out)
out, err = modGen.With(daggerQuery(`{foo{set(data: "abc"){id}}}`)).Stdout(ctx)
require.NoError(t, err)
id := gjson.Get(out, "foo.set.id").String()
var idp idproto.ID
err = idp.Decode(id)
require.NoError(t, err)
require.Equal(t, idp.Display(), `foo.set(data: "abc"): Foo!`)
out, err = modGen.With(daggerQuery(`{loadFooFromID(id: "%s"){get}}`, id)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"loadFooFromID":{"get": "abc"}}`, out)
})
}
}
func TestModuleArgOwnType(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "strings"
type Foo struct{}
type Message struct {
Content string
}
func (m *Foo) SayHello(name string) Message {
return Message{Content: "hello " + name}
}
func (m *Foo) Upper(msg Message) Message {
msg.Content = strings.ToUpper(msg.Content)
return msg |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
func (m *Foo) Uppers(msg []Message) []Message {
for i := range msg {
msg[i].Content = strings.ToUpper(msg[i].Content)
}
return msg
}`,
},
{
sdk: "python",
source: `from dagger import field, function, object_type
@object_type
class Message:
content: str = field()
@object_type
class Foo:
@function
def say_hello(self, name: str) -> Message:
return Message(content=f"hello {name}")
@function
def upper(self, msg: Message) -> Message:
msg.content = msg.content.upper()
return msg
@function
def uppers(self, msg: list[Message]) -> list[Message]:
for m in msg:
m.content = m.content.upper()
return msg
`,
}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | {
sdk: "typescript",
source: `
import { object, func, field } from "@dagger.io/dagger"
@object()
class Message {
@field()
content: string
constructor(content: string) {
this.content = content
}
}
@object()
class Foo {
@func()
sayHello(name: string): Message {
return new Message("hello " + name)
}
@func()
upper(msg: Message): Message {
msg.content = msg.content.toUpperCase()
return msg
}
@func()
uppers(msg: Message[]): Message[] {
for (let i = 0; i < msg.length; i++) {
msg[i].content = msg[i].content.toUpperCase()
}
return msg
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{sayHello(name: "world"){id}}}`)).Stdout(ctx)
require.NoError(t, err)
id := gjson.Get(out, "foo.sayHello.id").String()
var idp idproto.ID
err = idp.Decode(id)
require.NoError(t, err)
require.Equal(t, idp.Display(), `foo.sayHello(name: "world"): FooMessage!`)
out, err = modGen.With(daggerQuery(`{foo{upper(msg:"%s"){content}}}`, id)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"upper":{"content": "HELLO WORLD"}}}`, out)
out, err = modGen.With(daggerQuery(`{foo{uppers(msg:["%s", "%s"]){content}}}`, id, id)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"uppers":[{"content": "HELLO WORLD"}, {"content": "HELLO WORLD"}]}}`, out)
})
}
}
func TestModuleConflictingSameNameDeps(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
ctr := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dstr").
With(daggerExec("init", "--source=.", "--name=d", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type D struct{}
type Obj struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | Foo string
}
func (m *D) Fn(foo string) Obj {
return Obj{Foo: foo}
}
`,
})
ctr = ctr.
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dint").
With(daggerExec("init", "--source=.", "--name=d", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type D struct{}
type Obj struct {
Foo int
}
func (m *D) Fn(foo int) Obj {
return Obj{Foo: foo}
}
`,
})
ctr = ctr.
WithWorkdir("/work").
With(daggerExec("init", "--source=c", "--name=c", "--sdk=go", "c")).
WithWorkdir("/work/c").
With(daggerExec("install", "../dstr")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import ( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | "context"
)
type C struct{}
func (m *C) Fn(ctx context.Context, foo string) (string, error) {
return dag.D().Fn(foo).Foo(ctx)
}
`,
})
ctr = ctr.
WithWorkdir("/work").
With(daggerExec("init", "--source=b", "--name=b", "--sdk=go", "b")).
With(daggerExec("install", "-m=b", "./dint")).
WithNewFile("/work/b/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
)
type B struct{}
func (m *B) Fn(ctx context.Context, foo int) (int, error) {
return dag.D().Fn(foo).Foo(ctx)
}
`,
})
ctr = ctr.
WithWorkdir("/work").
With(daggerExec("init", "--source=a", "--name=a", "--sdk=go", "a")).
WithWorkdir("/work/a").
With(daggerExec("install", "../b")).
With(daggerExec("install", "../c")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | Contents: `package main
import (
"context"
"strconv"
)
type A struct{}
func (m *A) Fn(ctx context.Context) (string, error) {
fooStr, err := dag.C().Fn(ctx, "foo")
if err != nil {
return "", err
}
fooInt, err := dag.B().Fn(ctx, 123)
if err != nil {
return "", err
}
return fooStr + strconv.Itoa(fooInt), nil
}
`,
})
out, err := ctr.With(daggerQuery(`{a{fn}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"a":{"fn": "foo123"}}`, out)
types := currentSchema(ctx, t, ctr).Types
require.NotNil(t, types.Get("A"))
require.Nil(t, types.Get("B"))
require.Nil(t, types.Get("C"))
require.Nil(t, types.Get("D"))
}
func TestModuleSelfAPICall(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"github.com/Khan/genqlient/graphql"
)
type Test struct{}
func (m *Test) FnA(ctx context.Context) (string, error) {
resp := &graphql.Response{}
err := dag.Client.MakeRequest(ctx, &graphql.Request{
Query: "{test{fnB}}",
}, resp)
if err != nil {
return "", err
}
return resp.Data.(map[string]any)["test"].(map[string]any)["fnB"].(string), nil
}
func (m *Test) FnB() string {
return "hi from b" |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
`,
}).
With(daggerQuery(`{test{fnA}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"test":{"fnA": "hi from b"}}`, out)
}
func TestModuleGoWithOtherModuleTypes(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--source=.", "--name=dep", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Dep struct{}
type Obj struct {
Foo string
}
func (m *Dep) Fn() Obj {
return Obj{Foo: "foo"}
}
`,
}).
WithWorkdir("/work").
With(daggerExec("init", "--source=test", "--name=test", "--sdk=go", "test")).
With(daggerExec("install", "-m=test", "./dep")).
WithWorkdir("/work/test") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Run("return as other module object", func(t *testing.T) {
t.Run("direct", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn() (*DepObj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q cannot return external type from dependency module %q",
"Test", "Fn", "dep",
))
})
t.Run("list", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn() ([]*DepObj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q cannot return external type from dependency module %q",
"Test", "Fn", "dep",
))
})
})
t.Run("arg as other module object", func(t *testing.T) {
t.Run("direct", func(t *testing.T) {
_, err := ctr.WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn(obj *DepObj) error {
return nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q arg %q cannot reference external type from dependency module %q",
"Test", "Fn", "obj", "dep",
))
})
t.Run("list", func(t *testing.T) {
_, err := ctr.WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | func (m *Test) Fn(obj []*DepObj) error {
return nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q arg %q cannot reference external type from dependency module %q",
"Test", "Fn", "obj", "dep",
))
})
})
t.Run("field as other module object", func(t *testing.T) {
t.Run("direct", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
type Obj struct {
Foo *DepObj
}
func (m *Test) Fn() (*Obj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q field %q cannot reference external type from dependency module %q",
"Obj", "Foo", "dep",
))
})
t.Run("list", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
type Obj struct {
Foo []*DepObj
}
func (m *Test) Fn() (*Obj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q field %q cannot reference external type from dependency module %q",
"Obj", "Foo", "dep",
))
})
})
}
func TestModuleGoUseDaggerTypesDirect(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "main/internal/dagger"
type Minimal struct{}
func (m *Minimal) Foo(dir *Directory) (*dagger.Directory) {
return dir.WithNewFile("foo", "xxx")
}
func (m *Minimal) Bar(dir *dagger.Directory) (*Directory) {
return dir.WithNewFile("bar", "yyy")
}
`,
})
out, err := modGen.With(daggerQuery(`{directory{id}}`)).Stdout(ctx)
require.NoError(t, err)
dirID := gjson.Get(out, "directory.id").String()
out, err = modGen.With(daggerQuery(`{minimal{foo(dir: "%s"){file(path: "foo"){contents}}}}`, dirID)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"foo":{"file":{"contents": "xxx"}}}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{bar(dir: "%s"){file(path: "bar"){contents}}}}`, dirID)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"bar":{"file":{"contents": "yyy"}}}}`, out)
}
func TestModuleGoUtilsPkg(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"main/utils"
)
type Minimal struct{}
func (m *Minimal) Hello(ctx context.Context) (string, error) {
return utils.Foo().File("foo").Contents(ctx)
}
`,
}).
WithNewFile("utils/util.go", dagger.ContainerWithNewFileOpts{
Contents: `package utils
import "main/internal/dagger" |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | func Foo() *dagger.Directory {
return dagger.Connect().Directory().WithNewFile("/foo", "hello world")
}
`,
})
out, err := modGen.With(daggerQuery(`{minimal{hello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"hello":"hello world"}}`, out)
}
func TestModuleGoNameCase(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c))
ctr = ctr.
WithWorkdir("/toplevel/ssh").
With(daggerExec("init", "--name=ssh", "--sdk=go", "--source=.")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Ssh struct {}
func (ssh *Ssh) SayHello() string {
return "hello!"
}
`,
})
out, err := ctr.With(daggerQuery(`{ssh{sayHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"ssh":{"sayHello":"hello!"}}`, out)
ctr = ctr.
WithWorkdir("/toplevel"). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | With(daggerExec("init", "--name=toplevel", "--sdk=go", "--source=.")).
With(daggerExec("install", "./ssh")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type Toplevel struct {}
func (t *Toplevel) SayHello(ctx context.Context) (string, error) {
return dag.SSH().SayHello(ctx)
}
`,
})
logGen(ctx, t, ctr.Directory("."))
out, err = ctr.With(daggerQuery(`{toplevel{sayHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"toplevel":{"sayHello":"hello!"}}`, out)
}
var useInner = `package main
type Dep struct{}
func (m *Dep) Hello() string {
return "hello"
}
`
var useGoOuter = `package main
import "context"
type Use struct{}
func (m *Use) UseHello(ctx context.Context) (string, error) {
return dag.Dep().Hello(ctx)
}
`
var usePythonOuter = `from dagger import dag, function |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | @function
def use_hello() -> str:
return dag.dep().hello()
`
var useTSOuter = `
import { dag, object, func } from '@dagger.io/dagger'
@object()
class Use {
@func()
async useHello(): Promise<string> {
return dag.dep().hello()
}
}
`
func TestModuleUseLocal(t *testing.T) {
t.Parallel()
type testCase struct {
sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: useGoOuter,
},
{
sdk: "python",
source: usePythonOuter,
},
{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk: "typescript",
source: useTSOuter,
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--name=dep", "--sdk=go")).
With(sdkSource("go", useInner)).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerExec("install", "./dep"))
out, err := modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
_, err = modGen.With(daggerQuery(`{dep{hello}}`)).Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, `Query has no such field: "dep"`)
})
}
}
func TestModuleCodegenOnDepChange(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
changed string
expected string
}
for _, tc := range []testCase{
{
sdk: "go",
source: useGoOuter,
expected: "Hellov2",
changed: strings.ReplaceAll(useGoOuter, `Hello(ctx)`, `Hellov2(ctx)`),
},
{
sdk: "python",
source: usePythonOuter,
expected: "hellov2",
changed: strings.ReplaceAll(usePythonOuter, `.hello()`, `.hellov2()`),
},
{
sdk: "typescript",
source: useTSOuter,
expected: "hellov2",
changed: strings.ReplaceAll(useTSOuter, `.hello()`, `.hellov2()`),
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--name=dep", "--sdk=go")).
With(sdkSource("go", useInner)).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerExec("install", "./dep"))
out, err := modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
newInner := strings.ReplaceAll(useInner, `Hello()`, `Hellov2()`)
modGen = modGen.
WithWorkdir("/work/dep").
With(sdkSource("go", newInner)).
WithWorkdir("/work").
With(daggerExec("develop"))
codegenContents, err := modGen.File(sdkCodegenFile(t, tc.sdk)).Contents(ctx)
require.NoError(t, err)
require.Contains(t, codegenContents, tc.expected)
modGen = modGen.With(sdkSource(tc.sdk, tc.changed))
out, err = modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
})
}
}
func TestModuleSyncDeps(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
type testCase struct {
sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: useGoOuter,
},
{
sdk: "python",
source: usePythonOuter,
},
{
sdk: "typescript",
source: useTSOuter,
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--name=dep", "--sdk=go")).
With(sdkSource("go", useInner)).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerExec("install", "./dep"))
modGen = modGen.With(daggerQuery(`{use{useHello}}`))
out, err := modGen.Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
newInner := strings.ReplaceAll(useInner, `"hello"`, `"goodbye"`)
modGen = modGen.
WithWorkdir("/work/dep").
With(sdkSource("go", newInner)).
WithWorkdir("/work").
With(daggerExec("develop"))
out, err = modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"goodbye"}}`, out)
})
}
}
func TestModuleUseLocalMulti(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "context"
import "fmt"
type Use struct {}
func (m *Use) Names(ctx context.Context) ([]string, error) {
fooName, err := dag.Foo().Name(ctx)
if err != nil {
return nil, fmt.Errorf("foo.name: %w", err)
}
barName, err := dag.Bar().Name(ctx)
if err != nil {
return nil, fmt.Errorf("bar.name: %w", err)
}
return []string{fooName, barName}, nil
}
`,
},
{
sdk: "python", |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | source: `from dagger import dag, function
@function
async def names() -> list[str]:
return [
await dag.foo().name(),
await dag.bar().name(),
]
`,
},
{
sdk: "typescript",
source: `
import { dag, object, func } from '@dagger.io/dagger'
@object()
class Use {
@func()
async names(): Promise<string[]> {
return [await dag.foo().name(), await dag.bar().name()]
}
}
`,
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/foo"). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | WithNewFile("/work/foo/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Foo struct {}
func (m *Foo) Name() string { return "foo" }
`,
}).
With(daggerExec("init", "--source=.", "--name=foo", "--sdk=go")).
WithWorkdir("/work/bar").
WithNewFile("/work/bar/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Bar struct {}
func (m *Bar) Name() string { return "bar" }
`,
}).
With(daggerExec("init", "--source=.", "--name=bar", "--sdk=go")).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(daggerExec("install", "./foo")).
With(daggerExec("install", "./bar")).
With(sdkSource(tc.sdk, tc.source)).
WithEnvVariable("BUST", identity.NewID())
out, err := modGen.With(daggerQuery(`{use{names}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"names":["foo", "bar"]}}`, out)
})
}
}
func TestModuleConstructor(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | sdk string
source string
}
t.Run("basic", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import (
"context"
)
func New(
ctx context.Context,
foo string,
bar *int, // +optional
baz []string,
dir *Directory,
) *Test {
bar2 := 42
if bar != nil {
bar2 = *bar
}
return &Test{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | Foo: foo,
Bar: bar2,
Baz: baz,
Dir: dir,
}
}
type Test struct {
Foo string
Bar int
Baz []string
Dir *Directory
NeverSetDir *Directory
}
func (m *Test) GimmeFoo() string {
return m.Foo
}
func (m *Test) GimmeBar() int {
return m.Bar
}
func (m *Test) GimmeBaz() []string {
return m.Baz
}
func (m *Test) GimmeDirEnts(ctx context.Context) ([]string, error) {
return m.Dir.Entries(ctx)
}
`,
},
{
sdk: "python",
source: `import dagger |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | from dagger import field, function, object_type
@object_type
class Test:
foo: str = field()
dir: dagger.Directory = field()
bar: int = field(default=42)
baz: list[str] = field(default=list)
never_set_dir: dagger.Directory | None = field(default=None)
@function
def gimme_foo(self) -> str:
return self.foo
@function
def gimme_bar(self) -> int:
return self.bar
@function
def gimme_baz(self) -> list[str]:
return self.baz
@function
async def gimme_dir_ents(self) -> list[str]:
return await self.dir.entries()
`,
},
{
sdk: "typescript",
source: `
import { Directory, object, func, field } from '@dagger.io/dagger';
@object()
class Test {
@field()
foo: string |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | @field()
dir: Directory
@field()
bar: number
@field()
baz: string[]
@field()
neverSetDir?: Directory
constructor(foo: string, dir: Directory, bar = 42, baz: string[] = []) {
this.foo = foo;
this.dir = dir;
this.bar = bar;
this.baz = baz;
}
@func()
gimmeFoo(): string {
return this.foo;
}
@func()
gimmeBar(): number {
return this.bar;
}
@func()
gimmeBaz(): string[] {
return this.baz;
}
@func()
async gimmeDirEnts(): Promise<string[]> {
return this.dir.entries();
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | }
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := modInit(ctx, t, c, tc.sdk, tc.source)
out, err := ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "foo")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "abc")
out, err = ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "gimme-foo")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "abc")
out, err = ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "42")
out, err = ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "gimme-bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "42")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "123")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "gimme-bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "123")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "baz")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "x\ny\nz") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,662 | Using embedded fields with go modules fails with unhelpful error | Take the following code:
```go
type Playground struct {
// This breaks
*Directory
// This doesn't
// Directory *Directory
}
func New() Playground {
return Playground{Directory: dag.Directory()}
}
```
When attempting to evaluate anything on the `Playground` object, we get the following error:
```
Error: response from query: input: resolve: playground: failed to convert return value: unexpected result value type string for object "Playground"
``` | https://github.com/dagger/dagger/issues/6662 | https://github.com/dagger/dagger/pull/6715 | 2f975ef29ad78e08c5b9328f6db3797b4c57da69 | b966257dbc24b714e6ee39f01158f10f8fa24fd3 | "2024-02-13T15:54:25Z" | go | "2024-02-26T15:11:43Z" | core/integration/module_test.go | out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "gimme-baz")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "x\ny\nz")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "gimme-dir-ents")).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, strings.TrimSpace(out), "dagger.json")
})
}
})
t.Run("fields only", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import (
"context"
)
func New(ctx context.Context) (Test, error) {
v, err := dag.Container().From("alpine:3.18.4").File("/etc/alpine-release").Contents(ctx)
if err != nil {
return Test{}, err
}
return Test{
AlpineVersion: v,
}, nil
}
type Test struct {
AlpineVersion string
} |
Subsets and Splits