Refactor random generation into a definition to make it reusable

Signed-off-by: Tom Chauveau <tom.chauveau@epitech.eu>

tests/stdlib/aws/ecr/.dagger/env/default/plan/ecr.cue

@@ -11,8 +11,10 @@ TestConfig: awsConfig: aws.#Config & {
 }
 
 TestECR: {
+	random: #Random & {}
+
 	repository: "125635003186.dkr.ecr.\(TestConfig.awsConfig.region).amazonaws.com/dagger-ci"
-	tag:        "test-ecr-\(random)"
+	tag:        "test-ecr-\(random.out)"
 
 	creds: ecr.#Credentials & {
 		config: TestConfig.awsConfig
@@ -25,7 +27,7 @@ TestECR: {
 			op.#DockerBuild & {
 				dockerfile: """
 				FROM alpine
-				RUN echo \(random) > /test
+				RUN echo \(random.out) > /test
 				"""
 			},
 
@@ -61,7 +63,7 @@ TestECR: {
 		op.#Exec & {
 			always: true
 			args: [
-				"sh", "-c", "test $(cat test) = \(random)",
+				"sh", "-c", "test $(cat test) = \(random.out)",
 			]
 		},
 	]
@@ -76,7 +78,7 @@ TestECR: {
 		op.#DockerBuild & {
 			dockerfile: #"""
 				FROM \#(push.ref)
-				RUN test $(cat test) = \#(random)
+				RUN test $(cat test) = \#(random.out)
 			"""#
 		},
 	]

tests/stdlib/aws/ecr/.dagger/env/default/plan/random.cue

@@ -1,21 +1,33 @@
 package ecr
 
 import (
+	"strconv"
+
 	"dagger.io/alpine"
 	"dagger.io/dagger/op"
 )
 
-// Generate a random number
+#Random: {
-random: {
+	size: *12 | number
-	string
+
-	#up: [
+	out: {
-		op.#Load & {from: alpine.#Image},
+		string
-		op.#Exec & {
+
-			always: true
+		#up: [
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
+			op.#Load & {from: alpine.#Image},
-		},
+
-		op.#Export & {
+			op.#Exec & {
-			source: "/rand"
+				always: true
-		},
+				args: ["sh", "-c", #"""
-	]
+					tr -cd '[:alpha:]' < /dev/urandom | fold -w "$SIZE" | head -n 1 | tr '[A-Z]' '[a-z]' | tr -d '\n' > /rand
+					"""#,
+				]
+				env: SIZE: strconv.FormatInt(size, 10)
+			},
+
+			op.#Export & {
+				source: "/rand"
+			},
+		]
+	}
 }

tests/stdlib/docker/push-pull/push-pull.cue

@@ -15,7 +15,9 @@ registry: {
 }
 
 TestPushAndPull: {
-	ref: "daggerio/ci-test:\(random)"
+	random: #Random & {}
+
+	ref: "daggerio/ci-test:\(random.out)"
 
 	// Create image
 	image: docker.#ImageFromDockerfile & {

tests/stdlib/docker/push-pull/random.cue

@@ -1,21 +1,33 @@
 package docker
 
 import (
+	"strconv"
+
 	"dagger.io/alpine"
 	"dagger.io/dagger/op"
 )
 
-// Generate a random number
+#Random: {
-random: {
+	size: *12 | number
-	string
+
-	#up: [
+	out: {
-		op.#Load & {from: alpine.#Image},
+		string
-		op.#Exec & {
+
-			always: true
+		#up: [
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
+			op.#Load & {from: alpine.#Image},
-		},
+
-		op.#Export & {
+			op.#Exec & {
-			source: "/rand"
+				always: true
-		},
+				args: ["sh", "-c", #"""
-	]
+					tr -cd '[:alpha:]' < /dev/urandom | fold -w "$SIZE" | head -n 1 | tr '[A-Z]' '[a-z]' | tr -d '\n' > /rand
+					"""#,
+				]
+				env: SIZE: strconv.FormatInt(size, 10)
+			},
+
+			op.#Export & {
+				source: "/rand"
+			},
+		]
+	}
 }

tests/stdlib/docker/run/passphrase/.dagger/env/default/plan/passphrase.cue

@@ -9,11 +9,15 @@ key:        dagger.#Secret @dagger(input)
 passphrase: dagger.#Secret @dagger(input)
 user:       string         @dagger(input)
 
-TestRun: run: docker.#Run & {
+TestRun: {
-	host:         "143.198.64.230"
+	random: #Random & {}
-	ref:          "nginx:alpine"
+
-	"user":       user
+	run: docker.#Run & {
-	"passphrase": passphrase
+		host:         "143.198.64.230"
-	name:         "daggerci-test-simple-\(random)"
+		ref:          "nginx:alpine"
-	"key":        key
+		"user":       user
+		"passphrase": passphrase
+		name:         "daggerci-test-simple-\(random.out)"
+		"key":        key
+	}
 }

tests/stdlib/docker/run/passphrase/.dagger/env/default/plan/random.cue

@@ -1,20 +1,33 @@
 package docker
 
 import (
-	"dagger.io/dagger/op"
+	"strconv"
+
 	"dagger.io/alpine"
+	"dagger.io/dagger/op"
 )
 
-random: {
+#Random: {
-	string
+	size: *12 | number
-	#up: [
+
-		op.#Load & {from: alpine.#Image},
+	out: {
-		op.#Exec & {
+		string
-			always: true
+
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
+		#up: [
-		},
+			op.#Load & {from: alpine.#Image},
-		op.#Export & {
+
-			source: "/rand"
+			op.#Exec & {
-		},
+				always: true
-	]
+				args: ["sh", "-c", #"""
+					tr -cd '[:alpha:]' < /dev/urandom | fold -w "$SIZE" | head -n 1 | tr '[A-Z]' '[a-z]' | tr -d '\n' > /rand
+					"""#,
+				]
+				env: SIZE: strconv.FormatInt(size, 10)
+			},
+
+			op.#Export & {
+				source: "/rand"
+			},
+		]
+	}
 }

tests/stdlib/docker/run/simple/.dagger/env/default/plan/random.cue

@@ -1,20 +1,33 @@
 package docker
 
 import (
-	"dagger.io/dagger/op"
+	"strconv"
+
 	"dagger.io/alpine"
+	"dagger.io/dagger/op"
 )
 
-random: {
+#Random: {
-	string
+	size: *12 | number
-	#up: [
+
-		op.#Load & {from: alpine.#Image},
+	out: {
-		op.#Exec & {
+		string
-			always: true
+
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
+		#up: [
-		},
+			op.#Load & {from: alpine.#Image},
-		op.#Export & {
+
-			source: "/rand"
+			op.#Exec & {
-		},
+				always: true
-	]
+				args: ["sh", "-c", #"""
+					tr -cd '[:alpha:]' < /dev/urandom | fold -w "$SIZE" | head -n 1 | tr '[A-Z]' '[a-z]' | tr -d '\n' > /rand
+					"""#,
+				]
+				env: SIZE: strconv.FormatInt(size, 10)
+			},
+
+			op.#Export & {
+				source: "/rand"
+			},
+		]
+	}
 }

tests/stdlib/docker/run/simple/.dagger/env/default/plan/simple.cue

@@ -7,10 +7,14 @@ import (
 
 key: dagger.#Secret @dagger(input)
 
-TestRun: run: docker.#Run & {
+TestRun: {
-	host:  "143.198.64.230"
+	random: #Random & {}
-	ref:   "nginx:alpine"
+
-	user:  "root"
+	run: docker.#Run & {
-	name:  "daggerci-test-simple-\(random)"
+		host:  "143.198.64.230"
-	"key": key
+		ref:   "nginx:alpine"
+		user:  "root"
+		name:  "daggerci-test-simple-\(random.out)"
+		"key": key
+	}
 }

tests/stdlib/docker/run/wrong-passphrase/.dagger/env/default/plan/random.cue

@@ -1,20 +1,33 @@
 package docker
 
 import (
-	"dagger.io/dagger/op"
+	"strconv"
+
 	"dagger.io/alpine"
+	"dagger.io/dagger/op"
 )
 
-random: {
+#Random: {
-	string
+	size: *12 | number
-	#up: [
+
-		op.#Load & {from: alpine.#Image},
+	out: {
-		op.#Exec & {
+		string
-			always: true
+
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
+		#up: [
-		},
+			op.#Load & {from: alpine.#Image},
-		op.#Export & {
+
-			source: "/rand"
+			op.#Exec & {
-		},
+				always: true
-	]
+				args: ["sh", "-c", #"""
+					tr -cd '[:alpha:]' < /dev/urandom | fold -w "$SIZE" | head -n 1 | tr '[A-Z]' '[a-z]' | tr -d '\n' > /rand
+					"""#,
+				]
+				env: SIZE: strconv.FormatInt(size, 10)
+			},
+
+			op.#Export & {
+				source: "/rand"
+			},
+		]
+	}
 }

tests/stdlib/docker/run/wrong-passphrase/.dagger/env/default/plan/wrong-password.cue

@@ -10,11 +10,15 @@ key:        dagger.#Secret @dagger(input)
 passphrase: dagger.#Secret @dagger(input)
 user:       string         @dagger(input)
 
-TestRun: run: docker.#Run & {
+TestRun: {
-	host:         "143.198.64.230"
+	random: #Random & {}
-	ref:          "nginx:alpine"
+
-	"user":       user
+	run: docker.#Run & {
-	"passphrase": passphrase
+		host:         "143.198.64.230"
-	name:         "daggerci-test-simple-\(random)"
+		ref:          "nginx:alpine"
-	"key":        key
+		"user":       user
+		"passphrase": passphrase
+		name:         "daggerci-test-simple-\(random.out)"
+		"key":        key
+	}
 }

tests/stdlib/gcp/gcr/.dagger/env/default/plan/gcr.cue

@@ -9,8 +9,10 @@ import (
 TestConfig: gcpConfig: gcp.#Config
 
 TestGCR: {
+	random: #Random & {}
+
 	repository: "gcr.io/dagger-ci/test"
-	tag:        "test-gcr-\(random)"
+	tag:        "test-gcr-\(random.out)"
 
 	creds: gcr.#Credentials & {
 		config: TestConfig.gcpConfig
@@ -23,7 +25,7 @@ TestGCR: {
 			op.#DockerBuild & {
 				dockerfile: """
 				FROM alpine
