kjuulh/dagger
Archived
1
0
Fork 0
Code Issues 1 Pull Requests 1 Projects Releases Wiki Activity

Merge pull request #326 from dagger/bats-ops

Browse Source 
tests: migrate ops test to bats
This commit is contained in:
Andrea Luzzardi 2021-04-14 17:04:34 -07:00 committed by GitHub
commit 876ff7d4d6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
74 changed files with 685 additions and 687 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
tests/helpers.bash
View File

@ -10,3 +10,8 @@ common_setup() {
DAGGER_STORE="$(mktemp -d -t dagger-store-XXXXXX)" DAGGER_STORE="$(mktemp -d -t dagger-store-XXXXXX)"
export DAGGER_STORE export DAGGER_STORE
} }
skip_unless_secrets_available() {
local inputFile="$1"
sops exec-file "$inputFile" echo > /dev/null 2>&1 || skip "$inputFile cannot be decrypted"
}

65
tests/llb/copy/valid/component/main.cue
View File

@ -1,65 +0,0 @@
package testing
component: #up: [{
do: "fetch-container"
ref: "alpine"
}, {
do: "exec"
args: ["sh", "-c", """
printf lol > /id
"""]
dir: "/"
}]
test1: {
string
#up: [
{
do: "fetch-container"
ref: "busybox"
},
{
do: "copy"
from: component
src: "/id"
dest: "/"
},
{
do: "export"
source: "/id"
format: "string"
},
]
}
test2: {
string
#up: [
{
do: "fetch-container"
ref: "busybox"
},
{
do: "copy"
from: #up: [{
do: "fetch-container"
ref: "alpine"
}, {
do: "exec"
args: ["sh", "-c", """
printf lol > /id
"""]
dir: "/"
}]
src: "/id"
dest: "/"
},
{
do: "export"
source: "/id"
format: "string"
},
]
}

23
tests/llb/copy/valid/script/main.cue
View File

@ -1,23 +0,0 @@
package testing
test: {
string
#up: [
{
do: "fetch-container"
ref: "busybox"
},
{
do: "copy"
from: [{do: "fetch-container", ref: "alpine"}]
src: "/etc/issue"
dest: "/"
},
{
do: "export"
source: "/issue"
format: "string"
},
]
}

14
tests/llb/exec/exit_code/main.cue
View File

@ -1,14 +0,0 @@
package testing
#up: [
{
do: "fetch-container"
ref: "alpine"
},
{
do: "exec"
args: ["sh", "-c", "exit 123"]
// XXX Blocked by https://github.com/blocklayerhq/dagger/issues/19
dir: "/"
},
]

11
tests/llb/exec/invalid/main.cue
View File

@ -1,11 +0,0 @@
package testing
#up: [
{
do: "fetch-container"
ref: "alpine"
},
{
do: "exec"
},
]

7
tests/llb/fetch-container/invalid/main.cue
View File

@ -1,7 +0,0 @@
package testing
#up: [
{
do: "fetch-container"
},
]

8
tests/llb/fetch-container/nonexistent/image/main.cue
View File

@ -1,8 +0,0 @@
package testing
#up: [
{
do: "fetch-container"
ref: "doesnotexist"
},
]

7
tests/llb/fetch-git/invalid/main.cue
View File

@ -1,7 +0,0 @@
package testing
#up: [
{
do: "fetch-git"
},
]

33
tests/llb/load/invalid/cache/main.cue vendored
View File

@ -1,33 +0,0 @@
package testing
test1: {
string
#up: [
{
do: "load"
from: [{do: "fetch-container", ref: "alpine"}]
},
{
do: "export"
source: "/etc/issue"
format: "string"
},
]
}
test2: {
string
#up: [
{
do: "load"
from: [{do: "fetch-container", ref: "busybox"}]
},
{
do: "export"
source: "/etc/issue"
format: "string"
},
]
}

53
tests/llb/load/valid/component/main.cue
View File

@ -1,53 +0,0 @@
package testing
component: #up: [{
do: "fetch-container"
ref: "alpine"
}, {
do: "exec"
args: ["sh", "-c", """
printf lol > /id
"""]
dir: "/"
}]
test1: {
string
#up: [
{
do: "load"
from: component
},
{
do: "export"
source: "/id"
format: "string"
},
]
}
test2: {
string
#up: [
{
do: "load"
from: #up: [{
do: "fetch-container"
ref: "alpine"
}, {
do: "exec"
args: ["sh", "-c", """
printf lol > /id
"""]
dir: "/"
}]
},
{
do: "export"
source: "/id"
format: "string"
},
]
}

17
tests/llb/load/valid/script/main.cue
View File

@ -1,17 +0,0 @@
package testing
test: {
string
#up: [
{
do: "load"
from: [{do: "fetch-container", ref: "alpine"}]
},
{
do: "export"
source: "/etc/issue"
format: "string"
},
]
}

215
tests/ops.bats Normal file
View File

