func TestDockerCommandPrivilegedServices(t *testing.T) {
if helpers.SkipIntegrationTests(t, "docker", "info") {
return
}
build := &common.Build{
GetBuildResponse: common.LongRunningBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "docker",
Docker: &common.DockerConfig{
Image: "alpine",
Privileged: true,
},
},
},
}
build.Commands = "docker info"
build.Options = common.BuildOptions{
"image": "docker:git",
"services": []string{
"docker:dind",
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
assert.NoError(t, err)
}
func TestDockerCommandBuildAbort(t *testing.T) {
if helpers.SkipIntegrationTests(t, "docker", "info") {
return
}
build := &common.Build{
GetBuildResponse: common.LongRunningBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "docker",
Docker: &common.DockerConfig{
Image: "alpine",
},
},
},
SystemInterrupt: make(chan os.Signal, 1),
}
abortTimer := time.AfterFunc(time.Second, func() {
t.Log("Interrupt")
build.SystemInterrupt <- os.Interrupt
})
defer abortTimer.Stop()
timeoutTimer := time.AfterFunc(time.Minute, func() {
t.Log("Timedout")
t.FailNow()
})
defer timeoutTimer.Stop()
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
assert.EqualError(t, err, "aborted: interrupt")
}
func TestDockerCommandBuildCancel(t *testing.T) {
if helpers.SkipIntegrationTests(t, "docker", "info") {
return
}
build := &common.Build{
GetBuildResponse: common.LongRunningBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "docker",
Docker: &common.DockerConfig{
Image: "alpine",
},
},
},
}
trace := &common.Trace{Writer: os.Stdout, Abort: make(chan interface{}, 1)}
abortTimer := time.AfterFunc(time.Second, func() {
t.Log("Interrupt")
trace.Abort <- true
})
defer abortTimer.Stop()
timeoutTimer := time.AfterFunc(time.Minute, func() {
t.Log("Timedout")
t.FailNow()
})
defer timeoutTimer.Stop()
err := build.Run(&common.Config{}, trace)
assert.IsType(t, err, &common.BuildError{})
assert.EqualError(t, err, "canceled")
}
func TestVirtualBoxBuildAbort(t *testing.T) {
if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
return
}
build := &common.Build{
GetBuildResponse: common.LongRunningBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "virtualbox",
VirtualBox: &common.VirtualBoxConfig{
BaseName: vboxImage,
DisableSnapshots: true,
},
SSH: vboxSshConfig,
},
},
SystemInterrupt: make(chan os.Signal, 1),
}
abortTimer := time.AfterFunc(time.Second, func() {
t.Log("Interrupt")
build.SystemInterrupt <- os.Interrupt
})
defer abortTimer.Stop()
timeoutTimer := time.AfterFunc(time.Minute, func() {
t.Log("Timedout")
t.FailNow()
})
defer timeoutTimer.Stop()
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
assert.EqualError(t, err, "aborted: interrupt")
}
func TestPowerShellSuccessRun(t *testing.T) {
if helpers.SkipIntegrationTests(t, "powershell.exe") {
return
}
build := &common.Build{
GetBuildResponse: common.SuccessfulBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "shell",
Shell: "powershell",
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
assert.NoError(t, err)
}
func TestDockerCommandMissingImage(t *testing.T) {
if helpers.SkipIntegrationTests(t, "docker", "info") {
return
}
build := &common.Build{
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "docker",
Docker: &common.DockerConfig{
Image: "some/non-existing/image",
},
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
require.Error(t, err)
assert.Contains(t, err.Error(), "not found")
}
func TestDockerCommandSuccessRun(t *testing.T) {
if helpers.SkipIntegrationTests(t, "docker", "info") {
return
}
build := &common.Build{
GetBuildResponse: common.SuccessfulBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "docker",
Docker: &common.DockerConfig{
Image: "alpine",
},
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
assert.NoError(t, err)
}
func TestVirtualBoxMissingSSHCredentials(t *testing.T) {
if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
return
}
build := &common.Build{
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "virtualbox",
VirtualBox: &common.VirtualBoxConfig{
BaseName: "non-existing-image",
DisableSnapshots: true,
},
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
require.Error(t, err)
assert.Contains(t, err.Error(), "Missing SSH config")
}
func TestDockerCommandBuildFail(t *testing.T) {
if helpers.SkipIntegrationTests(t, "docker", "info") {
return
}
build := &common.Build{
GetBuildResponse: common.FailedBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "docker",
Docker: &common.DockerConfig{
Image: "alpine",
},
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
require.Error(t, err, "error")
assert.IsType(t, err, &common.BuildError{})
assert.Contains(t, err.Error(), "exit code 1")
}
func TestVirtualBoxSuccessRun(t *testing.T) {
if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
return
}
build := &common.Build{
GetBuildResponse: common.SuccessfulBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "virtualbox",
VirtualBox: &common.VirtualBoxConfig{
BaseName: vboxImage,
DisableSnapshots: true,
},
SSH: vboxSshConfig,
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
assert.NoError(t, err, "Make sure that you have done 'make -C tests/ubuntu virtualbox'")
}
func TestParallelsMissingImage(t *testing.T) {
if helpers.SkipIntegrationTests(t, prlCtl, "--version") {
return
}
build := &common.Build{
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "parallels",
Parallels: &common.ParallelsConfig{
BaseName: "non-existing-image",
DisableSnapshots: true,
},
SSH: prlSshConfig,
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
require.Error(t, err)
assert.Contains(t, err.Error(), "Could not find a registered machine named")
}
func TestParallelsSuccessRun(t *testing.T) {
if helpers.SkipIntegrationTests(t, prlCtl, "--version") {
return
}
build := &common.Build{
GetBuildResponse: common.SuccessfulBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "parallels",
Parallels: &common.ParallelsConfig{
BaseName: prlImage,
DisableSnapshots: true,
},
SSH: prlSshConfig,
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
assert.NoError(t, err, "Make sure that you have done 'make -C tests/ubuntu parallels'")
}
func TestVirtualBoxBuildCancel(t *testing.T) {
if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
return
}
build := &common.Build{
GetBuildResponse: common.LongRunningBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "virtualbox",
VirtualBox: &common.VirtualBoxConfig{
BaseName: vboxImage,
DisableSnapshots: true,
},
SSH: vboxSshConfig,
},
},
}
trace := &common.Trace{Writer: os.Stdout, Abort: make(chan interface{}, 1)}
abortTimer := time.AfterFunc(time.Second, func() {
t.Log("Interrupt")
trace.Abort <- true
})
defer abortTimer.Stop()
timeoutTimer := time.AfterFunc(time.Minute, func() {
t.Log("Timedout")
t.FailNow()
})
defer timeoutTimer.Stop()
err := build.Run(&common.Config{}, trace)
assert.IsType(t, err, &common.BuildError{})
assert.EqualError(t, err, "canceled")
}
func TestVirtualBoxBuildFail(t *testing.T) {
if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
return
}
build := &common.Build{
GetBuildResponse: common.FailedBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "virtualbox",
VirtualBox: &common.VirtualBoxConfig{
BaseName: vboxImage,
DisableSnapshots: true,
},
SSH: vboxSshConfig,
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
require.Error(t, err, "error")
assert.IsType(t, err, &common.BuildError{})
assert.Contains(t, err.Error(), "Process exited with: 1")
}
func TestParallelsBuildFail(t *testing.T) {
if helpers.SkipIntegrationTests(t, prlCtl, "--version") {
return
}
build := &common.Build{
GetBuildResponse: common.FailedBuild,
Runner: &common.RunnerConfig{
RunnerSettings: common.RunnerSettings{
Executor: "parallels",
Parallels: &common.ParallelsConfig{
BaseName: prlImage,
DisableSnapshots: true,
},
SSH: prlSshConfig,
},
},
}
err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
require.Error(t, err, "error")
assert.IsType(t, err, &common.BuildError{})
assert.Contains(t, err.Error(), "Process exited with: 1")
}
