status
stringclasses 1
value | repo_name
stringclasses 31
values | repo_url
stringclasses 31
values | issue_id
int64 1
104k
| title
stringlengths 4
233
| body
stringlengths 0
186k
⌀ | issue_url
stringlengths 38
56
| pull_url
stringlengths 37
54
| before_fix_sha
stringlengths 40
40
| after_fix_sha
stringlengths 40
40
| report_datetime
unknown | language
stringclasses 5
values | commit_datetime
unknown | updated_file
stringlengths 7
188
| chunk_content
stringlengths 1
1.03M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Playground struct{}
type Foo struct {
MsgContainer Bar
}
type Bar struct {
Msg string
}
func (m *Playground) MyFunction() Foo {
return Foo{MsgContainer: Bar{Msg: "hello world"}}
}
`,
},
{
sdk: "python",
source: `from dagger import field, function, object_type
@object_type |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | class Bar:
msg: str = field()
@object_type
class Foo:
msg_container: Bar = field()
@object_type
class Playground:
@function
def my_function(self) -> Foo:
return Foo(msg_container=Bar(msg="hello world"))
`,
},
{
sdk: "typescript",
source: `
import { object, func, field } from "@dagger.io/dagger"
@object()
class Bar {
@field()
msg: string;
constructor(msg: string) {
this.msg = msg;
}
}
@object()
class Foo {
@field()
msgContainer: Bar;
constructor(msgContainer: Bar) {
this.msgContainer = msgContainer; |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }
}
@object()
class Playground {
@func()
myFunction(): Foo {
return new Foo(new Bar("hello world"));
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=playground", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{playground{myFunction{msgContainer{msg}}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"playground":{"myFunction":{"msgContainer":{"msg": "hello world"}}}}`, out)
})
}
}
func TestModuleReturnCompositeCore(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Playground struct{}
func (m *Playground) MySlice() []*Container {
return []*Container{dag.Container().From("` + alpineImage + `").WithExec([]string{"echo", "hello world"})}
}
type Foo struct {
Con *Container
// verify fields can remain nil w/out error too
UnsetFile *File
}
func (m *Playground) MyStruct() *Foo {
return &Foo{Con: dag.Container().From("` + alpineImage + `").WithExec([]string{"echo", "hello world"})}
}
`,
},
{
sdk: "python",
source: `import dagger
from dagger import dag, field, function, object_type
@object_type
class Foo:
con: dagger.Container = field() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | unset_file: dagger.File | None = field(default=None)
@object_type
class Playground:
@function
def my_slice(self) -> list[dagger.Container]:
return [dag.container().from_("` + alpineImage + `").with_exec(["echo", "hello world"])]
@function
def my_struct(self) -> Foo:
return Foo(con=dag.container().from_("` + alpineImage + `").with_exec(["echo", "hello world"]))
`,
},
{
sdk: "typescript",
source: `
import { dag, Container, File, object, func, field } from "@dagger.io/dagger"
@object()
class Foo {
@field()
con: Container
@field()
unsetFile?: File
constructor(con: Container, usetFile?: File) {
this.con = con
this.usetFile = usetFile
}
}
@object()
class Playground {
@func()
mySlice(): Container[] { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | return [
dag.container().from("` + alpineImage + `").withExec(["echo", "hello world"])
]
}
@func()
myStruct(): Foo {
return new Foo(
dag.container().from("` + alpineImage + `").withExec(["echo", "hello world"])
)
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=playground", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{playground{mySlice{stdout}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"playground":{"mySlice":[{"stdout":"hello world\n"}]}}`, out)
out, err = modGen.With(daggerQuery(`{playground{myStruct{con{stdout}}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"playground":{"myStruct":{"con":{"stdout":"hello world\n"}}}}`, out)
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }
}
func TestModuleReturnComplexThing(t *testing.T) {
t.Parallel()
type testCase struct {
sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Playground struct{}
type ScanResult struct {
Containers []*Container ` + "`json:\"targets\"`" + `
Report ScanReport
}
type ScanReport struct {
Contents string ` + "`json:\"contents\"`" + `
Authors []string ` + "`json:\"Authors\"`" + `
}
func (m *Playground) Scan() ScanResult {
return ScanResult{
Containers: []*Container{
dag.Container().From("` + alpineImage + `").WithExec([]string{"echo", "hello world"}),
},
Report: ScanReport{
Contents: "hello world",
Authors: []string{"foo", "bar"},
}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }
}
`,
},
{
sdk: "python",
source: `import dagger
from dagger import dag, field, function, object_type
@object_type
class ScanReport:
contents: str = field()
authors: list[str] = field()
@object_type
class ScanResult:
containers: list[dagger.Container] = field(name="targets")
report: ScanReport = field()
@object_type
class Playground:
@function
def scan(self) -> ScanResult:
return ScanResult(
containers=[
dag.container().from_("` + alpineImage + `").with_exec(["echo", "hello world"]),
],
report=ScanReport(
contents="hello world",
authors=["foo", "bar"],
),
)
`, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | },
{
sdk: "typescript",
source: `
import { dag, Container, object, func, field } from "@dagger.io/dagger"
@object()
class ScanReport {
@field()
contents: string
@field()
authors: string[]
constructor(contents: string, authors: string[]) {
this.contents = contents
this.authors = authors
}
}
@object()
class ScanResult {
@field("targets")
containers: Container[]
@field()
report: ScanReport
constructor(containers: Container[], report: ScanReport) {
this.containers = containers
this.report = report
}
}
@object()
class Playground {
@func() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | async scan(): Promise<ScanResult> {
return new ScanResult(
[
dag.container().from("` + alpineImage + `").withExec(["echo", "hello world"])
],
new ScanReport("hello world", ["foo", "bar"])
)
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=playground", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{playground{scan{targets{stdout},report{contents,authors}}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"playground":{"scan":{"targets":[{"stdout":"hello world\n"}],"report":{"contents":"hello world","authors":["foo","bar"]}}}}`, out)
})
}
}
func TestModuleGlobalVarDAG(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "context"
type Foo struct {}
var someDefault = dag.Container().From("` + alpineImage + `")
func (m *Foo) Fn(ctx context.Context) (string, error) {
return someDefault.WithExec([]string{"echo", "foo"}).Stdout(ctx)
}
`,
},
{
sdk: "python",
source: `from dagger import dag, function, object_type
SOME_DEFAULT = dag.container().from_("` + alpineImage + `")
@object_type
class Foo:
@function
async def fn(self) -> str:
return await SOME_DEFAULT.with_exec(["echo", "foo"]).stdout()
`,
},
{
sdk: "typescript",
source: ` |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | import { dag, object, func } from "@dagger.io/dagger"
var someDefault = dag.container().from("` + alpineImage + `")
@object()
class Foo {
@func()
async fn(): Promise<string> {
return someDefault.withExec(["echo", "foo"]).stdout()
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{fn}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"fn":"foo\n"}}`, out)
})
}
}
func TestModuleIDableType(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Foo struct {
Data string
}
func (m *Foo) Set(data string) *Foo {
m.Data = data
return m
}
func (m *Foo) Get() string {
return m.Data
}
`,
},
{
sdk: "python",
source: `from typing import Self
from dagger import field, function, object_type
@object_type
class Foo:
data: str = ""
@function |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | def set(self, data: str) -> Self:
self.data = data
return self
@function
def get(self) -> str:
return self.data
`,
},
{
sdk: "typescript",
source: `
import { object, func } from "@dagger.io/dagger"
@object()
class Foo {
data: string = ""
@func()
set(data: string): Foo {
this.data = data
return this
}
@func()
get(): string {
return this.data
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{set(data: "abc"){get}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"set":{"get": "abc"}}}`, out)
out, err = modGen.With(daggerQuery(`{foo{set(data: "abc"){id}}}`)).Stdout(ctx)
require.NoError(t, err)
id := gjson.Get(out, "foo.set.id").String()
var idp idproto.ID
err = idp.Decode(id)
require.NoError(t, err)
require.Equal(t, idp.Display(), `foo.set(data: "abc"): Foo!`)
out, err = modGen.With(daggerQuery(`{loadFooFromID(id: "%s"){get}}`, id)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"loadFooFromID":{"get": "abc"}}`, out)
})
}
}
func TestModuleArgOwnType(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "strings"
type Foo struct{}
type Message struct {
Content string
}
func (m *Foo) SayHello(name string) Message {
return Message{Content: "hello " + name}
}
func (m *Foo) Upper(msg Message) Message {
msg.Content = strings.ToUpper(msg.Content)
return msg |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }
func (m *Foo) Uppers(msg []Message) []Message {
for i := range msg {
msg[i].Content = strings.ToUpper(msg[i].Content)
}
return msg
}`,
},
{
sdk: "python",
source: `from dagger import field, function, object_type
@object_type
class Message:
content: str = field()
@object_type
class Foo:
@function
def say_hello(self, name: str) -> Message:
return Message(content=f"hello {name}")
@function
def upper(self, msg: Message) -> Message:
msg.content = msg.content.upper()
return msg
@function
def uppers(self, msg: list[Message]) -> list[Message]:
for m in msg:
m.content = m.content.upper()
return msg
`,
}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | {
sdk: "typescript",
source: `
import { object, func, field } from "@dagger.io/dagger"
@object()
class Message {
@field()
content: string
constructor(content: string) {
this.content = content
}
}
@object()
class Foo {
@func()
sayHello(name: string): Message {
return new Message("hello " + name)
}
@func()
upper(msg: Message): Message {
msg.content = msg.content.toUpperCase()
return msg
}
@func()
uppers(msg: Message[]): Message[] {
for (let i = 0; i < msg.length; i++) {
msg[i].content = msg[i].content.toUpperCase()
}
return msg
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{sayHello(name: "world"){id}}}`)).Stdout(ctx)
require.NoError(t, err)
id := gjson.Get(out, "foo.sayHello.id").String()
var idp idproto.ID
err = idp.Decode(id)
require.NoError(t, err)
require.Equal(t, idp.Display(), `foo.sayHello(name: "world"): FooMessage!`)
out, err = modGen.With(daggerQuery(`{foo{upper(msg:"%s"){content}}}`, id)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"upper":{"content": "HELLO WORLD"}}}`, out)
out, err = modGen.With(daggerQuery(`{foo{uppers(msg:["%s", "%s"]){content}}}`, id, id)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"uppers":[{"content": "HELLO WORLD"}, {"content": "HELLO WORLD"}]}}`, out)
})
}
}
func TestModuleConflictingSameNameDeps(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
ctr := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dstr").
With(daggerExec("init", "--source=.", "--name=d", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type D struct{}
type Obj struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | Foo string
}
func (m *D) Fn(foo string) Obj {
return Obj{Foo: foo}
}
`,
})
ctr = ctr.
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dint").
With(daggerExec("init", "--source=.", "--name=d", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type D struct{}
type Obj struct {
Foo int
}
func (m *D) Fn(foo int) Obj {
return Obj{Foo: foo}
}
`,
})
ctr = ctr.
WithWorkdir("/work").
With(daggerExec("init", "--source=c", "--name=c", "--sdk=go", "c")).
WithWorkdir("/work/c").
With(daggerExec("install", "../dstr")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import ( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | "context"
)
type C struct{}
func (m *C) Fn(ctx context.Context, foo string) (string, error) {
return dag.D().Fn(foo).Foo(ctx)
}
`,
})
ctr = ctr.
WithWorkdir("/work").
With(daggerExec("init", "--source=b", "--name=b", "--sdk=go", "b")).
With(daggerExec("install", "-m=b", "./dint")).
WithNewFile("/work/b/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
)
type B struct{}
func (m *B) Fn(ctx context.Context, foo int) (int, error) {
return dag.D().Fn(foo).Foo(ctx)
}
`,
})
ctr = ctr.
WithWorkdir("/work").
With(daggerExec("init", "--source=a", "--name=a", "--sdk=go", "a")).
WithWorkdir("/work/a").
With(daggerExec("install", "../b")).
With(daggerExec("install", "../c")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | Contents: `package main
import (
"context"
"strconv"
)
type A struct{}
func (m *A) Fn(ctx context.Context) (string, error) {
fooStr, err := dag.C().Fn(ctx, "foo")
if err != nil {
return "", err
}
fooInt, err := dag.B().Fn(ctx, 123)
if err != nil {
return "", err
}
return fooStr + strconv.Itoa(fooInt), nil
}
`,
})
out, err := ctr.With(daggerQuery(`{a{fn}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"a":{"fn": "foo123"}}`, out)
types := currentSchema(ctx, t, ctr).Types
require.NotNil(t, types.Get("A"))
require.Nil(t, types.Get("B"))
require.Nil(t, types.Get("C"))
require.Nil(t, types.Get("D"))
}
func TestModuleSelfAPICall(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"github.com/Khan/genqlient/graphql"
)
type Test struct{}
func (m *Test) FnA(ctx context.Context) (string, error) {
resp := &graphql.Response{}
err := dag.Client.MakeRequest(ctx, &graphql.Request{
Query: "{test{fnB}}",
}, resp)
if err != nil {
return "", err
}
return resp.Data.(map[string]any)["test"].(map[string]any)["fnB"].(string), nil
}
func (m *Test) FnB() string {
return "hi from b" |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }
`,
}).
With(daggerQuery(`{test{fnA}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"test":{"fnA": "hi from b"}}`, out)
}
func TestModuleGoWithOtherModuleTypes(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--source=.", "--name=dep", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Dep struct{}
type Obj struct {
Foo string
}
func (m *Dep) Fn() Obj {
return Obj{Foo: "foo"}
}
`,
}).
WithWorkdir("/work").
With(daggerExec("init", "--source=test", "--name=test", "--sdk=go", "test")).
With(daggerExec("install", "-m=test", "./dep")).
WithWorkdir("/work/test") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Run("return as other module object", func(t *testing.T) {
t.Run("direct", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn() (*DepObj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q cannot return external type from dependency module %q",
"Test", "Fn", "dep",
))
})
t.Run("list", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn() ([]*DepObj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q cannot return external type from dependency module %q",
"Test", "Fn", "dep",
))
})
})
t.Run("arg as other module object", func(t *testing.T) {
t.Run("direct", func(t *testing.T) {
_, err := ctr.WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn(obj *DepObj) error {
return nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q arg %q cannot reference external type from dependency module %q",
"Test", "Fn", "obj", "dep",
))
})
t.Run("list", func(t *testing.T) {
_, err := ctr.WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | func (m *Test) Fn(obj []*DepObj) error {
return nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q arg %q cannot reference external type from dependency module %q",
"Test", "Fn", "obj", "dep",
))
})
})
t.Run("field as other module object", func(t *testing.T) {
t.Run("direct", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
type Obj struct {
Foo *DepObj
}
func (m *Test) Fn() (*Obj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q field %q cannot reference external type from dependency module %q",
"Obj", "Foo", "dep",
))
})
t.Run("list", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
type Obj struct {
Foo []*DepObj
}
func (m *Test) Fn() (*Obj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q field %q cannot reference external type from dependency module %q",
"Obj", "Foo", "dep",
))
})
})
}
func TestModuleGoUseDaggerTypesDirect(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "main/dagger"
type Minimal struct{}
func (m *Minimal) Foo(dir *Directory) (*dagger.Directory) {
return dir.WithNewFile("foo", "xxx")
}
func (m *Minimal) Bar(dir *dagger.Directory) (*Directory) {
return dir.WithNewFile("bar", "yyy")
}
`,
})
out, err := modGen.With(daggerQuery(`{directory{id}}`)).Stdout(ctx)
require.NoError(t, err)
dirID := gjson.Get(out, "directory.id").String()
out, err = modGen.With(daggerQuery(`{minimal{foo(dir: "%s"){file(path: "foo"){contents}}}}`, dirID)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"foo":{"file":{"contents": "xxx"}}}}`, out)
out, err = modGen.With(daggerQuery(`{minimal{bar(dir: "%s"){file(path: "bar"){contents}}}}`, dirID)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"bar":{"file":{"contents": "yyy"}}}}`, out)
}
func TestModuleGoUtilsPkg(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"main/utils"
)
type Minimal struct{}
func (m *Minimal) Hello(ctx context.Context) (string, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | return utils.Foo().File("foo").Contents(ctx)
}
`,
}).
WithNewFile("utils/util.go", dagger.ContainerWithNewFileOpts{
Contents: `package utils
import "main/dagger"
func Foo() *dagger.Directory {
return dagger.Connect().Directory().WithNewFile("/foo", "hello world")
}
`,
})
out, err := modGen.With(daggerQuery(`{minimal{hello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"minimal":{"hello":"hello world"}}`, out)
}
var useInner = `package main
type Dep struct{}
func (m *Dep) Hello() string {
return "hello"
}
`
var useGoOuter = `package main
import "context"
type Use struct{}
func (m *Use) UseHello(ctx context.Context) (string, error) {
return dag.Dep().Hello(ctx)
}
`
var usePythonOuter = `from dagger import dag, function |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | @function
def use_hello() -> str:
return dag.dep().hello()
`
var useTSOuter = `
import { dag, object, func } from '@dagger.io/dagger'
@object()
class Use {
@func()
async useHello(): Promise<string> {
return dag.dep().hello()
}
}
`
func TestModuleUseLocal(t *testing.T) {
t.Parallel()
type testCase struct {
sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: useGoOuter,
},
{
sdk: "python",
source: usePythonOuter,
},
{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk: "typescript",
source: useTSOuter,
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--name=dep", "--sdk=go")).
With(sdkSource("go", useInner)).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerExec("install", "./dep"))
out, err := modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
_, err = modGen.With(daggerQuery(`{dep{hello}}`)).Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, `Query has no such field: "dep"`)
})
}
}
func TestModuleCodegenOnDepChange(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk string
source string
changed string
expected string
}
for _, tc := range []testCase{
{
sdk: "go",
source: useGoOuter,
expected: "Hellov2",
changed: strings.ReplaceAll(useGoOuter, `Hello(ctx)`, `Hellov2(ctx)`),
},
{
sdk: "python",
source: usePythonOuter,
expected: "hellov2",
changed: strings.ReplaceAll(usePythonOuter, `.hello()`, `.hellov2()`),
},
{
sdk: "typescript",
source: useTSOuter,
expected: "hellov2",
changed: strings.ReplaceAll(useTSOuter, `.hello()`, `.hellov2()`),
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--name=dep", "--sdk=go")).
With(sdkSource("go", useInner)).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerExec("install", "./dep"))
out, err := modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
newInner := strings.ReplaceAll(useInner, `Hello()`, `Hellov2()`)
modGen = modGen.
WithWorkdir("/work/dep").
With(sdkSource("go", newInner)).
WithWorkdir("/work").
With(daggerExec("develop"))
codegenContents, err := modGen.File(sdkCodegenFile(t, tc.sdk)).Contents(ctx)
require.NoError(t, err)
require.Contains(t, codegenContents, tc.expected)
modGen = modGen.With(sdkSource(tc.sdk, tc.changed))
out, err = modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
})
}
}
func TestModuleSyncDeps(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
type testCase struct {
sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: useGoOuter,
},
{
sdk: "python",
source: usePythonOuter,
},
{
sdk: "typescript",
source: useTSOuter,
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--name=dep", "--sdk=go")).
With(sdkSource("go", useInner)).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerExec("install", "./dep"))
modGen = modGen.With(daggerQuery(`{use{useHello}}`))
out, err := modGen.Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
newInner := strings.ReplaceAll(useInner, `"hello"`, `"goodbye"`)
modGen = modGen.
WithWorkdir("/work/dep").
With(sdkSource("go", newInner)).
WithWorkdir("/work").
With(daggerExec("develop"))
out, err = modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"goodbye"}}`, out)
})
}
}
func TestModuleUseLocalMulti(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "context"
import "fmt"
type Use struct {}
func (m *Use) Names(ctx context.Context) ([]string, error) {
fooName, err := dag.Foo().Name(ctx)
if err != nil {
return nil, fmt.Errorf("foo.name: %w", err)
}
barName, err := dag.Bar().Name(ctx)
if err != nil {
return nil, fmt.Errorf("bar.name: %w", err)
}
return []string{fooName, barName}, nil
}
`,
},
{
sdk: "python", |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | source: `from dagger import dag, function
@function
async def names() -> list[str]:
return [
await dag.foo().name(),
await dag.bar().name(),
]
`,
},
{
sdk: "typescript",
source: `
import { dag, object, func } from '@dagger.io/dagger'
@object()
class Use {
@func()
async names(): Promise<string[]> {
return [await dag.foo().name(), await dag.bar().name()]
}
}
`,
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/foo"). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | WithNewFile("/work/foo/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Foo struct {}
func (m *Foo) Name() string { return "foo" }
`,
}).
With(daggerExec("init", "--source=.", "--name=foo", "--sdk=go")).
WithWorkdir("/work/bar").
WithNewFile("/work/bar/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Bar struct {}
func (m *Bar) Name() string { return "bar" }
`,
}).
With(daggerExec("init", "--source=.", "--name=bar", "--sdk=go")).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(daggerExec("install", "./foo")).
With(daggerExec("install", "./bar")).
With(sdkSource(tc.sdk, tc.source)).
WithEnvVariable("BUST", identity.NewID())
out, err := modGen.With(daggerQuery(`{use{names}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"names":["foo", "bar"]}}`, out)
})
}
}
func TestModuleConstructor(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk string
source string
}
t.Run("basic", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import (
"context"
)
func New(
ctx context.Context,
foo string,
bar *int, // +optional
baz []string,
dir *Directory,
) *Test {
bar2 := 42
if bar != nil {
bar2 = *bar
}
return &Test{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | Foo: foo,
Bar: bar2,
Baz: baz,
Dir: dir,
}
}
type Test struct {
Foo string
Bar int
Baz []string
Dir *Directory
NeverSetDir *Directory
}
func (m *Test) GimmeFoo() string {
return m.Foo
}
func (m *Test) GimmeBar() int {
return m.Bar
}
func (m *Test) GimmeBaz() []string {
return m.Baz
}
func (m *Test) GimmeDirEnts(ctx context.Context) ([]string, error) {
return m.Dir.Entries(ctx)
}
`,
},
{
sdk: "python",
source: `import dagger |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | from dagger import field, function, object_type
@object_type
class Test:
foo: str = field()
dir: dagger.Directory = field()
bar: int = field(default=42)
baz: list[str] = field(default=list)
never_set_dir: dagger.Directory | None = field(default=None)
@function
def gimme_foo(self) -> str:
return self.foo
@function
def gimme_bar(self) -> int:
return self.bar
@function
def gimme_baz(self) -> list[str]:
return self.baz
@function
async def gimme_dir_ents(self) -> list[str]:
return await self.dir.entries()
`,
},
{
sdk: "typescript",
source: `
import { Directory, object, func, field } from '@dagger.io/dagger';
@object()
class Test {
@field()
foo: string |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | @field()
dir: Directory
@field()
bar: number
@field()
baz: string[]
@field()
neverSetDir?: Directory
constructor(foo: string, dir: Directory, bar = 42, baz: string[] = []) {
this.foo = foo;
this.dir = dir;
this.bar = bar;
this.baz = baz;
}
@func()
gimmeFoo(): string {
return this.foo;
}
@func()
gimmeBar(): number {
return this.bar;
}
@func()
gimmeBaz(): string[] {
return this.baz;
}
@func()
async gimmeDirEnts(): Promise<string[]> {
return this.dir.entries();
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := modInit(ctx, t, c, tc.sdk, tc.source)
out, err := ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "foo")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "abc")
out, err = ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "gimme-foo")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "abc")
out, err = ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "42")
out, err = ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "gimme-bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "42")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "123")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "gimme-bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "123")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "baz")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "x\ny\nz") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "gimme-baz")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "x\ny\nz")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "gimme-dir-ents")).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, strings.TrimSpace(out), "dagger.json")
})
}
})
t.Run("fields only", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import (
"context"
)
func New(ctx context.Context) (Test, error) {
v, err := dag.Container().From("alpine:3.18.4").File("/etc/alpine-release").Contents(ctx)
if err != nil {
return Test{}, err
}
return Test{
AlpineVersion: v,
}, nil
}
type Test struct {
AlpineVersion string
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | `,
},
{
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()
))
`,
},
{
sdk: "typescript",
source: `
import { dag, object, field } from "@dagger.io/dagger"
@object()
class Test {
@field()
alpineVersion: string
// NOTE: this is not standard to do async operations in the constructor.
// This is only for testing purpose but it shouldn't be done in real usage.
constructor() {
return (async () => { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | this.alpineVersion = await dag.container().from("alpine:3.18.4").file("/etc/alpine-release").contents()
return this; // Return the newly-created instance
})();
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test").
With(daggerExec("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 ( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | "fmt"
)
func New() (*Test, error) {
return nil, fmt.Errorf("too bad")
}
type Test struct {
Foo string
}
`,
},
{
sdk: "python",
source: `from dagger import object_type, field
@object_type
class Test:
foo: str = field()
def __init__(self):
raise ValueError("too bad")
`,
},
{
sdk: "typescript",
source: `
import { object, field } from "@dagger.io/dagger"
@object()
class Test {
@field()
foo: string
constructor() {
throw new Error("too bad") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }
}
`,
},
} {
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("init", "--name=test", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
_, err := ctr.With(daggerCall("foo")).Stdout(ctx)
require.Error(t, err)
require.NoError(t, c.Close())
t.Log(logs.String())
require.Contains(t, logs.String(), "too bad")
})
}
})
t.Run("python: with default factory", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
content := identity.NewID()
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test"). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | With(daggerExec("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", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, content, strings.TrimSpace(out))
out, err = ctr.With(daggerCall("--foo=dagger.json", "foo", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, out, `"sdk": "python"`)
_, err = ctr.With(daggerCall("bar")).Sync(ctx)
require.NoError(t, err)
})
t.Run("typescript: with default factory", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
content := identity.NewID()
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test").
With(daggerExec("init", "--name=test", "--sdk=typescript")). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | With(sdkSource("typescript", fmt.Sprintf(`
import { dag, File, object, field } from "@dagger.io/dagger"
@object()
class Test {
@field()
foo: File = dag.directory().withNewFile("foo.txt", "%s").file("foo.txt")
@field()
bar: string[] = []
// Allow foo to be set through the constructor
constructor(foo?: File) {
if (foo) {
this.foo = foo
}
}
}
`, content),
))
out, err := ctr.With(daggerCall("foo", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, content, strings.TrimSpace(out))
out, err = ctr.With(daggerCall("--foo=dagger.json", "foo", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, out, `"sdk": "typescript"`)
_, err = ctr.With(daggerCall("bar")).Sync(ctx)
require.NoError(t, err)
})
}
func TestModuleWrapping(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Wrapper struct{}
func (m *Wrapper) Container() *WrappedContainer {
return &WrappedContainer{
dag.Container().From("` + alpineImage + `"),
}
}
type WrappedContainer struct {
Unwrap *Container` + "`" + `json:"unwrap"` + "`" + `
}
func (c *WrappedContainer) Echo(msg string) *WrappedContainer {
return &WrappedContainer{
c.Unwrap.WithExec([]string{"echo", "-n", msg}),
}
}
`,
},
{
sdk: "python",
source: `from typing import Self
import dagger
from dagger import dag, field, function, object_type |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | @object_type
class WrappedContainer:
unwrap: dagger.Container = field()
@function
def echo(self, msg: str) -> Self:
return WrappedContainer(unwrap=self.unwrap.with_exec(["echo", "-n", msg]))
@object_type
class Wrapper:
@function
def container(self) -> WrappedContainer:
return WrappedContainer(unwrap=dag.container().from_("` + alpineImage + `"))
`,
},
{
sdk: "typescript",
source: `
import { dag, Container, object, func, field } from "@dagger.io/dagger"
@object()
class WrappedContainer {
@field()
unwrap: Container
constructor(unwrap: Container) {
this.unwrap = unwrap
}
@func()
echo(msg: string): WrappedContainer {
return new WrappedContainer(this.unwrap.withExec(["echo", "-n", msg]))
}
}
@object() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | class Wrapper {
@func()
container(): WrappedContainer {
return new WrappedContainer(dag.container().from("` + alpineImage + `"))
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=wrapper", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
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 TestModuleLotsOfFunctions(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | 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).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: mainSrc,
}).
With(daggerExec("init", "--source=.", "--name=potatoSack", "--sdk=go"))
var eg errgroup.Group
for i := 0; i < funcCount; i++ {
i := i |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | 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(`
@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, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }).
With(daggerExec("init", "--source=.", "--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())
})
t.Run("typescript sdk", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
mainSrc := `
import { object, func } from "@dagger.io/dagger"
@object()
class PotatoSack {
`
for i := 0; i < funcCount; i++ {
mainSrc += fmt.Sprintf(`
@func()
potato_%d(): string { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | return "potato #%d"
}
`, i, i)
}
mainSrc += "\n}"
modGen := c.
Container().
From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(sdkSource("typescript", mainSrc)).
With(daggerExec("init", "--name=potatoSack", "--sdk=typescript"))
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,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
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) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | for _, depName := range depNames {
mainSrc += fmt.Sprintf(`
depS, err = dag.%s().Fn(ctx)
if err != nil {
return "", err
}
s += depS
`, strcase.ToCamel(depName))
}
mainSrc += "return s, nil\n}\n"
fmted, err := format.Source([]byte(mainSrc))
require.NoError(t, err)
return string(fmted)
}
var rootCfg modules.ModuleConfig
addModulesWithDeps := func(newMods int, depNames []string) []string {
t.Helper()
var newModNames []string
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),
})
var depCfgs []*modules.ModuleConfigDependency |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | for _, depName := range depNames {
depCfgs = append(depCfgs, &modules.ModuleConfigDependency{
Name: depName,
Source: filepath.Join("..", depName),
})
}
modGen = modGen.With(configFile(".", &modules.ModuleConfig{
Name: name,
SDK: "go",
Dependencies: depCfgs,
}))
}
return newModNames
}
curDeps := addModulesWithDeps(1, nil)
for i := 0; i < 6; i++ {
curDeps = addModulesWithDeps(len(curDeps)+1, curDeps)
}
addModulesWithDeps(1, curDeps)
modGen = modGen.With(configFile("..", &rootCfg))
_, err := modGen.With(daggerCall("fn")).Sync(ctx)
require.NoError(t, err)
}
func TestModuleNamespacing(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | 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":["*dagger.Sub1Obj made 1:yo", "*dagger.Sub2Obj made 2:yo"]}}`, out)
}
func TestModuleLoops(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
_, err := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
With(daggerExec("init", "--name=depA", "--sdk=go", "depA")).
With(daggerExec("init", "--name=depB", "--sdk=go", "depB")).
With(daggerExec("init", "--name=depC", "--sdk=go", "depC")).
With(daggerExec("install", "-m=depC", "./depB")).
With(daggerExec("install", "-m=depB", "./depA")).
With(daggerExec("install", "-m=depA", "./depC")).
Sync(ctx)
require.ErrorContains(t, err, `local module at "/work/depA" has a circular dependency`)
}
var badIDArgGoSrc string
var badIDArgPySrc string
var badIDArgTSSrc string
var badIDFieldGoSrc string
var badIDFieldTSSrc string
var badIDFnGoSrc string
var badIDFnPySrc string
var badIDFnTSSrc string
func TestModuleReservedWords(t *testing.T) {
t.Parallel()
type testCase struct {
sdk string
source string
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Run("id", func(t *testing.T) {
t.Parallel()
t.Run("arg", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: badIDArgGoSrc,
},
{
sdk: "python",
source: badIDArgPySrc,
},
{
sdk: "typescript",
source: badIDArgTSSrc,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
_, err := modInit(ctx, t, c, tc.sdk, tc.source).
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) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: badIDFieldGoSrc,
},
{
sdk: "typescript",
source: badIDFieldTSSrc,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=test", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
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()
for _, tc := range []testCase{
{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | sdk: "go",
source: badIDFnGoSrc,
},
{
sdk: "python",
source: badIDFnPySrc,
},
{
sdk: "typescript",
source: badIDFnTSSrc,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=test", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerQuery(`{test{id}}`)).
Sync(ctx)
require.ErrorContains(t, err, "cannot define function with reserved name \"id\"")
})
}
})
})
}
func TestModuleExecError(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(alpineImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=playground", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `
package main
import (
"context"
"errors"
)
type Playground struct{}
func (p *Playground) DoThing(ctx context.Context) error {
_, err := dag.Container().From("` + alpineImage + `").WithExec([]string{"sh", "-c", "exit 5"}).Sync(ctx)
var e *ExecError
if errors.As(err, &e) {
if e.ExitCode == 5 {
return nil
}
}
panic("yikes")
}
`})
_, err := modGen.
With(daggerQuery(`{playground{doThing}}`)).
Stdout(ctx)
require.NoError(t, err) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | }
func TestModuleCurrentModuleAPI(t *testing.T) {
t.Parallel()
t.Run("name", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=WaCkY", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type WaCkY struct {}
func (m *WaCkY) Fn(ctx context.Context) (string, error) {
return dag.CurrentModule().Name(ctx)
}
`,
}).
With(daggerCall("fn")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "WaCkY", strings.TrimSpace(out))
})
t.Run("source", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work"). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/subdir/coolfile.txt", dagger.ContainerWithNewFileOpts{
Contents: "nice",
}).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type Test struct {}
func (m *Test) Fn(ctx context.Context) *File {
return dag.CurrentModule().Source().File("subdir/coolfile.txt")
}
`,
}).
With(daggerCall("fn", "contents")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "nice", strings.TrimSpace(out))
})
t.Run("workdir", func(t *testing.T) {
t.Parallel()
t.Run("dir", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import ( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | "context"
"os"
)
type Test struct {}
func (m *Test) Fn(ctx context.Context) (*Directory, error) {
if err := os.MkdirAll("subdir/moresubdir", 0755); err != nil {
return nil, err
}
if err := os.WriteFile("subdir/moresubdir/coolfile.txt", []byte("nice"), 0644); err != nil {
return nil, err
}
return dag.CurrentModule().Workdir("subdir/moresubdir"), nil
}
`,
}).
With(daggerCall("fn", "file", "--path=coolfile.txt", "contents")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "nice", strings.TrimSpace(out))
})
t.Run("file", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import ( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | "context"
"os"
)
type Test struct {}
func (m *Test) Fn(ctx context.Context) (*File, error) {
if err := os.MkdirAll("subdir/moresubdir", 0755); err != nil {
return nil, err
}
if err := os.WriteFile("subdir/moresubdir/coolfile.txt", []byte("nice"), 0644); err != nil {
return nil, err
}
return dag.CurrentModule().WorkdirFile("subdir/moresubdir/coolfile.txt"), nil
}
`,
}).
With(daggerCall("fn", "contents")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "nice", strings.TrimSpace(out))
})
t.Run("error on escape", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import ( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | "context"
"os"
)
func New() (*Test, error) {
if err := os.WriteFile("/rootfile.txt", []byte("notnice"), 0644); err != nil {
return nil, err
}
if err := os.MkdirAll("/foo", 0755); err != nil {
return nil, err
}
if err := os.WriteFile("/foo/foofile.txt", []byte("notnice"), 0644); err != nil {
return nil, err
}
return &Test{}, nil
}
type Test struct {}
func (m *Test) EscapeFile(ctx context.Context) *File {
return dag.CurrentModule().WorkdirFile("../rootfile.txt")
}
func (m *Test) EscapeFileAbs(ctx context.Context) *File {
return dag.CurrentModule().WorkdirFile("/rootfile.txt")
}
func (m *Test) EscapeDir(ctx context.Context) *Directory {
return dag.CurrentModule().Workdir("../foo")
}
func (m *Test) EscapeDirAbs(ctx context.Context) *Directory {
return dag.CurrentModule().Workdir("/foo")
}
`,
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | _, err := ctr.
With(daggerCall("escape-file", "contents")).
Stdout(ctx)
require.ErrorContains(t, err, `workdir path "../rootfile.txt" escapes workdir`)
_, err = ctr.
With(daggerCall("escape-file-abs", "contents")).
Stdout(ctx)
require.ErrorContains(t, err, `workdir path "/rootfile.txt" escapes workdir`)
_, err = ctr.
With(daggerCall("escape-dir", "entries")).
Stdout(ctx)
require.ErrorContains(t, err, `workdir path "../foo" escapes workdir`)
_, err = ctr.
With(daggerCall("escape-dir-abs", "entries")).
Stdout(ctx)
require.ErrorContains(t, err, `workdir path "/foo" escapes workdir`)
})
})
}
func TestModuleCustomSDK(t *testing.T) {
t.Parallel()
t.Run("local", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/coolsdk").
With(daggerExec("init", "--source=.", "--name=cool-sdk", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | type CoolSdk struct {}
func (m *CoolSdk) ModuleRuntime(modSource *ModuleSource, introspectionJson string) *Container {
return modSource.WithSDK("go").AsModule().Runtime().WithEnvVariable("COOL", "true")
}
func (m *CoolSdk) Codegen(modSource *ModuleSource, introspectionJson string) *GeneratedCode {
return dag.GeneratedCode(modSource.WithSDK("go").AsModule().GeneratedContextDirectory())
}
func (m *CoolSdk) RequiredPaths() []string {
return []string{
"**/go.mod",
"**/go.sum",
"**/go.work",
"**/go.work.sum",
"**/vendor/",
"**/*.go",
}
}
`,
}).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=coolsdk")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "os"
type Test struct {}
func (m *Test) Fn() string {
return os.Getenv("COOL")
}
`,
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | out, err := ctr.
With(daggerCall("fn")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "true", strings.TrimSpace(out))
})
t.Run("git", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk="+testGitModuleRef("cool-sdk"))).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "os"
type Test struct {}
func (m *Test) Fn() string {
return os.Getenv("COOL")
}
`,
})
out, err := ctr.
With(daggerCall("fn")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "true", strings.TrimSpace(out))
})
}
func TestModuleHostError(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
)
type Test struct {}
func (m *Test) Fn(ctx context.Context) *Directory {
return dag.Host().Directory(".")
}
`,
}).
With(daggerCall("fn")).
Sync(ctx)
require.ErrorContains(t, err, "dag.Host undefined")
}
func daggerExec(args ...string) dagger.WithContainerFunc { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | 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 {
return daggerQueryAt("", query, args...)
}
func daggerQueryAt(modPath string, query string, args ...any) dagger.WithContainerFunc {
query = fmt.Sprintf(query, args...)
return func(c *dagger.Container) *dagger.Container {
execArgs := []string{"dagger", "--debug", "query"}
if modPath != "" {
execArgs = append(execArgs, "-m", modPath)
}
return c.WithExec(execArgs, dagger.ContainerWithExecOpts{
Stdin: query,
ExperimentalPrivilegedNesting: true,
})
}
}
func daggerCall(args ...string) dagger.WithContainerFunc {
return daggerCallAt("", args...)
}
func daggerCallAt(modPath string, args ...string) dagger.WithContainerFunc { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | return func(c *dagger.Container) *dagger.Container {
execArgs := []string{"dagger", "--debug", "call"}
if modPath != "" {
execArgs = append(execArgs, "-m", modPath)
}
return c.WithExec(append(execArgs, 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 configFile(dirPath string, cfg *modules.ModuleConfig) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
cfgPath := filepath.Join(dirPath, "dagger.json")
cfgBytes, err := json.Marshal(cfg)
if err != nil {
panic(err)
}
return c.WithNewFile(cfgPath, dagger.ContainerWithNewFileOpts{
Contents: string(cfgBytes),
})
}
}
func hostDaggerCommand(ctx context.Context, t testing.TB, workdir string, args ...string) *exec.Cmd { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | 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) {
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 {
sourcePath := sdkSourceFile(sdk)
if sourcePath == "" {
return c
}
return c.WithNewFile(sourcePath, dagger.ContainerWithNewFileOpts{
Contents: heredoc.Doc(contents),
})
}
}
func sdkSourceFile(sdk string) string { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | switch sdk {
case "go":
return "dagger/main.go"
case "python":
return "dagger/src/main.py"
case "typescript":
return "dagger/src/index.ts"
default:
return ""
}
}
func sdkCodegenFile(t *testing.T, sdk string) string {
t.Helper()
switch sdk {
case "go":
return "dagger/dagger/dagger.gen.go"
case "python":
return "dagger/sdk/src/dagger/client/gen.py"
case "typescript":
return "dagger/sdk/api/client.gen.ts"
default:
return ""
}
}
func modInit(ctx context.Context, t *testing.T, c *dagger.Client, sdk, contents string) *dagger.Container { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Helper()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=test", "--sdk="+sdk)).
With(sdkSource(sdk, contents))
return modGen
}
func currentSchema(ctx context.Context, t *testing.T, ctr *dagger.Container) *introspection.Schema {
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
}
var moduleIntrospection = daggerQuery(`
query { host { directory(path: ".") { asModule { initialize {
description |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | objects {
asObject {
name
description
constructor {
description
args {
name
description
defaultValue
}
}
functions {
name
description
args {
name
description
defaultValue
}
}
fields {
name
description
}
}
}
} } } } }
`)
func inspectModule(ctx context.Context, t *testing.T, ctr *dagger.Container) gjson.Result { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | core/integration/module_test.go | t.Helper()
out, err := ctr.With(moduleIntrospection).Stdout(ctx)
require.NoError(t, err)
result := gjson.Get(out, "host.directory.asModule.initialize")
t.Logf("module introspection:\n%v", result.Raw)
return result
}
func inspectModuleObjects(ctx context.Context, t *testing.T, ctr *dagger.Container) gjson.Result {
t.Helper()
return inspectModule(ctx, t, ctr).Get("objects.#.asObject")
}
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", "[email protected]"}).
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,669 | 🐞 installed module is unusable (codegen'd with wrong capitalization) | ### What is the issue?
Created module for running remote commands via SSH https://daggerverse.dev/mod/github.com/samalba/dagger-modules/ssh@35ed3e343d7e6faa3eab44570ee7531914dd4e65
I initialized the module with:
`dagger init --name ssh --sdk go --source .`
The module code uses a struct named `Ssh`. It works fine as standalone. However when you install the module from another module, it's available via `dag.SSH()` (different capitalization), which then fails to compile, because it cannot find the module version.
Simple way to reproduce: install the module from any other module and try to use it.
### Dagger version
dagger v0.9.10 (registry.dagger.io/engine) darwin/arm64 | https://github.com/dagger/dagger/issues/6669 | https://github.com/dagger/dagger/pull/6692 | a659c04b9982ef90a999dc20efb9485b11eda556 | 15cb7d10a00d0e0b19ea1a2e8fc07cf8c360d04c | "2024-02-13T22:55:54Z" | go | "2024-02-20T11:15:21Z" | 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,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | package core
import (
"context"
_ "embed"
"encoding/json"
"fmt"
"go/format"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"time"
"github.com/MakeNowJust/heredoc/v2"
"github.com/dagger/dagger/core/modules"
"github.com/dagger/dagger/dagql/idproto"
"github.com/iancoleman/strcase"
"github.com/moby/buildkit/identity"
"github.com/stretchr/testify/require"
"github.com/tidwall/gjson"
"golang.org/x/sync/errgroup"
"dagger.io/dagger"
"github.com/dagger/dagger/cmd/codegen/introspection"
)
func TestModuleGoInit(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | t.Parallel()
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("init", "--name=bare", "--sdk=go"))
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("reserved go.mod name", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=go", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{go{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | require.NoError(t, err)
require.JSONEq(t, `{"go":{"containerEcho":{"stdout":"hello\n"}}}`, out)
})
t.Run("uses expected Go module name, camel-cases Dagger module name", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=My-Module", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{myModule{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"myModule":{"containerEcho":{"stdout":"hello\n"}}}`, out)
generated, err := modGen.File("go.mod").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, "module main")
})
t.Run("creates go.mod beneath an existing go.mod if context is beneath it", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/go.mod", dagger.ContainerWithNewFileOpts{
Contents: "module example.com/test\n",
}).
WithNewFile("/work/foo.go", dagger.ContainerWithNewFileOpts{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | Contents: "package foo\n",
}).
WithWorkdir("/work/ci").
With(daggerExec("init", "--name=beneathGoMod", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{beneathGoMod{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"beneathGoMod":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("names Go module after Dagger module", func(t *testing.T) {
generated, err := modGen.Directory("dagger").File("go.mod").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, "module main")
})
})
t.Run("respects existing go.mod", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"go", "mod", "init", "example.com/test"}).
With(daggerExec("init", "--name=hasGoMod", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{hasGoMod{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasGoMod":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("preserves module name", func(t *testing.T) {
generated, err := modGen.File("go.mod").Contents(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | require.NoError(t, err)
require.Contains(t, generated, "module example.com/test")
})
})
t.Run("respects existing go.work", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithExec([]string{"go", "work", "init"}).
WithExec([]string{"go", "work", "use", "."}).
With(daggerExec("init", "--name=hasGoMod", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{hasGoMod{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasGoMod":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("go.work is edited", func(t *testing.T) {
generated, err := modGen.File("go.work").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, "\t.\n")
require.Contains(t, generated, "\t./dagger\n")
})
})
t.Run("respects existing go.work for top-level source", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithExec([]string{"go", "work", "init"}).
With(daggerExec("init", "--name=hasGoMod", "--sdk=go", "--source=."))
out, err := modGen.
With(daggerQuery(`{hasGoMod{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasGoMod":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("go.work is edited", func(t *testing.T) {
generated, err := modGen.File("go.work").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, "use .\n")
})
})
t.Run("ignores go.work for subdir", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithExec([]string{"go", "work", "init"}).
WithExec([]string{"go", "work", "use", "."}).
With(daggerExec("init", "--name=hasGoMod", "--sdk=go", "subdir"))
out, err := modGen. |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | WithWorkdir("./subdir").
With(daggerQuery(`{hasGoMod{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasGoMod":{"containerEcho":{"stdout":"hello\n"}}}`, out)
t.Run("go.work is unedited", func(t *testing.T) {
generated, err := modGen.File("go.work").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, "use .\n")
})
})
t.Run("respects parent go.mod if root points to it", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
generated := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithNewFile("/work/foo.go", dagger.ContainerWithNewFileOpts{
Contents: "package foo\n",
}).
With(daggerExec("init", "--name=child", "--sdk=go", "./child")).
WithWorkdir("/work/child").
With(daggerExec("develop")).
Directory("/work")
parentEntries, err := generated.Entries(ctx)
require.NoError(t, err)
require.Equal(t, []string{".git", "child", "foo.go", "go.mod", "go.sum"}, parentEntries)
childEntries, err := generated.Directory("child").Entries(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | require.NoError(t, err)
require.NotContains(t, childEntries, "go.mod")
t.Run("preserves parent module name", func(t *testing.T) {
goMod, err := generated.File("go.mod").Contents(ctx)
require.NoError(t, err)
require.Contains(t, goMod, "module example.com/test")
})
})
t.Run("respects existing go.mod even if root points to parent that has go.mod", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
generated := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"git", "init"}).
WithExec([]string{"go", "mod", "init", "example.com/test"}).
WithNewFile("/work/foo.go", dagger.ContainerWithNewFileOpts{
Contents: "package foo\n",
}).
WithWorkdir("/work/child").
WithExec([]string{"go", "mod", "init", "my-mod"}).
WithWorkdir("/work").
With(daggerExec("init", "--source=./child", "--name=child", "--sdk=go", "./child")).
WithWorkdir("/work/child").
With(daggerExec("develop")).
Directory("/work")
parentEntries, err := generated.Entries(ctx)
require.NoError(t, err) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | require.Equal(t, []string{".git", "child", "foo.go", "go.mod"}, parentEntries)
childEntries, err := generated.Directory("child").Entries(ctx)
require.NoError(t, err)
require.Contains(t, childEntries, "go.mod")
require.Contains(t, childEntries, "go.sum")
})
t.Run("respects existing main.go", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `
package main
type HasMainGo struct {}
func (m *HasMainGo) Hello() string { return "Hello, world!" }
`,
}).
With(daggerExec("init", "--name=hasMainGo", "--sdk=go", "--source=."))
out, err := modGen.
With(daggerQuery(`{hasMainGo{hello}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasMainGo":{"hello":"Hello, world!"}}`, out)
})
t.Run("respects existing main.go even if it uses types not generated yet", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `
package main
type HasDaggerTypes struct {}
func (m *HasDaggerTypes) Hello() *Container {
return dag.Container().
From("` + alpineImage + `").
WithExec([]string{"echo", "Hello, world!"})
}
`,
}).
With(daggerExec("init", "--source=.", "--name=hasDaggerTypes", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{hasDaggerTypes{hello{stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasDaggerTypes":{"hello":{"stdout":"Hello, world!\n"}}}`, out)
})
t.Run("respects existing package without creating main.go", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/notmain.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type HasNotMainGo struct {}
func (m *HasNotMainGo) Hello() string { return "Hello, world!" } |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | `,
}).
With(daggerExec("init", "--source=.", "--name=hasNotMainGo", "--sdk=go"))
out, err := modGen.
With(daggerQuery(`{hasNotMainGo{hello}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasNotMainGo":{"hello":"Hello, world!"}}`, out)
})
t.Run("with source", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=bare", "--sdk=go", "--source=some/subdir"))
out, err := modGen.
With(daggerQuery(`{bare{containerEcho(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"bare":{"containerEcho":{"stdout":"hello\n"}}}`, out)
sourceSubdirEnts, err := modGen.Directory("/work/some/subdir").Entries(ctx)
require.NoError(t, err)
require.Contains(t, sourceSubdirEnts, "main.go")
sourceRootEnts, err := modGen.Directory("/work").Entries(ctx)
require.NoError(t, err)
require.NotContains(t, sourceRootEnts, "main.go")
})
}
func TestModuleInitLICENSE(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | t.Run("bootstraps Apache-2.0 LICENSE file if none found", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=licensed-to-ill", "--sdk=go"))
content, err := modGen.File("LICENSE").Contents(ctx)
require.NoError(t, err)
require.Contains(t, content, "Apache License, Version 2.0")
})
t.Run("creates LICENSE file in the directory specified by arg", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=licensed-to-ill", "--sdk=go", "./mymod"))
content, err := modGen.File("mymod/LICENSE").Contents(ctx)
require.NoError(t, err)
require.Contains(t, content, "Apache License, Version 2.0")
})
t.Run("does not bootstrap LICENSE file if it exists in the parent dir", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/LICENSE", dagger.ContainerWithNewFileOpts{
Contents: "doesnt matter",
}).
WithWorkdir("/work/sub").
With(daggerExec("init", "--name=licensed-to-ill", "--sdk=go"))
_, err := modGen.File("LICENSE").Contents(ctx)
require.Error(t, err)
})
t.Run("bootstraps a LICENSE file when requested, even if it exists in the parent dir", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/LICENSE", dagger.ContainerWithNewFileOpts{
Contents: "doesnt matter",
}).
WithWorkdir("/work/sub").
With(daggerExec("init", "--name=licensed-to-ill", "--sdk=go", "--license=MIT"))
content, err := modGen.File("LICENSE").Contents(ctx)
require.NoError(t, err)
require.Contains(t, content, "MIT License")
})
}
func TestModuleGit(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,625 | 🐞 Modules: generated .gitxxx files are put next do dagger.json rather than on source path | Follow-up from:
- https://github.com/dagger/dagger/pull/6575
For example, in our root:
```
dagger init --sdk=python --source=dev
```
This will add, or overwrite, .gitattributes and .gitignore with `/sdk`, when it's actually in `dev/sdk`.
Everytime I do `dagger develop`, these files get overwritten.
\cc @sipsma | https://github.com/dagger/dagger/issues/6625 | https://github.com/dagger/dagger/pull/6699 | 4a04803cfb834c39b39ef7bac57fcf7b74c35d38 | 77a53a85956942540fb2078ef490ac8eeac56e0e | "2024-02-08T19:20:56Z" | go | "2024-02-20T14:01:32Z" | core/integration/module_test.go | sdk string
gitGeneratedFiles []string
gitIgnoredFiles []string
}
for _, tc := range []testCase{
{
sdk: "go",
gitGeneratedFiles: []string{
"/dagger.gen.go",
"/querybuilder/**",
},
},
{
sdk: "python",
gitGeneratedFiles: []string{
"/sdk/**",
},
gitIgnoredFiles: []string{ |
Subsets and Splits