@ -0,0 +1,215 @@
setup() {
load 'helpers'
common_setup
}
@test "op.#Load" {
run "$DAGGER" compute "$TESTDIR"/ops/load/valid/component
assert_success
assert_line '{"component":{},"test1":"lol","test2":"lol"}'
"$DAGGER" compute "$TESTDIR"/ops/load/valid/script
run "$DAGGER" compute "$TESTDIR"/ops/load/invalid/cache
assert_failure
}
@test "op.#Mount" {
# tmpfs
"$DAGGER" compute "$TESTDIR"/ops/mounts/valid/tmpfs
# cache
"$DAGGER" compute "$TESTDIR"/ops/mounts/valid/cache
# component
run "$DAGGER" compute "$TESTDIR"/ops/mounts/valid/component
assert_success
assert_line '{"test":"hello world"}'
# FIXME https://github.com/blocklayerhq/dagger/issues/46
# "$DAGGER" compute "$TESTDIR"/ops/mounts/valid/script
}
@test "op.#Copy" {
run "$DAGGER" compute "$TESTDIR"/ops/copy/valid/component
assert_success
assert_line '{"component":{},"test1":"lol","test2":"lol"}'
"$DAGGER" compute "$TESTDIR"/ops/copy/valid/script
# FIXME https://github.com/blocklayerhq/dagger/issues/44
# run "$DAGGER" compute "$TESTDIR"/ops/copy/invalid/cache
# assert_failure
}
@test "op.#Local" {
skip "There are no local tests right now (the feature is possibly not functioning at all: see https://github.com/blocklayerhq/dagger/issues/41)"
}
@test "op.#FetchContainer" {
# non existent container image"
run "$DAGGER" compute "$TESTDIR"/ops/fetch-container/nonexistent/image
assert_failure
# non existent container tag
run "$DAGGER" compute "$TESTDIR"/ops/fetch-container/nonexistent/tag
assert_failure
# non existent container digest
run "$DAGGER" compute "$TESTDIR"/ops/fetch-container/nonexistent/digest
assert_failure
# valid containers
run "$DAGGER" compute "$TESTDIR"/ops/fetch-container/exist
assert_success
# missing ref
# FIXME: distinguish missing inputs from incorrect config
# run "$DAGGER" compute "$TESTDIR"/ops/fetch-container/invalid
# assert_failure
# non existent container image with valid digest
# FIXME https://github.com/blocklayerhq/dagger/issues/32
# run "$DAGGER" compute "$TESTDIR"/ops/fetch-container/nonexistent/image-with-valid-digest
# assert_failure
}
@test "op.#PushContainer" {
skip_unless_secrets_available "$TESTDIR"/ops/push-container/inputs.yaml
"$DAGGER" compute --input-yaml "$TESTDIR"/ops/push-container/inputs.yaml "$TESTDIR"/ops/push-container
}
@test "op.#FetchGit" {
run "$DAGGER" compute "$TESTDIR"/ops/fetch-git/exist
assert_success
run "$DAGGER" compute "$TESTDIR"/ops/fetch-git/nonexistent/remote
assert_failure
run "$DAGGER" compute "$TESTDIR"/ops/fetch-git/nonexistent/ref
assert_failure
run "$DAGGER" compute "$TESTDIR"/ops/fetch-git/nonexistent/bork
assert_failure
# FIXME: distinguish missing inputs from incorrect config
# run "$DAGGER" compute "$TESTDIR"/ops/fetch-git/invalid
# assert_failure
}
@test "op.#Exec" {
run "$DAGGER" compute "$TESTDIR"/ops/exec/invalid
assert_failure
run "$DAGGER" compute "$TESTDIR"/ops/exec/error
assert_failure
run "$DAGGER" compute "$TESTDIR"/ops/exec/simple
assert_success
# XXX should run twice and test that the string "always output" is visible with DOCKER_OUTPUT=1
# Alternatively, use export, but this would test multiple things then...
run "$DAGGER" compute "$TESTDIR"/ops/exec/always
assert_success
run "$DAGGER" compute "$TESTDIR"/ops/exec/env/invalid
assert_failure
run "$DAGGER" compute "$TESTDIR"/ops/exec/env/valid
assert_success
run "$DAGGER" compute --input-string 'bar=overlay environment' "$TESTDIR"/ops/exec/env/overlay
assert_success
run "$DAGGER" compute "$TESTDIR"/ops/exec/dir/doesnotexist
assert_success
run "$DAGGER" compute "$TESTDIR"/ops/exec/dir/exist
assert_success
run "$DAGGER" compute "$TESTDIR"/ops/exec/undefined/non_concrete_referenced
assert_success
assert_line '{"hello":"world"}'
# NOTE: the exec is meant to fail - and we test that as a way to confirm it has been executed
run "$DAGGER" compute "$TESTDIR"/ops/exec/undefined/non_concrete_not_referenced
assert_failure
# package with optional def, not referenced, should be executed
run "$DAGGER" compute "$TESTDIR"/ops/exec/undefined/with_pkg_def
assert_success
# script with optional prop, not referenced, should be executed
run "$DAGGER" compute "$TESTDIR"/ops/exec/undefined/with_pkg_optional
assert_success
# FIXME https://github.com/blocklayerhq/dagger/issues/74
# run "$DAGGER" compute "$TESTDIR"/ops/exec/exit_code
# assert_failure # --exit=123
# script with non-optional prop, not referenced, should be executed
# FIXME https://github.com/blocklayerhq/dagger/issues/70
# run "$DAGGER" compute "$TESTDIR"/ops/exec/undefined/with_pkg_mandatory
# assert_failure
}
@test "op.#Export" {
run "$DAGGER" compute "$TESTDIR"/ops/export/json
assert_success
assert_line '{"testMap":{"something":"something"},"testScalar":true}'
run "$DAGGER" compute "$TESTDIR"/ops/export/string
assert_success
assert_line '{"test":"something"}'
run "$DAGGER" compute "$TESTDIR"/ops/export/withvalidation
assert_success
assert_line '{"test":"something"}'
run "$DAGGER" compute "$TESTDIR"/ops/export/concurrency
assert_success
# does not pass additional validation
run "$DAGGER" compute "$TESTDIR"/ops/export/invalid/validation
assert_failure
# invalid format
run "$DAGGER" compute "$TESTDIR"/ops/export/invalid/format
assert_failure
# invalid path
run "$DAGGER" compute "$TESTDIR"/ops/export/invalid/path
assert_failure
run "$DAGGER" compute "$TESTDIR"/ops/export/float
assert_success
assert_line '{"test":-123.5}'
run "$DAGGER" compute "$TESTDIR"/ops/export/yaml
assert_success
assert_line '{"testMap":{"something":"something"},"testScalar":true}'
run "$DAGGER" compute "$TESTDIR"/ops/export/bool
assert_success
assert_line '{"test":true}'
# FIXME: https://github.com/blocklayerhq/dagger/issues/96
# run "$DAGGER" compute "$TESTDIR"/ops/export/number
# assert_success
# assert_line '{"test":-123.5}'
}
@test "op.#Subdir" {
run "$DAGGER" compute "$TESTDIR"/ops/subdir/simple
assert_success
assert_line '{"hello":"world"}'
}
@test "op.#DockerBuild" {
run "$DAGGER" compute --input-dir TestData="$TESTDIR"/ops/dockerbuild/testdata "$TESTDIR"/ops/dockerbuild
assert_success
}

