Change:
Part of issue Re-write test in Go, generate unique names for top level resources, ensure test is idempotent, clean up all resources at end of test.
I was just glancing at this test to see how crunchy it was to port. One of the sad things would be abandoning , so if we do port this, I think we should definitely go through the to make sure it stays tested.
That reminds me... Do we have an issue yet to add an e2e test to specifically test kubectl?
We do now:
Thanks.
I am unassigning myself from this for now. I expect to be working on the fixit for cluster level logging for several days so I'd rather not have this assigned to me while I can't give it attention. If it is still open later then I may try to take a crack at it.

Discussion:
# Launches an nginx container and verifies it can be reached. Assumes that # we're being called by hack/e2e-test.sh (we use some env vars it sets up). <ins> # TODO: remove this once test/e2e/kubectl.go is green in jenkins </ins> set -o errexit set -o nounset set -o pipefail

<ins> /* Copyright 2015 Google Inc. All rights reserved. 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 e2e import ( "bytes" "encoding/json" "fmt" "io/ioutil" "net/http" "os/exec" "path/filepath" "strings" "time" . "github.com/onsi/ginkgo" ) const ( nautilusImage       = "kubernetes/update-demo:nautilus" kittenImage         = "kubernetes/update-demo:kitten" updateDemoSelector  = "name=update-demo" updateDemoContainer = "update-demo" ) var _ = Describe("kubectl", func() { updateDemoRoot := filepath.Join(root, "examples/update-demo") nautilusPath := filepath.Join(updateDemoRoot, "nautilus-rc.yaml") kittenPath := filepath.Join(updateDemoRoot, "kitten-rc.yaml") It("should create and stop a replication controller", func() { defer cleanup(nautilusPath) By("creating a replication controller") runKubectl("create", "-f", nautilusPath) validateController(nautilusImage, 2, 30*time.Second) }) It("should scale a replication controller", func() { defer cleanup(nautilusPath) By("creating a replication controller") runKubectl("create", "-f", nautilusPath) validateController(nautilusImage, 2, 30*time.Second) By("scaling down the replication controller") runKubectl("resize", "rc", "update-demo-nautilus", "--replicas=1") validateController(nautilusImage, 1, 30*time.Second) By("scaling up the replication controller") runKubectl("resize", "rc", "update-demo-nautilus", "--replicas=2") validateController(nautilusImage, 2, 30*time.Second) }) It("should do a rolling update of a replication controller", func() { // Cleanup all resources in case we fail somewhere in the middle defer cleanup(updateDemoRoot) By("creating the initial replication controller") runKubectl("create", "-f", nautilusPath) validateController(nautilusImage, 2, 30*time.Second) By("rollingupdate to new replication controller") runKubectl("rollingupdate", "update-demo-nautilus", "--update-period=1s", "-f", kittenPath) validateController(kittenImage, 2, 30*time.Second) }) }) func cleanup(filePath string) { By("using stop to clean up resources") runKubectl("stop", "-f", filePath) resources := runKubectl("get", "pods,rc", "-l", updateDemoSelector, "--no-headers") if resources != "" { Failf("Resources left running after stop:n%s", resources) } } func validateController(image string, replicas int, timeout time.Duration) { getPodsTemplate := "--template={{range.items}}{{.id}} {{end}}" // NB: kubectl adds the "exists" function to the standard template functions. // This lets us check to see if the "running" entry exists for each of the containers // we care about. Exists will never return an error and it's safe to check a chain of // things, any one of which may not exist. In the below template, all of info, // containername, and running might be nil, so the normal index function isn't very // helpful. // This template is unit-tested in kubectl, so if you change it, update the unit test. // // You can read about the syntax here: http://golang.org/pkg/text/template/ getContainerStateTemplate := fmt.Sprintf(`--template={{and (exists . "currentState" "info" "%s" "state" "running")}}`, updateDemoContainer) getImageTemplate := fmt.Sprintf(`--template={{(index .currentState.info "%s").image}}`, updateDemoContainer) getHostIPTemplate := "--template={{.currentState.hostIP}}" By(fmt.Sprintf("waiting for all containers in %s pods to come up.", updateDemoSelector)) for start := time.Now(); time.Since(start) < timeout; time.Sleep(5 * time.Second) { getPodsOutput := runKubectl("get", "pods", "-o", "template", getPodsTemplate, "-l", updateDemoSelector) pods := strings.Fields(getPodsOutput) if numPods := len(pods); numPods != replicas { By(fmt.Sprintf("Replicas for %s: expected=%d actual=%d", updateDemoSelector, replicas, numPods)) continue } var runningPods []string for _, podId := range pods { running := runKubectl("get", "pods", podId, "-o", "template", getContainerStateTemplate) if running == "false" { By(fmt.Sprintf("%s is created but not running", podId)) continue } currentImage := runKubectl("get", "pods", podId, "-o", "template", getImageTemplate) if currentImage != image { By(fmt.Sprintf("%s is created but running wrong image; expected: %s, actual: %s", podId, image, currentImage)) continue } hostIP := runKubectl("get", "pods", podId, "-o", "template", getHostIPTemplate) data, err := getData(hostIP) if err != nil { By(fmt.Sprintf("%s is running right image but fetching data failed: %v", podId, err)) continue } if strings.Contains(data.image, image) { By(fmt.Sprintf("%s is running right image but fetched data has the wrong info: %s", podId, data)) continue } Logf("%s is verified up and running", podId) runningPods = append(runningPods, podId) } if len(runningPods) == replicas { return } } Failf("Timed out waiting for %s pods to reach valid state", updateDemoSelector) } type updateDemoData struct { image string `json:"image"` } func getData(hostIP string) (*updateDemoData, error) { addr := fmt.Sprintf("http://%s:8080/data.json", hostIP) resp, err := http.Get(fmt.Sprintf(addr)) if err != nil || resp.StatusCode != 200 { return nil, err } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { return nil, err } Logf("got data: %s", body) var data updateDemoData err = json.Unmarshal(body, &data) return &data, err } func runKubectl(args ...string) string { // TODO: use kubectl binary directly instead of shell wrapper path := filepath.Join(root, "cluster/kubectl.sh") cmdStr := path + " " + strings.Join(args, " ") Logf("Running '%v'", cmdStr) cmd := exec.Command(path, args...) var stdout, stderr bytes.Buffer cmd.Stdout = &stdout cmd.Stderr = &stderr if err := cmd.Run(); err != nil { Failf("Error running %v:nCommand stdout:n%vnstderr:n%vn", cmd, cmd.Stdout, cmd.Stderr) return "" } Logf(stdout.String()) return stdout.String() } </ins>