opensourcemirror
/
concourse
mirror of https://github.com/concourse/concourse.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge pull request #4102 from concourse/topgun/4098 

topgun/k8s: refactor tests to support targeting PKS
This commit is contained in:
Ciro S. Costa 2019-07-17 12:47:39 -04:00 committed by GitHub
parent 4b19fa7866 759966f910
commit 48b9eacc57
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 143 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
topgun/k8s/baggageclaim_drivers_test.go
View File

@ -1,97 +1,98 @@
package k8s_test
import (
"github.com/onsi/gomega/gexec"
"time"
. "github.com/concourse/concourse/topgun"
. "github.com/onsi/ginkgo"
. "github.com/onsi/ginkgo/extensions/table"
. "github.com/onsi/gomega"
)
var _ = Describe("Baggageclaim Drivers", func() {
var (
proxySession *gexec.Session
atcEndpoint string
)
var _ = Describe("baggageclaim drivers", func() {
AfterEach(func() {
cleanup(releaseName, namespace, proxySession)
cleanup(releaseName, namespace, nil)
})
type Case struct {
Driver string
NodeImage string
ShouldWork bool
}
onPks(func() {
baggageclaimWorks("btrfs")
baggageclaimWorks("overlay")
baggageclaimWorks("naive")
})
DescribeTable("across different node images",
func(c Case) {
setReleaseNameAndNamespace("bd-" + c.Driver + "-" + c.NodeImage)
onGke(func() {
helmDeployTestFlags := []string{
"--set=concourse.web.kubernetes.enabled=false",
"--set=concourse.worker.baggageclaim.driver=" + c.Driver,
"--set=worker.nodeSelector.nodeImage=" + c.NodeImage,
"--set=worker.replicas=1",
}
const (
COS = "--set=worker.nodeSelector.nodeImage=cos"
UBUNTU = "--set=worker.nodeSelector.nodeImage=ubuntu"
)
deployConcourseChart(releaseName, helmDeployTestFlags...)
Context("cos image", func() {
baggageclaimFails("btrfs", COS)
baggageclaimWorks("overlay", COS)
baggageclaimWorks("naive", COS)
})
if !c.ShouldWork {
Eventually(func() []byte {
workerLogsSession := Start(nil, "kubectl", "logs",
"--namespace="+namespace, "-lapp="+namespace+"-worker")
<-workerLogsSession.Exited
Context("ubuntu image", func() {
baggageclaimWorks("btrfs", UBUNTU)
baggageclaimWorks("overlay", UBUNTU)
baggageclaimWorks("naive", UBUNTU)
})
return workerLogsSession.Out.Contents()
}).Should(ContainSubstring("failed-to-set-up-driver"))
return
}
})
})
func baggageclaimWorks(driver string, selectorFlags ...string) {
Context(driver, func() {
It("works", func() {
setReleaseNameAndNamespace("bd-" + driver)
deployWithDriverAndSelectors(driver, selectorFlags...)
waitAllPodsInNamespaceToBeReady(namespace)
By("Creating the web proxy")
proxySession, atcEndpoint = startPortForwarding(namespace, "service/"+releaseName+"-web", "8080")
_, atcEndpoint := startPortForwarding(namespace, "service/"+releaseName+"-web", "8080")
By("Logging in")
fly.Login("test", "test", atcEndpoint)
Eventually(func() []Worker {
return getRunningWorkers(fly.GetWorkers())
}, 2*time.Minute, 10*time.Second).
ShouldNot(HaveLen(0))
By("Setting and triggering a dumb pipeline")
fly.Run("set-pipeline", "-n", "-c", "../pipelines/get-task.yml", "-p", "some-pipeline")
fly.Run("unpause-pipeline", "-p", "some-pipeline")
fly.Run("trigger-job", "-w", "-j", "some-pipeline/simple-job")
},
Entry("with btrfs on cos", Case{
Driver: "btrfs",
NodeImage: "cos",
ShouldWork: false,
}),
Entry("with btrfs on ubuntu", Case{
Driver: "btrfs",
NodeImage: "ubuntu",
ShouldWork: true,
}),
Entry("with overlay on cos", Case{
Driver: "overlay",
NodeImage: "cos",
ShouldWork: true,
}),
Entry("with overlay on ubuntu", Case{
Driver: "overlay",
NodeImage: "ubuntu",
ShouldWork: true,
}),
Entry("with naive on cos", Case{
Driver: "naive",
NodeImage: "cos",
ShouldWork: true,
}),
Entry("with naive on ubuntu", Case{
Driver: "naive",
NodeImage: "ubuntu",
ShouldWork: true,
}),
)
})
})
})
}
func baggageclaimFails(driver string, selectorFlags ...string) {
Context(driver, func() {
It("fails", func() {
setReleaseNameAndNamespace("bd-" + driver)
deployWithDriverAndSelectors(driver, selectorFlags...)
Eventually(func() []byte {
workerLogsSession := Start(nil, "kubectl", "logs",
"--namespace="+namespace, "-lapp="+namespace+"-worker")
<-workerLogsSession.Exited
return workerLogsSession.Out.Contents()
}).Should(ContainSubstring("failed-to-set-up-driver"))
})
})
}
func deployWithDriverAndSelectors(driver string, selectorFlags ...string) {
helmDeployTestFlags := []string{
"--set=concourse.web.kubernetes.enabled=false",
"--set=concourse.worker.baggageclaim.driver=" + driver,
"--set=worker.replicas=1",
}
deployConcourseChart(releaseName, append(helmDeployTestFlags, selectorFlags...)...)
}