32
tests/llb/copy/invalid/cache/main.cue → tests/ops/copy/invalid/cache/main.cue vendored
View File

@ -1,21 +1,24 @@
package testing package testing
import "dagger.io/dagger/op"
test1: { test1: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "busybox" ref: "busybox"
}, },
{ op.#Copy & {
do: "copy" from: [
from: [{do: "fetch-container", ref: "alpine"}] op.#FetchContainer & {
ref: "alpine"
},
]
src: "/etc/issue" src: "/etc/issue"
dest: "/" dest: "/"
}, },
{ op.#Export & {
do: "export"
source: "/issue" source: "/issue"
format: "string" format: "string"
}, },
@ -26,18 +29,19 @@ test2: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "busybox" ref: "busybox"
}, },
{ op.#Copy & {
do: "copy" from: [
from: [{do: "fetch-container", ref: "busybox"}] op.#FetchContainer & {
ref: "busybox"
},
]
src: "/etc/issue" src: "/etc/issue"
dest: "/" dest: "/"
}, },
{ op.#Export & {
do: "export"
source: "/issue" source: "/issue"
format: "string" format: "string"
}, },

61
tests/ops/copy/valid/component/main.cue Normal file
View File

@ -0,0 +1,61 @@
package testing
import "dagger.io/dagger/op"
component: #up: [
op.#FetchContainer & {
ref: "alpine"
},
op.#Exec & {
args: ["sh", "-c", """
printf lol > /id
"""]
},
]
test1: {
string
#up: [
op.#FetchContainer & {
ref: "busybox"
},
op.#Copy & {
from: component
src: "/id"
dest: "/"
},
op.#Export & {
source: "/id"
format: "string"
},
]
}
test2: {
string
#up: [
op.#FetchContainer & {
ref: "busybox"
},
op.#Copy & {
from: #up: [
op.#FetchContainer & {
ref: "alpine"
},
op.#Exec & {
args: ["sh", "-c", """
printf lol > /id
"""]
},
]
src: "/id"
dest: "/"
},
op.#Export & {
source: "/id"
format: "string"
},
]
}

26
tests/ops/copy/valid/script/main.cue Normal file
View File

@ -0,0 +1,26 @@
package testing
import "dagger.io/dagger/op"
test: {
string
#up: [
op.#FetchContainer & {
ref: "busybox"
},
op.#Copy & {
from: [
op.#FetchContainer & {
ref: "alpine"
},
]
src: "/etc/issue"
dest: "/"
},
op.#Export & {
source: "/issue"
format: "string"
},
]
}

0
tests/llb/dockerbuild/main.cue → tests/ops/dockerbuild/main.cue
View File

0
tests/llb/dockerbuild/testdata/Dockerfile → tests/ops/dockerbuild/testdata/Dockerfile vendored
View File

0
tests/llb/dockerbuild/testdata/dockerfilepath/Dockerfile.custom → tests/ops/dockerbuild/testdata/dockerfilepath/Dockerfile.custom vendored
View File

0
tests/llb/dockerbuild/testdata/foo → tests/ops/dockerbuild/testdata/foo vendored
View File

8
tests/llb/exec/always/main.cue → tests/ops/exec/always/main.cue
View File

@ -1,12 +1,12 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["echo", "always output"] args: ["echo", "always output"]
always: true always: true
}, },

8
tests/llb/exec/dir/doesnotexist/main.cue → tests/ops/exec/dir/doesnotexist/main.cue
View File

@ -1,12 +1,12 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo "pwd is: $(pwd)" echo "pwd is: $(pwd)"
[ "$(pwd)" == "/thisisnonexistent" ] || exit 1 [ "$(pwd)" == "/thisisnonexistent" ] || exit 1

8
tests/llb/exec/dir/exist/main.cue → tests/ops/exec/dir/exist/main.cue
View File

@ -1,12 +1,12 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo "pwd is: $(pwd)" echo "pwd is: $(pwd)"
[ "$(pwd)" == "/etc" ] || exit 1 [ "$(pwd)" == "/etc" ] || exit 1

8
tests/llb/exec/env/invalid/main.cue → tests/ops/exec/env/invalid/main.cue vendored
View File

@ -1,12 +1,12 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", #""" args: ["sh", "-c", #"""
echo "$foo" echo "$foo"
"""#] """#]

8
tests/llb/exec/env/overlay/main.cue → tests/ops/exec/env/overlay/main.cue vendored
View File

@ -1,14 +1,14 @@
package testing package testing
import "dagger.io/dagger/op"
bar: string bar: string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo "foo: $foo" echo "foo: $foo"
[ "$foo" == "overlay environment" ] || exit 1 [ "$foo" == "overlay environment" ] || exit 1

7
tests/llb/exec/env/valid/main.cue → tests/ops/exec/env/valid/main.cue vendored
View File

@ -1,12 +1,13 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container" do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
[ "$foo" == "output environment" ] || exit 1 [ "$foo" == "output environment" ] || exit 1
"""] """]

