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
timestamp[us, tz=UTC] | language
stringclasses 5
values | commit_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 7
188
| chunk_content
stringlengths 1
1.03M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
committedModGen := goGitBase(t, c).
With(daggerExec("mod", "init", "--name=bare", "--sdk=python")).
WithExec([]string{"rm", ".gitignore"}).
WithExec([]string{"git", "add", "."}).
WithExec([]string{"git", "commit", "-m", "init with generated files"})
changedAfterSync, err := committedModGen.
With(daggerExec("mod", "sync")).
WithExec([]string{"git", "diff"}).
WithExec([]string{"git", "status", "--short"}).
Stdout(ctx)
require.NoError(t, err)
t.Logf("changed after sync:\n%s", changedAfterSync)
require.Contains(t, changedAfterSync, "D sdk/pyproject.toml\n")
require.Contains(t, changedAfterSync, "D sdk/src/dagger/__init__.py\n")
}
var goSignatures string
func TestModuleGoSignatures(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: goSignatures,
})
logGen(ctx, t, modGen.Directory("."))
t.Run("func Hello() string", func(t *testing.T) {
t.Parallel()
out, err := modGen.With(daggerQuery(`{minimal{hello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"hello":"hello"}}`, out)
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Run("func Echo(string) string", func(t *testing.T) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
out, err := modGen.With(daggerQuery(`{minimal{echoOptionalPointer(msg: "hello")}}`)).Stdout(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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)
})
t.Run("func EchoOptionalSlice([]string) string", func(t *testing.T) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
out, err := modGen.With(daggerQuery(`{minimal{helloContext}}`)).Stdout(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"helloContext":"hello context"}}`, out)
})
t.Run("func EchoContext(context.Context, string) string", func(t *testing.T) {
t.Parallel()
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) {
t.Parallel()
out, err := modGen.With(daggerQuery(`{minimal{helloStringError}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"helloStringError":"hello i worked"}}`, out)
})
t.Run("func HelloVoid()", func(t *testing.T) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
out, err := modGen.With(daggerQuery(`{minimal{echoOpts(msg: "hi")}}`)).Stdout(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
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) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type Minimal struct {} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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, dir Optional[Directory]) (string, error) {
d, ok := dir.Get()
if ok {
return d.File("foo").Contents(ctx)
}
return "", nil
}
`,
})
logGen(ctx, t, modGen.Directory("."))
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) {
t.Parallel()
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) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | })
t.Run("func ReadPointer(ctx, *Directory) (string, error)", func(t *testing.T) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
out, err := modGen.With(daggerQuery(fmt.Sprintf(`{minimal{readVariadic(dir: ["%s"])}}`, dirID))).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"readVariadic":"bar"}}`, out)
})
t.Run("func ReadOptional(ctx, Optional[Directory]) (string, error)", func(t *testing.T) {
t.Parallel()
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) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--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
}
func (b *bar) Hello(name string) string {
return name
}
`, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | })
logGen(ctx, t, modGen.Directory("."))
out, err := modGen.With(inspectModule).Stdout(ctx)
require.NoError(t, err)
objs := gjson.Get(out, "host.directory.asModule.objects")
require.Equal(t, 2, len(objs.Array()))
minimal := objs.Get(`0.asObject`)
require.Equal(t, "Minimal", minimal.Get("name").String())
foo := objs.Get(`1.asObject`)
require.Equal(t, "MinimalFoo", foo.Get("name").String())
modGen = c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--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) string {
return name
}
func (f *Foo) Hello(name string) string {
return name
}
func (b *bar) Hello(name string) string {
return name
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | `,
})
logGen(ctx, t, modGen.Directory("."))
_, err = modGen.With(inspectModule).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) {
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("mod", "init", "--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
}
`,
})
logGen(ctx, t, modGen.Directory("."))
_, 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")
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | var inspectModule = daggerQuery(`
query {
host {
directory(path: ".") {
asModule {
objects {
asObject {
name
description
functions {
name
description
args {
name
description
defaultValue
}
}
fields {
name
description
}
}
}
}
}
}
}
`)
func TestModuleGoDocs(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: goSignatures,
})
logGen(ctx, t, modGen.Directory("."))
out, err := modGen.With(inspectModule).Stdout(ctx)
require.NoError(t, err)
obj := gjson.Get(out, "host.directory.asModule.objects.0.asObject")
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,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--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
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | // 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
}
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 |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | return foo
}
`,
})
logGen(ctx, t, modGen.Directory("."))
out, err := modGen.With(inspectModule).Stdout(ctx)
require.NoError(t, err)
obj := gjson.Get(out, "host.directory.asModule.objects.0.asObject")
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())
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()) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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")`)
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 TestModuleGoOptionalMustBeNil(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Minimal struct {}
func (m *Minimal) Foo(x *Optional[*string]) string {
if v, _ := x.Get(); v != nil {
panic("uh oh")
}
return ""
}
func (m *Minimal) Bar(opts struct {
x *Optional[*string]
}) string {
if v, _ := opts.x.Get(); v != nil {
panic("uh oh")
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | return ""
}
func (m *Minimal) Baz(
// +optional
x *string,
) string {
if x != nil {
panic("uh oh")
}
return ""
}
func (m *Minimal) Qux(opts struct {
// +optional
x *string
}) string {
if opts.x != nil {
panic("uh oh")
}
return ""
}
`,
})
logGen(ctx, t, modGen.Directory("."))
for _, name := range []string{"foo", "bar", "baz", "qux"} {
out, err := modGen.With(daggerQuery(`{minimal{%s}}`, name)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, fmt.Sprintf(`{"minimal": {"%s": ""}}`, name), out)
}
}
func TestModuleGoPrivateField(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `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
}
`,
})
logGen(ctx, t, modGen.Directory("."))
out, err := modGen.With(inspectModule).Stdout(ctx)
require.NoError(t, err)
obj := gjson.Get(out, "host.directory.asModule.objects.0.asObject")
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()) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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, `Cannot query field "bar"`)
}
var goExtend string
func TestModuleGoExtendCore(t *testing.T) {
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("mod", "init", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: goExtend,
}).
With(daggerExec("mod", "sync")).
Sync(ctx)
require.Error(t, err)
require.NoError(t, c.Close())
require.Contains(t, logs.String(), "cannot define methods on objects from outside this module")
}
var goCustomTypes string
var pythonCustomTypes string
func TestModuleCustomTypes(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
type testCase struct {
sdk string
sourcePath string
sourceContent string
}
for _, tc := range []testCase{
{
sdk: "go",
sourcePath: "main.go",
sourceContent: goCustomTypes,
},
{
sdk: "python",
sourcePath: "src/main.py",
sourceContent: pythonCustomTypes,
},
} {
t.Run(fmt.Sprintf("custom %s types", tc.sdk), func(t *testing.T) {
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=test", "--sdk="+tc.sdk)).
WithNewFile(tc.sourcePath, dagger.ContainerWithNewFileOpts{
Contents: tc.sourceContent,
})
if tc.sdk == "go" {
logGen(ctx, t, modGen.Directory("."))
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | out, err := modGen.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 TestModuleGoReturnTypeDetection(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=foo", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Foo struct {}
type X struct {
Message string ` + "`json:\"message\"`" + `
}
func (m *Foo) MyFunction() X {
return X{Message: "foo"}
}
`,
})
logGen(ctx, t, modGen.Directory("."))
out, err := modGen.With(daggerQuery(`{foo{myFunction{message}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"myFunction":{"message":"foo"}}}`, out)
}
func TestModuleGoReturnStruct(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--name=foo", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `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"}
}
`,
})
logGen(ctx, t, modGen.Directory("."))
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 TestModuleGoReturnNestedStruct(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--name=playground", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `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"}}
}
`,
})
logGen(ctx, t, modGen.Directory("."))
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 TestModuleGoReturnCompositeCore(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--name=playground", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Playground struct{}
func (m *Playground) MySlice() []*Container {
return []*Container{dag.Container().From("alpine:latest").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("alpine:latest").WithExec([]string{"echo", "hello world"})}
}
`,
})
logGen(ctx, t, modGen.Directory("."))
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,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | }
func TestModuleGoReturnComplexThing(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=playground", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `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("alpine:latest").WithExec([]string{"echo", "hello world"}),
},
Report: ScanReport{
Contents: "hello world",
Authors: []string{"foo", "bar"},
},
}
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | `,
})
logGen(ctx, t, modGen.Directory("."))
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 TestModuleGoGlobalVarDAG(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=foo", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type Foo struct {}
var someDefault = dag.Container().From("alpine:latest")
func (m *Foo) Fn(ctx context.Context) (string, error) {
return someDefault.WithExec([]string{"echo", "foo"}).Stdout(ctx)
}
`,
})
logGen(ctx, t, modGen.Directory("."))
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) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
type testCase struct {
sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Foo struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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
def set(self, data: str) -> Self:
self.data = data
return self
@function
def get(self) -> str:
return self.data
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
if tc.sdk == "go" {
logGen(ctx, t, modGen.Directory("."))
}
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()
require.Contains(t, id, "moddata:")
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()
c, ctx := connect(t)
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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
}
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 |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | @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
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
if tc.sdk == "go" {
logGen(ctx, t, modGen.Directory(".")) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | }
out, err := modGen.With(daggerQuery(`{foo{sayHello(name: "world"){id}}}`)).Stdout(ctx)
require.NoError(t, err)
id := gjson.Get(out, "foo.sayHello.id").String()
require.Contains(t, id, "moddata:")
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) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dstr").
With(daggerExec("mod", "init", "--name=d", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type D struct{}
type Obj struct {
Foo string
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | func (m *D) Fn(foo string) Obj {
return Obj{Foo: foo}
}
`,
})
ctr = ctr.
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dint").
With(daggerExec("mod", "init", "--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/c").
With(daggerExec("mod", "init", "--name=c", "--sdk=go", "--root=..")).
With(daggerExec("mod", "install", "../dstr")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
)
type C struct{} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | func (m *C) Fn(ctx context.Context, foo string) (string, error) {
return dag.D().Fn(foo).Foo(ctx)
}
`,
})
ctr = ctr.
WithWorkdir("/work/b").
With(daggerExec("mod", "init", "--name=b", "--sdk=go", "--root=..")).
With(daggerExec("mod", "install", "../dint")).
WithNewFile("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/a").
With(daggerExec("mod", "init", "--name=a", "--sdk=go", "--root=..")).
With(daggerExec("mod", "install", "../b")).
With(daggerExec("mod", "install", "../c")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"strconv" |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | )
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) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | WithWorkdir("/work").
With(daggerExec("mod", "init", "--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.c.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"
}
`,
}).
With(daggerQuery(`{test{fnA}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"test":{"fnA": "hi from b"}}`, out)
}
func TestModuleWithOtherModuleTypes(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("mod", "init", "--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/test").
With(daggerExec("mod", "init", "--name=test", "--sdk=go", "--root=..")).
With(daggerExec("mod", "install", "../dep"))
t.Run("return as other module object", func(t *testing.T) {
t.Parallel()
t.Run("direct", func(t *testing.T) {
t.Parallel()
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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) {
t.Parallel()
_, 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", |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | "Test", "Fn", "dep",
))
})
})
t.Run("arg as other module object", func(t *testing.T) {
t.Parallel()
t.Run("direct", func(t *testing.T) {
t.Parallel()
_, 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) {
t.Parallel()
_, err := ctr.WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn(obj []*DepObj) error { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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.Parallel()
t.Run("direct", func(t *testing.T) {
t.Parallel()
_, 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()). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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",
))
})
t.Run("list", func(t *testing.T) {
t.Parallel()
_, 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",
))
})
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | }
var useInner string
var useOuter string
func TestModuleUseLocal(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
t.Run("go uses go", func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("mod", "init", "--name=dep", "--sdk=go")).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=use", "--sdk=go")).
WithNewFile("/work/dep/main.go", dagger.ContainerWithNewFileOpts{
Contents: useInner,
}).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: useOuter,
}).
With(daggerExec("mod", "install", "./dep")).
WithEnvVariable("BUST", identity.NewID())
logGen(ctx, t, modGen.Directory("."))
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, `Cannot query field "dep" on type "Query".`) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | })
t.Run("python uses go", func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("mod", "init", "--name=dep", "--sdk=go")).
WithNewFile("/work/dep/main.go", dagger.ContainerWithNewFileOpts{
Contents: useInner,
}).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=use", "--sdk=python")).
With(daggerExec("mod", "install", "./dep")).
WithNewFile("/work/src/main.py", dagger.ContainerWithNewFileOpts{
Contents: `from dagger import dag, function
@function
def use_hello() -> str:
return dag.dep().hello()
`,
})
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, `Cannot query field "dep" on type "Query".`)
})
}
func TestModuleCodegenonDepChange(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
t.Run("go uses go", func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("mod", "init", "--name=dep", "--sdk=go")).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=use", "--sdk=go")).
WithNewFile("/work/dep/main.go", dagger.ContainerWithNewFileOpts{
Contents: useInner,
}).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: useOuter,
}).
With(daggerExec("mod", "install", "./dep"))
logGen(ctx, t, modGen.Directory("."))
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.
WithNewFile("/work/dep/main.go", dagger.ContainerWithNewFileOpts{
Contents: newInner,
}).
WithExec([]string{"sh", "-c", "dagger mod sync"}, dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | codegenContents, err := modGen.File("/work/dagger.gen.go").Contents(ctx)
require.NoError(t, err)
require.Contains(t, codegenContents, "Hellov2")
newOuter := strings.ReplaceAll(useOuter, `Hello(ctx)`, `Hellov2(ctx)`)
modGen = modGen.
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: newOuter,
})
out, err = modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
})
t.Run("python uses go", func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("mod", "init", "--name=dep", "--sdk=go")).
WithNewFile("/work/dep/main.go", dagger.ContainerWithNewFileOpts{
Contents: useInner,
}).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=use", "--sdk=python")).
With(daggerExec("mod", "install", "./dep")).
WithNewFile("/work/src/main.py", dagger.ContainerWithNewFileOpts{
Contents: `from dagger import dag, function
@function
def use_hello() -> str:
return dag.dep().hello()
`, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | })
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.
WithNewFile("/work/dep/main.go", dagger.ContainerWithNewFileOpts{
Contents: newInner,
}).
WithExec([]string{"sh", "-c", "dagger mod sync"}, dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
})
codegenContents, err := modGen.File("/work/sdk/src/dagger/client/gen.py").Contents(ctx)
require.NoError(t, err)
require.Contains(t, codegenContents, "hellov2")
modGen = modGen.
WithNewFile("/work/src/main.py", dagger.ContainerWithNewFileOpts{
Contents: `from dagger import dag, function
@function
def use_hello() -> str:
return dag.dep().hellov2()
`,
})
out, err = modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
})
}
func TestModuleGoUseLocalMulti(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/foo").
WithNewFile("/work/foo/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Foo struct {}
func (m *Foo) Name() string { return "foo" }
`,
}).
With(daggerExec("mod", "init", "--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("mod", "init", "--name=bar", "--sdk=go")).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=use", "--sdk=go")). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | With(daggerExec("mod", "install", "./foo")).
With(daggerExec("mod", "install", "./bar")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `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
}
`,
}).
WithEnvVariable("BUST", identity.NewID())
logGen(ctx, t, modGen.Directory("."))
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()
c, ctx := connect(t)
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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 Optional[int],
baz []string,
dir *Directory,
) *Test {
return &Test{
Foo: foo,
Bar: bar.GetOr(42),
Baz: baz,
Dir: dir,
}
}
type Test struct {
Foo string
Bar int
Baz []string |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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
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: |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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()
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test").
With(daggerExec("mod", "init", "--name=test", "--sdk="+tc.sdk)).
With(sdkSource(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") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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")
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"
) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | 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
}
`,
},
{
sdk: "python",
source: `from dagger import dag, field, function, object_type
@object_type
class Test:
alpine_version: str = field()
@classmethod
async def create(cls) -> "Test":
return cls(alpine_version=await (
dag.container()
.from_("alpine:3.18.4")
.file("/etc/alpine-release")
.contents()
))
`,
}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | } {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test").
With(daggerExec("mod", "init", "--name=test", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := ctr.With(daggerCall("alpine-version")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "3.18.4")
})
}
})
t.Run("return error", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import (
"fmt"
)
func New() (*Test, error) {
return nil, fmt.Errorf("too bad")
}
type Test struct {
Foo string
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | `,
},
{
sdk: "python",
source: `from dagger import object_type, field
@object_type
class Test:
foo: str = field()
def __init__(self):
raise ValueError("too bad")
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test").
With(daggerExec("mod", "init", "--name=test", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
_, err := ctr.With(daggerCall("foo")).Stdout(ctx)
require.Error(t, err)
require.Contains(t, logs.String(), "too bad")
})
}
})
t.Run("python: with default factory", func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
content := identity.NewID()
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test").
With(daggerExec("mod", "init", "--name=test", "--sdk=python")).
With(sdkSource("python", fmt.Sprintf(`import dagger
from dagger import dag, object_type, field
@object_type
class Test:
foo: dagger.File = field(default=lambda: (
dag.directory()
.with_new_file("foo.txt", contents="%s")
.file("foo.txt")
))
bar: list[str] = field(default=list)
`, content),
))
out, err := ctr.With(daggerCall("foo")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), content)
out, err = ctr.With(daggerCall("--foo=dagger.json", "foo")).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, out, `"sdk": "python"`)
_, err = ctr.With(daggerCall("bar")).Sync(ctx)
require.NoError(t, err)
})
}
var wrapper string
func TestModuleGoWrapping(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--name=wrapper", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: wrapper,
})
logGen(ctx, t, modGen.Directory("."))
id := identity.NewID()
out, err := modGen.With(daggerQuery(
fmt.Sprintf(`{wrapper{container{echo(msg:%q){unwrap{stdout}}}}}`, id),
)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t,
fmt.Sprintf(`{"wrapper":{"container":{"echo":{"unwrap":{"stdout":%q}}}}}`, id),
out)
}
func TestModuleConfigAPI(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
moduleDir := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/subdir").
With(daggerExec("mod", "init", "--name=test", "--sdk=go", "--root=..")).
Directory("/work")
cfg := c.ModuleConfig(moduleDir, dagger.ModuleConfigOpts{Subpath: "subdir"})
name, err := cfg.Name(ctx)
require.NoError(t, err)
require.Equal(t, "test", name)
sdk, err := cfg.SDK(ctx)
require.NoError(t, err)
require.Equal(t, "go", sdk)
root, err := cfg.Root(ctx)
require.NoError(t, err)
require.Equal(t, "..", root)
}
func TestModulePythonInit(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Run("from scratch", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=bare", "--sdk=python"))
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("with different root", func(t *testing.T) {
t.Parallel() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/child").
With(daggerExec("mod", "init", "--name=bare", "--sdk=python", "--root=.."))
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("respects existing pyproject.toml", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("pyproject.toml", dagger.ContainerWithNewFileOpts{
Contents: `[project]
name = "has-pyproject"
version = "0.0.0"
`,
}).
With(daggerExec("mod", "init", "--name=hasPyproject", "--sdk=python"))
out, err := modGen.
With(daggerQuery(`{hasPyproject{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasPyproject":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("preserves module name", func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | generated, err := modGen.File("pyproject.toml").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, `name = "has-pyproject"`)
})
})
t.Run("respects existing main.py", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/src/main/__init__.py", dagger.ContainerWithNewFileOpts{
Contents: "from . import notmain\n",
}).
WithNewFile("/work/src/main/notmain.py", dagger.ContainerWithNewFileOpts{
Contents: `from dagger import function
@function
def hello() -> str:
return "Hello, world!"
`,
}).
With(daggerExec("mod", "init", "--name=hasMainPy", "--sdk=python"))
out, err := modGen.
With(daggerQuery(`{hasMainPy{hello}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasMainPy":{"hello":"Hello, world!"}}`, out)
})
}
func TestModulePythonReturnSelf(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | 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("mod", "init", "--name=foo", "--sdk=python")).
WithNewFile("src/main.py", dagger.ContainerWithNewFileOpts{
Contents: `from typing import Self
from dagger import field, function, object_type
@object_type
class Foo:
message: str = field(default="")
@function
def bar(self) -> Self:
self.message = "foobar"
return self
`,
})
out, err := modGen.With(daggerQuery(`{foo{bar{message}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"bar":{"message":"foobar"}}}`, out)
}
func TestModuleTypescriptInit(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Skip("unstable because of a typescript error")
t.Run("from scratch", func(t *testing.T) {
t.Skip("unstable because of a typescript error")
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=bare", "--sdk=typescript"))
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("with different root", func(t *testing.T) {
t.Skip("unstable because of a typescript error")
t.Parallel() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/child").
With(daggerExec("mod", "init", "--name=bare", "--sdk=typescript", "--root=.."))
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)
})
}
func TestModuleLotsOfFunctions(t *testing.T) {
t.Parallel()
const funcCount = 100
t.Run("go sdk", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
mainSrc := `
package main
type PotatoSack struct {}
`
for i := 0; i < funcCount; i++ {
mainSrc += fmt.Sprintf(`
func (m *PotatoSack) Potato%d() string {
return "potato #%d"
}
`, i, i)
}
modGen := c.Container().From(golangImage). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: mainSrc,
}).
With(daggerExec("mod", "init", "--name=potatoSack", "--sdk=go"))
logGen(ctx, t, modGen.Directory("."))
var eg errgroup.Group
for i := 0; i < funcCount; i++ {
i := i
if i%10 != 0 {
continue
}
eg.Go(func() error {
_, err := modGen.
With(daggerCall(fmt.Sprintf("potato%d", i))).
Sync(ctx)
return err
})
}
require.NoError(t, eg.Wait())
})
t.Run("python sdk", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
mainSrc := `from dagger import function
`
for i := 0; i < funcCount; i++ {
mainSrc += fmt.Sprintf(` |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | @function
def potato_%d() -> str:
return "potato #%d"
`, i, i)
}
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("./src/main.py", dagger.ContainerWithNewFileOpts{
Contents: mainSrc,
}).
With(daggerExec("mod", "init", "--name=potatoSack", "--sdk=python"))
var eg errgroup.Group
for i := 0; i < funcCount; i++ {
i := i
if i%10 != 0 {
continue
}
eg.Go(func() error {
_, err := modGen.
With(daggerCall(fmt.Sprintf("potato%d", i))).
Sync(ctx)
return err
})
}
require.NoError(t, eg.Wait())
})
}
func TestModuleLotsOfDeps(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work")
modCount := 0
getModMainSrc := func(name string, depNames []string) string {
t.Helper()
mainSrc := fmt.Sprintf(`package main
import "context"
type %s struct {}
func (m *%s) Fn(ctx context.Context) (string, error) {
s := "%s"
var depS string
_ = depS
var err error
_ = err
`, strcase.ToCamel(name), strcase.ToCamel(name), name)
for _, depName := range depNames {
mainSrc += fmt.Sprintf(`
depS, err = dag.%s().Fn(ctx)
if err != nil {
return "", err |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | }
s += depS
`, strcase.ToCamel(depName))
}
mainSrc += "return s, nil\n}\n"
fmted, err := format.Source([]byte(mainSrc))
require.NoError(t, err)
return string(fmted)
}
getModDaggerConfig := func(name string, depNames []string) string {
t.Helper()
var depVals []string
for _, depName := range depNames {
depVals = append(depVals, "../"+depName)
}
cfg := modules.Config{
Name: name,
Root: "..",
SDK: "go",
Dependencies: depVals,
}
bs, err := json.Marshal(cfg)
require.NoError(t, err)
return string(bs)
}
addModulesWithDeps := func(newMods int, depNames []string) []string {
t.Helper()
var newModNames []string |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | for i := 0; i < newMods; i++ {
name := fmt.Sprintf("mod%d", modCount)
modCount++
newModNames = append(newModNames, name)
modGen = modGen.
WithWorkdir("/work/"+name).
WithNewFile("./main.go", dagger.ContainerWithNewFileOpts{
Contents: getModMainSrc(name, depNames),
}).
WithNewFile("./dagger.json", dagger.ContainerWithNewFileOpts{
Contents: getModDaggerConfig(name, depNames),
})
}
return newModNames
}
curDeps := addModulesWithDeps(1, nil)
for i := 0; i < 6; i++ {
curDeps = addModulesWithDeps(len(curDeps)+1, curDeps)
}
addModulesWithDeps(1, curDeps)
_, err := modGen.With(daggerCall("fn")).Stdout(ctx)
require.NoError(t, err)
}
func TestModuleNamespacing(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
moduleSrcPath, err := filepath.Abs("./testdata/modules/go/namespacing")
require.NoError(t, err)
ctr := c.Container().From(alpineImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithMountedDirectory("/work", c.Host().Directory(moduleSrcPath)).
WithWorkdir("/work")
out, err := ctr.
With(daggerQuery(`{test{fn(s:"yo")}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"test":{"fn":"1:yo 2:yo"}}`, out)
}
func TestModuleRoots(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
moduleSrcPath, err := filepath.Abs("./testdata/modules/go/roots")
require.NoError(t, err)
entries, err := os.ReadDir(moduleSrcPath)
require.NoError(t, err)
ctr := c.Container().From(alpineImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithMountedDirectory("/work", c.Host().Directory(moduleSrcPath))
for _, entry := range entries {
entry := entry
t.Run(entry.Name(), func(t *testing.T) {
t.Parallel()
ctr := ctr.WithWorkdir("/work/" + entry.Name())
out, err := ctr.
With(daggerQuery(fmt.Sprintf(`{%s{hello}}`, strcase.ToLowerCamel(entry.Name())))).
Stdout(ctx)
if strings.HasPrefix(entry.Name(), "good-") {
require.NoError(t, err)
require.JSONEq(t, fmt.Sprintf(`{"%s":{"hello": "hello"}}`, strcase.ToLowerCamel(entry.Name())), out)
} else if strings.HasPrefix(entry.Name(), "bad-") {
require.Error(t, err)
require.Regexp(t, "is not under( module)? root", err.Error())
}
})
}
}
func TestModuleDaggerCall(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
t.Run("service args", func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
)
type Test struct {}
func (m *Test) Fn(ctx context.Context, svc *Service) (string, error) {
return dag.Container().From("alpine:3.18").WithExec([]string{"apk", "add", "curl"}).
WithServiceBinding("daserver", svc).
WithExec([]string{"curl", "http://daserver:8000"}).
Stdout(ctx)
}
`,
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | logGen(ctx, t, modGen.Directory("."))
httpServer, _ := httpService(ctx, t, c, "im up")
endpoint, err := httpServer.Endpoint(ctx)
require.NoError(t, err)
out, err := modGen.
WithServiceBinding("testserver", httpServer).
With(daggerCall("fn", "--svc", "tcp://"+endpoint)).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "im up")
})
t.Run("list args", func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=minimal", "--sdk=go")).
WithNewFile("foo.txt", dagger.ContainerWithNewFileOpts{
Contents: "bar",
}).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"strings"
)
type Minimal struct {}
func (m *Minimal) Hello(msgs []string) string {
return strings.Join(msgs, "+")
}
func (m *Minimal) Reads(ctx context.Context, files []File) (string, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | var contents []string
for _, f := range files {
content, err := f.Contents(ctx)
if err != nil {
return "", err
}
contents = append(contents, content)
}
return strings.Join(contents, "+"), nil
}
`,
})
logGen(ctx, t, modGen.Directory("."))
out, err := modGen.With(daggerCall("hello", "--msgs", "yo", "--msgs", "my", "--msgs", "friend")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "yo+my+friend")
out, err = modGen.With(daggerCall("reads", "--files=foo.txt", "--files=foo.txt")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "bar+bar")
})
t.Run("return list objects", func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Minimal struct {}
type Foo struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | Bar int ` + "`" + `json:"bar"` + "`" + `
}
func (m *Minimal) Fn() []*Foo {
var foos []*Foo
for i := 0; i < 3; i++ {
foos = append(foos, &Foo{Bar: i})
}
return foos
}
`,
})
logGen(ctx, t, modGen.Directory("."))
out, err := modGen.With(daggerCall("fn", "bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "0\n1\n2")
})
t.Run("directory arg inputs", func(t *testing.T) {
t.Parallel()
t.Run("local dir", func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=test", "--sdk=go")).
WithNewFile("/dir/subdir/foo.txt", dagger.ContainerWithNewFileOpts{
Contents: "foo",
}).
WithNewFile("/dir/subdir/bar.txt", dagger.ContainerWithNewFileOpts{
Contents: "bar",
}). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct {}
func (m *Test) Fn(dir *Directory) *Directory {
return dir
}
`,
})
out, err := modGen.With(daggerCall("fn", "--dir", "/dir/subdir")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "bar.txt\nfoo.txt")
out, err = modGen.With(daggerCall("fn", "--dir", "file:///dir/subdir")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "bar.txt\nfoo.txt")
})
t.Run("git dir", func(t *testing.T) {
t.Parallel()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct {}
func (m *Test) Fn(dir *Directory, subpath Optional[string]) *Directory {
return dir.Directory(subpath.GetOr("."))
}
`,
})
for _, tc := range []struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | baseURL string
subpath string
}{
{
baseURL: "https://github.com/dagger/dagger",
},
{
baseURL: "https://github.com/dagger/dagger",
subpath: ".changes", |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | },
{
baseURL: "https://github.com/dagger/dagger.git",
},
{
baseURL: "https://github.com/dagger/dagger.git",
subpath: ".changes",
},
} {
tc := tc
t.Run(fmt.Sprintf("%s:%s", tc.baseURL, tc.subpath), func(t *testing.T) {
t.Parallel()
url := tc.baseURL + "#v0.9.1"
if tc.subpath != "" {
url += ":" + tc.subpath
}
args := []string{"fn", "--dir", url}
if tc.subpath == "" {
args = append(args, "--subpath", ".changes")
}
out, err := modGen.With(daggerCall(args...)).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, out, "v0.9.1.md")
require.NotContains(t, out, "v0.9.2.md")
})
}
})
})
}
func TestModuleGoSyncDeps(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("mod", "init", "--name=dep", "--sdk=go")).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=use", "--sdk=go")).
WithNewFile("/work/dep/main.go", dagger.ContainerWithNewFileOpts{
Contents: useInner,
}).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: useOuter,
}).
With(daggerExec("mod", "install", "./dep"))
logGen(ctx, t, modGen.Directory("."))
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.
WithNewFile("/work/dep/main.go", dagger.ContainerWithNewFileOpts{
Contents: newInner,
}).
With(daggerExec("mod", "sync")) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | logGen(ctx, t, modGen.Directory("."))
out, err = modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"goodbye"}}`, out)
}
func TestModuleLoops(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/depA").
With(daggerExec("mod", "init", "--name=depA", "--sdk=go", "--root=..")).
WithWorkdir("/work/depB").
With(daggerExec("mod", "init", "--name=depB", "--sdk=go", "--root=..")).
With(daggerExec("mod", "install", "../depA")).
WithWorkdir("/work/depC").
With(daggerExec("mod", "init", "--name=depC", "--sdk=go", "--root=..")).
With(daggerExec("mod", "install", "../depB")).
WithWorkdir("/work/depA").
With(daggerExec("mod", "install", "../depC")).
Sync(ctx)
require.ErrorContains(t, err, "module depA has a circular dependency")
}
var badIDArgGoSrc string
var badIDArgPySrc string
var badIDFieldGoSrc string
var badIDFnGoSrc string
var badIDFnPySrc string
func TestModuleReservedWords(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
t.Run("id", func(t *testing.T) {
t.Parallel()
t.Run("arg", func(t *testing.T) {
t.Parallel()
t.Run("go", func(t *testing.T) {
t.Parallel()
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: badIDArgGoSrc,
}).
With(daggerQuery(`{test{fn(id:"no")}}`)).
Sync(ctx)
require.ErrorContains(t, err, "cannot define argument with reserved name \"id\"")
})
t.Run("python", func(t *testing.T) {
t.Parallel()
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=test", "--sdk=python")).
WithNewFile("/work/src/main.py", dagger.ContainerWithNewFileOpts{
Contents: badIDArgPySrc,
}). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | With(daggerQuery(`{test{fn(id:"no")}}`)).
Sync(ctx)
require.ErrorContains(t, err, "cannot define argument with reserved name \"id\"")
})
})
t.Run("field", func(t *testing.T) {
t.Parallel()
t.Run("go", func(t *testing.T) {
t.Parallel()
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: badIDFieldGoSrc,
}).
With(daggerQuery(`{test{fn{id}}}`)).
Sync(ctx)
require.ErrorContains(t, err, "cannot define field with reserved name \"id\"")
})
})
t.Run("fn", func(t *testing.T) {
t.Parallel()
t.Run("go", func(t *testing.T) {
t.Parallel()
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | Contents: badIDFnGoSrc,
}).
With(daggerQuery(`{test{id}}`)).
Sync(ctx)
require.ErrorContains(t, err, "cannot define function with reserved name \"id\"")
})
t.Run("python", func(t *testing.T) {
t.Parallel()
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=test", "--sdk=python")).
WithNewFile("/work/src/main.py", dagger.ContainerWithNewFileOpts{
Contents: badIDFnPySrc,
}).
With(daggerQuery(`{test{fn(id:"no")}}`)).
Sync(ctx)
require.ErrorContains(t, err, "cannot define function with reserved name \"id\"")
})
})
})
}
func daggerExec(args ...string) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
return c.WithExec(append([]string{"dagger", "--debug"}, args...), dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
})
}
}
func daggerQuery(query string, args ...any) dagger.WithContainerFunc { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | query = fmt.Sprintf(query, args...)
return func(c *dagger.Container) *dagger.Container {
return c.WithExec([]string{"dagger", "--debug", "query"}, dagger.ContainerWithExecOpts{
Stdin: query,
ExperimentalPrivilegedNesting: true,
})
}
}
func daggerCall(args ...string) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
return c.WithExec(append([]string{"dagger", "--debug", "call"}, args...), dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
})
}
}
func daggerFunctions(args ...string) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
return c.WithExec(append([]string{"dagger", "--debug", "functions"}, args...), dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
})
}
}
func hostDaggerCommand(ctx context.Context, t testing.TB, workdir string, args ...string) *exec.Cmd {
t.Helper()
cmd := exec.CommandContext(ctx, daggerCliPath(t), args...)
cmd.Dir = workdir
return cmd
}
func hostDaggerExec(ctx context.Context, t testing.TB, workdir string, args ...string) ([]byte, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Helper()
cmd := hostDaggerCommand(ctx, t, workdir, args...)
output, err := cmd.CombinedOutput()
if err != nil {
err = fmt.Errorf("%s: %w", string(output), err)
}
return output, err
}
func sdkSource(sdk, contents string) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
var sourcePath string
switch sdk {
case "go":
sourcePath = "main.go"
case "python":
sourcePath = "src/main.py"
default:
return c
}
return c.WithNewFile(sourcePath, dagger.ContainerWithNewFileOpts{
Contents: contents,
})
}
}
func currentSchema(ctx context.Context, t *testing.T, ctr *dagger.Container) *introspection.Schema { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Helper()
out, err := ctr.With(daggerQuery(introspection.Query)).Stdout(ctx)
require.NoError(t, err)
var schemaResp introspection.Response
err = json.Unmarshal([]byte(out), &schemaResp)
require.NoError(t, err)
return schemaResp.Schema
}
func goGitBase(t *testing.T, c *dagger.Client) *dagger.Container {
t.Helper()
return c.Container().From(golangImage).
WithExec([]string{"apk", "add", "git"}).
WithExec([]string{"git", "config", "--global", "user.email", "dagger@example.com"}).
WithExec([]string{"git", "config", "--global", "user.name", "Dagger Tests"}).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"git", "init"})
}
func logGen(ctx context.Context, t *testing.T, modSrc *dagger.Directory) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/integration/module_test.go | t.Helper()
generated, err := modSrc.File("dagger.gen.go").Contents(ctx)
require.NoError(t, err)
t.Cleanup(func() {
t.Name()
fileName := filepath.Join(
os.TempDir(),
t.Name(),
fmt.Sprintf("dagger.gen.%d.go", time.Now().Unix()),
)
if err := os.MkdirAll(filepath.Dir(fileName), 0o755); err != nil {
t.Logf("failed to create temp dir for generated code: %v", err)
return
}
if err := os.WriteFile(fileName, []byte(generated), 0644); err != nil {
t.Logf("failed to write generated code to %s: %v", fileName, err)
} else {
t.Logf("wrote generated code to %s", fileName)
}
})
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/schema/coremod.go | package schema
import (
"context"
"fmt"
"github.com/dagger/dagger/core"
"github.com/opencontainers/go-digest"
)
type CoreMod struct {
compiledSchema *CompiledSchema
introspectionJSON string
}
var _ Mod = (*CoreMod)(nil)
func (m *CoreMod) Name() string {
return coreModuleName
}
func (m *CoreMod) DagDigest() digest.Digest {
return digest.FromString(coreModuleName)
}
func (m *CoreMod) Dependencies() []Mod {
return nil
}
func (m *CoreMod) Schema(_ context.Context) ([]SchemaResolvers, error) {
return []SchemaResolvers{m.compiledSchema.SchemaResolvers}, nil
}
func (m *CoreMod) SchemaIntrospectionJSON(_ context.Context) (string, error) {
return m.introspectionJSON, nil |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/schema/coremod.go | }
func (m *CoreMod) ModTypeFor(ctx context.Context, typeDef *core.TypeDef, checkDirectDeps bool) (ModType, bool, error) {
switch typeDef.Kind {
case core.TypeDefKindString, core.TypeDefKindInteger, core.TypeDefKindBoolean, core.TypeDefKindVoid:
return &PrimitiveType{}, true, nil
case core.TypeDefKindList:
underlyingType, ok, err := m.ModTypeFor(ctx, typeDef.AsList.ElementTypeDef, checkDirectDeps)
if err != nil {
return nil, false, fmt.Errorf("failed to get underlying type: %w", err)
}
if !ok {
return nil, false, nil
}
return &ListType{underlying: underlyingType}, true, nil
case core.TypeDefKindObject:
typeName := gqlObjectName(typeDef.AsObject.Name)
resolver, ok := m.compiledSchema.Resolvers()[typeName]
if !ok {
return nil, false, nil
}
idableResolver, ok := resolver.(IDableObjectResolver)
if !ok {
return nil, false, nil
}
return &CoreModObject{coreMod: m, resolver: idableResolver}, true, nil
default:
return nil, false, fmt.Errorf("unexpected type def kind %s", typeDef.Kind)
}
}
type CoreModObject struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/schema/coremod.go | coreMod *CoreMod
resolver IDableObjectResolver
}
var _ ModType = (*CoreModObject)(nil)
func (obj *CoreModObject) ConvertFromSDKResult(_ context.Context, value any) (any, error) {
if value == nil {
return nil, nil
}
id, ok := value.(string)
if !ok {
return value, nil
}
return obj.resolver.FromID(id)
}
func (obj *CoreModObject) ConvertToSDKInput(ctx context.Context, value any) (any, error) {
return obj.resolver.ToID(value)
}
func (obj *CoreModObject) SourceMod() Mod {
return obj.coreMod
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/schema/usermod.go | package schema
import (
"bytes"
"context"
"fmt"
"sync"
"github.com/dagger/dagger/core"
"github.com/dagger/dagger/core/resourceid"
"github.com/dagger/graphql"
"github.com/moby/buildkit/util/bklog"
"github.com/opencontainers/go-digest"
"github.com/vektah/gqlparser/v2/ast"
"github.com/vektah/gqlparser/v2/formatter"
)
/*
A user defined module loaded into this server's DAG.
*/
type UserMod struct {
api *APIServer
metadata *core.Module
deps *ModDeps
sdk SDK
dagDigest digest.Digest
lazilyLoadedObjects []*UserModObject
loadObjectsErr error
loadObjectsLock sync.Mutex
}
var _ Mod = (*UserMod)(nil)
func newUserMod(api *APIServer, modMeta *core.Module, deps *ModDeps, sdk SDK) (*UserMod, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/schema/usermod.go | selfDigest, err := modMeta.BaseDigest()
if err != nil {
return nil, fmt.Errorf("failed to get module digest: %w", err)
}
dagDigest := digest.FromString(selfDigest.String() + " " + deps.DagDigest().String())
m := &UserMod{
api: api,
metadata: modMeta,
deps: deps,
sdk: sdk,
dagDigest: dagDigest,
}
return m, nil
}
func (m *UserMod) Name() string {
return m.metadata.Name
}
func (m *UserMod) DagDigest() digest.Digest {
return m.dagDigest
}
func (m *UserMod) Dependencies() []Mod {
return m.deps.mods
}
func (m *UserMod) Codegen(ctx context.Context) (*core.GeneratedCode, error) {
return m.sdk.Codegen(ctx, m)
}
func (m *UserMod) Runtime(ctx context.Context) (*core.Container, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/schema/usermod.go | return m.sdk.Runtime(ctx, m)
}
func (m *UserMod) Objects(ctx context.Context) (loadedObjects []*UserModObject, rerr error) {
m.loadObjectsLock.Lock()
defer m.loadObjectsLock.Unlock()
if len(m.lazilyLoadedObjects) > 0 {
return m.lazilyLoadedObjects, nil
}
if m.loadObjectsErr != nil {
return nil, m.loadObjectsErr
}
defer func() {
m.lazilyLoadedObjects = loadedObjects
m.loadObjectsErr = rerr
}()
runtime, err := m.Runtime(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get module runtime: %w", err)
}
getModDefFn, err := newModFunction(ctx, m, nil, runtime, core.NewFunction("", &core.TypeDef{
Kind: core.TypeDefKindObject,
AsObject: core.NewObjectTypeDef("Module", ""),
}))
if err != nil {
return nil, fmt.Errorf("failed to create module definition function for module %q: %w", m.Name(), err)
}
result, err := getModDefFn.Call(ctx, &CallOpts{Cache: true, SkipSelfSchema: true})
if err != nil { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/schema/usermod.go | return nil, fmt.Errorf("failed to call module %q to get functions: %w", m.Name(), err)
}
modMeta, ok := result.(*core.Module)
if !ok {
return nil, fmt.Errorf("expected Module result, got %T", result)
}
objs := make([]*UserModObject, 0, len(modMeta.Objects))
for _, objTypeDef := range modMeta.Objects {
if err := m.validateTypeDef(ctx, objTypeDef); err != nil {
return nil, fmt.Errorf("failed to validate type def: %w", err)
}
if err := m.namespaceTypeDef(ctx, objTypeDef); err != nil {
return nil, fmt.Errorf("failed to namespace type def: %w", err)
}
obj, err := newModObject(ctx, m, objTypeDef)
if err != nil {
return nil, fmt.Errorf("failed to create object: %w", err)
}
objs = append(objs, obj)
}
return objs, nil
}
func (m *UserMod) ModTypeFor(ctx context.Context, typeDef *core.TypeDef, checkDirectDeps bool) (ModType, bool, error) {
switch typeDef.Kind {
case core.TypeDefKindString, core.TypeDefKindInteger, core.TypeDefKindBoolean, core.TypeDefKindVoid:
return &PrimitiveType{}, true, nil
case core.TypeDefKindList:
underlyingType, ok, err := m.ModTypeFor(ctx, typeDef.AsList.ElementTypeDef, checkDirectDeps)
if err != nil {
return nil, false, fmt.Errorf("failed to get underlying type: %w", err) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/schema/usermod.go | }
if !ok {
return nil, false, nil
}
return &ListType{underlying: underlyingType}, true, nil
case core.TypeDefKindObject:
if checkDirectDeps {
depType, ok, err := m.deps.ModTypeFor(ctx, typeDef)
if err != nil {
return nil, false, fmt.Errorf("failed to get type from dependency: %w", err)
}
if ok {
return depType, true, nil
}
}
objs, err := m.Objects(ctx)
if err != nil {
return nil, false, err
}
for _, obj := range objs {
if obj.typeDef.AsObject.Name == typeDef.AsObject.Name {
return obj, true, nil
}
}
return nil, false, nil
default:
return nil, false, fmt.Errorf("unexpected type def kind %s", typeDef.Kind)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,252 | 🐞 Module constructor returns pointer for empty object instead of returning nil for *Directory type | ### What is the issue?
When I created a module constructor with `// +optional=true` missing flag returned a pointer of the empty object instead of nil.
Example Code:
```go
package main
func New(
// +optional=true
src *Directory,
) *A {
return &A{Src: src}
}
type A struct {
Src *Directory
}
func (m *A) IsEmpty() bool {
return m.Src == nil
}
```
### Log output
```shell
dagger call is-empty
✔ dagger call is-empty [1.38s]
┃ false
• Cloud URL: https://dagger.cloud/runs/6ed9327f-a4e3-4257-9864-87733b642a5f
• Engine: 64fae4326b32 (version v0.9.4)
⧗ 2.79s ✔ 31 ∅ 7
```
### Steps to reproduce
The code from example can be used for reproducing the issue.
### SDK version
GO SDK v0.9.4
### OS version
macOS 14.0
cc: @jedevc | https://github.com/dagger/dagger/issues/6252 | https://github.com/dagger/dagger/pull/6257 | fd8922f8b964be83bd3fed1490fda114641ac480 | 3b82755058493c63d399bf095b1c3c4b4eba2834 | 2023-12-11T16:59:25Z | go | 2023-12-13T11:16:00Z | core/schema/usermod.go | }
func (m *UserMod) MainModuleObject(ctx context.Context) (*UserModObject, error) {
objs, err := m.Objects(ctx)
if err != nil {
return nil, err
}
for _, obj := range objs {
if obj.typeDef.AsObject.Name == gqlObjectName(m.metadata.Name) {
return obj, nil
}
}
return nil, fmt.Errorf("failed to find main module object %q", m.metadata.Name)
}
func (m *UserMod) Schema(ctx context.Context) ([]SchemaResolvers, error) {
ctx = bklog.WithLogger(ctx, bklog.G(ctx).WithField("module", m.Name()))
bklog.G(ctx).Debug("getting module schema")
objs, err := m.Objects(ctx)
if err != nil {
return nil, err
}
schemas := make([]SchemaResolvers, 0, len(objs))
for _, obj := range objs {
objSchemaDoc, objResolvers, err := obj.Schema(ctx)
if err != nil {
return nil, err
}
buf := &bytes.Buffer{}
formatter.NewFormatter(buf).FormatSchemaDocument(objSchemaDoc)
typeSchemaStr := buf.String()
schema := StaticSchema(StaticSchemaParams{ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.