scheduler: expose paused property of a Job.

scheduler/appengine/apiservers/scheduler_test.go

 // Copyright 2017 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package apiservers
 
 import (
         "fmt"
         "testing"
         "time"
@@ skipping 57 matching lines @@
                                         },
                                 }, nil
                         }
                         reply, err := ss.GetJobs(ctx, nil)
                         So(err, ShouldBeNil)
                         So(reply.GetJobs(), ShouldResemble, []*scheduler.Job{
                                 {
                                         JobRef:   &scheduler.JobRef{Job: "foo", Project: "bar"},
                                         Schedule: "0 * * * * * *",
                                         State:    &scheduler.JobState{UiStatus: "RUNNING"},
+                                        Paused:   false,
                                 },
                                 {
                                         JobRef:   &scheduler.JobRef{Job: "faz", Project: "baz"},
                                         Schedule: "with 1m interval",
                                         State:    &scheduler.JobState{UiStatus: "PAUSED"},
+                                        Paused:   true,
                                 },
                         })
                 })
 
                 Convey("One Project", func() {
                         fakeEng.getProjectJobs = func(projectID string) ([]*engine.Job, error) {
                                 So(projectID, ShouldEqual, "bar")
                                 return []*engine.Job{
                                         {
                                                 JobID:     "bar/foo",
                                                 ProjectID: "bar",
                                                 Schedule:  "0 * * * * * *",
                                                 State:     engine.JobState{State: engine.JobStateRunning},
                                                 Task:      fakeTaskBlob,
                                         },
                                 }, nil
                         }
                         reply, err := ss.GetJobs(ctx, &scheduler.JobsRequest{Project: "bar"})
                         So(err, ShouldBeNil)
                         So(reply.GetJobs(), ShouldResemble, []*scheduler.Job{
                                 {
                                         JobRef:   &scheduler.JobRef{Job: "foo", Project: "bar"},
                                         Schedule: "0 * * * * * *",
                                         State:    &scheduler.JobState{UiStatus: "RUNNING"},
+                                        Paused:   false,
                                 },
                         })
                 })
+
+                Convey("Paused but currently running job", func() {
+                        fakeEng.getProjectJobs = func(projectID string) ([]*engine.Job, error) {
+                                So(projectID, ShouldEqual, "bar")
+                                return []*engine.Job{
+                                        {
+                                                // Job which is paused but its latest invocation still running.
+                                                JobID:     "bar/foo",
+                                                ProjectID: "bar",
+                                                Schedule:  "0 * * * * * *",
+                                                State:     engine.JobState{State: engine.JobStateRunning},
+                                                Paused:    true,
+                                                Task:      fakeTaskBlob,
+                                        },
+                                }, nil
+                        }
+                        reply, err := ss.GetJobs(ctx, &scheduler.JobsRequest{Project: "bar"})
+                        So(err, ShouldBeNil)
+                        So(reply.GetJobs(), ShouldResemble, []*scheduler.Job{
+                                {
+                                        JobRef:   &scheduler.JobRef{Job: "foo", Project: "bar"},
+                                        Schedule: "0 * * * * * *",
+                                        State:    &scheduler.JobState{UiStatus: "RUNNING"},
+                                        Paused:   true,
+                                },
+                        })
+                })
         })
 }
 
 func TestGetInvocationsApi(t *testing.T) {
         t.Parallel()
 
         Convey("Scheduler GetInvocations API works", t, func() {
                 ctx := gaetesting.TestingContext()
                 fakeEng, catalog := newTestEngine()
                 _, err := registerUrlFetcher(catalog)
@@ skipping 308 matching lines @@
         return f.resumeJob(jobID, who)
 }
 
 func (f *fakeEngine) AbortInvocation(c context.Context, jobID string, invID int64, who identity.Identity) error {
         return f.abortInvocation(jobID, invID, who)
 }
 
 func (f *fakeEngine) AbortJob(c context.Context, jobID string, who identity.Identity) error {
         return f.abortJob(jobID, who)
 }