8
tests/llb/exec/error/main.cue → tests/ops/exec/error/main.cue
View File

@ -1,12 +1,12 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["erroringout"] args: ["erroringout"]
}, },
] ]

12
tests/ops/exec/exit_code/main.cue Normal file
View File

@ -0,0 +1,12 @@
package testing
import "dagger.io/dagger/op"
#up: [
op.#FetchContainer & {
ref: "alpine"
},
op.#Exec & {
args: ["sh", "-c", "exit 123"]
},
]

11
tests/ops/exec/invalid/main.cue Normal file
View File

@ -0,0 +1,11 @@
package testing
import "dagger.io/dagger/op"
#up: [
op.#FetchContainer & {
ref: "alpine"
},
op.#Exec & {
},
]

8
tests/llb/exec/simple/main.cue → tests/ops/exec/simple/main.cue
View File

@ -1,12 +1,12 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["echo", "simple output"] args: ["echo", "simple output"]
}, },
] ]

8
tests/llb/exec/undefined/non_concrete_not_referenced/main.cue → tests/ops/exec/undefined/non_concrete_not_referenced/main.cue
View File

@ -1,15 +1,15 @@
package testing package testing
import "dagger.io/dagger/op"
hello: "world" hello: "world"
bar: string bar: string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
dir: "/" dir: "/"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo \(hello) echo \(hello)

8
tests/llb/exec/undefined/non_concrete_referenced/main.cue → tests/ops/exec/undefined/non_concrete_referenced/main.cue
View File

@ -1,15 +1,15 @@
package testing package testing
import "dagger.io/dagger/op"
hello: "world" hello: "world"
bar: string bar: string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
dir: "/" dir: "/"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo \(bar) echo \(bar)

0
tests/llb/exec/undefined/with_pkg_def/cue.mod/module.cue → tests/ops/exec/undefined/with_pkg_def/cue.mod/module.cue
View File

0
tests/llb/exec/undefined/with_pkg_def/cue.mod/pkg/dagger.io/def/main.cue → tests/ops/exec/undefined/with_pkg_def/cue.mod/pkg/dagger.io/def/main.cue
View File

4
tests/llb/exec/undefined/with_pkg_def/main.cue → tests/ops/exec/undefined/with_pkg_def/main.cue
View File

@ -1,12 +1,12 @@
package testing package testing
import ( import (
"dagger.io/dagger/op"
"dagger.io/def" "dagger.io/def"
) )
#up: [ #up: [
{ op.#Load & {
do: "load",
from: def from: def
}, },
] ]

0
tests/llb/exec/undefined/with_pkg_mandatory/cue.mod/module.cue → tests/ops/exec/undefined/with_pkg_mandatory/cue.mod/module.cue
View File

0
tests/llb/exec/undefined/with_pkg_mandatory/cue.mod/pkg/dagger.io/nonoptional/main.cue → tests/ops/exec/undefined/with_pkg_mandatory/cue.mod/pkg/dagger.io/nonoptional/main.cue
View File

4
tests/llb/exec/undefined/with_pkg_mandatory/main.cue → tests/ops/exec/undefined/with_pkg_mandatory/main.cue
View File

@ -2,11 +2,11 @@ package testing
import ( import (
"dagger.io/nonoptional" "dagger.io/nonoptional"
"dagger.io/dagger/op"
) )
#up: [ #up: [
{ op.#Load & {
do: "load",
from: nonoptional from: nonoptional
}, },
] ]

0
tests/llb/exec/undefined/with_pkg_optional/cue.mod/module.cue → tests/ops/exec/undefined/with_pkg_optional/cue.mod/module.cue
View File

0
tests/llb/exec/undefined/with_pkg_optional/cue.mod/pkg/dagger.io/optional/main.cue → tests/ops/exec/undefined/with_pkg_optional/cue.mod/pkg/dagger.io/optional/main.cue
View File

4
tests/llb/exec/undefined/with_pkg_optional/main.cue → tests/ops/exec/undefined/with_pkg_optional/main.cue
View File

@ -2,11 +2,11 @@ package testing
import ( import (
"dagger.io/optional" "dagger.io/optional"
"dagger.io/dagger/op"
) )
#up: [ #up: [
{ op.#Load & {
do: "load",
from: optional from: optional
}, },
] ]

11
tests/llb/export/bool/main.cue → tests/ops/export/bool/main.cue
View File

@ -1,23 +1,22 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
bool bool
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
printf "true" > /tmp/out printf "true" > /tmp/out
""", """,
] ]
dir: "/" dir: "/"
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "json" format: "json"

95
tests/llb/export/concurrency/main.cue → tests/ops/export/concurrency/main.cue
View File

@ -1,23 +1,22 @@
package testing package testing
import "dagger.io/dagger/op"
test1: { test1: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol1 > /tmp/out echo lol1 > /tmp/out
"""] """]
dir: "/" dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },
@ -28,20 +27,17 @@ test2: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol2 > /tmp/out echo lol2 > /tmp/out
"""] """]
dir: "/" dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },
@ -52,20 +48,17 @@ test3: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol3 > /tmp/out echo lol3 > /tmp/out
"""] """]
dir: "/" dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },
@ -76,20 +69,17 @@ test4: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol4 > /tmp/out echo lol4 > /tmp/out
"""] """]
dir: "/" dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },
@ -100,20 +90,16 @@ test5: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol5 > /tmp/out echo lol5 > /tmp/out
"""] """]
dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },
@ -124,20 +110,16 @@ test6: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol6 > /tmp/out echo lol6 > /tmp/out
"""] """]
dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },
@ -148,20 +130,16 @@ test7: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol7 > /tmp/out echo lol7 > /tmp/out
"""] """]
dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },
@ -172,20 +150,17 @@ test8: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol8 > /tmp/out echo lol8 > /tmp/out
"""] """]
dir: "/" dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },
@ -196,20 +171,17 @@ test9: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol9 > /tmp/out echo lol9 > /tmp/out
"""] """]
dir: "/" dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },
@ -220,20 +192,17 @@ test10: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo lol10 > /tmp/out echo lol10 > /tmp/out
"""] """]
dir: "/" dir: "/"
always: true always: true
}, },
{ op.#Export & {
do: "export"
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"
}, },