-				RUN echo \(random) > /test
+				RUN echo \(random.out) > /test
 				"""
 			},
 
@@ -59,7 +61,7 @@ TestGCR: {
 		op.#Exec & {
 			always: true
 			args: [
-				"sh", "-c", "test $(cat test) = \(random)",
+				"sh", "-c", "test $(cat test) = \(random.out)",
 			]
 		},
 	]
@@ -74,7 +76,7 @@ TestGCR: {
 		op.#DockerBuild & {
 			dockerfile: #"""
 				FROM \#(push.ref)
-				RUN test $(cat test) = \#(random)
+				RUN test $(cat test) = \#(random.out)
 			"""#
 		},
 	]

tests/stdlib/gcp/gcr/.dagger/env/default/plan/random.cue

@@ -1,20 +1,33 @@
 package gcr
 
 import (
+	"strconv"
+
 	"dagger.io/alpine"
 	"dagger.io/dagger/op"
 )
 
-// Generate a random number
+#Random: {
-random: {
+	size: *12 | number
-	string
+
-	#up: [
+	out: {
-		op.#Load & {from: alpine.#Image},
+		string
-		op.#Exec & {
+
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
+		#up: [
-		},
+			op.#Load & {from: alpine.#Image},
-		op.#Export & {
+
-			source: "/rand"
+			op.#Exec & {
-		},
+				always: true
-	]
+				args: ["sh", "-c", #"""
+					tr -cd '[:alpha:]' < /dev/urandom | fold -w "$SIZE" | head -n 1 | tr '[A-Z]' '[a-z]' | tr -d '\n' > /rand
+					"""#,
+				]
+				env: SIZE: strconv.FormatInt(size, 10)
+			},
+
+			op.#Export & {
+				source: "/rand"
+			},
+		]
+	}
 }

tests/stdlib/kubernetes/helm/helm.cue

@@ -11,9 +11,11 @@ kubeconfig: dagger.#Secret @dagger(input)
 
 // Deploy user local chart
 TestHelmSimpleChart: {
+	random: #Random & {}
+
 	// Deploy chart
 	deploy: helm.#Chart & {
-		name:         "dagger-test-helm-simple-chart-\(random)"
+		name:         "dagger-test-helm-simple-chart-\(random.out)"
 		namespace:    "dagger-test"
 		"kubeconfig": kubeconfig
 		chartSource:  dagger.#Artifact
@@ -28,9 +30,11 @@ TestHelmSimpleChart: {
 
 // Deploy remote chart
 TestHelmRepoChart: {
+	random: #Random & {}
+
 	// Deploy chart
 	deploy: helm.#Chart & {
-		name:         "dagger-test-helm-repository-\(random)"
+		name:         "dagger-test-helm-repository-\(random.out)"
 		namespace:    "dagger-test"
 		"kubeconfig": kubeconfig
 		chart:        "redis"

tests/stdlib/kubernetes/helm/random.cue

@@ -1,21 +1,33 @@
 package helm
 
 import (
+	"strconv"
+
 	"dagger.io/alpine"
 	"dagger.io/dagger/op"
 )
 
-// Generate a random number
+#Random: {
-random: {
+	size: *12 | number
-	string
+
-	#up: [
+	out: {
-		op.#Load & {from: alpine.#Image},
+		string
-		op.#Exec & {
+
-			always: true
+		#up: [
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
+			op.#Load & {from: alpine.#Image},
-		},
+
-		op.#Export & {
+			op.#Exec & {
-			source: "/rand"
+				always: true
-		},
+				args: ["sh", "-c", #"""
-	]
+					tr -cd '[:alpha:]' < /dev/urandom | fold -w "$SIZE" | head -n 1 | tr '[A-Z]' '[a-z]' | tr -d '\n' > /rand
+					"""#,
+				]
+				env: SIZE: strconv.FormatInt(size, 10)
+			},
+
+			op.#Export & {
+				source: "/rand"
+			},
+		]
+	}
 }

tests/stdlib/kubernetes/kubernetes.cue

@@ -11,11 +11,13 @@ import (
 kubeconfig: dagger.#Secret @dagger(input)
 
 TestKubeApply: {
+	random: #Random & {}
+
 	// Pod spec
 	kubeSrc: {
 		apiVersion: "v1"
 		kind:       "Pod"
-		metadata: name: "kube-test-\(random)"
+		metadata: name: "kube-test-\(random.out)"
 		spec: {
 			restartPolicy: "Never"
 			containers: [{

tests/stdlib/kubernetes/random.cue

@@ -1,21 +1,33 @@
 package kubernetes
 
 import (
+	"strconv"
+
 	"dagger.io/alpine"
 	"dagger.io/dagger/op"
 )
 
-// Generate a random number
+#Random: {
-random: {
+	size: *12 | number
-	string
+
-	#up: [
+	out: {
-		op.#Load & {from: alpine.#Image},
+		string
-		op.#Exec & {
+
-			always: true
+		#up: [
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
+			op.#Load & {from: alpine.#Image},
-		},
+
-		op.#Export & {
+			op.#Exec & {
-			source: "/rand"
+				always: true
-		},
+				args: ["sh", "-c", #"""
-	]
+					tr -cd '[:alpha:]' < /dev/urandom | fold -w "$SIZE" | head -n 1 | tr '[A-Z]' '[a-z]' | tr -d '\n' > /rand
+					"""#,
+				]
+				env: SIZE: strconv.FormatInt(size, 10)
+			},
+
+			op.#Export & {
+				source: "/rand"
+			},
+		]
+	}
 }

tests/stdlib/netlify/.dagger/env/default/plan/netlify.cue

@@ -7,10 +7,12 @@ import (
 )
 
 TestNetlify: {
+	random: #Random & {}
+
 	// Generate a website containing the random number
 	html: #up: [
 		op.#WriteFile & {
-			content: random
+			content: random.out
 			dest:    "index.html"
 		},
 	]
@@ -38,7 +40,7 @@ TestNetlify: {
 				"pipefail",
 				"-c",
 				#"""