86
topgun/k8s/container_limits_test.go
View File

@ -4,7 +4,6 @@ import (
"time"
"github.com/onsi/gomega/gbytes"
"github.com/onsi/gomega/gexec"
. "github.com/concourse/concourse/topgun"
. "github.com/onsi/ginkgo"
@ -12,50 +11,62 @@ import (
)
var _ = Describe("Container Limits", func() {
var (
proxySession *gexec.Session
atcEndpoint string
nodeImage string
helmDeployTestFlags []string
const (
TaskCPULimit = "--set=concourse.web.defaultTaskCpuLimit=512"
TaskMemoryLimit = "--set=concourse.web.defaultTaskMemoryLimit=1GB"
COS = "--set=worker.nodeSelector.nodeImage=cos"
UBUNTU = "--set=worker.nodeSelector.nodeImage=ubuntu"
)
BeforeEach(func() {
setReleaseNameAndNamespace("cl")
})
JustBeforeEach(func() {
helmDeployTestFlags = []string{
`--set=worker.replicas=1`,
`--set=concourse.web.defaultTaskCpuLimit=512`,
`--set=concourse.web.defaultTaskMemoryLimit=1GB`,
"--set=worker.nodeSelector.nodeImage=" + nodeImage,
}
deployConcourseChart(releaseName, helmDeployTestFlags...)
onPks(func() {
containerLimitsWork(TaskCPULimit, TaskMemoryLimit)
})
waitAllPodsInNamespaceToBeReady(namespace)
By("Creating the web proxy")
proxySession, atcEndpoint = startPortForwarding(namespace, "service/"+releaseName+"-web", "8080")
By("Logging in")
fly.Login("test", "test", atcEndpoint)
Eventually(func() []Worker {
return getRunningWorkers(fly.GetWorkers())
}, 2*time.Minute, 10*time.Second).
ShouldNot(HaveLen(0))
onGke(func() {
containerLimitsWork(COS, TaskCPULimit, TaskMemoryLimit)
containerLimitsFail(UBUNTU, TaskCPULimit, TaskMemoryLimit)
})
AfterEach(func() {
cleanup(releaseName, namespace, proxySession)
cleanup(releaseName, namespace, nil)
})
Context("using cos as NodeImage", func() {
BeforeEach(func() {
nodeImage = "cos"
})
})
func waitAndLogin() {
waitAllPodsInNamespaceToBeReady(namespace)
By("Creating the web proxy")
_, atcEndpoint := startPortForwarding(namespace, "service/"+releaseName+"-web", "8080")
By("Logging in")
fly.Login("test", "test", atcEndpoint)
Eventually(func() []Worker {
return getRunningWorkers(fly.GetWorkers())
}, 2*time.Minute, 10*time.Second).
ShouldNot(HaveLen(0))
}
func deployWithSelectors(selectorFlags ...string) {
helmDeployTestFlags := []string{
"--set=concourse.web.kubernetes.enabled=false",
"--set=worker.replicas=1",
}
deployConcourseChart(releaseName, append(helmDeployTestFlags, selectorFlags...)...)
}
func containerLimitsWork(selectorFlags ...string) {
Context("container limits work", func() {
It("returns the configure default container limit", func() {
deployWithSelectors(selectorFlags...)
waitAndLogin()
buildSession := fly.Start("execute", "-c", "../tasks/tiny.yml")
<-buildSession.Exited
Expect(buildSession.ExitCode()).To(Equal(0))
@ -72,13 +83,13 @@ var _ = Describe("Container Limits", func() {
Expect(hijackSession).To(gbytes.Say("1073741824\n512"))
})
})
}
Context("using Ubuntu as NodeImage", func() {
BeforeEach(func() {
nodeImage = "ubuntu"
})
func containerLimitsFail(selectorFlags ...string) {
Context("container limits fail", func() {
It("fails to set the memory limit", func() {
deployWithSelectors(selectorFlags...)
waitAndLogin()
buildSession := fly.Start("execute", "-c", "../tasks/tiny.yml")
<-buildSession.Exited
Expect(buildSession.ExitCode()).To(Equal(2))
@ -87,5 +98,4 @@ var _ = Describe("Container Limits", func() {
Expect(buildSession).To(gbytes.Say("permission denied"))
})
})
})
}

27
topgun/k8s/k8s_suite_test.go
View File

@ -36,6 +36,7 @@ type environment struct {
ConcourseImageName string `env:"CONCOURSE_IMAGE_NAME,required"`
ConcourseImageTag string `env:"CONCOURSE_IMAGE_TAG"`
FlyPath string `env:"FLY_PATH"`
K8sEngine string `env:"K8S_ENGINE" envDefault:"GKE"`
}
var (
@ -283,3 +284,29 @@ func cleanup(releaseName, namespace string, proxySession *gexec.Session) {
Wait(proxySession.Interrupt())
}
}
func onPks(f func()) {
Context("PKS", func() {
BeforeEach(func() {
if Environment.K8sEngine != "PKS" {
Skip("not running on PKS")
}
})
f()
})
}
func onGke(f func()) {
Context("GKE", func() {
BeforeEach(func() {
if Environment.K8sEngine != "GKE" {
Skip("not running on GKE")
}
})
f()
})
}