Merge pull request #36021 from soltysh/cronjobs

Automatic merge from submit-queue

Rename ScheduledJobs to CronJobs

I went with @smarterclayton idea of registering named types in schema. This way we can support both the new (CronJobs) and old (ScheduledJobs) resource name. Fixes #32150.

fyi @erictune @caesarxuchao @janetkuo 

Not ready yet, but getting close there...

**Release note**:
```release-note
Rename ScheduledJobs to CronJobs.
```

test/e2e/BUILD

@@ -22,6 +22,7 @@ go_library(
         "cluster_logging_utils.go",
         "cluster_size_autoscaling.go",
         "cluster_upgrade.go",
+        "cronjob.go",
         "daemon_restart.go",
         "daemon_set.go",
         "dashboard.go",
@@ -91,7 +92,6 @@ go_library(
         "resize_nodes.go",
         "resource_quota.go",
         "restart.go",
-        "scheduledjob.go",
         "scheduler_predicates.go",
         "security_context.go",
         "service.go",

test/e2e/cronjob.go

@@ -33,31 +33,32 @@ import (
 )
 
 const (
-	// How long to wait for a scheduledjob
-	scheduledJobTimeout = 5 * time.Minute
+	// How long to wait for a cronjob
+	cronJobTimeout = 5 * time.Minute
 )
 
 var (
+	CronJobGroupVersionResource      = unversioned.GroupVersionResource{Group: batch.GroupName, Version: "v2alpha1", Resource: "cronjobs"}
 	ScheduledJobGroupVersionResource = unversioned.GroupVersionResource{Group: batch.GroupName, Version: "v2alpha1", Resource: "scheduledjobs"}
 	BatchV2Alpha1GroupVersion        = unversioned.GroupVersion{Group: batch.GroupName, Version: "v2alpha1"}
 )
 
-var _ = framework.KubeDescribe("ScheduledJob", func() {
-	f := framework.NewDefaultGroupVersionFramework("scheduledjob", BatchV2Alpha1GroupVersion)
+var _ = framework.KubeDescribe("CronJob", func() {
+	f := framework.NewDefaultGroupVersionFramework("cronjob", BatchV2Alpha1GroupVersion)
 
 	BeforeEach(func() {
-		framework.SkipIfMissingResource(f.ClientPool, ScheduledJobGroupVersionResource, f.Namespace.Name)
+		framework.SkipIfMissingResource(f.ClientPool, CronJobGroupVersionResource, f.Namespace.Name)
 	})
 
 	// multiple jobs running at once
 	It("should schedule multiple jobs concurrently", func() {
-		By("Creating a scheduledjob")
-		scheduledJob := newTestScheduledJob("concurrent", "*/1 * * * ?", batch.AllowConcurrent, true)
-		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
+		By("Creating a cronjob")
+		cronJob := newTestCronJob("concurrent", "*/1 * * * ?", batch.AllowConcurrent, true)
+		cronJob, err := createCronJob(f.ClientSet, f.Namespace.Name, cronJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring more than one job is running at a time")
-		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name, 2)
+		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, cronJob.Name, 2)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring at least two running jobs exists by listing jobs explicitly")
@@ -66,21 +67,21 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 		activeJobs := filterActiveJobs(jobs)
 		Expect(len(activeJobs) >= 2).To(BeTrue())
 
-		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
+		By("Removing cronjob")
+		err = deleteCronJob(f.ClientSet, f.Namespace.Name, cronJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	// suspended should not schedule jobs
 	It("should not schedule jobs when suspended [Slow]", func() {
-		By("Creating a suspended scheduledjob")
-		scheduledJob := newTestScheduledJob("suspended", "*/1 * * * ?", batch.AllowConcurrent, true)
-		scheduledJob.Spec.Suspend = newBool(true)
-		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
+		By("Creating a suspended cronjob")
+		cronJob := newTestCronJob("suspended", "*/1 * * * ?", batch.AllowConcurrent, true)
+		cronJob.Spec.Suspend = newBool(true)
+		cronJob, err := createCronJob(f.ClientSet, f.Namespace.Name, cronJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring no jobs are scheduled")
-		err = waitForNoJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
+		err = waitForNoJobs(f.ClientSet, f.Namespace.Name, cronJob.Name)
 		Expect(err).To(HaveOccurred())
 
 		By("Ensuring no job exists by listing jobs explicitly")
@@ -88,26 +89,26 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 		Expect(err).NotTo(HaveOccurred())
 		Expect(jobs.Items).To(HaveLen(0))
 
-		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
+		By("Removing cronjob")
+		err = deleteCronJob(f.ClientSet, f.Namespace.Name, cronJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	// only single active job is allowed for ForbidConcurrent
 	It("should not schedule new jobs when ForbidConcurrent [Slow]", func() {
-		By("Creating a ForbidConcurrent scheduledjob")
-		scheduledJob := newTestScheduledJob("forbid", "*/1 * * * ?", batch.ForbidConcurrent, true)
-		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
+		By("Creating a ForbidConcurrent cronjob")
+		cronJob := newTestCronJob("forbid", "*/1 * * * ?", batch.ForbidConcurrent, true)
+		cronJob, err := createCronJob(f.ClientSet, f.Namespace.Name, cronJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring a job is scheduled")
-		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name, 1)
+		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, cronJob.Name, 1)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring exactly one is scheduled")
-		scheduledJob, err = getScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
+		cronJob, err = getCronJob(f.ClientSet, f.Namespace.Name, cronJob.Name)
 		Expect(err).NotTo(HaveOccurred())
-		Expect(scheduledJob.Status.Active).Should(HaveLen(1))
+		Expect(cronJob.Status.Active).Should(HaveLen(1))
 
 		By("Ensuring exaclty one running job exists by listing jobs explicitly")
 		jobs, err := f.ClientSet.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
@@ -116,29 +117,29 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 		Expect(activeJobs).To(HaveLen(1))
 
 		By("Ensuring no more jobs are scheduled")
-		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name, 2)
+		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, cronJob.Name, 2)
 		Expect(err).To(HaveOccurred())
 
-		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
+		By("Removing cronjob")
+		err = deleteCronJob(f.ClientSet, f.Namespace.Name, cronJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	// only single active job is allowed for ReplaceConcurrent
 	It("should replace jobs when ReplaceConcurrent", func() {
-		By("Creating a ReplaceConcurrent scheduledjob")
-		scheduledJob := newTestScheduledJob("replace", "*/1 * * * ?", batch.ReplaceConcurrent, true)
-		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
+		By("Creating a ReplaceConcurrent cronjob")
+		cronJob := newTestCronJob("replace", "*/1 * * * ?", batch.ReplaceConcurrent, true)
+		cronJob, err := createCronJob(f.ClientSet, f.Namespace.Name, cronJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring a job is scheduled")
-		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name, 1)
+		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, cronJob.Name, 1)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring exactly one is scheduled")
-		scheduledJob, err = getScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
+		cronJob, err = getCronJob(f.ClientSet, f.Namespace.Name, cronJob.Name)
 		Expect(err).NotTo(HaveOccurred())
-		Expect(scheduledJob.Status.Active).Should(HaveLen(1))
+		Expect(cronJob.Status.Active).Should(HaveLen(1))
 
 		By("Ensuring exaclty one running job exists by listing jobs explicitly")
 		jobs, err := f.ClientSet.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
@@ -150,16 +151,16 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 		err = waitForJobReplaced(f.ClientSet, f.Namespace.Name, jobs.Items[0].Name)
 		Expect(err).NotTo(HaveOccurred())
 
-		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
+		By("Removing cronjob")
+		err = deleteCronJob(f.ClientSet, f.Namespace.Name, cronJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	// shouldn't give us unexpected warnings
 	It("should not emit unexpected warnings", func() {
-		By("Creating a scheduledjob")
-		scheduledJob := newTestScheduledJob("concurrent", "*/1 * * * ?", batch.AllowConcurrent, false)
-		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
+		By("Creating a cronjob")
+		cronJob := newTestCronJob("concurrent", "*/1 * * * ?", batch.AllowConcurrent, false)
+		cronJob, err := createCronJob(f.ClientSet, f.Namespace.Name, cronJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring at least two jobs and at least one finished job exists by listing jobs explicitly")
@@ -169,24 +170,24 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring no unexpected event has happened")
-		err = checkNoUnexpectedEvents(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
+		err = checkNoUnexpectedEvents(f.ClientSet, f.Namespace.Name, cronJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 
-		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
+		By("Removing cronjob")
+		err = deleteCronJob(f.ClientSet, f.Namespace.Name, cronJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 })
 
-// newTestScheduledJob returns a scheduledjob which does one of several testing behaviors.
-func newTestScheduledJob(name, schedule string, concurrencyPolicy batch.ConcurrencyPolicy, sleep bool) *batch.ScheduledJob {
+// newTestCronJob returns a cronjob which does one of several testing behaviors.
+func newTestCronJob(name, schedule string, concurrencyPolicy batch.ConcurrencyPolicy, sleep bool) *batch.CronJob {
 	parallelism := int32(1)
 	completions := int32(1)
-	sj := &batch.ScheduledJob{
+	sj := &batch.CronJob{
 		ObjectMeta: api.ObjectMeta{
 			Name: name,
 		},
-		Spec: batch.ScheduledJobSpec{
+		Spec: batch.CronJobSpec{
 			Schedule:          schedule,
 			ConcurrencyPolicy: concurrencyPolicy,
 			JobTemplate: batch.JobTemplateSpec{
@@ -228,22 +229,22 @@ func newTestScheduledJob(name, schedule string, concurrencyPolicy batch.Concurre
 	return sj
 }
 
-func createScheduledJob(c clientset.Interface, ns string, scheduledJob *batch.ScheduledJob) (*batch.ScheduledJob, error) {
-	return c.Batch().ScheduledJobs(ns).Create(scheduledJob)
+func createCronJob(c clientset.Interface, ns string, cronJob *batch.CronJob) (*batch.CronJob, error) {
+	return c.Batch().CronJobs(ns).Create(cronJob)
 }
 
-func getScheduledJob(c clientset.Interface, ns, name string) (*batch.ScheduledJob, error) {
-	return c.Batch().ScheduledJobs(ns).Get(name)
+func getCronJob(c clientset.Interface, ns, name string) (*batch.CronJob, error) {
+	return c.Batch().CronJobs(ns).Get(name)
 }
 
-func deleteScheduledJob(c clientset.Interface, ns, name string) error {
-	return c.Batch().ScheduledJobs(ns).Delete(name, nil)
+func deleteCronJob(c clientset.Interface, ns, name string) error {
+	return c.Batch().CronJobs(ns).Delete(name, nil)
 }
 
 // Wait for at least given amount of active jobs.
-func waitForActiveJobs(c clientset.Interface, ns, scheduledJobName string, active int) error {
-	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
-		curr, err := c.Batch().ScheduledJobs(ns).Get(scheduledJobName)
+func waitForActiveJobs(c clientset.Interface, ns, cronJobName string, active int) error {
+	return wait.Poll(framework.Poll, cronJobTimeout, func() (bool, error) {
+		curr, err := c.Batch().CronJobs(ns).Get(cronJobName)
 		if err != nil {
 			return false, err
 		}
@@ -253,8 +254,8 @@ func waitForActiveJobs(c clientset.Interface, ns, scheduledJobName string, activ
 
 // Wait for no jobs to appear.
 func waitForNoJobs(c clientset.Interface, ns, jobName string) error {
-	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
-		curr, err := c.Batch().ScheduledJobs(ns).Get(jobName)
+	return wait.Poll(framework.Poll, cronJobTimeout, func() (bool, error) {
+		curr, err := c.Batch().CronJobs(ns).Get(jobName)
 		if err != nil {
 			return false, err
 		}
@@ -265,7 +266,7 @@ func waitForNoJobs(c clientset.Interface, ns, jobName string) error {
 
 // Wait for a job to be replaced with a new one.
 func waitForJobReplaced(c clientset.Interface, ns, previousJobName string) error {
-	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
+	return wait.Poll(framework.Poll, cronJobTimeout, func() (bool, error) {
 		jobs, err := c.Batch().Jobs(ns).List(api.ListOptions{})
 		if err != nil {
 			return false, err
@@ -282,7 +283,7 @@ func waitForJobReplaced(c clientset.Interface, ns, previousJobName string) error
 
 // waitForJobsAtLeast waits for at least a number of jobs to appear.
 func waitForJobsAtLeast(c clientset.Interface, ns string, atLeast int) error {
-	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
+	return wait.Poll(framework.Poll, cronJobTimeout, func() (bool, error) {
 		jobs, err := c.Batch().Jobs(ns).List(api.ListOptions{})
 		if err != nil {
 			return false, err
@@ -293,7 +294,7 @@ func waitForJobsAtLeast(c clientset.Interface, ns string, atLeast int) error {
 
 // waitForAnyFinishedJob waits for any completed job to appear.
 func waitForAnyFinishedJob(c clientset.Interface, ns string) error {
-	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
+	return wait.Poll(framework.Poll, cronJobTimeout, func() (bool, error) {
 		jobs, err := c.Batch().Jobs(ns).List(api.ListOptions{})
 		if err != nil {
 			return false, err
@@ -309,10 +310,10 @@ func waitForAnyFinishedJob(c clientset.Interface, ns string) error {
 
 // checkNoUnexpectedEvents checks unexpected events didn't happen.
 // Currently only "UnexpectedJob" is checked.
-func checkNoUnexpectedEvents(c clientset.Interface, ns, scheduledJobName string) error {
-	sj, err := c.Batch().ScheduledJobs(ns).Get(scheduledJobName)
+func checkNoUnexpectedEvents(c clientset.Interface, ns, cronJobName string) error {
+	sj, err := c.Batch().CronJobs(ns).Get(cronJobName)
 	if err != nil {
-		return fmt.Errorf("error in getting scheduledjob %s/%s: %v", ns, scheduledJobName, err)
+		return fmt.Errorf("error in getting cronjob %s/%s: %v", ns, cronJobName, err)
 	}
 	events, err := c.Core().Events(ns).Search(sj)
 	if err != nil {

test/e2e/generated_clientset.go

@@ -188,17 +188,17 @@ var _ = framework.KubeDescribe("Generated release_1_5 clientset", func() {
 	})
 })
 
-func newTestingScheduledJob(name string, value string) *v2alpha1.ScheduledJob {
+func newTestingCronJob(name string, value string) *v2alpha1.CronJob {
 	parallelism := int32(1)
 	completions := int32(1)
-	return &v2alpha1.ScheduledJob{
+	return &v2alpha1.CronJob{
 		ObjectMeta: v1.ObjectMeta{
 			Name: name,
 			Labels: map[string]string{
 				"time": value,
 			},
 		},
-		Spec: v2alpha1.ScheduledJobSpec{
+		Spec: v2alpha1.CronJobSpec{
 			Schedule:          "*/1 * * * ?",
 			ConcurrencyPolicy: v2alpha1.AllowConcurrent,
 			JobTemplate: v2alpha1.JobTemplateSpec{
@@ -238,7 +238,7 @@ func newTestingScheduledJob(name string, value string) *v2alpha1.ScheduledJob {
 
 var _ = framework.KubeDescribe("Generated release_1_5 clientset", func() {
 	f := framework.NewDefaultFramework("clientset")
-	It("should create v2alpha1 scheduleJobs, delete scheduleJobs, watch scheduleJobs", func() {
+	It("should create v2alpha1 cronJobs, delete cronJobs, watch cronJobs", func() {
 		var enabled bool
 		groupList, err := f.ClientSet_1_5.Discovery().ServerGroups()
 		ExpectNoError(err)
@@ -256,59 +256,59 @@ var _ = framework.KubeDescribe("Generated release_1_5 clientset", func() {
 			framework.Logf("%s is not enabled, test skipped", v2alpha1.SchemeGroupVersion)
 			return
 		}
-		scheduleJobClient := f.ClientSet_1_5.BatchV2alpha1().ScheduledJobs(f.Namespace.Name)
-		By("constructing the scheduledJob")
-		name := "scheduledjob" + string(uuid.NewUUID())
+		cronJobClient := f.ClientSet_1_5.BatchV2alpha1().CronJobs(f.Namespace.Name)
+		By("constructing the cronJob")
+		name := "cronjob" + string(uuid.NewUUID())
 		value := strconv.Itoa(time.Now().Nanosecond())
-		scheduledJob := newTestingScheduledJob(name, value)
+		cronJob := newTestingCronJob(name, value)
 		By("setting up watch")
 		selector := labels.SelectorFromSet(labels.Set(map[string]string{"time": value})).String()
 		options := v1.ListOptions{LabelSelector: selector}
-		scheduleJobs, err := scheduleJobClient.List(options)
+		cronJobs, err := cronJobClient.List(options)
 		if err != nil {
-			framework.Failf("Failed to query for scheduleJobs: %v", err)
+			framework.Failf("Failed to query for cronJobs: %v", err)
 		}
-		Expect(len(scheduleJobs.Items)).To(Equal(0))
+		Expect(len(cronJobs.Items)).To(Equal(0))
 		options = v1.ListOptions{
 			LabelSelector:   selector,
-			ResourceVersion: scheduleJobs.ListMeta.ResourceVersion,
+			ResourceVersion: cronJobs.ListMeta.ResourceVersion,
 		}
-		w, err := scheduleJobClient.Watch(options)
+		w, err := cronJobClient.Watch(options)
 		if err != nil {
 			framework.Failf("Failed to set up watch: %v", err)
 		}
 
-		By("creating the scheduledJob")
-		scheduledJob, err = scheduleJobClient.Create(scheduledJob)
+		By("creating the cronJob")
+		cronJob, err = cronJobClient.Create(cronJob)
 		if err != nil {
-			framework.Failf("Failed to create scheduledJob: %v", err)
+			framework.Failf("Failed to create cronJob: %v", err)
 		}
 
-		By("verifying the scheduledJob is in kubernetes")
+		By("verifying the cronJob is in kubernetes")
 		options = v1.ListOptions{
 			LabelSelector:   selector,
-			ResourceVersion: scheduledJob.ResourceVersion,
+			ResourceVersion: cronJob.ResourceVersion,
 		}
-		scheduleJobs, err = scheduleJobClient.List(options)
+		cronJobs, err = cronJobClient.List(options)
 		if err != nil {
-			framework.Failf("Failed to query for scheduleJobs: %v", err)
+			framework.Failf("Failed to query for cronJobs: %v", err)
 		}
-		Expect(len(scheduleJobs.Items)).To(Equal(1))
+		Expect(len(cronJobs.Items)).To(Equal(1))
 
-		By("verifying scheduledJob creation was observed")
+		By("verifying cronJob creation was observed")
 		observeCreation(w)
 
-		By("deleting the scheduledJob")
-		if err := scheduleJobClient.Delete(scheduledJob.Name, nil); err != nil {
-			framework.Failf("Failed to delete scheduledJob: %v", err)
+		By("deleting the cronJob")
+		if err := cronJobClient.Delete(cronJob.Name, nil); err != nil {
+			framework.Failf("Failed to delete cronJob: %v", err)
 		}
 
 		options = v1.ListOptions{LabelSelector: selector}
-		scheduleJobs, err = scheduleJobClient.List(options)
+		cronJobs, err = cronJobClient.List(options)
 		if err != nil {
-			framework.Failf("Failed to list scheduleJobs to verify deletion: %v", err)
+			framework.Failf("Failed to list cronJobs to verify deletion: %v", err)
 		}
-		Expect(len(scheduleJobs.Items)).To(Equal(0))
+		Expect(len(cronJobs.Items)).To(Equal(0))
 	})
 })
 

test/e2e/kubectl.go

@@ -193,7 +193,7 @@ var _ = framework.KubeDescribe("Kubectl alpha client", func() {
 		})
 
 		AfterEach(func() {
-			framework.RunKubectlOrDie("delete", "scheduledjobs", sjName, nsFlag)
+			framework.RunKubectlOrDie("delete", "cronjobs", sjName, nsFlag)
 		})
 
 		It("should create a ScheduledJob", func() {
@@ -203,7 +203,7 @@ var _ = framework.KubeDescribe("Kubectl alpha client", func() {
 			framework.RunKubectlOrDie("run", sjName, "--restart=OnFailure", "--generator=scheduledjob/v2alpha1",
 				"--schedule="+schedule, "--image="+busyboxImage, nsFlag)
 			By("verifying the ScheduledJob " + sjName + " was created")
-			sj, err := c.Batch().ScheduledJobs(ns).Get(sjName)
+			sj, err := c.Batch().CronJobs(ns).Get(sjName)
 			if err != nil {
 				framework.Failf("Failed getting ScheduledJob %s: %v", sjName, err)
 			}
@@ -219,6 +219,43 @@ var _ = framework.KubeDescribe("Kubectl alpha client", func() {
 			}
 		})
 	})
+
+	framework.KubeDescribe("Kubectl run CronJob", func() {
+		var nsFlag string
+		var cjName string
+
+		BeforeEach(func() {
+			nsFlag = fmt.Sprintf("--namespace=%v", ns)
+			cjName = "e2e-test-echo-cronjob"
+		})
+
+		AfterEach(func() {
+			framework.RunKubectlOrDie("delete", "cronjobs", cjName, nsFlag)
+		})
+
+		It("should create a CronJob", func() {
+			framework.SkipIfMissingResource(f.ClientPool, CronJobGroupVersionResource, f.Namespace.Name)
+
+			schedule := "*/5 * * * ?"
+			framework.RunKubectlOrDie("run", cjName, "--restart=OnFailure", "--generator=cronjob/v2alpha1",
+				"--schedule="+schedule, "--image="+busyboxImage, nsFlag)
+			By("verifying the CronJob " + cjName + " was created")
+			sj, err := c.Batch().CronJobs(ns).Get(cjName)
+			if err != nil {
+				framework.Failf("Failed getting CronJob %s: %v", cjName, err)
+			}
+			if sj.Spec.Schedule != schedule {
+				framework.Failf("Failed creating a CronJob with correct schedule %s", schedule)
+			}
+			containers := sj.Spec.JobTemplate.Spec.Template.Spec.Containers
+			if containers == nil || len(containers) != 1 || containers[0].Image != busyboxImage {
+				framework.Failf("Failed creating CronJob %s for 1 pod with expected image %s: %#v", cjName, busyboxImage, containers)
+			}
+			if sj.Spec.JobTemplate.Spec.Template.Spec.RestartPolicy != api.RestartPolicyOnFailure {
+				framework.Failf("Failed creating a CronJob with correct restart policy for --restart=OnFailure")
+			}
+		})
+	})
 })
 
 var _ = framework.KubeDescribe("Kubectl client", func() {

test/test_owners.csv

@@ -589,7 +589,7 @@ k8s.io/kubernetes/pkg/controller/replicaset,fgrzadkowski,0
 k8s.io/kubernetes/pkg/controller/replication,fgrzadkowski,0
 k8s.io/kubernetes/pkg/controller/resourcequota,ghodss,1
 k8s.io/kubernetes/pkg/controller/route,gmarek,0
-k8s.io/kubernetes/pkg/controller/scheduledjob,soltysh,1
+k8s.io/kubernetes/pkg/controller/cronjob,soltysh,1
 k8s.io/kubernetes/pkg/controller/service,asalkeld,0
 k8s.io/kubernetes/pkg/controller/serviceaccount,liggitt,0
 k8s.io/kubernetes/pkg/controller/volume/attachdetach,luxas,1
@@ -677,8 +677,8 @@ k8s.io/kubernetes/pkg/registry/autoscaling/horizontalpodautoscaler,bgrant0607,1
 k8s.io/kubernetes/pkg/registry/autoscaling/horizontalpodautoscaler/etcd,justinsb,1
 k8s.io/kubernetes/pkg/registry/batch/job,kargakis,1
 k8s.io/kubernetes/pkg/registry/batch/job/etcd,Q-Lee,1
-k8s.io/kubernetes/pkg/registry/batch/scheduledjob,nikhiljindal,1
-k8s.io/kubernetes/pkg/registry/batch/scheduledjob/etcd,mtaufen,1
+k8s.io/kubernetes/pkg/registry/batch/cronjob,nikhiljindal,1
+k8s.io/kubernetes/pkg/registry/batch/cronjob/etcd,mtaufen,1
 k8s.io/kubernetes/pkg/registry/certificates/certificates,smarterclayton,1
 k8s.io/kubernetes/pkg/registry/core/componentstatus,krousey,1
 k8s.io/kubernetes/pkg/registry/core/configmap,janetkuo,1