Interface update, per-method Contexts.

service/datastore/serialize/serialize_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 serialize
 
 import (
         "bytes"
         "fmt"
         "io"
         "testing"
         "time"
 
         "github.com/luci/gae/service/blobstore"
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/data/cmpbin"
+
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func init() {
         WritePropertyMapDeterministic = true
 }
 
 var (
         mp   = ds.MkProperty
         mpNI = ds.MkPropertyNI
 )
 
 type dspmapTC struct {
         name  string
         props ds.PropertyMap
 }
 
-var mkKey = ds.MakeKey
+func mkKey(appID, namespace string, elems ...interface{}) *ds.Key {
+        return ds.KeyContext{appID, namespace}.MakeKey(elems...)
+}
 
 func mkBuf(data []byte) Buffer {
         return Invertible(bytes.NewBuffer(data))
 }
 
 // TODO(riannucci): dedup with datastore/key testing file
 func ShouldEqualKey(actual interface{}, expected ...interface{}) string {
         if len(expected) != 1 {
                 return fmt.Sprintf("Assertion requires 1 expected value, got %d", len(expected))
         }
@@ skipping 58 matching lines @@
                         },
                 },
         }
 
         Convey("PropertyMap serialization", t, func() {
                 Convey("round trip", func() {
                         for _, tc := range tests {
                                 tc := tc
                                 Convey(tc.name, func() {
                                         data := ToBytesWithContext(tc.props)
-                                        dec, err := ReadPropertyMap(mkBuf(data), WithContext, "", "")
+                                        dec, err := ReadPropertyMap(mkBuf(data), WithContext, ds.KeyContext{})
                                         So(err, ShouldBeNil)
                                         So(dec, ShouldResemble, tc.props)
                                 })
                         }
                 })
         })
 }
 
 func die(err error) {
         if err != nil {
@@ skipping 72 matching lines @@
                         t, err := ReadTime(mkBuf(buf.Bytes()))
                         So(err, ShouldBeNil)
                         So(t.Equal(time.Time{}), ShouldBeTrue)
                 })
 
                 Convey("ReadKey", func() {
                         Convey("good cases", func() {
                                 Convey("w/ ctx decodes normally w/ ctx", func() {
                                         k := mkKey("aid", "ns", "knd", "yo", "other", 10)
                                         data := ToBytesWithContext(k)
-                                        dk, err := ReadKey(mkBuf(data), WithContext, "", "")
+                                        dk, err := ReadKey(mkBuf(data), WithContext, ds.KeyContext{})
                                         So(err, ShouldBeNil)
                                         So(dk, ShouldEqualKey, k)
                                 })
                                 Convey("w/ ctx decodes normally w/o ctx", func() {
                                         k := mkKey("aid", "ns", "knd", "yo", "other", 10)
                                         data := ToBytesWithContext(k)
-                                        dk, err := ReadKey(mkBuf(data), WithoutContext, "spam", "nerd")
+                                        dk, err := ReadKey(mkBuf(data), WithoutContext, ds.KeyContext{"spam", "nerd"})
                                         So(err, ShouldBeNil)
                                         So(dk, ShouldEqualKey, mkKey("spam", "nerd", "knd", "yo", "other", 10))
                                 })
                                 Convey("w/o ctx decodes normally w/ ctx", func() {
                                         k := mkKey("aid", "ns", "knd", "yo", "other", 10)
                                         data := ToBytes(k)
-                                        dk, err := ReadKey(mkBuf(data), WithContext, "spam", "nerd")
+                                        dk, err := ReadKey(mkBuf(data), WithContext, ds.KeyContext{"spam", "nerd"})
                                         So(err, ShouldBeNil)
                                         So(dk, ShouldEqualKey, mkKey("", "", "knd", "yo", "other", 10))
                                 })
                                 Convey("w/o ctx decodes normally w/o ctx", func() {
                                         k := mkKey("aid", "ns", "knd", "yo", "other", 10)
                                         data := ToBytes(k)
-                                        dk, err := ReadKey(mkBuf(data), WithoutContext, "spam", "nerd")
+                                        dk, err := ReadKey(mkBuf(data), WithoutContext, ds.KeyContext{"spam", "nerd"})
                                         So(err, ShouldBeNil)
                                         So(dk, ShouldEqualKey, mkKey("spam", "nerd", "knd", "yo", "other", 10))
                                 })
                                 Convey("IntIDs always sort before StringIDs", func() {
                                         // -1 writes as almost all 1's in the first byte under cmpbin, even
                                         // though it's technically not a valid key.
                                         k := mkKey("aid", "ns", "knd", -1)
                                         data := ToBytes(k)
 
                                         k = mkKey("aid", "ns", "knd", "hat")
                                         data2 := ToBytes(k)
 
                                         So(string(data), ShouldBeLessThan, string(data2))
                                 })
                         })
 
                         Convey("err cases", func() {
                                 buf := mkBuf(nil)
                                 Convey("nil", func() {
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldEqual, io.EOF)
                                 })
                                 Convey("str", func() {
                                         _, err := buf.WriteString("sup")
                                         die(err)
-                                        _, err = ReadKey(buf, WithContext, "", "")
+                                        _, err = ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldErrLike, "expected actualCtx")
                                 })
                                 Convey("truncated 1", func() {
                                         die(buf.WriteByte(1)) // actualCtx == 1
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldEqual, io.EOF)
                                 })
                                 Convey("truncated 2", func() {
                                         die(buf.WriteByte(1)) // actualCtx == 1
                                         ws(buf, "aid")
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldEqual, io.EOF)
                                 })
                                 Convey("truncated 3", func() {
                                         die(buf.WriteByte(1)) // actualCtx == 1
                                         ws(buf, "aid")
                                         ws(buf, "ns")
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldEqual, io.EOF)
                                 })
                                 Convey("huge key", func() {
                                         die(buf.WriteByte(1)) // actualCtx == 1
                                         ws(buf, "aid")
                                         ws(buf, "ns")
                                         for i := 1; i < 60; i++ {
                                                 die(buf.WriteByte(1))
                                                 die(WriteKeyTok(buf, ds.KeyTok{Kind: "sup", IntID: int64(i)}))
                                         }
                                         die(buf.WriteByte(0))
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldErrLike, "huge key")
                                 })
                                 Convey("insufficient tokens", func() {
                                         die(buf.WriteByte(1)) // actualCtx == 1
                                         ws(buf, "aid")
                                         ws(buf, "ns")
                                         wui(buf, 2)
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldEqual, io.EOF)
                                 })
                                 Convey("partial token 1", func() {
                                         die(buf.WriteByte(1)) // actualCtx == 1
                                         ws(buf, "aid")
                                         ws(buf, "ns")
                                         die(buf.WriteByte(1))
                                         ws(buf, "hi")
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldEqual, io.EOF)
                                 })
                                 Convey("partial token 2", func() {
                                         die(buf.WriteByte(1)) // actualCtx == 1
                                         ws(buf, "aid")
                                         ws(buf, "ns")
                                         die(buf.WriteByte(1))
                                         ws(buf, "hi")
                                         die(buf.WriteByte(byte(ds.PTString)))
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldEqual, io.EOF)
                                 })
                                 Convey("bad token (invalid type)", func() {
                                         die(buf.WriteByte(1)) // actualCtx == 1
                                         ws(buf, "aid")
                                         ws(buf, "ns")
                                         die(buf.WriteByte(1))
                                         ws(buf, "hi")
                                         die(buf.WriteByte(byte(ds.PTBlobKey)))
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldErrLike, "invalid type PTBlobKey")
                                 })
                                 Convey("bad token (invalid IntID)", func() {
                                         die(buf.WriteByte(1)) // actualCtx == 1
                                         ws(buf, "aid")
                                         ws(buf, "ns")
                                         die(buf.WriteByte(1))
                                         ws(buf, "hi")
                                         die(buf.WriteByte(byte(ds.PTInt)))
                                         wi(buf, -2)
-                                        _, err := ReadKey(buf, WithContext, "", "")
+                                        _, err := ReadKey(buf, WithContext, ds.KeyContext{})
                                         So(err, ShouldErrLike, "zero/negative")
                                 })
                         })
                 })
 
                 Convey("ReadGeoPoint", func() {
                         buf := mkBuf(nil)
                         Convey("trunc 1", func() {
                                 _, err := ReadGeoPoint(buf)
                                 So(err, ShouldEqual, io.EOF)
@@ skipping 24 matching lines @@
                 Convey("ReadTime", func() {
                         Convey("trunc 1", func() {
                                 _, err := ReadTime(mkBuf(nil))
                                 So(err, ShouldEqual, io.EOF)
                         })
                 })
 
                 Convey("ReadProperty", func() {
                         buf := mkBuf(nil)
                         Convey("trunc 1", func() {
-                                p, err := ReadProperty(buf, WithContext, "", "")
+                                p, err := ReadProperty(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldEqual, io.EOF)
                                 So(p.Type(), ShouldEqual, ds.PTNull)
                                 So(p.Value(), ShouldBeNil)
                         })
                         Convey("trunc (PTBytes)", func() {
                                 die(buf.WriteByte(byte(ds.PTBytes)))
-                                _, err := ReadProperty(buf, WithContext, "", "")
+                                _, err := ReadProperty(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldEqual, io.EOF)
                         })
                         Convey("trunc (PTBlobKey)", func() {
                                 die(buf.WriteByte(byte(ds.PTBlobKey)))
-                                _, err := ReadProperty(buf, WithContext, "", "")
+                                _, err := ReadProperty(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldEqual, io.EOF)
                         })
                         Convey("invalid type", func() {
                                 die(buf.WriteByte(byte(ds.PTUnknown + 1)))
-                                _, err := ReadProperty(buf, WithContext, "", "")
+                                _, err := ReadProperty(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldErrLike, "unknown type!")
                         })
                 })
 
                 Convey("ReadPropertyMap", func() {
                         buf := mkBuf(nil)
                         Convey("trunc 1", func() {
-                                _, err := ReadPropertyMap(buf, WithContext, "", "")
+                                _, err := ReadPropertyMap(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldEqual, io.EOF)
                         })
                         Convey("too many rows", func() {
                                 wui(buf, 1000000)
-                                _, err := ReadPropertyMap(buf, WithContext, "", "")
+                                _, err := ReadPropertyMap(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldErrLike, "huge number of rows")
                         })
                         Convey("trunc 2", func() {
                                 wui(buf, 10)
-                                _, err := ReadPropertyMap(buf, WithContext, "", "")
+                                _, err := ReadPropertyMap(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldEqual, io.EOF)
                         })
                         Convey("trunc 3", func() {
                                 wui(buf, 10)
                                 ws(buf, "ohai")
-                                _, err := ReadPropertyMap(buf, WithContext, "", "")
+                                _, err := ReadPropertyMap(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldEqual, io.EOF)
                         })
                         Convey("too many values", func() {
                                 wui(buf, 10)
                                 ws(buf, "ohai")
                                 wui(buf, 100000)
-                                _, err := ReadPropertyMap(buf, WithContext, "", "")
+                                _, err := ReadPropertyMap(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldErrLike, "huge number of properties")
                         })
                         Convey("trunc 4", func() {
                                 wui(buf, 10)
                                 ws(buf, "ohai")
                                 wui(buf, 10)
-                                _, err := ReadPropertyMap(buf, WithContext, "", "")
+                                _, err := ReadPropertyMap(buf, WithContext, ds.KeyContext{})
                                 So(err, ShouldEqual, io.EOF)
                         })
                 })
 
                 Convey("IndexDefinition", func() {
                         id := ds.IndexDefinition{Kind: "kind"}
                         data := ToBytes(*id.PrepForIdxTable())
                         newID, err := ReadIndexDefinition(mkBuf(data))
                         So(err, ShouldBeNil)
                         So(newID.Flip(), ShouldResemble, id.Normalize())
@@ skipping 63 matching lines @@
                                                 "__ancestor__": {
                                                         ToBytes(mp(fakeKey)),
                                                         ToBytes(mp(fakeKey.Parent())),
                                                 },
                                         })
                                 })
                         })
                 })
         })
 }