Refactor keys and queries in datastore service and implementation.

impl/memory/taskqueue_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package memory
 
 import (
         "fmt"
         "math/rand"
         "net/http"
         "testing"
         "time"
 
         dsS "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         tqS "github.com/luci/gae/service/taskqueue"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/clock/testclock"
         "github.com/luci/luci-go/common/mathrand"
+        . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
 func TestTaskQueue(t *testing.T) {
         t.Parallel()
 
         Convey("TaskQueue", t, func() {
                 now := time.Date(2000, time.January, 1, 1, 1, 1, 1, time.UTC)
                 c, tc := testclock.UseTime(context.Background(), now)
@@ skipping 77 matching lines @@
                                         So(tq.Delete(t, ""), ShouldBeNil)
 
                                         // can't add a deleted task!
                                         So(tq.Add(t, ""), ShouldEqual, tqS.ErrTaskAlreadyAdded)
                                 })
 
                                 Convey("cannot set ETA+Delay", func() {
                                         t.ETA = clock.Now(c).Add(time.Hour)
                                         tc.Add(time.Second)
                                         t.Delay = time.Hour
-                                        So(func() { tq.Add(t, "") }, ShouldPanic)
+                                        So(func() {
+                                                So(tq.Add(t, ""), ShouldBeNil)
+                                        }, ShouldPanic)
                                 })
 
                                 Convey("must use a reasonable method", func() {
                                         t.Method = "Crystal"
                                         So(tq.Add(t, "").Error(), ShouldContainSubstring, "bad method")
                                 })
 
                                 Convey("payload gets dumped for non POST/PUT methods", func() {
                                         t.Method = "HEAD"
                                         t.Payload = []byte("coool")
@@ skipping 110 matching lines @@
                 Convey("works with transactions", func() {
                         t := &tqS.Task{Path: "/hello/world"}
                         So(tq.Add(t, ""), ShouldBeNil)
 
                         t2 := &tqS.Task{Path: "/hi/city"}
                         So(tq.Add(t2, ""), ShouldBeNil)
 
                         So(tq.Delete(t2, ""), ShouldBeNil)
 
                         Convey("can view regular tasks", func() {
-                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         tqt := tqS.GetRaw(c).Testable()
 
                                         So(tqt.GetScheduledTasks()["default"][t.Name], ShouldResemble, t)
                                         So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
                                         So(tqt.GetTransactionTasks()["default"], ShouldBeNil)
                                         return nil
-                                }, nil)
+                                }, nil), ShouldBeNil)
                         })
 
                         Convey("can add a new task", func() {
                                 t3 := &tqS.Task{Path: "/sandwitch/victory"}
 
                                 err := dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         tq := tqS.Get(c)
                                         tqt := tq.Testable()
 
                                         So(tq.Add(t3, ""), ShouldBeNil)
@@ skipping 17 matching lines @@
 
                                 So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
                                 So(tqt.GetTransactionTasks()["default"], ShouldBeNil)
                         })
 
                         Convey("can add a new task (but reset the state in a test)", func() {
                                 t3 := &tqS.Task{Path: "/sandwitch/victory"}
 
                                 ttq := tqS.Interface(nil)
 
-                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         ttq = tqS.Get(c)
                                         tqt := ttq.Testable()
 
                                         So(ttq.Add(t3, ""), ShouldBeNil)
 
                                         So(tqt.GetScheduledTasks()["default"][t.Name], ShouldResemble, t)
                                         So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
                                         So(tqt.GetTransactionTasks()["default"][0], ShouldResemble, t3)
 
                                         tqt.ResetTasks()
 
                                         So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 0)
                                         So(len(tqt.GetTombstonedTasks()["default"]), ShouldEqual, 0)
                                         So(len(tqt.GetTransactionTasks()["default"]), ShouldEqual, 0)
 
                                         return nil
-                                }, nil)
+                                }, nil), ShouldBeNil)
 
                                 So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 0)
                                 So(len(tqt.GetTombstonedTasks()["default"]), ShouldEqual, 0)
                                 So(len(tqt.GetTransactionTasks()["default"]), ShouldEqual, 0)
 
                                 Convey("and reusing a closed context is bad times", func() {
                                         So(ttq.Add(nil, "").Error(), ShouldContainSubstring, "expired")
                                 })
                         })
 
                         Convey("you can AddMulti as well", func() {
-                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         tq := tqS.Get(c)
                                         tqt := tq.Testable()
 
                                         t.Name = ""
                                         tasks := []*tqS.Task{t.Duplicate(), t.Duplicate(), t.Duplicate()}
                                         So(tq.AddMulti(tasks, ""), ShouldBeNil)
                                         So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 1)
                                         So(len(tqt.GetTransactionTasks()["default"]), ShouldEqual, 3)
                                         return nil
-                                }, nil)
+                                }, nil), ShouldBeNil)
                                 So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 4)
                                 So(len(tqt.GetTransactionTasks()["default"]), ShouldEqual, 0)
                         })
 
                         Convey("unless you add too many things", func() {
-                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         for i := 0; i < 5; i++ {
                                                 So(tqS.Get(c).Add(t.Duplicate(), ""), ShouldBeNil)
                                         }
                                         So(tqS.Get(c).Add(t, "").Error(), ShouldContainSubstring, "BAD_REQUEST")
                                         return nil
-                                }, nil)
+                                }, nil), ShouldBeNil)
                         })
 
                         Convey("unless you Add to a bad queue", func() {
-                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         So(tqS.Get(c).Add(t, "meat").Error(), ShouldContainSubstring, "UNKNOWN_QUEUE")
 
                                         Convey("unless you add it!", func() {
                                                 tqS.GetRaw(c).Testable().CreateQueue("meat")
                                                 So(tqS.Get(c).Add(t, "meat"), ShouldBeNil)
                                         })
 
                                         return nil
-                                }, nil)
+                                }, nil), ShouldBeNil)
                         })
 
                         Convey("No other features are available, however", func() {
-                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         So(tqS.Get(c).Delete(t, "").Error(), ShouldContainSubstring, "cannot DeleteMulti from a transaction")
                                         So(tqS.Get(c).Purge("").Error(), ShouldContainSubstring, "cannot Purge from a transaction")
                                         _, err := tqS.Get(c).Stats("")
                                         So(err.Error(), ShouldContainSubstring, "cannot Stats from a transaction")
                                         return nil
-                                }, nil)
+                                }, nil), ShouldBeNil)
                         })
 
                         Convey("adding a new task only happens if we don't errout", func() {
-                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         t3 := tq.NewTask("/sandwitch/victory")
                                         So(tqS.Get(c).Add(t3, ""), ShouldBeNil)
                                         return fmt.Errorf("nooooo")
-                                }, nil)
+                                }, nil), ShouldErrLike, "nooooo")
 
                                 So(tqt.GetScheduledTasks()["default"][t.Name], ShouldResemble, t)
                                 So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
                                 So(tqt.GetTransactionTasks()["default"], ShouldBeNil)
                         })
 
                         Convey("likewise, a panic doesn't schedule anything", func() {
                                 func() {
-                                        defer func() { recover() }()
-                                        dsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                        defer func() { _ = recover() }()
+                                        So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                                 tq := tqS.Get(c)
 
                                                 So(tq.Add(tq.NewTask("/sandwitch/victory"), ""), ShouldBeNil)
 
                                                 panic(fmt.Errorf("nooooo"))
-                                        }, nil)
+                                        }, nil), ShouldBeNil)
                                 }()
 
                                 So(tqt.GetScheduledTasks()["default"][t.Name], ShouldResemble, t)
                                 So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
                                 So(tqt.GetTransactionTasks()["default"], ShouldBeNil)
                         })
 
                 })
         })
 }