11
tests/llb/export/float/main.cue → tests/ops/export/float/main.cue
View File

@ -1,22 +1,21 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
float float
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo -123.5 > /tmp/out echo -123.5 > /tmp/out
""", """,
] ]
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "json" format: "json"

11
tests/llb/export/invalid/format/main.cue → tests/ops/export/invalid/format/main.cue
View File

@ -1,22 +1,21 @@
package testing package testing
import "dagger.io/dagger/op"
teststring: { teststring: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo something > /tmp/out echo something > /tmp/out
""", """,
] ]
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "lalalalal" format: "lalalalal"

6
tests/llb/export/invalid/path/main.cue → tests/ops/export/invalid/path/main.cue
View File

@ -4,12 +4,10 @@ teststring: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/lalala" source: "/tmp/lalala"
format: "string" format: "string"

11
tests/llb/export/invalid/validation/main.cue → tests/ops/export/invalid/validation/main.cue
View File

@ -1,23 +1,22 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
string string
=~"^NAAAA.+" =~"^NAAAA.+"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
printf something > /tmp/out printf something > /tmp/out
""", """,
] ]
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"

22
tests/llb/export/json/main.cue → tests/ops/export/json/main.cue
View File

@ -1,23 +1,21 @@
package testing package testing
import "dagger.io/dagger/op"
testScalar: { testScalar: {
bool bool
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo true > /tmp/out echo true > /tmp/out
""", """,
] ]
dir: "/"
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "json" format: "json"
@ -26,20 +24,16 @@ testScalar: {
} }
testMap: #up: [ testMap: #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo '{"something": "something"}' > /tmp/out echo '{"something": "something"}' > /tmp/out
""", """,
] ]
dir: "/"
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "json" format: "json"

11
tests/llb/export/number/main.cue → tests/ops/export/number/main.cue
View File

@ -1,22 +1,21 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
number number
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo -123.5 > /tmp/out echo -123.5 > /tmp/out
""", """,
] ]
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "json" format: "json"

11
tests/llb/export/string/main.cue → tests/ops/export/string/main.cue
View File

@ -1,22 +1,21 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
printf something > /tmp/out printf something > /tmp/out
""", """,
] ]
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"

11
tests/llb/export/withvalidation/main.cue → tests/ops/export/withvalidation/main.cue
View File

@ -1,23 +1,22 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
string string
=~"^some.+" =~"^some.+"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
printf something > /tmp/out printf something > /tmp/out
""", """,
] ]
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "string" format: "string"

13
tests/llb/export/yaml/main.cue → tests/ops/export/yaml/main.cue
View File

@ -1,24 +1,21 @@
package testing package testing
import "dagger.io/dagger/op"
testScalar: { testScalar: {
bool bool
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo true > /tmp/out echo true > /tmp/out
""", """,
] ]
// XXX Blocked by https://github.com/blocklayerhq/dagger/issues/19
dir: "/"
}, },
{ op.#Export & {
do: "export"
// Source path in the container // Source path in the container
source: "/tmp/out" source: "/tmp/out"
format: "yaml" format: "yaml"

17
tests/llb/fetch-container/exist/main.cue → tests/ops/fetch-container/exist/main.cue
View File

@ -1,36 +1,33 @@
package testing package testing
import "dagger.io/dagger/op"
busybox1: #up: [ busybox1: #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "busybox" ref: "busybox"
}, },
] ]
busybox2: #up: [ busybox2: #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "busybox:latest" ref: "busybox:latest"
}, },
] ]
busybox3: #up: [ busybox3: #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "busybox:1.33-musl" ref: "busybox:1.33-musl"
}, },
] ]
busybox4: #up: [ busybox4: #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "busybox@sha256:e2af53705b841ace3ab3a44998663d4251d33ee8a9acaf71b66df4ae01c3bbe7" ref: "busybox@sha256:e2af53705b841ace3ab3a44998663d4251d33ee8a9acaf71b66df4ae01c3bbe7"
}, },
] ]
busybox5: #up: [ busybox5: #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "busybox:1.33-musl@sha256:e2af53705b841ace3ab3a44998663d4251d33ee8a9acaf71b66df4ae01c3bbe7" ref: "busybox:1.33-musl@sha256:e2af53705b841ace3ab3a44998663d4251d33ee8a9acaf71b66df4ae01c3bbe7"
}, },
] ]

8
tests/ops/fetch-container/invalid/main.cue Normal file
View File

@ -0,0 +1,8 @@
package testing
import "dagger.io/dagger/op"
#up: [
op.#FetchContainer & {
},
]

5
tests/llb/fetch-container/nonexistent/digest/main.cue → tests/ops/fetch-container/nonexistent/digest/main.cue
View File

@ -1,8 +1,9 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine@sha256:c6c7524e2111f22a9f7577211232d89a9e68cf5b9ed4a41ba77957c9771380a5" ref: "alpine@sha256:c6c7524e2111f22a9f7577211232d89a9e68cf5b9ed4a41ba77957c9771380a5"
}, },
] ]

5
tests/llb/fetch-container/nonexistent/image-with-valid-digest/main.cue → tests/ops/fetch-container/nonexistent/image-with-valid-digest/main.cue
View File