-        test "$(curl \#(deploy.deployUrl))" = "\#(random)"
+        test "$(curl \#(deploy.deployUrl))" = "\#(random.out)"
         """#,
 			]
 		},

tests/stdlib/netlify/.dagger/env/default/plan/random.cue

@@ -1,20 +1,33 @@
 package netlify
 
 import (
+	"strconv"
+
 	"dagger.io/alpine"
 	"dagger.io/dagger/op"
 )
 
-// Generate a random number
+#Random: {
-random: {
+	size: *12 | number
-	string
+
-	#up: [
+	out: {
-		op.#Load & {from: alpine.#Image},
+		string
-		op.#Exec & {
+
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
+		#up: [
-		},
+			op.#Load & {from: alpine.#Image},
-		op.#Export & {
+
-			source: "/rand"
+			op.#Exec & {
-		},
+				always: true
-	]
+				args: ["sh", "-c", #"""
+					tr -cd '[:alpha:]' < /dev/urandom | fold -w "$SIZE" | head -n 1 | tr '[A-Z]' '[a-z]' | tr -d '\n' > /rand
+					"""#,
+				]
+				env: SIZE: strconv.FormatInt(size, 10)
+			},
+
+			op.#Export & {
+				source: "/rand"
+			},
+		]
+	}
 }

tests/stdlib/netlify/netlify.cue

@@ -1,46 +0,0 @@
-package netlify
-
-import (
-	"dagger.io/dagger/op"
-	"dagger.io/alpine"
-	"dagger.io/netlify"
-)
-
-TestNetlify: {
-	// Generate a website containing the random number
-	html: #up: [
-		op.#WriteFile & {
-			content: random
-			dest:    "index.html"
-		},
-	]
-
-	// Deploy to netlify
-	deploy: netlify.#Site & {
-		contents: html
-		name:     "dagger-test"
-	}
-
-	// Check if the deployed site has the random marker
-	check: #up: [
-		op.#Load & {
-			from: alpine.#Image & {
-				package: bash: "=~5.1"
-				package: curl: true
-			}
-		},
-		op.#Exec & {
-			args: [
-				"/bin/bash",
-				"--noprofile",
-				"--norc",
-				"-eo",
-				"pipefail",
-				"-c",
-				#"""
-                test "$(curl \#(deploy.deployUrl))" = "\#(random)"
-                """#,
-			]
-		},
-	]
-}

tests/stdlib/netlify/random.cue

@@ -1,21 +0,0 @@
-package netlify
-
-import (
-	"dagger.io/alpine"
-	"dagger.io/dagger/op"
-)
-
-// Generate a random number
-random: {
-	string
-	#up: [
-		op.#Load & {from: alpine.#Image},
-		op.#Exec & {
-			always: true
-			args: ["sh", "-c", "cat /dev/urandom | tr -dc 'a-z' | fold -w 10 | head -n 1 | tr -d '\n' > /rand"]
-		},
-		op.#Export & {
-			source: "/rand"
-		},
-	]
-}