scheduler: Fix engine_test.go after luci/gae roll.

scheduler/appengine/engine/engine_test.go

 // Copyright 2015 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 engine
 
 import (
         "encoding/json"
         "math/rand"
         "sort"
@@ skipping 104 matching lines @@
                         }}), ShouldBeNil)
                 So(allJobs(c), ShouldResemble, []Job{
                         {
                                 JobID:     "abc/1",
                                 ProjectID: "abc",
                                 Revision:  "rev2",
                                 Enabled:   true,
                                 Schedule:  "*/1 * * * * * *",
                                 State: JobState{
                                         State:     "SCHEDULED",
-                                        TickNonce: 9111178027324032851,
+                                        TickNonce: 6891407870632131044,
                                         TickTime:  epoch.Add(1 * time.Second),
                                 },
                         },
                 })
                 // Enqueued timer task to launch it.
                 task = ensureOneTask(c, "timers-q")
                 So(task.Path, ShouldEqual, "/timers")
                 So(task.ETA, ShouldResemble, epoch.Add(1*time.Second))
                 tq.GetTestable(c).ResetTasks()
 
@@ skipping 101 matching lines @@
                 So(e.ResetAllJobsOnDevServer(c), ShouldBeNil)
                 So(allJobs(c), ShouldResemble, []Job{
                         {
                                 JobID:     "abc/1",
                                 ProjectID: "abc",
                                 Revision:  "rev1",
                                 Enabled:   true,
                                 Schedule:  "*/5 * * * * * *",
                                 State: JobState{
                                         State:     "SCHEDULED",
-                                        TickNonce: 9111178027324032851,
+                                        TickNonce: 6891407870632131044,
                                         TickTime:  epoch.Add(65 * time.Second),
                                 },
                         },
                 })
         })
 }
 
 func TestFullFlow(t *testing.T) {
         Convey("full flow", t, func() {
                 c := newTestContext(epoch)
@@ skipping 37 matching lines @@
                 So(allJobs(c), ShouldResemble, []Job{
                         {
                                 JobID:     "abc/1",
                                 ProjectID: "abc",
                                 Revision:  "rev1",
                                 Enabled:   true,
                                 Schedule:  "*/5 * * * * * *",
                                 Task:      taskBytes,
                                 State: JobState{
                                         State:           "QUEUED",
-                                        TickNonce:       9111178027324032851,
+                                        TickNonce:       6891407870632131044,
                                         TickTime:        epoch.Add(10 * time.Second),
-                                        InvocationNonce: 631000787647335445,
+                                        InvocationNonce: 1907242367099883828,
                                         InvocationTime:  epoch.Add(5 * time.Second),
                                 },
                         },
                 })
 
                 // Next tick task is added.
                 tickTask := ensureOneTask(c, "timers-q")
                 So(tickTask.Path, ShouldEqual, "/timers")
                 So(tickTask.ETA, ShouldResemble, epoch.Add(10*time.Second))
 
                 // Invocation task (ETA is 1 sec in the future).
                 invTask := ensureOneTask(c, "invs-q")
                 So(invTask.Path, ShouldEqual, "/invs")
                 So(invTask.ETA, ShouldResemble, epoch.Add(6*time.Second))
                 tq.GetTestable(c).ResetTasks()
 
                 // Time to run the job and it fails to launch with a transient error.
                 mgr.launchTask = func(ctl task.Controller) error {
                         // Check data provided via the controller.
                         So(ctl.JobID(), ShouldEqual, "abc/1")
-                        So(ctl.InvocationID(), ShouldEqual, int64(9200093518582666224))
-                        So(ctl.InvocationNonce(), ShouldEqual, int64(631000787647335445))
+                        So(ctl.InvocationID(), ShouldEqual, int64(9200093518582546608))
+                        So(ctl.InvocationNonce(), ShouldEqual, int64(1907242367099883828))
                         So(ctl.Task(), ShouldResemble, &messages.NoopTask{})
 
                         ctl.DebugLog("oops, fail")
                         return errors.WrapTransient(errors.New("oops"))
                 }
                 So(errors.IsTransient(e.ExecuteSerializedAction(c, invTask.Payload, 0)), ShouldBeTrue)
 
                 // Still in QUEUED state, but with InvocatioID assigned.
                 jobs := allJobs(c)
                 So(jobs, ShouldResemble, []Job{
                         {
                                 JobID:     "abc/1",
                                 ProjectID: "abc",
                                 Revision:  "rev1",
                                 Enabled:   true,
                                 Schedule:  "*/5 * * * * * *",
                                 Task:      taskBytes,
                                 State: JobState{
                                         State:           "QUEUED",
-                                        TickNonce:       9111178027324032851,
+                                        TickNonce:       6891407870632131044,
                                         TickTime:        epoch.Add(10 * time.Second),
-                                        InvocationNonce: 631000787647335445,
+                                        InvocationNonce: 1907242367099883828,
                                         InvocationTime:  epoch.Add(5 * time.Second),
-                                        InvocationID:    9200093518582666224,
+                                        InvocationID:    9200093518582546608,
                                 },
                         },
                 })
                 jobKey := ds.KeyForObj(c, &jobs[0])
 
                 // Check Invocation fields.
-                inv := Invocation{ID: 9200093518582666224, JobKey: jobKey}
+                inv := Invocation{ID: 9200093518582546608, JobKey: jobKey}
                 So(ds.Get(c, &inv), ShouldBeNil)
                 inv.JobKey = nil // for easier ShouldResemble below
                 debugLog := inv.DebugLog
                 inv.DebugLog = ""
                 So(inv, ShouldResemble, Invocation{
-                        ID:              9200093518582666224,
-                        InvocationNonce: 631000787647335445,
+                        ID:              9200093518582546608,
+                        InvocationNonce: 1907242367099883828,
                         Revision:        "rev1",
                         Started:         epoch.Add(5 * time.Second),
                         Finished:        epoch.Add(5 * time.Second),
                         Task:            taskBytes,
                         DebugLog:        "",
                         Status:          task.StatusFailed,
                         MutationsCount:  1,
                 })
                 So(debugLog, ShouldContainSubstring, "[22:42:05.000] Invocation initiated (attempt 1)")
                 So(debugLog, ShouldContainSubstring, "[22:42:05.000] oops, fail")
@@ skipping 11 matching lines @@
                         So(allJobs(c), ShouldResemble, []Job{
                                 {
                                         JobID:     "abc/1",
                                         ProjectID: "abc",
                                         Revision:  "rev1",
                                         Enabled:   true,
                                         Schedule:  "*/5 * * * * * *",
                                         Task:      taskBytes,
                                         State: JobState{
                                                 State:                "RUNNING",
-                                                TickNonce:            9111178027324032851,
+                                                TickNonce:            6891407870632131044,
                                                 TickTime:             epoch.Add(10 * time.Second),
-                                                InvocationNonce:      631000787647335445,
+                                                InvocationNonce:      1907242367099883828,
                                                 InvocationRetryCount: 1,
                                                 InvocationTime:       epoch.Add(5 * time.Second),
-                                                InvocationID:         9200093518581789696,
+                                                InvocationID:         9200093518581921600,
                                         },
                                 },
                         })
-                        inv := Invocation{ID: 9200093518581789696, JobKey: jobKey}
+                        inv := Invocation{ID: 9200093518581921600, JobKey: jobKey}
                         So(ds.Get(c, &inv), ShouldBeNil)
                         inv.JobKey = nil // for easier ShouldResemble below
                         So(inv, ShouldResemble, Invocation{
-                                ID:              9200093518581789696,
-                                InvocationNonce: 631000787647335445,
+                                ID:              9200093518581921600,
+                                InvocationNonce: 1907242367099883828,
                                 Revision:        "rev1",
                                 Started:         epoch.Add(5 * time.Second),
                                 Task:            taskBytes,
                                 DebugLog:        "[22:42:05.000] Invocation initiated (attempt 2)\n[22:42:05.000] Starting\n",
                                 RetryCount:      1,
                                 Status:          task.StatusRunning,
                                 MutationsCount:  1,
                         })
 
                         // Noop save, just for the code coverage.
                         So(ctl.Save(), ShouldBeNil)
 
                         // Change state to the final one.
                         ctl.State().Status = task.StatusSucceeded
                         ctl.State().ViewURL = "http://view_url"
                         ctl.State().TaskData = []byte("blah")
                         return nil
                 }
                 So(e.ExecuteSerializedAction(c, invTask.Payload, 1), ShouldBeNil)
 
                 // After final save.
-                inv = Invocation{ID: 9200093518581789696, JobKey: jobKey}
+                inv = Invocation{ID: 9200093518581921600, JobKey: jobKey}
                 So(ds.Get(c, &inv), ShouldBeNil)
                 inv.JobKey = nil // for easier ShouldResemble below
                 debugLog = inv.DebugLog
                 inv.DebugLog = ""
                 So(inv, ShouldResemble, Invocation{
-                        ID:              9200093518581789696,
-                        InvocationNonce: 631000787647335445,
+                        ID:              9200093518581921600,
+                        InvocationNonce: 1907242367099883828,
                         Revision:        "rev1",
                         Started:         epoch.Add(5 * time.Second),
                         Finished:        epoch.Add(5 * time.Second),
                         Task:            taskBytes,
                         DebugLog:        "",
                         RetryCount:      1,
                         Status:          task.StatusSucceeded,
                         ViewURL:         "http://view_url",
                         TaskData:        []byte("blah"),
                         MutationsCount:  2,
                 })
                 So(debugLog, ShouldContainSubstring, "[22:42:05.000] Invocation initiated (attempt 2)")
                 So(debugLog, ShouldContainSubstring, "[22:42:05.000] Starting")
                 So(debugLog, ShouldContainSubstring, "with status SUCCEEDED")
 
                 // Previous invocation is canceled.
-                inv = Invocation{ID: 9200093518582666224, JobKey: jobKey}
+                inv = Invocation{ID: 9200093518582546608, JobKey: jobKey}
                 So(ds.Get(c, &inv), ShouldBeNil)
                 inv.JobKey = nil // for easier ShouldResemble below
                 debugLog = inv.DebugLog
                 inv.DebugLog = ""
                 So(inv, ShouldResemble, Invocation{
-                        ID:              9200093518582666224,
-                        InvocationNonce: 631000787647335445,
+                        ID:              9200093518582546608,
+                        InvocationNonce: 1907242367099883828,
                         Revision:        "rev1",
                         Started:         epoch.Add(5 * time.Second),
                         Finished:        epoch.Add(5 * time.Second),
                         Task:            taskBytes,
                         DebugLog:        "",
                         Status:          task.StatusFailed,
                         MutationsCount:  1,
                 })
                 So(debugLog, ShouldContainSubstring, "[22:42:05.000] Invocation initiated (attempt 1)")
                 So(debugLog, ShouldContainSubstring, "[22:42:05.000] oops, fail")
                 So(debugLog, ShouldContainSubstring, "with status FAILED")
                 So(debugLog, ShouldContainSubstring, "[22:42:05.000] It will probably be retried")
 
                 // Job is in scheduled state again.
                 So(allJobs(c), ShouldResemble, []Job{
                         {
                                 JobID:     "abc/1",
                                 ProjectID: "abc",
                                 Revision:  "rev1",
                                 Enabled:   true,
                                 Schedule:  "*/5 * * * * * *",
                                 Task:      taskBytes,
                                 State: JobState{
                                         State:     "SCHEDULED",
-                                        TickNonce: 9111178027324032851,
+                                        TickNonce: 6891407870632131044,
                                         TickTime:  epoch.Add(10 * time.Second),
                                         PrevTime:  epoch.Add(5 * time.Second),
                                 },
                         },
                 })
         })
 }
 
 func TestGenerateInvocationID(t *testing.T) {
         Convey("generateInvocationID does not collide", t, func() {
@@ skipping 587 matching lines @@
 
 func ensureOneTask(c context.Context, q string) *tq.Task {
         tqt := tq.GetTestable(c)
         tasks := tqt.GetScheduledTasks()[q]
         So(len(tasks), ShouldEqual, 1)
         for _, t := range tasks {
                 return t
         }
         return nil
 }