@ -1,10 +1,11 @@
package testing package testing
import "dagger.io/dagger/op"
// XXX WATCHOUT // XXX WATCHOUT
// Once buildkit has pulled that digest, it will stay cached and happily succeed WHATEVER the image name then is // Once buildkit has pulled that digest, it will stay cached and happily succeed WHATEVER the image name then is
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "busyboxaaa@sha256:e2af53705b841ace3ab3a44998663d4251d33ee8a9acaf71b66df4ae01c3bbe7" ref: "busyboxaaa@sha256:e2af53705b841ace3ab3a44998663d4251d33ee8a9acaf71b66df4ae01c3bbe7"
}, },
] ]

9
tests/ops/fetch-container/nonexistent/image/main.cue Normal file
View File

@ -0,0 +1,9 @@
package testing
import "dagger.io/dagger/op"
#up: [
op.#FetchContainer & {
ref: "doesnotexist"
},
]

5
tests/llb/fetch-container/nonexistent/tag/main.cue → tests/ops/fetch-container/nonexistent/tag/main.cue
View File

@ -1,8 +1,9 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine:doesnotexist" ref: "alpine:doesnotexist"
}, },
] ]

5
tests/llb/fetch-git/exist/main.cue → tests/ops/fetch-git/exist/main.cue
View File

@ -1,8 +1,9 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchGit & {
do: "fetch-git"
remote: "https://github.com/blocklayerhq/acme-clothing.git" remote: "https://github.com/blocklayerhq/acme-clothing.git"
ref: "master" ref: "master"
}, },

8
tests/ops/fetch-git/invalid/main.cue Normal file
View File

@ -0,0 +1,8 @@
package testing
import "dagger.io/dagger/op"
#up: [
op.#FetchGit & {
},
]

5
tests/llb/fetch-git/nonexistent/bork/main.cue → tests/ops/fetch-git/nonexistent/bork/main.cue
View File

@ -1,8 +1,9 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchGit & {
do: "fetch-git"
remote: "pork://pork" remote: "pork://pork"
ref: "master" ref: "master"
}, },

5
tests/llb/fetch-git/nonexistent/ref/main.cue → tests/ops/fetch-git/nonexistent/ref/main.cue
View File

@ -1,8 +1,9 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchGit & {
do: "fetch-git"
remote: "https://github.com/blocklayerhq/acme-clothing.git" remote: "https://github.com/blocklayerhq/acme-clothing.git"
ref: "lalalalal" ref: "lalalalal"
}, },

5
tests/llb/fetch-git/nonexistent/remote/main.cue → tests/ops/fetch-git/nonexistent/remote/main.cue
View File

@ -1,8 +1,9 @@
package testing package testing
import "dagger.io/dagger/op"
#up: [ #up: [
{ op.#FetchGit & {
do: "fetch-git"
remote: "https://github.com/blocklayerhq/lalalala.git" remote: "https://github.com/blocklayerhq/lalalala.git"
ref: "master" ref: "master"
}, },

39
tests/ops/load/invalid/cache/main.cue vendored Normal file
View File

@ -0,0 +1,39 @@
package testing
import "dagger.io/dagger/op"
test1: {
string
#up: [
op.#Load & {
from: [
op.#FetchContainer & {
ref: "alpine"
},
]
},
op.#Export & {
source: "/etc/issue"
format: "string"
},
]
}
test2: {
string
#up: [
op.#Load & {
from: [
op.#FetchContainer & {
ref: "busybox"
},
]
},
op.#Export & {
source: "/etc/issue"
format: "string"
},
]
}

51
tests/ops/load/valid/component/main.cue Normal file
View File

@ -0,0 +1,51 @@
package testing
import "dagger.io/dagger/op"
component: #up: [
op.#FetchContainer & {
ref: "alpine"
},
op.#Exec & {
args: ["sh", "-c", """
printf lol > /id
"""]
},
]
test1: {
string
#up: [
op.#Load & {
from: component
},
op.#Export & {
source: "/id"
format: "string"
},
]
}
test2: {
string
#up: [
op.#Load & {
from: #up: [
op.#FetchContainer & {
ref: "alpine"
},
op.#Exec & {
args: ["sh", "-c", """
printf lol > /id
"""]
},
]
},
op.#Export & {
source: "/id"
format: "string"
},
]
}

21
tests/ops/load/valid/script/main.cue Normal file
View File

@ -0,0 +1,21 @@
package testing
import "dagger.io/dagger/op"
test: {
string
#up: [
op.#Load & {
from: [
op.#FetchContainer & {
ref: "alpine"
},
]
},
op.#Export & {
source: "/etc/issue"
format: "string"
},
]
}

11
tests/llb/mounts/valid/cache/main.cue → tests/ops/mounts/valid/cache/main.cue vendored
View File

@ -1,23 +1,22 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
string string
#up: [ #up: [
{ op.#Load & {
do: "load"
from: [{do: "fetch-container", ref: "alpine"}] from: [{do: "fetch-container", ref: "alpine"}]
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo "NOT SURE WHAT TO TEST YET" > /out echo "NOT SURE WHAT TO TEST YET" > /out
"""] """]
dir: "/" dir: "/"
mount: something: "cache" mount: something: "cache"
}, },
{ op.#Export & {
do: "export"
source: "/out" source: "/out"
format: "string" format: "string"
}, },

23
tests/llb/mounts/valid/component/main.cue → tests/ops/mounts/valid/component/main.cue
View File

