Add unit tests for kubeadm upgrade

cmd/kubeadm/app/phases/selfhosting/podspec_mutation_test.go

@@ -73,7 +73,7 @@ func TestMutatePodSpec(t *testing.T) {
 	}
 
 	for _, rt := range tests {
-		mutatePodSpec(getDefaultMutators(), rt.component, rt.podSpec)
+		mutatePodSpec(GetDefaultMutators(), rt.component, rt.podSpec)
 
 		if !reflect.DeepEqual(*rt.podSpec, rt.expected) {
 			t.Errorf("failed mutatePodSpec:\nexpected:\n%v\nsaw:\n%v", rt.expected, *rt.podSpec)

cmd/kubeadm/app/phases/selfhosting/selfhosting_test.go

@@ -182,7 +182,8 @@ spec:
       - hostPath:
           path: /etc/pki
         name: ca-certs-etc-pki
-  updateStrategy: {}
+  updateStrategy:
+    type: RollingUpdate
 status:
   currentNumberScheduled: 0
   desiredNumberScheduled: 0
@@ -330,7 +331,8 @@ spec:
       - hostPath:
           path: /etc/pki
         name: ca-certs-etc-pki
-  updateStrategy: {}
+  updateStrategy:
+    type: RollingUpdate
 status:
   currentNumberScheduled: 0
   desiredNumberScheduled: 0
@@ -430,7 +432,8 @@ spec:
           path: /etc/kubernetes/scheduler.conf
           type: FileOrCreate
         name: kubeconfig
-  updateStrategy: {}
+  updateStrategy:
+    type: RollingUpdate
 status:
   currentNumberScheduled: 0
   desiredNumberScheduled: 0
@@ -471,7 +474,7 @@ func TestBuildDaemonSet(t *testing.T) {
 			t.Fatalf("couldn't load the specified Pod")
 		}
 
-		ds := buildDaemonSet(rt.component, podSpec, getDefaultMutators())
+		ds := BuildDaemonSet(rt.component, podSpec, GetDefaultMutators())
 		dsBytes, err := yaml.Marshal(ds)
 		if err != nil {
 			t.Fatalf("failed to marshal daemonset to YAML: %v", err)

cmd/kubeadm/app/phases/upgrade/policy_test.go

+/*
+Copyright 2017 The Kubernetes 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 upgrade
+
+import (
+	"testing"
+
+	"k8s.io/kubernetes/pkg/util/version"
+)
+
+func TestEnforceVersionPolicies(t *testing.T) {
+	tests := []struct {
+		vg                          *fakeVersionGetter
+		expectedMandatoryErrs       int
+		expectedSkippableErrs       int
+		allowExperimental, allowRCs bool
+		newK8sVersion               string
+	}{
+		{ // everything ok
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.7.5",
+			},
+			newK8sVersion: "v1.7.5",
+		},
+		{ // everything ok
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.2",
+				kubeadmVersion: "v1.8.1",
+			},
+			newK8sVersion: "v1.8.0",
+		},
+		{ // downgrades not supported
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.7.3",
+			},
+			newK8sVersion:         "v1.7.2",
+			expectedSkippableErrs: 1,
+		},
+		{ // upgrades without bumping the version number not supported yet. TODO: Change this?
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.7.3",
+			},
+			newK8sVersion:         "v1.7.3",
+			expectedSkippableErrs: 1,
+		},
+		{ // new version must be higher than v1.7.0
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.7.3",
+			},
+			newK8sVersion:         "v1.6.10",
+			expectedMandatoryErrs: 1, // version must be higher than v1.7.0
+			expectedSkippableErrs: 1, // version shouldn't be downgraded
+		},
+		{ // upgrading two minor versions in one go is not supported
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.9.0",
+			},
+			newK8sVersion:         "v1.9.0",
+			expectedMandatoryErrs: 1, // can't upgrade two minor versions
+			expectedSkippableErrs: 1, // kubelet <-> apiserver skew too large
+		},
+		{ // kubeadm version must be higher than the new kube version. However, patch version skews may be forced
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.7.3",
+			},
+			newK8sVersion:         "v1.7.5",
+			expectedSkippableErrs: 1,
+		},
+		{ // kubeadm version must be higher than the new kube version. Trying to upgrade k8s to a higher minor version than kubeadm itself should never be supported
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.7.3",
+			},
+			newK8sVersion:         "v1.8.0",
+			expectedMandatoryErrs: 1,
+		},
+		{ // the maximum skew between the cluster version and the kubelet versions should be one minor version. This may be forced through though.
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.6.8",
+				kubeadmVersion: "v1.8.0",
+			},
+			newK8sVersion:         "v1.8.0",
+			expectedSkippableErrs: 1,
+		},
+		{ // experimental upgrades supported if the flag is set
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.8.0-beta.1",
+			},
+			newK8sVersion:     "v1.8.0-beta.1",
+			allowExperimental: true,
+		},
+		{ // release candidate upgrades supported if the flag is set
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.8.0-rc.1",
+			},
+			newK8sVersion: "v1.8.0-rc.1",
+			allowRCs:      true,
+		},
+		{ // release candidate upgrades supported if the flag is set
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.8.0-rc.1",
+			},
+			newK8sVersion:     "v1.8.0-rc.1",
+			allowExperimental: true,
+		},
+		{ // the user should not be able to upgrade to an experimental version if they haven't opted into that
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.8.0-beta.1",
+			},
+			newK8sVersion:         "v1.8.0-beta.1",
+			allowRCs:              true,
+			expectedSkippableErrs: 1,
+		},
+		{ // the user should not be able to upgrade to an release candidate version if they haven't opted into that
+			vg: &fakeVersionGetter{
+				clusterVersion: "v1.7.3",
+				kubeletVersion: "v1.7.3",
+				kubeadmVersion: "v1.8.0-rc.1",
+			},
+			newK8sVersion:         "v1.8.0-rc.1",
+			expectedSkippableErrs: 1,
+		},
+	}
+
+	for _, rt := range tests {
+
+		newK8sVer, err := version.ParseSemantic(rt.newK8sVersion)
+		if err != nil {
+			t.Fatalf("couldn't parse version %s: %v", rt.newK8sVersion, err)
+		}
+
+		actualSkewErrs := EnforceVersionPolicies(rt.vg, rt.newK8sVersion, newK8sVer, rt.allowExperimental, rt.allowRCs)
+		if actualSkewErrs == nil {
+			// No errors were seen. Report unit test failure if we expected to see errors
+			if rt.expectedMandatoryErrs+rt.expectedSkippableErrs > 0 {
+				t.Errorf("failed TestEnforceVersionPolicies\n\texpected errors but got none")
+			}
+			// Otherwise, just move on with the next test
+			continue
+		}
+
+		if len(actualSkewErrs.Skippable) != rt.expectedSkippableErrs {
+			t.Errorf("failed TestEnforceVersionPolicies\n\texpected skippable errors: %d\n\tgot skippable errors: %d %v", rt.expectedSkippableErrs, len(actualSkewErrs.Skippable), *rt.vg)
+		}
+		if len(actualSkewErrs.Mandatory) != rt.expectedMandatoryErrs {
+			t.Errorf("failed TestEnforceVersionPolicies\n\texpected mandatory errors: %d\n\tgot mandatory errors: %d %v", rt.expectedMandatoryErrs, len(actualSkewErrs.Mandatory), *rt.vg)
+		}
+	}
+}

cmd/kubeadm/app/phases/upgrade/prepull_test.go

+/*
+Copyright 2017 The Kubernetes 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 upgrade
+
+import (
+	"fmt"
+	"testing"
+	"time"
+	//"k8s.io/kubernetes/pkg/util/version"
+)
+
+// failedCreatePrepuller is a fake prepuller that errors for kube-controller-manager in the CreateFunc call
+type failedCreatePrepuller struct{}
+
+func NewFailedCreatePrepuller() Prepuller {
+	return &failedCreatePrepuller{}
+}
+
+func (p *failedCreatePrepuller) CreateFunc(component string) error {
+	if component == "kube-controller-manager" {
+		return fmt.Errorf("boo")
+	}
+	return nil
+}
+
+func (p *failedCreatePrepuller) WaitFunc(component string) {}
+
+func (p *failedCreatePrepuller) DeleteFunc(component string) error {
+	return nil
+}
+
+// foreverWaitPrepuller is a fake prepuller that basically waits "forever" (10 mins, but longer than the 10sec timeout)
+type foreverWaitPrepuller struct{}
+
+func NewForeverWaitPrepuller() Prepuller {
+	return &foreverWaitPrepuller{}
+}
+
+func (p *foreverWaitPrepuller) CreateFunc(component string) error {
+	return nil
+}
+
+func (p *foreverWaitPrepuller) WaitFunc(component string) {
+	time.Sleep(10 * time.Minute)
+}
+
+func (p *foreverWaitPrepuller) DeleteFunc(component string) error {
+	return nil
+}
+
+// failedDeletePrepuller is a fake prepuller that errors for kube-scheduler in the DeleteFunc call
+type failedDeletePrepuller struct{}
+
+func NewFailedDeletePrepuller() Prepuller {
+	return &failedDeletePrepuller{}
+}
+
+func (p *failedDeletePrepuller) CreateFunc(component string) error {
+	return nil
+}
+
+func (p *failedDeletePrepuller) WaitFunc(component string) {}
+
+func (p *failedDeletePrepuller) DeleteFunc(component string) error {
+	if component == "kube-scheduler" {
+		return fmt.Errorf("boo")
+	}
+	return nil
+}
+
+// goodPrepuller is a fake prepuller that works as expected
+type goodPrepuller struct{}
+
+func NewGoodPrepuller() Prepuller {
+	return &goodPrepuller{}
+}
+
+func (p *goodPrepuller) CreateFunc(component string) error {
+	time.Sleep(300 * time.Millisecond)
+	return nil
+}
+
+func (p *goodPrepuller) WaitFunc(component string) {
+	time.Sleep(300 * time.Millisecond)
+}
+
+func (p *goodPrepuller) DeleteFunc(component string) error {
+	time.Sleep(300 * time.Millisecond)
+	return nil
+}
+
+func TestPrepullImagesInParallel(t *testing.T) {
+	tests := []struct {
+		p           Prepuller
+		timeout     time.Duration
+		expectedErr bool
+	}{
+		{ // should error out; create failed
+			p:           NewFailedCreatePrepuller(),
+			timeout:     10 * time.Second,
+			expectedErr: true,
+		},
+		{ // should error out; timeout exceeded
+			p:           NewForeverWaitPrepuller(),
+			timeout:     10 * time.Second,
+			expectedErr: true,
+		},
+		{ // should error out; delete failed
+			p:           NewFailedDeletePrepuller(),
+			timeout:     10 * time.Second,
+			expectedErr: true,
+		},
+		{ // should work just fine
+			p:           NewGoodPrepuller(),
+			timeout:     10 * time.Second,
+			expectedErr: false,
+		},
+	}
+
+	for _, rt := range tests {
+
+		actualErr := PrepullImagesInParallel(rt.p, rt.timeout)
+		if (actualErr != nil) != rt.expectedErr {
+			t.Errorf(
+				"failed TestPrepullImagesInParallel\n\texpected error: %t\n\tgot: %t",
+				rt.expectedErr,
+				(actualErr != nil),
+			)
+		}
+	}
+}