blob: 6235add8a3c40ae79e99198771b6b012a3e8faaa [file] [log] [blame]
// Copyright 2021 The LUCI Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package main
import (
"encoding/base64"
"encoding/json"
"io/ioutil"
"os"
"path/filepath"
"testing"
"github.com/maruel/subcommands"
. "github.com/smartystreets/goconvey/convey"
"go.chromium.org/luci/client/cmd/swarming/lib"
"go.chromium.org/luci/common/api/swarming/swarming/v1"
)
// IntegrationTestEnvVar is the name of the environment variable which controls
// whether integaration tests are executed.
// The value must be "1" for integration tests to run.
const IntegrationTestEnvVar = "INTEGRATION_TESTS"
func init() {
// Unset SWARMING_TASK_ID environment variable, otherwise task trigger may
// fail for parent task association.
os.Unsetenv(lib.TaskIDEnvVar)
}
// runIntegrationTests true if integration tests should run.
func runIntegrationTests() bool {
return os.Getenv(IntegrationTestEnvVar) == "1"
}
// runCmd runs swarming commands appending common flags.
// It skips if integration should not run.
func runCmd(t *testing.T, cmd string, args ...string) int {
if !runIntegrationTests() {
t.Skipf("Skip integration tests")
}
args = append([]string{cmd, "-server", "chromium-swarm-dev.appspot.com", "-quiet"}, args...)
return subcommands.Run(getApplication(), args)
}
func TestBotsCommand(t *testing.T) {
t.Parallel()
Convey(`ok`, t, func() {
dir := t.TempDir()
jsonPath := filepath.Join(dir, "out.json")
So(runCmd(t, "bots", "-json", jsonPath), ShouldEqual, 0)
})
}
func TestTasksCommand(t *testing.T) {
t.Parallel()
Convey(`ok`, t, func() {
dir := t.TempDir()
jsonPath := filepath.Join(dir, "out.json")
So(runCmd(t, "tasks", "-limit", "1", "-json", jsonPath), ShouldEqual, 0)
})
}
// triggerTask triggers a task and returns the triggered TaskRequest.
func triggerTask(t *testing.T, args []string) *swarming.SwarmingRpcsTaskRequestMetadata {
dir := t.TempDir()
jsonPath := filepath.Join(dir, "out.json")
sbDir := t.TempDir()
sbPath := filepath.Join(sbDir, "secret_bytes.txt")
err := ioutil.WriteFile(sbPath, []byte("This is secret!"), 0600)
So(err, ShouldBeNil)
args = append(args, []string{
"-d", "pool=infra.tests",
"-d", "os=Linux",
"-realm", "infra:tests",
"-dump-json", jsonPath,
"-idempotent",
"-secret-bytes-path", sbPath,
"--", "/bin/bash", "-c", "echo hi > ${ISOLATED_OUTDIR}/out",
}...)
So(runCmd(t, "trigger", args...), ShouldEqual, 0)
results := readTriggerResults(jsonPath)
So(results.Tasks, ShouldHaveLength, 1)
task := results.Tasks[0]
slice := task.Request.TaskSlices[0]
redactedSb := base64.StdEncoding.EncodeToString([]byte("<REDACTED>"))
So(slice.Properties.SecretBytes, ShouldEqual, redactedSb)
return results.Tasks[0]
}
// readTriggerResults reads TriggerResults from output json file.
func readTriggerResults(jsonPath string) *lib.TriggerResults {
resultsJSON, err := ioutil.ReadFile(jsonPath)
So(err, ShouldBeNil)
results := &lib.TriggerResults{}
err = json.Unmarshal(resultsJSON, results)
So(err, ShouldBeNil)
return results
}
func testCollectCommand(t *testing.T, taskID string) {
dir := t.TempDir()
So(runCmd(t, "collect", "-output-dir", dir, taskID), ShouldEqual, 0)
out, err := ioutil.ReadFile(filepath.Join(dir, taskID, "out"))
So(err, ShouldBeNil)
So(string(out), ShouldResemble, "hi\n")
}
func runIntegrationTest(t *testing.T, triggerArgs []string) {
triggeredTask := triggerTask(t, triggerArgs)
So(runCmd(t, "request_show", triggeredTask.TaskId), ShouldEqual, 0)
testCollectCommand(t, triggeredTask.TaskId)
}
func TestWithCAS(t *testing.T) {
t.Parallel()
Convey(`ok`, t, func() {
// TODO(jwata): ensure the digest is uploaded on CAS.
// https://cas-viewer-dev.appspot.com/projects/chromium-swarm-dev/instances/default_instance/blobs/ad455795d66ac6d3bc0905f6a137dda1fb1d2de252a9f2a73329428fe1cf645a/77/tree
// Use the same digest with the output so that the content is kept on
// CAS (hopefully...)
runIntegrationTest(t, []string{"-digest", "ad455795d66ac6d3bc0905f6a137dda1fb1d2de252a9f2a73329428fe1cf645a/77"})
})
}
const spawnTaskInputJSON = `
{
"requests": [
{
"name": "spawn-task test with CAS",
"realm": "infra:tests",
"priority": "200",
"task_slices": [
{
"expiration_secs": "21600",
"properties": {
"dimensions": [
{"key": "pool", "value": "infra.tests"},
{"key": "os", "value": "Linux"}
],
"cas_input_root": {
"cas_instance": "projects/chromium-swarm-dev/instances/default_instance",
"digest": {
"hash": "ad455795d66ac6d3bc0905f6a137dda1fb1d2de252a9f2a73329428fe1cf645a",
"size_bytes": "77"
}
},
"command": ["/bin/bash", "-c", "echo hi > ${ISOLATED_OUTDIR}/out"],
"execution_timeout_secs": "3600",
"idempotent": true
}
}
]
}
]
}
`
func TestSpawnTasksCommand(t *testing.T) {
t.Parallel()
Convey(`ok`, t, func() {
// prepare input file.
dir := t.TempDir()
inputPath := filepath.Join(dir, "input.json")
err := ioutil.WriteFile(inputPath, []byte(spawnTaskInputJSON), 0600)
So(err, ShouldBeNil)
outputPath := filepath.Join(dir, "output.json")
So(runCmd(t, "spawn_task", "-json-input", inputPath, "-json-output", outputPath), ShouldEqual, 0)
results := readTriggerResults(outputPath)
So(results.Tasks, ShouldHaveLength, 1)
})
}