@ -1,33 +1,34 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
string string
#up: [ #up: [
{ op.#Load & {
do: "load" from: [
from: [{do: "fetch-container", ref: "alpine"}] op.#FetchContainer & {
ref: "alpine"
}, },
{ ]
do: "exec" },
op.#Exec & {
args: ["sh", "-c", """ args: ["sh", "-c", """
cat /mnt/test/lol > /out cat /mnt/test/lol > /out
"""] """]
mount: "/mnt/test": from: #up: [ mount: "/mnt/test": from: #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
echo -n "hello world" > /lol echo -n "hello world" > /lol
"""] """]
}, },
] ]
}, },
{ op.#Export & {
do: "export"
source: "/out" source: "/out"
format: "string" format: "string"
}, },

18
tests/llb/mounts/valid/script/main.cue → tests/ops/mounts/valid/script/main.cue
View File

@ -1,19 +1,22 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
string string
#up: [ #up: [
{ op.#Load & {
do: "load" from: [
from: [{do: "fetch-container", ref: "alpine"}] op.#FetchContainer & {
ref: "alpine"
}, },
{ ]
do: "exec" },
op.#Exec & {
args: ["sh", "-c", """ args: ["sh", "-c", """
ls -lA /lol > /out ls -lA /lol > /out
"""] """]
dir: "/"
mount: something: { mount: something: {
input: [{ input: [{
do: "fetch-container" do: "fetch-container"
@ -22,8 +25,7 @@ test: {
path: "/lol" path: "/lol"
} }
}, },
{ op.#Export & {
do: "export"
source: "/out" source: "/out"
format: "string" format: "string"
}, },

21
tests/llb/mounts/valid/tmpfs/main.cue → tests/ops/mounts/valid/tmpfs/main.cue
View File

@ -1,32 +1,33 @@
package testing package testing
import "dagger.io/dagger/op"
test: { test: {
string string
#up: [ #up: [
{ op.#Load & {
do: "load" from: [
from: [{do: "fetch-container", ref: "alpine"}] op.#FetchContainer & {
ref: "alpine"
}, },
{ ]
do: "exec" },
op.#Exec & {
args: ["sh", "-c", """ args: ["sh", "-c", """
echo ok > /out echo ok > /out
echo ok > /tmpdir/out echo ok > /tmpdir/out
"""] """]
dir: "/"
mount: "/tmpdir": "tmpfs" mount: "/tmpdir": "tmpfs"
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", """ args: ["sh", "-c", """
[ -f /out ] || exit 1 [ -f /out ] || exit 1
# content of /cache/tmp must not exist in this layer # content of /cache/tmp must not exist in this layer
[ ! -f /tmpdir/out ] || exit 1 [ ! -f /tmpdir/out ] || exit 1
"""] """]
}, },
{ op.#Export & {
do: "export"
source: "/out" source: "/out"
format: "string" format: "string"
}, },

0
tests/llb/push-container/inputs.yaml → tests/ops/push-container/inputs.yaml
View File

0
tests/llb/push-container/main.cue → tests/ops/push-container/main.cue
View File

17
tests/llb/subdir/simple/main.cue → tests/ops/subdir/simple/main.cue
View File

@ -1,27 +1,24 @@
package main package main
import "dagger.io/dagger/op"
hello: { hello: {
string string
#up: [ #up: [
{ op.#FetchContainer & {
do: "fetch-container"
ref: "alpine" ref: "alpine"
}, },
{ op.#Exec & {
do: "exec"
args: ["mkdir", "-p", "/tmp/foo"] args: ["mkdir", "-p", "/tmp/foo"]
}, },
{ op.#Exec & {
do: "exec"
args: ["sh", "-c", "echo -n world > /tmp/foo/hello"] args: ["sh", "-c", "echo -n world > /tmp/foo/hello"]
}, },
{ op.#Subdir & {
do: "subdir"
dir: "/tmp/foo" dir: "/tmp/foo"
}, },
{ op.#Export & {
do: "export"
source: "/hello" source: "/hello"
format: "string" format: "string"
}, },

187
tests/test-llb.sh
View File

@ -1,187 +0,0 @@
#!/usr/bin/env bash
set -o errexit -o errtrace -o functrace -o nounset -o pipefail
# Test Directory
d=$(cd "$(dirname "${BASH_SOURCE[0]:-$PWD}")" 2>/dev/null 1>&2 && pwd)
test::llb(){
local dagger="$1"
test::llb::load "$dagger"
test::llb::mount "$dagger"
test::llb::copy "$dagger"
test::llb::local "$dagger"
test::llb::fetchcontainer "$dagger"
test::llb::pushcontainer "$dagger"
test::llb::fetchgit "$dagger"
test::llb::exec "$dagger"
test::llb::export "$dagger"
test::llb::subdir "$dagger"
test::llb::dockerbuild "$dagger"
}
test::llb::load(){
test::one "Load: valid components" --exit=0 --stdout='{"component":{},"test1":"lol","test2":"lol"}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/load/valid/component
test::one "Load: valid script" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/load/valid/script
test::one "Load: invalid caching (FIXME https://github.com/blocklayerhq/dagger/issues/44)" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/load/invalid/cache
}
test::llb::mount(){
test::one "Mount: tmpfs" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/mounts/valid/tmpfs
test::one "Mount: cache" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/mounts/valid/cache
test::one "Mount: component" --exit=0 --stdout='{"test":"hello world"}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/mounts/valid/component
disable test::one "Mount: script (FIXME https://github.com/blocklayerhq/dagger/issues/46)" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/mounts/valid/script
}
test::llb::copy(){
test::one "Copy: valid components" --exit=0 --stdout='{"component":{},"test1":"lol","test2":"lol"}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/copy/valid/component
test::one "Copy: valid script" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/copy/valid/script
disable test::one "Copy: invalid caching (FIXME https://github.com/blocklayerhq/dagger/issues/44)" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/copy/invalid/cache
}
test::llb::local(){
disable "" "There are no local tests right now (the feature is possibly not functioning at all: see https://github.com/blocklayerhq/dagger/issues/41)"
}
test::llb::fetchcontainer(){
local dagger="$1"
# Fetch container
disable test::one "FetchContainer: missing ref (FIXME: distinguish missing inputs from incorrect config)" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-container/invalid
test::one "FetchContainer: non existent container image" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-container/nonexistent/image
test::one "FetchContainer: non existent container tag" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-container/nonexistent/tag
test::one "FetchContainer: non existent container digest" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-container/nonexistent/digest
test::one "FetchContainer: valid containers" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-container/exist
disable test::one "FetchContainer: non existent container image with valid digest (FIXME https://github.com/blocklayerhq/dagger/issues/32)" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-container/nonexistent/image-with-valid-digest
}
test::llb::pushcontainer(){
local dagger="$1"
test::secret "$d"/llb/push-container/inputs.yaml "PushContainer: simple" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/push-container
}
test::llb::fetchgit(){
local dagger="$1"
# Fetch git
test::one "FetchGit: valid" --exit=0 --stdout="{}" \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-git/exist
disable test::one "FetchGit: invalid (FIXME: distinguish missing inputs from incorrect config) " --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-git/invalid
test::one "FetchGit: non existent remote" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-git/nonexistent/remote
test::one "FetchGit: non existent ref" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-git/nonexistent/ref
test::one "FetchGit: non existent bork" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/fetch-git/nonexistent/bork
}
test::llb::exec(){
# Exec
test::one "Exec: invalid" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/invalid
test::one "Exec: error" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/error
test::one "Exec: simple" --exit=0 --stdout={} \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/simple
# XXX should run twice and test that the string "always output" is visible with DOCKER_OUTPUT=1
# Alternatively, use export, but this would test multiple things then...
test::one "Exec: always" --exit=0 --stdout={} \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/always
test::one "Exec: env invalid" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/env/invalid
test::one "Exec: env valid" --exit=0 --stdout={} \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/env/valid
test::one "Exec: env with overlay" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute --input-string 'bar=overlay environment' "$d"/llb/exec/env/overlay
test::one "Exec: non existent dir" --exit=0 --stdout={} \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/dir/doesnotexist
test::one "Exec: valid dir" --exit=0 --stdout={} \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/dir/exist
disable test::one "Exec: exit code propagation (FIXME https://github.com/blocklayerhq/dagger/issues/74)" --exit=123 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/exit_code
test::one "Exec: script with referenced non-concrete property should not be executed, and should succeed overall" --exit=0 --stdout='{"hello":"world"}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/undefined/non_concrete_referenced
# NOTE: the exec is meant to fail - and we test that as a way to confirm it has been executed
test::one "Exec: script with unreferenced undefined properties should be executed" --exit=1 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/undefined/non_concrete_not_referenced
test::one "Exec: package with optional def, not referenced, should be executed" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/undefined/with_pkg_def
test::one "Exec: script with optional prop, not referenced, should be executed" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/undefined/with_pkg_optional
disable test::one "Exec: script with non-optional prop, not referenced, should be executed (FIXME https://github.com/blocklayerhq/dagger/issues/70)" --exit=1 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/exec/undefined/with_pkg_mandatory
}
test::llb::export(){
test::one "Export: json" --exit=0 --stdout='{"testMap":{"something":"something"},"testScalar":true}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/json
test::one "Export: string" --exit=0 --stdout='{"test":"something"}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/string
test::one "Export: string with additional constraint success" --exit=0 --stdout='{"test":"something"}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/withvalidation
test::one "Export: many concurrent" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/concurrency
test::one "Export: does not pass additional validation" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/invalid/validation
test::one "Export: invalid format" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/invalid/format
test::one "Export: invalid path" --exit=1 --stdout= \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/invalid/path
test::one "Export: number" --exit=0 --stdout='{"test":-123.5}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/float
disable test::one "Export: number (FIXME: https://github.com/blocklayerhq/dagger/issues/96)" --exit=0 --stdout='{"test":-123.5}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/number
test::one "Export: yaml" --exit=0 --stdout='{"testMap":{"something":"something"},"testScalar":true}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/yaml
test::one "Export: bool" --exit=0 --stdout='{"test":true}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/export/bool
}
test::llb::subdir() {
test::one "Subdir: simple usage" --exit=0 --stdout='{"hello":"world"}' \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute "$d"/llb/subdir/simple
}
test::llb::dockerbuild() {
test::one "Docker Build" --exit=0 \
"$dagger" "${DAGGER_BINARY_ARGS[@]}" compute --input-dir TestData="$d"/llb/dockerbuild/testdata "$d"/llb/dockerbuild
}

3
tests/test.sh
View File

@ -18,8 +18,6 @@ d=$(cd "$(dirname "${BASH_SOURCE[0]:-$PWD}")" 2>/dev/null 1>&2 && pwd)
# shellcheck source=/dev/null # shellcheck source=/dev/null
. "$d/test-compute.sh" . "$d/test-compute.sh"
# shellcheck source=/dev/null # shellcheck source=/dev/null
. "$d/test-llb.sh"
# shellcheck source=/dev/null
. "$d/test-stdlib.sh" . "$d/test-stdlib.sh"
# shellcheck source=/dev/null # shellcheck source=/dev/null
. "$d/test-examples.sh" . "$d/test-examples.sh"
@ -28,7 +26,6 @@ test::all(){
local dagger="$1" local dagger="$1"
test::suite "compute" && test::compute "$dagger" test::suite "compute" && test::compute "$dagger"
test::suite "llb" && test::llb "$dagger"
test::suite "stdlib" && test::stdlib "$dagger" test::suite "stdlib" && test::stdlib "$dagger"
test::suite "examples" && test::examples "$dagger" test::suite "examples" && test::examples "$dagger"
} }