Refactor keys and queries in datastore service and implementation.

impl/memory/memcache_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 (
         "testing"
         "time"
 
         mcS "github.com/luci/gae/service/memcache"
         "github.com/luci/luci-go/common/clock/testclock"
+        . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
 func TestMemcache(t *testing.T) {
         t.Parallel()
 
         Convey("memcache", t, func() {
                 now := time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)
                 c, tc := testclock.UseTime(context.Background(), now)
@@ skipping 71 matching lines @@
                                 testItem := &mcItem{
                                         key:   "sup",
                                         value: []byte("newp"),
                                         CasID: 2,
                                 }
                                 getItm := mc.NewItem("sup")
                                 So(mc.Get(getItm), ShouldBeNil)
                                 So(getItm, ShouldResemble, testItem)
 
                                 Convey("Flush works too", func() {
-                                        mc.Flush()
+                                        So(mc.Flush(), ShouldBeNil)
                                         So(mc.Get(getItm), ShouldEqual, mcS.ErrCacheMiss)
                                 })
                         })
 
                         Convey("Increment", func() {
                                 val, err := mc.Increment("num", 7, 2)
                                 So(err, ShouldBeNil)
                                 So(val, ShouldEqual, 9)
 
                                 Convey("IncrementExisting", func() {
@@ skipping 46 matching lines @@
                 })
 
                 Convey("check that the internal implementation is sane", func() {
                         curTime := now
                         err := mc.Add(&mcItem{
                                 key:        "sup",
                                 value:      []byte("cool"),
                                 expiration: time.Second * 2,
                         })
 
-                        mc.Get(mc.NewItem("sup"))
-                        mc.Get(mc.NewItem("sup"))
-                        mc.Get(mc.NewItem("sup"))
-                        mc.Get(mc.NewItem("sup"))
-                        mc.Get(mc.NewItem("wot"))
+                        So(mc.Get(mc.NewItem("sup")), ShouldBeNil)
+                        So(mc.Get(mc.NewItem("sup")), ShouldBeNil)
+                        So(mc.Get(mc.NewItem("sup")), ShouldBeNil)
+                        So(mc.Get(mc.NewItem("sup")), ShouldBeNil)
+                        So(mc.Get(mc.NewItem("wot")), ShouldErrLike, mcS.ErrCacheMiss)
 
                         mci := mc.Raw().(*memcacheImpl)
 
                         So(err, ShouldBeNil)
                         stats, err := mc.Stats()
                         So(err, ShouldBeNil)
                         So(stats.Items, ShouldEqual, 1)
                         So(stats.Bytes, ShouldEqual, 4)
                         So(stats.Hits, ShouldEqual, 4)
                         So(stats.Misses, ShouldEqual, 1)
@@ skipping 13 matching lines @@
                         testItem := &mcItem{
                                 key:   "sup",
                                 value: []byte("cool"),
                                 CasID: 1,
                         }
                         So(getItm, ShouldResemble, testItem)
                 })
 
         })
 }