status
stringclasses 1
value | repo_name
stringclasses 31
values | repo_url
stringclasses 31
values | issue_id
int64 1
104k
| title
stringlengths 4
233
| body
stringlengths 0
186k
⌀ | issue_url
stringlengths 38
56
| pull_url
stringlengths 37
54
| before_fix_sha
stringlengths 40
40
| after_fix_sha
stringlengths 40
40
| report_datetime
timestamp[us, tz=UTC] | language
stringclasses 5
values | commit_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 7
188
| chunk_content
stringlengths 1
1.03M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | t.Parallel()
c, ctx := connect(t)
defer c.Close()
lower := c.Directory().WithNewFile("some-file", "lower-content")
upper := c.Directory().WithNewFile("some-file", "upper-content")
ctr := c.Container().
From("alpine:3.16.2").
WithMountedDirectory("/mnt/dir", lower)
t.Run("initial content is lower", func(t *testing.T) {
mnts, err := ctr.Mounts(ctx)
require.NoError(t, err)
require.Equal(t, []string{"/mnt/dir"}, mnts)
out, err := ctr.WithExec([]string{"cat", "/mnt/dir/some-file"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "lower-content", out)
})
replaced := ctr.WithMountedDirectory("/mnt/dir", upper)
t.Run("mounts of same path are replaced", func(t *testing.T) {
mnts, err := replaced.Mounts(ctx)
require.NoError(t, err)
require.Equal(t, []string{"/mnt/dir"}, mnts)
out, err := replaced.WithExec([]string{"cat", "/mnt/dir/some-file"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "upper-content", out)
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | t.Run("removing a replaced mount does not reveal previous mount", func(t *testing.T) {
removed := replaced.WithoutMount("/mnt/dir")
mnts, err := removed.Mounts(ctx)
require.NoError(t, err)
require.Empty(t, mnts)
})
clobberedDir := c.Directory().WithNewFile("some-file", "clobbered-content")
clobbered := replaced.WithMountedDirectory("/mnt", clobberedDir)
t.Run("replacing parent of a mount clobbers child", func(t *testing.T) {
mnts, err := clobbered.Mounts(ctx)
require.NoError(t, err)
require.Equal(t, []string{"/mnt"}, mnts)
out, err := clobbered.WithExec([]string{"cat", "/mnt/some-file"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "clobbered-content", out)
})
clobberedSubDir := c.Directory().WithNewFile("some-file", "clobbered-sub-content")
clobberedSub := clobbered.WithMountedDirectory("/mnt/dir", clobberedSubDir)
t.Run("restoring mount under clobbered mount", func(t *testing.T) {
mnts, err := clobberedSub.Mounts(ctx)
require.NoError(t, err)
require.Equal(t, []string{"/mnt", "/mnt/dir"}, mnts)
out, err := clobberedSub.WithExec([]string{"cat", "/mnt/dir/some-file"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "clobbered-sub-content", out)
})
}
func TestContainerDirectory(t *testing.T) {
t.Parallel()
dirRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Directory struct {
WithNewFile struct {
WithNewFile struct {
ID core.DirectoryID
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
withNewFile(path: "some-dir/sub-file", contents: "sub-content") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.WithNewFile.ID
writeRes := struct {
Container struct {
From struct {
WithMountedDirectory struct {
WithMountedDirectory struct {
WithExec struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Directory struct {
ID core.DirectoryID
}
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
withMountedDirectory(path: "/mnt/dir/overlap", source: $id) {
withExec(args: ["sh", "-c", "echo hello >> /mnt/dir/overlap/another-file"]) {
directory(path: "/mnt/dir/overlap") {
id
}
}
}
}
}
}
}`, &writeRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
writtenID := writeRes.Container.From.WithMountedDirectory.WithMountedDirectory.WithExec.Directory.ID
execRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
WithMountedDirectory struct {
WithExec struct {
Stdout string
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
withExec(args: ["cat", "/mnt/dir/another-file"]) {
stdout
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": writtenID,
}})
require.NoError(t, err)
require.Equal(t, "hello\n", execRes.Container.From.WithMountedDirectory.WithExec.Stdout)
}
func TestContainerDirectoryErrors(t *testing.T) {
t.Parallel()
dirRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Directory struct {
WithNewFile struct {
WithNewFile struct {
ID core.DirectoryID
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
withNewFile(path: "some-dir/sub-file", contents: "sub-content") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.WithNewFile.ID
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
directory(path: "/mnt/dir/some-file") {
id |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | }
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "path /mnt/dir/some-file is a file, not a directory")
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
directory(path: "/mnt/dir/bogus") {
id
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: no such file or directory")
err = testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withMountedTemp(path: "/mnt/tmp") { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | directory(path: "/mnt/tmp/bogus") {
id
}
}
}
}
}`, nil, nil)
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: cannot retrieve path from tmpfs")
cacheID := newCache(t)
err = testutil.Query(
`query Test($cache: CacheID!) {
container {
from(address: "alpine:3.16.2") {
withMountedCache(path: "/mnt/cache", cache: $cache) {
directory(path: "/mnt/cache/bogus") {
id
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"cache": cacheID,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: cannot retrieve path from cache")
}
func TestContainerDirectorySourcePath(t *testing.T) {
t.Parallel()
dirRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Directory struct {
WithNewFile struct {
Directory struct {
ID core.DirectoryID
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-dir/sub-dir/sub-file", contents: "sub-content\n") {
directory(path: "some-dir") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.Directory.ID
writeRes := struct {
Container struct {
From struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | WithMountedDirectory struct {
WithExec struct {
Directory struct {
ID core.DirectoryID
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
withExec(args: ["sh", "-c", "echo more-content >> /mnt/dir/sub-dir/sub-file"]) {
directory(path: "/mnt/dir/sub-dir") {
id
}
}
}
}
}
}`, &writeRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
writtenID := writeRes.Container.From.WithMountedDirectory.WithExec.Directory.ID
execRes := struct {
Container struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | From struct {
WithMountedDirectory struct {
WithExec struct {
Stdout string
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
withExec(args: ["cat", "/mnt/dir/sub-file"]) {
stdout
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": writtenID,
}})
require.NoError(t, err)
require.Equal(t, "sub-content\nmore-content\n", execRes.Container.From.WithMountedDirectory.WithExec.Stdout)
}
func TestContainerFile(t *testing.T) {
t.Parallel()
id := newDirWithFile(t, "some-file", "some-content-")
writeRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
WithMountedDirectory struct {
WithMountedDirectory struct {
WithExec struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | File struct {
ID core.FileID
}
}
}
}
}
}
}{}
err := testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
withMountedDirectory(path: "/mnt/dir/overlap", source: $id) {
withExec(args: ["sh", "-c", "echo -n appended >> /mnt/dir/overlap/some-file"]) {
file(path: "/mnt/dir/overlap/some-file") {
id
}
}
}
}
}
}
}`, &writeRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
writtenID := writeRes.Container.From.WithMountedDirectory.WithMountedDirectory.WithExec.File.ID
execRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
WithMountedFile struct {
WithExec struct {
Stdout string
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: FileID!) {
container {
from(address: "alpine:3.16.2") {
withMountedFile(path: "/mnt/file", source: $id) {
withExec(args: ["cat", "/mnt/file"]) {
stdout
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": writtenID,
}})
require.NoError(t, err)
require.Equal(t, "some-content-appended", execRes.Container.From.WithMountedFile.WithExec.Stdout)
}
func TestContainerFileErrors(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | t.Parallel()
id := newDirWithFile(t, "some-file", "some-content")
err := testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
file(path: "/mnt/dir/bogus") {
id
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: no such file or directory")
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
file(path: "/mnt/dir") {
id
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | }
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "path /mnt/dir is a directory, not a file")
err = testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withMountedTemp(path: "/mnt/tmp") {
file(path: "/mnt/tmp/bogus") {
id
}
}
}
}
}`, nil, nil)
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: cannot retrieve path from tmpfs")
cacheID := newCache(t)
err = testutil.Query(
`query Test($cache: CacheID!) {
container {
from(address: "alpine:3.16.2") {
withMountedCache(path: "/mnt/cache", cache: $cache) {
file(path: "/mnt/cache/bogus") {
id |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | }
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"cache": cacheID,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: cannot retrieve path from cache")
secretID := newSecret(t, "some-secret")
err = testutil.Query(
`query Test($secret: SecretID!) {
container {
from(address: "alpine:3.16.2") {
withMountedSecret(path: "/sekret", source: $secret) {
file(path: "/sekret") {
contents
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"secret": secretID,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "sekret: no such file or directory")
}
func TestContainerFSDirectory(t *testing.T) {
t.Parallel()
dirRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
Directory struct {
ID core.DirectoryID
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
directory(path: "/etc") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
etcID := dirRes.Container.From.Directory.ID
execRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
WithMountedDirectory struct {
WithExec struct {
Stdout string
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/etc", source: $id) {
withExec(args: ["cat", "/mnt/etc/alpine-release"]) {
stdout
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": etcID,
}})
require.NoError(t, err)
require.Equal(t, "3.16.2\n", execRes.Container.From.WithMountedDirectory.WithExec.Stdout)
}
func TestContainerRelativePaths(t *testing.T) {
t.Parallel()
dirRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Directory struct {
WithNewFile struct {
ID core.DirectoryID
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
id
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.ID
writeRes := struct {
Container struct {
From struct {
WithExec struct {
WithWorkdir struct {
WithWorkdir struct {
Workdir string
WithMountedDirectory struct {
WithMountedTemp struct {
WithMountedCache struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Mounts []string
WithExec struct {
Directory struct {
ID core.DirectoryID
}
}
WithoutMount struct {
Mounts []string
}
}
}
}
}
}
}
}
}
}{}
cacheID := newCache(t)
err = testutil.Query(
`query Test($id: DirectoryID!, $cache: CacheID!) {
container {
from(address: "alpine:3.16.2") {
withExec(args: ["mkdir", "-p", "/mnt/sub"]) {
withWorkdir(path: "/mnt") {
withWorkdir(path: "sub") {
workdir
withMountedDirectory(path: "dir", source: $id) {
withMountedTemp(path: "tmp") {
withMountedCache(path: "cache", cache: $cache) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | mounts
withExec(args: ["touch", "dir/another-file"]) {
directory(path: "dir") {
id
}
}
withoutMount(path: "cache") {
mounts
}
}
}
}
}
}
}
}
}
}`, &writeRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
"cache": cacheID,
}})
require.NoError(t, err)
require.Equal(t,
[]string{"/mnt/sub/dir", "/mnt/sub/tmp", "/mnt/sub/cache"},
writeRes.Container.From.WithExec.WithWorkdir.WithWorkdir.WithMountedDirectory.WithMountedTemp.WithMountedCache.Mounts)
require.Equal(t,
[]string{"/mnt/sub/dir", "/mnt/sub/tmp"},
writeRes.Container.From.WithExec.WithWorkdir.WithWorkdir.WithMountedDirectory.WithMountedTemp.WithMountedCache.WithoutMount.Mounts)
writtenID := writeRes.Container.From.WithExec.WithWorkdir.WithWorkdir.WithMountedDirectory.WithMountedTemp.WithMountedCache.WithExec.Directory.ID
execRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
WithMountedDirectory struct {
WithExec struct {
Stdout string
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
withExec(args: ["ls", "/mnt/dir"]) {
stdout
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": writtenID,
}})
require.NoError(t, err)
require.Equal(t, "another-file\nsome-file\n", execRes.Container.From.WithMountedDirectory.WithExec.Stdout)
}
func TestContainerMultiFrom(t *testing.T) {
t.Parallel()
dirRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Directory struct {
ID core.DirectoryID
}
}{}
err := testutil.Query(
`{
directory {
id
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.ID
execRes := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
WithMountedDirectory struct {
WithExec struct {
From struct {
WithExec struct {
WithExec struct {
Stdout string
}
}
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "node:18.10.0-alpine") {
withMountedDirectory(path: "/mnt", source: $id) {
withExec(args: ["sh", "-c", "node --version >> /mnt/versions"]) {
from(address: "golang:1.18.2-alpine") {
withExec(args: ["sh", "-c", "go version >> /mnt/versions"]) {
withExec(args: ["cat", "/mnt/versions"]) {
stdout |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | }
}
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
require.Contains(t, execRes.Container.From.WithMountedDirectory.WithExec.From.WithExec.WithExec.Stdout, "v18.10.0\n")
require.Contains(t, execRes.Container.From.WithMountedDirectory.WithExec.From.WithExec.WithExec.Stdout, "go version go1.18.2")
}
func TestContainerPublish(t *testing.T) {
c, ctx := connect(t)
defer c.Close()
testRef := registryRef("container-publish")
pushedRef, err := c.Container().
From("alpine:3.16.2").
Publish(ctx, testRef)
require.NoError(t, err)
require.NotEqual(t, testRef, pushedRef)
require.Contains(t, pushedRef, "@sha256:")
contents, err := c.Container().
From(pushedRef).Rootfs().File("/etc/alpine-release").Contents(ctx)
require.NoError(t, err)
require.Equal(t, contents, "3.16.2\n")
}
func TestExecFromScratch(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | ctx, cancel := context.WithCancel(context.Background())
defer cancel()
c, err := dagger.Connect(ctx)
require.NoError(t, err)
defer c.Close()
execBusybox := c.Container().
WithMountedFile("/busybox", c.Container().From("busybox:musl").File("/bin/busybox")).
WithExec([]string{"/busybox"})
_, err = execBusybox.Stdout(ctx)
require.NoError(t, err)
_, err = execBusybox.Publish(ctx, registryRef("from-scratch"))
require.NoError(t, err)
}
func TestContainerMultipleMounts(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
defer c.Close()
dir := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(dir, "one"), []byte("1"), 0o600))
require.NoError(t, os.WriteFile(filepath.Join(dir, "two"), []byte("2"), 0o600))
require.NoError(t, os.WriteFile(filepath.Join(dir, "three"), []byte("3"), 0o600))
one := c.Host().Directory(dir).File("one")
two := c.Host().Directory(dir).File("two")
three := c.Host().Directory(dir).File("three")
build := c.Container().From("alpine:3.16.2").
WithMountedFile("/example/one", one).
WithMountedFile("/example/two", two).
WithMountedFile("/example/three", three)
build = build.WithExec([]string{"ls", "/example/one", "/example/two", "/example/three"})
build = build.WithExec([]string{"cat", "/example/one", "/example/two", "/example/three"})
out, err := build.Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "123", out)
}
func TestContainerExport(t *testing.T) {
t.Parallel()
ctx := context.Background()
wd := t.TempDir()
dest := t.TempDir()
c, err := dagger.Connect(ctx, dagger.WithWorkdir(wd))
require.NoError(t, err) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | defer c.Close()
ctr := c.Container().From("alpine:3.16.2")
t.Run("to absolute dir", func(t *testing.T) {
imagePath := filepath.Join(dest, "image.tar")
ok, err := ctr.Export(ctx, imagePath)
require.NoError(t, err)
require.True(t, ok)
entries := tarEntries(t, imagePath)
require.Contains(t, entries, "oci-layout")
require.Contains(t, entries, "index.json")
require.Contains(t, entries, "manifest.json")
})
t.Run("to workdir", func(t *testing.T) {
ok, err := ctr.Export(ctx, "./image.tar")
require.NoError(t, err)
require.True(t, ok)
entries := tarEntries(t, filepath.Join(wd, "image.tar"))
require.Contains(t, entries, "oci-layout")
require.Contains(t, entries, "index.json")
require.Contains(t, entries, "manifest.json")
})
t.Run("to outer dir", func(t *testing.T) {
ok, err := ctr.Export(ctx, "../")
require.Error(t, err)
require.False(t, ok)
})
}
func TestContainerImport(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | t.Parallel()
ctx := context.Background()
dest := t.TempDir()
c, err := dagger.Connect(ctx)
require.NoError(t, err)
defer c.Close()
imagePath := filepath.Join(dest, "image.tar")
t.Run("OCI", func(t *testing.T) {
ctr := c.Container().
From("alpine:3.16.2").
WithEnvVariable("FOO", "bar")
ok, err := ctr.Export(ctx, imagePath)
require.NoError(t, err)
require.True(t, ok)
imported := c.Container().Import(c.Host().Directory(dest).File("image.tar"))
out, err := imported.WithExec([]string{"sh", "-c", "echo $FOO"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "bar\n", out)
})
t.Run("Docker", func(t *testing.T) {
ref := name.MustParseReference("alpine:3.16.2")
img, err := remote.Image(ref)
require.NoError(t, err)
err = tarball.WriteToFile(imagePath, ref, img)
require.NoError(t, err)
imported := c.Container().Import(c.Host().Directory(dest).File("image.tar"))
out, err := imported.WithExec([]string{"cat", "/etc/alpine-release"}).Stdout(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | require.NoError(t, err)
require.Equal(t, "3.16.2\n", out)
})
}
func TestContainerMultiPlatformExport(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
c, err := dagger.Connect(ctx, dagger.WithLogOutput(os.Stdout))
require.NoError(t, err)
defer c.Close()
variants := make([]*dagger.Container, 0, len(platformToUname))
for platform := range platformToUname {
ctr := c.Container(dagger.ContainerOpts{Platform: platform}).
From("alpine:3.16.2").
WithExec([]string{"uname", "-m"})
variants = append(variants, ctr)
}
dest := filepath.Join(t.TempDir(), "image.tar")
ok, err := c.Container().Export(ctx, dest, dagger.ContainerExportOpts{
PlatformVariants: variants,
})
require.NoError(t, err)
require.True(t, ok)
entries := tarEntries(t, dest)
require.Contains(t, entries, "oci-layout")
require.Contains(t, entries, "index.json")
require.NotContains(t, entries, "manifest.json")
}
func TestContainerMultiPlatformImport(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | ctx, cancel := context.WithCancel(context.Background())
defer cancel()
c, err := dagger.Connect(ctx, dagger.WithLogOutput(os.Stdout))
require.NoError(t, err)
defer c.Close()
variants := make([]*dagger.Container, 0, len(platformToUname))
for platform := range platformToUname {
ctr := c.Container(dagger.ContainerOpts{Platform: platform}).
From("alpine:3.16.2")
variants = append(variants, ctr)
}
tmp := t.TempDir()
imagePath := filepath.Join(tmp, "image.tar")
ok, err := c.Container().Export(ctx, imagePath, dagger.ContainerExportOpts{
PlatformVariants: variants,
})
require.NoError(t, err)
require.True(t, ok)
for platform, uname := range platformToUname {
imported := c.Container(dagger.ContainerOpts{Platform: platform}).
Import(c.Host().Directory(tmp).File("image.tar"))
out, err := imported.WithExec([]string{"uname", "-m"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, uname+"\n", out)
}
}
func TestContainerWithDirectoryToMount(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | t.Parallel()
ctx := context.Background()
c, err := dagger.Connect(ctx, dagger.WithLogOutput(os.Stdout))
require.NoError(t, err)
defer c.Close()
mnt := c.Directory().
WithNewDirectory("/top/sub-dir/sub-file").
Directory("/top")
ctr := c.Container().
From("alpine:3.16.2").
WithMountedDirectory("/mnt", mnt)
dir := c.Directory().
WithNewFile("/copied-file", "some-content")
ctr = ctr.WithDirectory("/mnt/sub-dir/copied-dir", dir)
contents, err := ctr.WithExec([]string{"find", "/mnt"}).Stdout(ctx)
require.NoError(t, err)
require.ElementsMatch(t, []string{
"/mnt",
"/mnt/sub-dir",
"/mnt/sub-dir/sub-file",
"/mnt/sub-dir/copied-dir",
"/mnt/sub-dir/copied-dir/copied-file",
}, strings.Split(strings.Trim(contents, "\n"), "\n"))
}
var echoSocketSrc string
func TestContainerWithUnixSocket(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
defer c.Close()
tmp := t.TempDir()
sock := filepath.Join(tmp, "test.sock")
l, err := net.Listen("unix", sock)
require.NoError(t, err)
defer l.Close()
go func() {
for {
c, err := l.Accept()
if err != nil {
if !errors.Is(err, net.ErrClosed) {
t.Logf("accept: %s", err)
panic(err)
}
return
}
n, err := io.Copy(c, c)
if err != nil {
t.Logf("hello: %s", err)
panic(err)
}
t.Logf("copied %d bytes", n)
err = c.Close()
if err != nil {
t.Logf("close: %s", err)
panic(err)
}
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | }()
echo := c.Directory().WithNewFile("main.go", echoSocketSrc).File("main.go")
ctr := c.Container().
From("golang:1.20.0-alpine").
WithMountedFile("/src/main.go", echo).
WithUnixSocket("/tmp/test.sock", c.Host().UnixSocket(sock)).
WithExec([]string{"go", "run", "/src/main.go", "/tmp/test.sock", "hello"})
stdout, err := ctr.Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "hello\n", stdout)
t.Run("socket can be removed", func(t *testing.T) {
without := ctr.WithoutUnixSocket("/tmp/test.sock").
WithExec([]string{"ls", "/tmp"})
stdout, err = without.Stdout(ctx)
require.NoError(t, err)
require.Empty(t, stdout)
})
t.Run("replaces existing socket at same path", func(t *testing.T) {
repeated := ctr.WithUnixSocket("/tmp/test.sock", c.Host().UnixSocket(sock))
stdout, err := repeated.Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "hello\n", stdout)
without := repeated.WithoutUnixSocket("/tmp/test.sock").
WithExec([]string{"ls", "/tmp"})
stdout, err = without.Stdout(ctx)
require.NoError(t, err)
require.Empty(t, stdout)
})
}
func TestContainerExecError(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | t.Parallel()
ctx := context.Background()
c, err := dagger.Connect(ctx, dagger.WithLogOutput(os.Stdout))
require.NoError(t, err)
outMsg := "THIS SHOULD GO TO STDOUT"
encodedOutMsg := base64.StdEncoding.EncodeToString([]byte(outMsg))
errMsg := "THIS SHOULD GO TO STDERR"
encodedErrMsg := base64.StdEncoding.EncodeToString([]byte(errMsg))
t.Run("includes output of failed exec in error", func(t *testing.T) {
_, err = c.Container().
From("alpine:3.16.2").
WithExec([]string{"sh", "-c", fmt.Sprintf(
`echo %s | base64 -d >&1; echo %s | base64 -d >&2; exit 1`, encodedOutMsg, encodedErrMsg,
)}).
Sync(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), outMsg)
require.Contains(t, err.Error(), errMsg)
})
t.Run("includes output of failed exec in error when redirects are enabled", func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | _, err = c.Container().
From("alpine:3.16.2").
WithExec(
[]string{"sh", "-c", fmt.Sprintf(
`echo %s | base64 -d >&1; echo %s | base64 -d >&2; exit 1`, encodedOutMsg, encodedErrMsg,
)},
dagger.ContainerWithExecOpts{
RedirectStdout: "/out",
RedirectStderr: "/err",
},
).
Sync(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), outMsg)
require.Contains(t, err.Error(), errMsg)
})
t.Run("truncates output past a maximum size", func(t *testing.T) {
var stdoutBuf bytes.Buffer
for i := 0; i < 2*core.MaxExecErrorOutputBytes; i++ {
stdoutBuf.WriteByte('a')
}
stdoutStr := stdoutBuf.String()
encodedOutMsg := base64.StdEncoding.EncodeToString(stdoutBuf.Bytes())
var stderrBuf bytes.Buffer
for i := 0; i < 2*core.MaxExecErrorOutputBytes; i++ {
stderrBuf.WriteByte('b')
}
stderrStr := stderrBuf.String() |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | encodedErrMsg := base64.StdEncoding.EncodeToString(stderrBuf.Bytes())
_, err = c.Container().
From("alpine:3.16.2").
WithExec(
[]string{"sh", "-c", fmt.Sprintf(
`echo %s | base64 -d >&1; echo %s | base64 -d >&2; exit 1`, encodedOutMsg, encodedErrMsg,
)},
).
Sync(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), stdoutStr[:core.MaxExecErrorOutputBytes])
require.NotContains(t, err.Error(), stdoutStr[:core.MaxExecErrorOutputBytes+1])
require.Contains(t, err.Error(), stderrStr[:core.MaxExecErrorOutputBytes])
require.NotContains(t, err.Error(), stderrStr[:core.MaxExecErrorOutputBytes+1])
})
}
func TestContainerWithRegistryAuth(t *testing.T) {
t.Parallel()
ctx := context.Background()
c, err := dagger.Connect(ctx, dagger.WithLogOutput(os.Stdout))
require.NoError(t, err)
defer c.Close()
testRef := privateRegistryRef("container-with-registry-auth")
container := c.Container().From("alpine:3.16.2")
_, err = container.Publish(ctx, testRef)
require.Error(t, err)
t.Run("legacy secret API", func(t *testing.T) {
pushedRef, err := container.
WithRegistryAuth( |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | privateRegistryHost,
"john",
c.Container().
WithNewFile("secret.txt", dagger.ContainerWithNewFileOpts{Contents: "xFlejaPdjrt25Dvr"}).
File("secret.txt").
Secret(),
).
Publish(ctx, testRef)
require.NoError(t, err)
require.NotEqual(t, testRef, pushedRef)
require.Contains(t, pushedRef, "@sha256:")
})
t.Run("new secret API", func(t *testing.T) {
pushedRef, err := container.
WithRegistryAuth(
privateRegistryHost,
"john",
c.SetSecret("this-secret", "xFlejaPdjrt25Dvr"),
).
Publish(ctx, testRef)
require.NoError(t, err)
require.NotEqual(t, testRef, pushedRef)
require.Contains(t, pushedRef, "@sha256:")
})
}
func TestContainerImageRef(t *testing.T) {
t.Parallel()
t.Run("should test query returning imageRef", func(t *testing.T) {
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
ImageRef string
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
imageRef
}
}
}`, &res, nil)
require.NoError(t, err)
require.Contains(t, res.Container.From.ImageRef, "docker.io/library/alpine:3.16.2@sha256:")
})
t.Run("should throw error after the container image modification with exec", func(t *testing.T) {
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
ImageRef string
}
}
}{}
err := testutil.Query(
`{
container {
from(address:"hello-world") {
exec(args:["/hello"]) {
imageRef
}
}
}
}`, &res, nil)
require.Error(t, err)
require.Contains(t, err.Error(), "Image reference can only be retrieved immediately after the 'Container.From' call. Error in fetching imageRef as the container image is changed")
})
t.Run("should throw error after the container image modification with exec", func(t *testing.T) {
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
From struct {
ImageRef string
}
}
}{}
err := testutil.Query(
`{
container {
from(address:"hello-world") {
withExec(args:["/hello"]) {
imageRef
}
}
}
}`, &res, nil)
require.Error(t, err)
require.Contains(t, err.Error(), "Image reference can only be retrieved immediately after the 'Container.From' call. Error in fetching imageRef as the container image is changed")
})
t.Run("should throw error after the container image modification with directory", func(t *testing.T) {
c, ctx := connect(t)
defer c.Close()
dir := c.Directory(). |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | WithNewFile("some-file", "some-content").
WithNewFile("some-dir/sub-file", "sub-content").
Directory("some-dir")
ctr := c.Container().
From("alpine:3.16.2").
WithWorkdir("/workdir").
WithDirectory("with-dir", dir)
_, err := ctr.ImageRef(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), "Image reference can only be retrieved immediately after the 'Container.From' call. Error in fetching imageRef as the container image is changed")
})
}
func TestContainerBuildNilContextError(t *testing.T) {
t.Parallel()
ctx := context.Background()
c, err := dagger.Connect(ctx, dagger.WithLogOutput(os.Stdout))
require.NoError(t, err)
defer c.Close()
err = testutil.Query(
`{
container {
build(context: "") {
id
}
}
}`, &map[any]any{}, nil)
require.ErrorContains(t, err, "invalid nil input definition to definition op")
}
func TestContainerInsecureRootCapabilites(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
defer c.Close()
ctx, cancel := context.WithCancel(ctx)
defer cancel()
privilegedCaps := []string{
"cap_sys_admin",
"cap_net_admin",
"cap_sys_module",
"cap_sys_ptrace",
"cap_sys_boot",
"cap_sys_rawio",
"cap_sys_resource",
}
for _, capSet := range []string{"CapPrm", "CapEff", "CapBnd"} {
out, err := c.Container().From("alpine:3.16.2").
WithExec([]string{"apk", "add", "libcap"}).
WithExec([]string{"sh", "-c", "capsh --decode=$(grep " + capSet + " /proc/self/status | awk '{print $2}')"}). |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Stdout(ctx)
require.NoError(t, err)
for _, privCap := range privilegedCaps {
require.NotContains(t, out, privCap)
}
}
for _, capSet := range []string{"CapPrm", "CapEff", "CapBnd", "CapInh", "CapAmb"} {
out, err := c.Container().From("alpine:3.16.2").
WithExec([]string{"apk", "add", "libcap"}).
WithExec([]string{"sh", "-c", "capsh --decode=$(grep " + capSet + " /proc/self/status | awk '{print $2}')"}, dagger.ContainerWithExecOpts{
InsecureRootCapabilities: true,
}).
Stdout(ctx)
require.NoError(t, err)
for _, privCap := range privilegedCaps {
require.Contains(t, out, privCap)
}
}
}
func TestContainerInsecureRootCapabilitesWithService(t *testing.T) {
c, ctx := connect(t)
defer c.Close()
ctx, cancel := context.WithCancel(ctx)
defer cancel()
dockerd := c.Container().From("docker:23.0.1-dind").
WithMountedCache("/var/lib/docker", c.CacheVolume("docker-lib"), dagger.ContainerWithMountedCacheOpts{
Sharing: dagger.Private, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | }).
WithMountedCache("/tmp", c.CacheVolume("share-tmp")).
WithExposedPort(2375).
WithExec([]string{
"dockerd",
"--host=tcp:0.0.0.0:2375",
"--tls=false",
}, dagger.ContainerWithExecOpts{
InsecureRootCapabilities: true,
})
dockerHost, err := dockerd.Endpoint(ctx, dagger.ContainerEndpointOpts{
Scheme: "tcp",
})
require.NoError(t, err)
randID := identity.NewID()
out, err := c.Container().From("docker:23.0.1-cli").
WithMountedCache("/tmp", c.CacheVolume("share-tmp")).
WithServiceBinding("docker", dockerd).
WithEnvVariable("DOCKER_HOST", dockerHost).
WithExec([]string{"sh", "-e", "-c", strings.Join([]string{
fmt.Sprintf("echo %s-from-outside > /tmp/from-outside", randID),
"docker run --rm -v /tmp:/tmp alpine cat /tmp/from-outside",
fmt.Sprintf("docker run --rm -v /tmp:/tmp alpine sh -c 'echo %s-from-inside > /tmp/from-inside'", randID),
"cat /tmp/from-inside",
}, "\n")}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, fmt.Sprintf("%s-from-outside\n%s-from-inside\n", randID, randID), out)
}
func TestContainerNoExec(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
defer c.Close()
code, err := c.Container().From("alpine:3.16.2").ExitCode(ctx)
require.NoError(t, err)
require.Equal(t, 0, code)
stdout, err := c.Container().From("alpine:3.16.2").Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "", stdout)
stderr, err := c.Container().From("alpine:3.16.2").Stderr(ctx)
require.NoError(t, err)
require.Equal(t, "", stderr)
_, err = c.Container().
From("alpine:3.16.2").
WithDefaultArgs(dagger.ContainerWithDefaultArgsOpts{
Args: nil,
}).
ExitCode(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), "no command has been set")
}
func TestContainerWithMountedFileOwner(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
t.Cleanup(func() { c.Close() })
t.Run("simple file", func(t *testing.T) {
tmp := t.TempDir()
err := os.WriteFile(filepath.Join(tmp, "message.txt"), []byte("hello world"), 0o600)
require.NoError(t, err)
file := c.Host().Directory(tmp).File("message.txt")
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithMountedFile(name, file, dagger.ContainerWithMountedFileOpts{
Owner: owner,
})
})
})
t.Run("file from subdirectory", func(t *testing.T) {
tmp := t.TempDir()
err := os.Mkdir(filepath.Join(tmp, "subdir"), 0755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(tmp, "subdir", "message.txt"), []byte("hello world"), 0o600)
require.NoError(t, err)
file := c.Host().Directory(tmp).Directory("subdir").File("message.txt")
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithMountedFile(name, file, dagger.ContainerWithMountedFileOpts{
Owner: owner,
})
})
})
}
func TestContainerWithMountedDirectoryOwner(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
t.Cleanup(func() { c.Close() })
t.Run("simple directory", func(t *testing.T) {
tmp := t.TempDir()
err := os.WriteFile(filepath.Join(tmp, "message.txt"), []byte("hello world"), 0o600)
require.NoError(t, err)
dir := c.Host().Directory(tmp)
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithMountedDirectory(name, dir, dagger.ContainerWithMountedDirectoryOpts{
Owner: owner,
})
})
})
t.Run("subdirectory", func(t *testing.T) {
tmp := t.TempDir()
err := os.Mkdir(filepath.Join(tmp, "subdir"), 0755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(tmp, "subdir", "message.txt"), []byte("hello world"), 0o600)
require.NoError(t, err)
dir := c.Host().Directory(tmp).Directory("subdir")
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithMountedDirectory(name, dir, dagger.ContainerWithMountedDirectoryOpts{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Owner: owner,
})
})
})
t.Run("permissions", func(t *testing.T) {
dir := c.Directory().
WithNewDirectory("perms", dagger.DirectoryWithNewDirectoryOpts{
Permissions: 0745,
}).
WithNewFile("perms/foo", "whee", dagger.DirectoryWithNewFileOpts{
Permissions: 0645,
}).
Directory("perms")
ctr := c.Container().From("alpine:3.16.2").
WithExec([]string{"adduser", "-D", "inherituser"}).
WithExec([]string{"adduser", "-u", "1234", "-D", "auser"}).
WithExec([]string{"addgroup", "-g", "4321", "agroup"}).
WithUser("inherituser").
WithMountedDirectory("/data", dir, dagger.ContainerWithMountedDirectoryOpts{
Owner: "auser:agroup",
})
out, err := ctr.WithExec([]string{"stat", "-c", "%a:%U:%G", "/data"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "745:auser:agroup\n", out)
out, err = ctr.WithExec([]string{"stat", "-c", "%a:%U:%G", "/data/foo"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "645:auser:agroup\n", out)
})
}
func TestContainerWithFileOwner(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
t.Cleanup(func() { c.Close() })
t.Run("simple file", func(t *testing.T) {
tmp := t.TempDir()
err := os.WriteFile(filepath.Join(tmp, "message.txt"), []byte("hello world"), 0o600)
require.NoError(t, err)
file := c.Host().Directory(tmp).File("message.txt")
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithFile(name, file, dagger.ContainerWithFileOpts{
Owner: owner,
})
})
})
t.Run("file from subdirectory", func(t *testing.T) {
tmp := t.TempDir()
err := os.Mkdir(filepath.Join(tmp, "subdir"), 0755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(tmp, "subdir", "message.txt"), []byte("hello world"), 0o600)
require.NoError(t, err)
file := c.Host().Directory(tmp).Directory("subdir").File("message.txt")
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithFile(name, file, dagger.ContainerWithFileOpts{
Owner: owner,
})
})
})
}
func TestContainerWithDirectoryOwner(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
t.Cleanup(func() { c.Close() })
t.Run("simple directory", func(t *testing.T) {
tmp := t.TempDir()
err := os.WriteFile(filepath.Join(tmp, "message.txt"), []byte("hello world"), 0o600)
require.NoError(t, err)
dir := c.Host().Directory(tmp)
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithDirectory(name, dir, dagger.ContainerWithDirectoryOpts{
Owner: owner,
})
})
})
t.Run("subdirectory", func(t *testing.T) {
tmp := t.TempDir()
err := os.Mkdir(filepath.Join(tmp, "subdir"), 0755)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(tmp, "subdir", "message.txt"), []byte("hello world"), 0o600)
require.NoError(t, err)
dir := c.Host().Directory(tmp).Directory("subdir")
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithDirectory(name, dir, dagger.ContainerWithDirectoryOpts{
Owner: owner,
})
})
})
}
func TestContainerWithNewFileOwner(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
t.Cleanup(func() { c.Close() })
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithNewFile(name, dagger.ContainerWithNewFileOpts{
Owner: owner,
})
})
}
func TestContainerWithMountedCacheOwner(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
t.Cleanup(func() { c.Close() })
cache := c.CacheVolume("test")
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithMountedCache(name, cache, dagger.ContainerWithMountedCacheOpts{
Owner: owner,
})
})
t.Run("permissions (empty)", func(t *testing.T) {
ctr := c.Container().From("alpine:3.16.2").
WithExec([]string{"adduser", "-D", "inherituser"}).
WithExec([]string{"adduser", "-u", "1234", "-D", "auser"}).
WithExec([]string{"addgroup", "-g", "4321", "agroup"}).
WithUser("inherituser").
WithMountedCache("/data", cache, dagger.ContainerWithMountedCacheOpts{
Owner: "auser:agroup",
})
out, err := ctr.WithExec([]string{"stat", "-c", "%a:%U:%G", "/data"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "755:auser:agroup\n", out)
})
t.Run("permissions (source)", func(t *testing.T) {
dir := c.Directory().
WithNewDirectory("perms", dagger.DirectoryWithNewDirectoryOpts{
Permissions: 0745,
}).
WithNewFile("perms/foo", "whee", dagger.DirectoryWithNewFileOpts{
Permissions: 0645, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | }).
Directory("perms")
ctr := c.Container().From("alpine:3.16.2").
WithExec([]string{"adduser", "-D", "inherituser"}).
WithExec([]string{"adduser", "-u", "1234", "-D", "auser"}).
WithExec([]string{"addgroup", "-g", "4321", "agroup"}).
WithUser("inherituser").
WithMountedCache("/data", cache, dagger.ContainerWithMountedCacheOpts{
Source: dir,
Owner: "auser:agroup",
})
out, err := ctr.WithExec([]string{"stat", "-c", "%a:%U:%G", "/data"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "745:auser:agroup\n", out)
out, err = ctr.WithExec([]string{"stat", "-c", "%a:%U:%G", "/data/foo"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "645:auser:agroup\n", out)
})
}
func TestContainerWithMountedSecretOwner(t *testing.T) {
c, ctx := connect(t)
t.Cleanup(func() { c.Close() })
secret := c.SetSecret("test", "hunter2")
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithMountedSecret(name, secret, dagger.ContainerWithMountedSecretOpts{
Owner: owner,
})
})
}
func TestContainerWithUnixSocketOwner(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | c, ctx := connect(t)
t.Cleanup(func() { c.Close() })
tmp := t.TempDir()
sock := filepath.Join(tmp, "test.sock")
l, err := net.Listen("unix", sock)
require.NoError(t, err)
defer l.Close()
socket := c.Host().UnixSocket(sock)
testOwnership(ctx, t, c, func(ctr *dagger.Container, name string, owner string) *dagger.Container {
return ctr.WithUnixSocket(name, socket, dagger.ContainerWithUnixSocketOpts{
Owner: owner,
})
})
}
func testOwnership(
ctx context.Context,
t *testing.T,
c *dagger.Client,
addContent func(ctr *dagger.Container, name, owner string) *dagger.Container,
) {
t.Parallel()
ctr := c.Container().From("alpine:3.16.2").
WithExec([]string{"adduser", "-D", "inherituser"}).
WithExec([]string{"adduser", "-u", "1234", "-D", "auser"}).
WithExec([]string{"addgroup", "-g", "4321", "agroup"}).
WithUser("inherituser").
WithWorkdir("/data")
type example struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | name string
owner string
output string
}
for _, example := range []example{
{name: "userid", owner: "1234", output: "auser auser"},
{name: "userid-twice", owner: "1234:1234", output: "auser auser"},
{name: "username", owner: "auser", output: "auser auser"},
{name: "username-twice", owner: "auser:auser", output: "auser auser"},
{name: "ids", owner: "1234:4321", output: "auser agroup"},
{name: "username-gid", owner: "auser:4321", output: "auser agroup"},
{name: "uid-groupname", owner: "1234:agroup", output: "auser agroup"},
{name: "names", owner: "auser:agroup", output: "auser agroup"}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | {name: "no-inherit", owner: "", output: "root root"},
} {
example := example
t.Run(example.name, func(t *testing.T) {
withOwner := addContent(ctr, example.name, example.owner)
output, err := withOwner.
WithUser("root").
WithExec([]string{
"sh", "-exc",
"find * | xargs stat -c '%U %G'",
}).
Stdout(ctx)
require.NoError(t, err)
for _, line := range strings.Split(output, "\n") {
if line == "" {
continue
}
require.Equal(t, example.output, line)
}
})
}
}
func TestContainerParallelMutation(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | Container struct {
A struct {
EnvVariable string
}
B string
}
}{}
err := testutil.Query(
`{
container {
a: withEnvVariable(name: "FOO", value: "BAR") {
envVariable(name: "FOO")
}
b: envVariable(name: "FOO")
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.A.EnvVariable, "BAR")
require.Empty(t, res.Container.B, "BAR")
}
func TestContainerForceCompression(t *testing.T) {
t.Parallel()
for _, tc := range []struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | compression dagger.ImageLayerCompression
expectedDockerMediaType string
expectedOCIMediaType string
}{
{
dagger.Gzip,
"application/vnd.docker.image.rootfs.diff.tar.gzip",
"application/vnd.oci.image.layer.v1.tar+gzip",
},
{
dagger.Zstd,
"application/vnd.docker.image.rootfs.diff.tar.zstd",
"application/vnd.oci.image.layer.v1.tar+zstd",
},
{
dagger.Uncompressed,
"application/vnd.docker.image.rootfs.diff.tar",
"application/vnd.oci.image.layer.v1.tar",
},
{
dagger.Estargz,
"",
"application/vnd.oci.image.layer.v1.tar+gzip",
},
} {
tc := tc |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | t.Run(string(tc.compression), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
defer c.Close()
ref := registryRef("testcontainerpublishforcecompression" + strings.ToLower(string(tc.compression)))
_, err := c.Container().
From("alpine:3.16.2").
Publish(ctx, ref, dagger.ContainerPublishOpts{
ForcedCompression: tc.compression,
})
require.NoError(t, err)
parsedRef, err := name.ParseReference(ref, name.Insecure)
require.NoError(t, err)
imgDesc, err := remote.Get(parsedRef, remote.WithTransport(http.DefaultTransport))
require.NoError(t, err)
img, err := imgDesc.Image()
require.NoError(t, err)
layers, err := img.Layers()
require.NoError(t, err)
for _, layer := range layers {
mediaType, err := layer.MediaType()
require.NoError(t, err)
expectedMediaType := tc.expectedDockerMediaType
if tc.compression == dagger.Estargz {
expectedMediaType = tc.expectedOCIMediaType
}
require.EqualValues(t, expectedMediaType, mediaType)
}
tarPath := filepath.Join(t.TempDir(), "export.tar")
_, err = c.Container(). |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | From("alpine:3.16.2").
Export(ctx, tarPath, dagger.ContainerExportOpts{
ForcedCompression: tc.compression,
})
require.NoError(t, err)
indexBytes := readTarFile(t, tarPath, "index.json")
var index ocispecs.Index
require.NoError(t, json.Unmarshal(indexBytes, &index))
manifestDigest := index.Manifests[0].Digest
manifestBytes := readTarFile(t, tarPath, "blobs/sha256/"+manifestDigest.Encoded())
var manifest ocispecs.Manifest
require.NoError(t, json.Unmarshal(manifestBytes, &manifest))
for _, layer := range manifest.Layers {
require.EqualValues(t, tc.expectedOCIMediaType, layer.MediaType)
}
})
}
}
func TestContainerBuildMergesWithParent(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
builderCtr := c.Directory().WithNewFile(
"Dockerfile",
`
FROM node:alpine
ENV FOO=BAR
LABEL "com.example.test-should-replace"="foo"
RUN node --version
`, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | )
testCtr := c.Container().
WithEnvVariable("BOOL", "DOG").
WithEnvVariable("FOO", "BAZ").
WithLabel("com.example.test-should-exist", "test").
WithLabel("com.example.test-should-replace", "bar").
WithExposedPort(5000).
Build(builderCtr)
envShouldExist, err := testCtr.EnvVariable(ctx, "BOOL")
require.NoError(t, err)
require.Equal(t, "DOG", envShouldExist)
envShouldBeReplaced, err := testCtr.EnvVariable(ctx, "FOO")
require.NoError(t, err)
require.Equal(t, "BAR", envShouldBeReplaced)
labelShouldExist, err := testCtr.Label(ctx, "com.example.test-should-exist")
require.NoError(t, err)
require.Equal(t, "test", labelShouldExist)
labelShouldBeReplaced, err := testCtr.Label(ctx, "com.example.test-should-replace")
require.NoError(t, err)
require.Equal(t, "foo", labelShouldBeReplaced)
ports, err := testCtr.ExposedPorts(ctx)
require.NoError(t, err)
port, err := ports[0].Port(ctx)
require.NoError(t, err)
require.Equal(t, 5000, port)
}
func TestContainerFromMergesWithParent(t *testing.T) {
t.Parallel()
c, ctx := connect(t) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,077 | Add `(truncated output)` to stdout/stderr errors | @helderco mentioned:
> Can we append some notice like "truncated output"? Multiple users have been confused that the output is truncated, reporting it as a bug. | https://github.com/dagger/dagger/issues/5077 | https://github.com/dagger/dagger/pull/5163 | 7d8738d64889572fd5ac7d9930c2f16b4c3629d2 | e0fecd2682e63b5c0fb18a18e77f4ea001bf6219 | 2023-05-02T21:11:43Z | go | 2023-05-22T21:21:17Z | core/integration/container_test.go | testCtr := c.Container().
WithEnvVariable("FOO", "BAR").
WithEnvVariable("PATH", "/replace/me").
WithLabel("moby.buildkit.frontend.caps", "replace-me").
WithLabel("com.example.test-should-exist", "exist").
WithExposedPort(5000).
From("docker/dockerfile:1.5")
envShouldExist, err := testCtr.EnvVariable(ctx, "FOO")
require.NoError(t, err)
require.Equal(t, "BAR", envShouldExist)
envShouldBeReplaced, err := testCtr.EnvVariable(ctx, "PATH")
require.NoError(t, err)
require.Equal(t, "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", envShouldBeReplaced)
labelShouldExist, err := testCtr.Label(ctx, "com.example.test-should-exist")
require.NoError(t, err)
require.Equal(t, "exist", labelShouldExist)
existingLabelFromImageShouldExist, err := testCtr.Label(ctx, "moby.buildkit.frontend.network.none")
require.NoError(t, err)
require.Equal(t, "true", existingLabelFromImageShouldExist)
labelShouldBeReplaced, err := testCtr.Label(ctx, "moby.buildkit.frontend.caps")
require.NoError(t, err)
require.Equal(t, "moby.buildkit.frontend.inputs,moby.buildkit.frontend.subrequests,moby.buildkit.frontend.contexts", labelShouldBeReplaced)
ports, err := testCtr.ExposedPorts(ctx)
require.NoError(t, err)
port, err := ports[0].Port(ctx)
require.NoError(t, err)
require.Equal(t, 5000, port)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | package core
import (
"bytes"
"context"
_ "embed"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"net/http"
"os"
"path/filepath"
"strings"
"testing"
"dagger.io/dagger"
"github.com/dagger/dagger/core"
"github.com/dagger/dagger/core/schema"
"github.com/dagger/dagger/internal/testutil"
"github.com/google/go-containerregistry/pkg/name"
"github.com/google/go-containerregistry/pkg/v1/remote"
"github.com/google/go-containerregistry/pkg/v1/tarball"
"github.com/moby/buildkit/identity"
ocispecs "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/stretchr/testify/require"
)
func TestContainerScratch(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
ID string
Fs struct {
Entries []string
}
}
}{}
err := testutil.Query(
`{
container {
id
fs {
entries
}
}
}`, &res, nil)
require.NoError(t, err)
require.Empty(t, res.Container.Fs.Entries)
}
func TestContainerFrom(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
From struct {
Fs struct {
File struct {
Contents string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
fs {
file(path: "/etc/alpine-release") {
contents
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.Fs.File.Contents, "3.16.2\n")
}
func TestContainerWith(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | t.Parallel()
ctx := context.Background()
c, err := dagger.Connect(ctx)
require.NoError(t, err)
defer c.Close()
foo := "bar"
alpine := c.Container().From("alpine:3.16.2").With(func(c *dagger.Container) *dagger.Container {
return c.WithEnvVariable("FOO", foo)
})
out, err := alpine.WithExec([]string{"printenv", "FOO"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "bar\n", out)
withFood := func(c *dagger.Container) *dagger.Container {
return c.WithEnvVariable("FOOD", "bar")
}
out, err = c.Container().From("alpine:3.16.2").
With(withFood).
WithExec([]string{"printenv", "FOOD"}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "bar\n", out)
withEnv := func(env, val string) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
return c.WithEnvVariable(env, val)
}
}
env := "HELLO" |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | val := "WORLD"
out, err = c.Container().From("alpine:3.16.2").
With(withEnv(env, val)).
WithExec([]string{"printenv", env}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, val+"\n", out)
}
func TestContainerBuild(t *testing.T) {
ctx := context.Background()
c, err := dagger.Connect(ctx)
require.NoError(t, err)
defer c.Close()
contextDir := c.Directory().
WithNewFile("main.go",
`package main
import "fmt"
import "os"
func main() {
for _, env := range os.Environ() {
fmt.Println(env)
}
}`)
t.Run("default Dockerfile location", func(t *testing.T) {
src := contextDir.
WithNewFile("Dockerfile",
`FROM golang:1.18.2-alpine
WORKDIR /src
COPY main.go .
RUN go mod init hello |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | RUN go build -o /usr/bin/goenv main.go
ENV FOO=bar
CMD goenv
`)
env, err := c.Container().Build(src).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, env, "FOO=bar\n")
})
t.Run("custom Dockerfile location", func(t *testing.T) {
src := contextDir.
WithNewFile("subdir/Dockerfile.whee",
`FROM golang:1.18.2-alpine
WORKDIR /src
COPY main.go .
RUN go mod init hello
RUN go build -o /usr/bin/goenv main.go
ENV FOO=bar
CMD goenv
`)
env, err := c.Container().Build(src, dagger.ContainerBuildOpts{
Dockerfile: "subdir/Dockerfile.whee",
}).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, env, "FOO=bar\n")
})
t.Run("subdirectory with default Dockerfile location", func(t *testing.T) {
src := contextDir.
WithNewFile("Dockerfile",
`FROM golang:1.18.2-alpine
WORKDIR /src |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | COPY main.go .
RUN go mod init hello
RUN go build -o /usr/bin/goenv main.go
ENV FOO=bar
CMD goenv
`)
sub := c.Directory().WithDirectory("subcontext", src).Directory("subcontext")
env, err := c.Container().Build(sub).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, env, "FOO=bar\n")
})
t.Run("subdirectory with custom Dockerfile location", func(t *testing.T) {
src := contextDir.
WithNewFile("subdir/Dockerfile.whee",
`FROM golang:1.18.2-alpine
WORKDIR /src
COPY main.go .
RUN go mod init hello
RUN go build -o /usr/bin/goenv main.go
ENV FOO=bar
CMD goenv
`)
sub := c.Directory().WithDirectory("subcontext", src).Directory("subcontext")
env, err := c.Container().Build(sub, dagger.ContainerBuildOpts{
Dockerfile: "subdir/Dockerfile.whee",
}).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, env, "FOO=bar\n")
})
t.Run("with build args", func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | src := contextDir.
WithNewFile("Dockerfile",
`FROM golang:1.18.2-alpine
ARG FOOARG=bar
WORKDIR /src
COPY main.go .
RUN go mod init hello
RUN go build -o /usr/bin/goenv main.go
ENV FOO=$FOOARG
CMD goenv
`)
env, err := c.Container().Build(src).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, env, "FOO=bar\n")
env, err = c.Container().Build(src, dagger.ContainerBuildOpts{BuildArgs: []dagger.BuildArg{{Name: "FOOARG", Value: "barbar"}}}).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, env, "FOO=barbar\n")
})
t.Run("with target", func(t *testing.T) {
src := contextDir.
WithNewFile("Dockerfile",
`FROM golang:1.18.2-alpine AS base
CMD echo "base"
FROM base AS stage1
CMD echo "stage1"
FROM base AS stage2
CMD echo "stage2"
`)
output, err := c.Container().Build(src).Stdout(ctx)
require.NoError(t, err) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | require.Contains(t, output, "stage2\n")
output, err = c.Container().Build(src, dagger.ContainerBuildOpts{Target: "stage1"}).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, output, "stage1\n")
require.NotContains(t, output, "stage2\n")
})
t.Run("with build secrets", func(t *testing.T) {
sec := c.SetSecret("my-secret", "barbar")
require.NoError(t, err)
src := contextDir.
WithNewFile("Dockerfile",
`FROM golang:1.18.2-alpine
WORKDIR /src
RUN --mount=type=secret,id=my-secret test "$(cat /run/secrets/my-secret)" = "barbar"
RUN --mount=type=secret,id=my-secret cp /run/secrets/my-secret /secret
CMD cat /secret
`)
stdout, err := c.Container().Build(src, dagger.ContainerBuildOpts{
Secrets: []*dagger.Secret{sec},
}).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, stdout, "***")
})
t.Run("just build, don't execute", func(t *testing.T) {
src := contextDir.
WithNewFile("Dockerfile", "FROM alpine:3.16.2\nCMD false")
_, err = c.Container().Build(src).Sync(ctx)
require.NoError(t, err)
_, err = c.Container().Build(src).WithExec(nil).Sync(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | require.NotEmpty(t, err)
})
t.Run("just build, short-circuit", func(t *testing.T) {
src := contextDir.
WithNewFile("Dockerfile", "FROM alpine:3.16.2\nRUN false")
_, err = c.Container().Build(src).Sync(ctx)
require.NotEmpty(t, err)
})
}
func TestContainerWithRootFS(t *testing.T) {
t.Parallel()
ctx := context.Background()
c, err := dagger.Connect(ctx)
require.NoError(t, err)
defer c.Close()
alpine316 := c.Container().From("alpine:3.16.2")
alpine316ReleaseStr, err := alpine316.File("/etc/alpine-release").Contents(ctx)
require.NoError(t, err)
alpine316ReleaseStr = strings.TrimSpace(alpine316ReleaseStr)
dir := alpine316.Rootfs()
exitCode, err := c.Container().WithEnvVariable("ALPINE_RELEASE", alpine316ReleaseStr).WithRootfs(dir).WithExec([]string{
"/bin/sh",
"-c",
"test -f /etc/alpine-release && test \"$(head -n 1 /etc/alpine-release)\" = \"$ALPINE_RELEASE\"",
}).ExitCode(ctx)
require.NoError(t, err)
require.Equal(t, exitCode, 0)
alpine315 := c.Container().From("alpine:3.15.6")
varVal := "testing123"
alpine315WithVar := alpine315.WithEnvVariable("DAGGER_TEST", varVal) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | varValResp, err := alpine315WithVar.EnvVariable(ctx, "DAGGER_TEST")
require.NoError(t, err)
require.Equal(t, varVal, varValResp)
alpine315ReplacedFS := alpine315WithVar.WithRootfs(dir)
varValResp, err = alpine315ReplacedFS.EnvVariable(ctx, "DAGGER_TEST")
require.NoError(t, err)
require.Equal(t, varVal, varValResp)
releaseStr, err := alpine315ReplacedFS.File("/etc/alpine-release").Contents(ctx)
require.NoError(t, err)
require.Equal(t, "3.16.2\n", releaseStr)
}
var helloSrc string
func TestContainerWithRootFSSubdir(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
defer c.Close()
hello := c.Directory().WithNewFile("main.go", helloSrc).File("main.go")
ctr := c.Container().
From("golang:1.20.0-alpine").
WithMountedFile("/src/main.go", hello).
WithEnvVariable("CGO_ENABLED", "0").
WithExec([]string{"go", "build", "-o", "/out/hello", "/src/main.go"})
out, err := c.Container().
WithRootfs(ctr.Directory("/out")).
WithExec([]string{"/hello"}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "Hello, world!\n", out)
}
func TestContainerExecSync(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | t.Parallel()
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withExec(args: ["false"]) {
sync
}
}
}
}`, nil, nil)
require.Contains(t, err.Error(), `process "false" did not complete successfully`)
}
func TestContainerExecExitCode(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
From struct {
WithExec struct {
ExitCode *int
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withExec(args: ["true"]) {
exitCode
}
}
}
}`, &res, nil) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | require.NoError(t, err)
require.NotNil(t, res.Container.From.WithExec.ExitCode)
require.Equal(t, 0, *res.Container.From.WithExec.ExitCode)
/*
It's not currently possible to get a nonzero exit code back because
Buildkit raises an error.
We could perhaps have the shim mask the exit status and always exit 0, but
we would have to be careful not to let that happen in a big chained LLB
since it would prevent short-circuiting.
We could only do it when the user requests the exitCode, but then we would
actually need to run the command _again_ since we'd need some way to tell
the shim what to do.
Hmm...
err = testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withExec(args: ["false"]) {
exitCode
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithExec.ExitCode, 1)
*/
}
func TestContainerExecStdoutStderr(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
From struct {
WithExec struct {
Stdout string
Stderr string
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withExec(args: ["sh", "-c", "echo hello; echo goodbye >/dev/stderr"]) {
stdout
stderr
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithExec.Stdout, "hello\n")
require.Equal(t, res.Container.From.WithExec.Stderr, "goodbye\n")
}
func TestContainerExecStdin(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
From struct {
WithExec struct {
Stdout string
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withExec(args: ["cat"], stdin: "hello") {
stdout
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithExec.Stdout, "hello")
}
func TestContainerExecRedirectStdoutStderr(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
From struct {
WithExec struct {
Out, Err struct {
Contents string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withExec(
args: ["sh", "-c", "echo hello; echo goodbye >/dev/stderr"],
redirectStdout: "out",
redirectStderr: "err"
) {
out: file(path: "out") {
contents
}
err: file(path: "err") {
contents
}
}
}
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | }`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithExec.Out.Contents, "hello\n")
require.Equal(t, res.Container.From.WithExec.Err.Contents, "goodbye\n")
c, ctx := connect(t)
defer c.Close()
execWithMount := c.Container().From("alpine:3.16.2").
WithMountedDirectory("/mnt", c.Directory()).
WithExec([]string{"sh", "-c", "echo hello; echo goodbye >/dev/stderr"}, dagger.ContainerWithExecOpts{
RedirectStdout: "/mnt/out",
RedirectStderr: "/mnt/err",
})
stdout, err := execWithMount.File("/mnt/out").Contents(ctx)
require.NoError(t, err)
require.Equal(t, "hello\n", stdout)
stderr, err := execWithMount.File("/mnt/err").Contents(ctx)
require.NoError(t, err)
require.Equal(t, "goodbye\n", stderr)
_, err = execWithMount.Stdout(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), "stdout: no such file or directory")
_, err = execWithMount.Stderr(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), "stderr: no such file or directory")
}
func TestContainerExecWithWorkdir(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | WithWorkdir struct {
WithExec struct {
Stdout string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withWorkdir(path: "/usr") {
withExec(args: ["pwd"]) {
stdout
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithWorkdir.WithExec.Stdout, "/usr\n")
}
func TestContainerExecWithUser(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct {
User string
WithUser struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | User string
WithExec struct {
Stdout string
}
}
}
}
}{}
t.Run("user name", func(t *testing.T) {
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
user
withUser(name: "daemon") {
user
withExec(args: ["whoami"]) {
stdout
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, "", res.Container.From.User)
require.Equal(t, "daemon", res.Container.From.WithUser.User)
require.Equal(t, "daemon\n", res.Container.From.WithUser.WithExec.Stdout)
})
t.Run("user and group name", func(t *testing.T) {
err := testutil.Query( |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | `{
container {
from(address: "alpine:3.16.2") {
user
withUser(name: "daemon:floppy") {
user
withExec(args: ["sh", "-c", "whoami; groups"]) {
stdout
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, "", res.Container.From.User)
require.Equal(t, "daemon:floppy", res.Container.From.WithUser.User)
require.Equal(t, "daemon\nfloppy\n", res.Container.From.WithUser.WithExec.Stdout)
})
t.Run("user ID", func(t *testing.T) {
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
user
withUser(name: "2") {
user
withExec(args: ["whoami"]) {
stdout
}
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | }
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, "", res.Container.From.User)
require.Equal(t, "2", res.Container.From.WithUser.User)
require.Equal(t, "daemon\n", res.Container.From.WithUser.WithExec.Stdout)
})
t.Run("user and group ID", func(t *testing.T) {
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
user
withUser(name: "2:11") {
user
withExec(args: ["sh", "-c", "whoami; groups"]) {
stdout
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, "", res.Container.From.User)
require.Equal(t, "2:11", res.Container.From.WithUser.User)
require.Equal(t, "daemon\nfloppy\n", res.Container.From.WithUser.WithExec.Stdout)
})
}
func TestContainerExecWithEntrypoint(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | t.Parallel()
c, ctx := connect(t)
defer c.Close()
base := c.Container().From("alpine:3.16.2")
before, err := base.Entrypoint(ctx)
require.NoError(t, err)
require.Empty(t, before)
withEntry := base.WithEntrypoint([]string{"sh"})
after, err := withEntry.Entrypoint(ctx)
require.NoError(t, err)
require.Equal(t, []string{"sh"}, after)
used, err := withEntry.WithExec([]string{"-c", "echo $HOME"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "/root\n", used)
_, err = withEntry.WithExec([]string{"sh", "-c", "echo $HOME"}).Sync(ctx)
require.Error(t, err)
skipped, err := withEntry.WithExec([]string{"sh", "-c", "echo $HOME"}, dagger.ContainerWithExecOpts{
SkipEntrypoint: true,
}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "/root\n", skipped)
withoutEntry := withEntry.WithEntrypoint(nil)
removed, err := withoutEntry.Entrypoint(ctx)
require.NoError(t, err)
require.Empty(t, removed)
}
func TestContainerWithDefaultArgs(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
From struct {
Entrypoint []string
DefaultArgs []string
WithExec struct {
Stdout string
}
WithDefaultArgs struct {
Entrypoint []string
DefaultArgs []string
}
WithEntrypoint struct {
Entrypoint []string
DefaultArgs []string
WithExec struct {
Stdout string
}
WithDefaultArgs struct {
Entrypoint []string
DefaultArgs []string
WithExec struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Stdout string
}
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
entrypoint
defaultArgs
withDefaultArgs {
entrypoint
defaultArgs
}
withEntrypoint(args: ["sh", "-c"]) {
entrypoint
defaultArgs
withExec(args: ["echo $HOME"]) {
stdout
}
withDefaultArgs(args: ["id"]) {
entrypoint
defaultArgs
withExec(args: []) {
stdout
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | }
}
}
}
}`, &res, nil)
t.Run("default alpine (no entrypoint)", func(t *testing.T) {
require.NoError(t, err)
require.Empty(t, res.Container.From.Entrypoint)
require.Equal(t, []string{"/bin/sh"}, res.Container.From.DefaultArgs)
})
t.Run("with nil default args", func(t *testing.T) {
require.Empty(t, res.Container.From.WithDefaultArgs.Entrypoint)
require.Empty(t, res.Container.From.WithDefaultArgs.DefaultArgs)
})
t.Run("with entrypoint set", func(t *testing.T) {
require.Equal(t, []string{"sh", "-c"}, res.Container.From.WithEntrypoint.Entrypoint)
require.Equal(t, []string{"/bin/sh"}, res.Container.From.WithEntrypoint.DefaultArgs)
})
t.Run("with exec args", func(t *testing.T) {
require.Equal(t, "/root\n", res.Container.From.WithEntrypoint.WithExec.Stdout)
})
t.Run("with default args set", func(t *testing.T) {
require.Equal(t, []string{"sh", "-c"}, res.Container.From.WithEntrypoint.WithDefaultArgs.Entrypoint)
require.Equal(t, []string{"id"}, res.Container.From.WithEntrypoint.WithDefaultArgs.DefaultArgs)
require.Equal(t, "uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel),11(floppy),20(dialout),26(tape),27(video)\n", res.Container.From.WithEntrypoint.WithDefaultArgs.WithExec.Stdout)
})
}
func TestContainerExecWithEnvVariable(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
From struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | WithEnvVariable struct {
WithExec struct {
Stdout string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withEnvVariable(name: "FOO", value: "bar") {
withExec(args: ["env"]) {
stdout
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Contains(t, res.Container.From.WithEnvVariable.WithExec.Stdout, "FOO=bar\n")
}
func TestContainerVariables(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct {
EnvVariables []schema.EnvVariable
WithExec struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Stdout string
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
envVariables {
name
value
}
withExec(args: ["env"]) {
stdout
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, []schema.EnvVariable{
{Name: "PATH", Value: "/go/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
{Name: "GOLANG_VERSION", Value: "1.18.2"},
{Name: "GOPATH", Value: "/go"},
}, res.Container.From.EnvVariables)
require.Contains(t, res.Container.From.WithExec.Stdout, "GOPATH=/go\n")
}
func TestContainerVariable(t *testing.T) {
t.Parallel()
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
From struct {
EnvVariable *string
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
envVariable(name: "GOLANG_VERSION")
}
}
}`, &res, nil)
require.NoError(t, err)
require.NotNil(t, res.Container.From.EnvVariable)
require.Equal(t, "1.18.2", *res.Container.From.EnvVariable)
err = testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
envVariable(name: "UNKNOWN")
}
}
}`, &res, nil)
require.NoError(t, err)
require.Nil(t, res.Container.From.EnvVariable)
}
func TestContainerWithoutVariable(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | t.Parallel()
res := struct {
Container struct {
From struct {
WithoutEnvVariable struct {
EnvVariables []schema.EnvVariable
WithExec struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Stdout string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
withoutEnvVariable(name: "GOLANG_VERSION") {
envVariables {
name
value
}
withExec(args: ["env"]) {
stdout
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithoutEnvVariable.EnvVariables, []schema.EnvVariable{
{Name: "PATH", Value: "/go/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
{Name: "GOPATH", Value: "/go"},
})
require.NotContains(t, res.Container.From.WithoutEnvVariable.WithExec.Stdout, "GOLANG_VERSION")
}
func TestContainerEnvVariablesReplace(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | t.Parallel()
res := struct {
Container struct {
From struct {
WithEnvVariable struct {
EnvVariables []schema.EnvVariable
WithExec struct {
Stdout string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
withEnvVariable(name: "GOPATH", value: "/gone") {
envVariables {
name
value |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | }
withExec(args: ["env"]) {
stdout
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithEnvVariable.EnvVariables, []schema.EnvVariable{
{Name: "PATH", Value: "/go/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
{Name: "GOLANG_VERSION", Value: "1.18.2"},
{Name: "GOPATH", Value: "/gone"},
})
require.Contains(t, res.Container.From.WithEnvVariable.WithExec.Stdout, "GOPATH=/gone\n")
}
func TestContainerLabel(t *testing.T) {
ctx := context.Background()
c, err := dagger.Connect(ctx)
require.NoError(t, err)
defer c.Close()
t.Run("container with new label", func(t *testing.T) {
label, err := c.Container().From("alpine:3.16.2").WithLabel("FOO", "BAR").Label(ctx, "FOO")
require.NoError(t, err)
require.Contains(t, label, "BAR")
})
t.Run("container labels", func(t *testing.T) {
res := struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | Container struct {
From struct {
Labels []schema.Label
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "nginx") {
labels {
name
value
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, []schema.Label{
{Name: "maintainer", Value: "NGINX Docker Maintainers <docker-maint@nginx.com>"},
}, res.Container.From.Labels) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,140 | Expand environment variables in `withEnvVariable` values | ### Discussed in https://github.com/dagger/dagger/discussions/5001
<div type='discussions-op-text'>
<sup>Originally posted by **wingyplus** April 21, 2023</sup>
I want to install something and append it to `PATH` to make it accessible. So how to prepend the new directory into the env variable as we do with `PATH`?</div>
Solution proposed by @vito :
> I agree; extending $PATH seems like a common use case. it would be nice to have parity with Dockerfile ENV which supports interpolation.
>
> It might be a surprising default, since who knows what values people might try to set in env vars. An expand: true param would be simple enough to implement by using [os.Expand](https://pkg.go.dev/os#Expand) and fetching values from the current image config.
>
> ```
> container {
> withEnvVariable(name: "PATH", value: "/opt/venv/bin:${PATH}", expand: true) {
> withExec(args: []string{"sh", "-c", "echo $PATH"}) {
> stdout
> }
> }
> }
> ```
> (Interpolate might be a more obvious name.) | https://github.com/dagger/dagger/issues/5140 | https://github.com/dagger/dagger/pull/5160 | c2fcf8390801585188042d12ee8190b436cc9c2f | e171dc4252e464031737b51fee4c54531b4b537d | 2023-05-16T15:18:49Z | go | 2023-05-25T09:29:47Z | core/integration/container_test.go | })
t.Run("container without label", func(t *testing.T) {
label, err := c.Container().From("nginx").WithoutLabel("maintainer").Label(ctx, "maintainer")
require.NoError(t, err)
require.Empty(t, label)
})
t.Run("container replace label", func(t *testing.T) {
label, err := c.Container().From("nginx").WithLabel("maintainer", "bar").Label(ctx, "maintainer")
require.NoError(t, err)
require.Contains(t, label, "bar")
})
t.Run("container with new label - nil panics", func(t *testing.T) {
label, err := c.Container().WithLabel("FOO", "BAR").Label(ctx, "FOO")
require.NoError(t, err)
require.Contains(t, label, "BAR")
})
t.Run("container label - nil panics", func(t *testing.T) {
label, err := c.Container().Label(ctx, "FOO")
require.NoError(t, err)
require.Empty(t, label)
})
t.Run("container without label - nil panics", func(t *testing.T) {
label, err := c.Container().WithoutLabel("maintainer").Label(ctx, "maintainer")
require.NoError(t, err)
require.Empty(t, label)
})
t.Run("container labels - nil panics", func(t *testing.T) {
res := struct { |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.