Add 'user friendly' datastore API.

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"
 
-        rdsS "github.com/luci/gae/service/rawdatastore"
+        dsS "github.com/luci/gae/service/datastore"
         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/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
 func TestTaskQueue(t *testing.T) {
         t.Parallel()
@@ skipping 198 matching lines @@
                         So(err, ShouldBeNil)
 
                         t2 := &tqS.Task{Path: "/hi/city"}
                         tEnQ2, err := tq.Add(t2, "")
                         So(err, ShouldBeNil)
 
                         err = tq.Delete(tEnQ2, "")
                         So(err, ShouldBeNil)
 
                         Convey("can view regular tasks", func() {
-                                rdsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         tq := tqS.Get(c).(interface {
                                                 tqS.Testable
                                                 tqS.Interface
                                         })
 
                                         So(tq.GetScheduledTasks()["default"][tEnQ.Name], ShouldResemble, tEnQ)
                                         So(tq.GetTombstonedTasks()["default"][tEnQ2.Name], ShouldResemble, tEnQ2)
                                         So(tq.GetTransactionTasks()["default"], ShouldBeNil)
                                         return nil
                                 }, nil)
                         })
 
                         Convey("can add a new task", func() {
                                 tEnQ3 := (*tqS.Task)(nil)
 
-                                rdsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         tq := tqS.Get(c).(interface {
                                                 tqS.Testable
                                                 tqS.Interface
                                         })
 
                                         t3 := &tqS.Task{Path: "/sandwitch/victory"}
                                         tEnQ3, err = tq.Add(t3, "")
                                         So(err, ShouldBeNil)
 
                                         So(tq.GetScheduledTasks()["default"][tEnQ.Name], ShouldResemble, tEnQ)
@@ skipping 18 matching lines @@
                         })
 
                         Convey("can a new task (but reset the state in a test)", func() {
                                 tEnQ3 := (*tqS.Task)(nil)
 
                                 ttq := interface {
                                         tqS.Testable
                                         tqS.Interface
                                 }(nil)
 
-                                rdsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         ttq = tqS.Get(c).(interface {
                                                 tqS.Testable
                                                 tqS.Interface
                                         })
 
                                         t3 := &tqS.Task{Path: "/sandwitch/victory"}
                                         tEnQ3, err = ttq.Add(t3, "")
                                         So(err, ShouldBeNil)
 
                                         So(ttq.GetScheduledTasks()["default"][tEnQ.Name], ShouldResemble, tEnQ)
@@ skipping 13 matching lines @@
                                 So(len(tq.GetTombstonedTasks()["default"]), ShouldEqual, 0)
                                 So(len(tq.GetTransactionTasks()["default"]), ShouldEqual, 0)
 
                                 Convey("and reusing a closed context is bad times", func() {
                                         _, err := ttq.Add(nil, "")
                                         So(err.Error(), ShouldContainSubstring, "expired")
                                 })
                         })
 
                         Convey("you can AddMulti as well", func() {
-                                rdsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         tq := tqS.Get(c).(interface {
                                                 tqS.Testable
                                                 tqS.Interface
                                         })
                                         _, err := tq.AddMulti([]*tqS.Task{t, t, t}, "")
                                         So(err, ShouldBeNil)
                                         So(len(tq.GetScheduledTasks()["default"]), ShouldEqual, 1)
                                         So(len(tq.GetTransactionTasks()["default"]), ShouldEqual, 3)
                                         return nil
                                 }, nil)
                                 So(len(tq.GetScheduledTasks()["default"]), ShouldEqual, 4)
                                 So(len(tq.GetTransactionTasks()["default"]), ShouldEqual, 0)
                         })
 
                         Convey("unless you add too many things", func() {
-                                rdsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         for i := 0; i < 5; i++ {
                                                 _, err = tqS.Get(c).Add(t, "")
                                                 So(err, ShouldBeNil)
                                         }
                                         _, err = tqS.Get(c).Add(t, "")
                                         So(err.Error(), ShouldContainSubstring, "BAD_REQUEST")
                                         return nil
                                 }, nil)
                         })
 
                         Convey("unless you Add to a bad queue", func() {
-                                rdsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         _, err = tqS.Get(c).Add(t, "meat")
                                         So(err.Error(), ShouldContainSubstring, "UNKNOWN_QUEUE")
 
                                         Convey("unless you add it!", func() {
                                                 tqS.Get(c).(tqS.Testable).CreateQueue("meat")
                                                 _, err = tqS.Get(c).Add(t, "meat")
                                                 So(err, ShouldBeNil)
                                         })
 
                                         return nil
                                 }, nil)
                         })
 
                         Convey("No other features are available, however", func() {
                                 err := error(nil)
                                 func() {
                                         defer func() { err = recover().(error) }()
-                                        rdsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                        dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                                 tqS.Get(c).Delete(t, "")
                                                 return nil
                                         }, nil)
                                 }()
                                 So(err.Error(), ShouldContainSubstring, "TaskQueue.Delete")
                         })
 
                         Convey("adding a new task only happens if we don't errout", func() {
-                                rdsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                         t3 := &tqS.Task{Path: "/sandwitch/victory"}
                                         _, err = tqS.Get(c).Add(t3, "")
                                         So(err, ShouldBeNil)
                                         return fmt.Errorf("nooooo")
                                 }, nil)
 
                                 So(tq.GetScheduledTasks()["default"][tEnQ.Name], ShouldResemble, tEnQ)
                                 So(tq.GetTombstonedTasks()["default"][tEnQ2.Name], ShouldResemble, tEnQ2)
                                 So(tq.GetTransactionTasks()["default"], ShouldBeNil)
                         })
 
                         Convey("likewise, a panic doesn't schedule anything", func() {
                                 func() {
                                         defer func() { recover() }()
-                                        rdsS.Get(c).RunInTransaction(func(c context.Context) error {
+                                        dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                                 tq := tqS.Get(c).(interface {
                                                         tqS.Testable
                                                         tqS.Interface
                                                 })
 
                                                 t3 := &tqS.Task{Path: "/sandwitch/victory"}
                                                 _, err = tq.Add(t3, "")
                                                 So(err, ShouldBeNil)
 
                                                 panic(fmt.Errorf("nooooo"))
                                         }, nil)
                                 }()
 
                                 So(tq.GetScheduledTasks()["default"][tEnQ.Name], ShouldResemble, tEnQ)
                                 So(tq.GetTombstonedTasks()["default"][tEnQ2.Name], ShouldResemble, tEnQ2)
                                 So(tq.GetTransactionTasks()["default"], ShouldBeNil)
                         })
 
                 })
         })
 }