Refactor a bit.

service/rawdatastore/datastore_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.
 
 // adapted from github.com/golang/appengine/datastore
 
-package helper
+package rawdatastore
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
         "math"
         "reflect"
         "strconv"
         "strings"
         "testing"
         "time"
 
-        "github.com/luci/gae"
+        "github.com/luci/gae/service/blobstore"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 var (
-        mp   = gae.MkDSProperty
-        mpNI = gae.MkDSPropertyNI
+        mp   = MkProperty
+        mpNI = MkPropertyNI
 )
 
 const testAppID = "testApp"
 
 type (
         myBlob   []byte
         myByte   byte
         myString string
 )
 
@@ skipping 20 matching lines @@
         }
         return b
 }
 
 var (
         testKey0     = mkKey("aid", "", "kind", "name0")
         testKey1a    = mkKey("aid", "", "kind", "name1")
         testKey1b    = mkKey("aid", "", "kind", "name1")
         testKey2a    = mkKey("aid", "", "kind", "name0", "kind", "name2")
         testKey2b    = mkKey("aid", "", "kind", "name0", "kind", "name2")
-        testGeoPt0   = gae.DSGeoPoint{Lat: 1.2, Lng: 3.4}
-        testGeoPt1   = gae.DSGeoPoint{Lat: 5, Lng: 10}
-        testBadGeoPt = gae.DSGeoPoint{Lat: 1000, Lng: 34}
+        testGeoPt0   = GeoPoint{Lat: 1.2, Lng: 3.4}
+        testGeoPt1   = GeoPoint{Lat: 5, Lng: 10}
+        testBadGeoPt = GeoPoint{Lat: 1000, Lng: 34}
 )
 
 type B0 struct {
         B []byte
 }
 
 type B1 struct {
         B []int8
 }
 
 type B2 struct {
         B myBlob
 }
 
 type B3 struct {
         B []myByte
 }
 
 type B4 struct {
         B [][]byte
 }
 
 type B5 struct {
-        B gae.DSByteString
+        B ByteString
 }
 
 type C0 struct {
         I int
         C chan int
 }
 
 type C1 struct {
         I int
         C *chan int
 }
 
 type C2 struct {
         I int
         C []chan int
 }
 
 type C3 struct {
         C string
 }
 
 type E struct{}
 
 type G0 struct {
-        G gae.DSGeoPoint
+        G GeoPoint
 }
 
 type G1 struct {
-        G []gae.DSGeoPoint
+        G []GeoPoint
 }
 
 type K0 struct {
-        K gae.DSKey
+        K Key
 }
 
 type K1 struct {
-        K []gae.DSKey
+        K []Key
 }
 
 type N0 struct {
         X0
         ID       int64  `gae:"$id"`
         _kind    string `gae:"$kind,whatnow"`
         Nonymous X0
         Ignore   string `gae:"-"`
         Other    string
 }
@@ skipping 171 matching lines @@
         I int
         R []MutuallyRecursive1
 }
 
 type MutuallyRecursive1 struct {
         I int
         R []MutuallyRecursive0
 }
 
 type ExoticTypes struct {
-        BS   gae.BSKey
-        DSBS gae.DSByteString
+        BS   blobstore.Key
+        DSBS ByteString
 }
 
 type Underspecified struct {
-        Iface gae.DSPropertyConverter
+        Iface PropertyConverter
 }
 
 type MismatchTypes struct {
         S  string
         B  bool
         F  float32
-        K  gae.DSKey
+        K  Key
         T  time.Time
-        G  gae.DSGeoPoint
+        G  GeoPoint
         IS []int
 }
 
 type BadSpecial struct {
         ID int64  `gae:"$id"`
         id string `gae:"$id"`
 }
 
 type Doubler struct {
         S string
         I int64
         B bool
 }
 
-func (d *Doubler) Load(props gae.DSPropertyMap) error {
+func (d *Doubler) Load(props PropertyMap) error {
         return GetPLS(d).Load(props)
 }
 
-func (d *Doubler) Save(withMeta bool) (gae.DSPropertyMap, error) {
+func (d *Doubler) Save(withMeta bool) (PropertyMap, error) {
         pls := GetPLS(d)
         propMap, err := pls.Save(withMeta)
         if err != nil {
                 return nil, err
         }
 
         // Edit that map and send it on.
         for _, props := range propMap {
                 for i := range props {
                         switch v := props[i].Value().(type) {
                         case string:
                                 // + means string concatenation.
                                 props[i].SetValue(v+v, props[i].IndexSetting())
                         case int64:
                                 // + means integer addition.
                                 props[i].SetValue(v+v, props[i].IndexSetting())
                         }
                 }
         }
         return propMap, nil
 }
 
-func (d *Doubler) GetMeta(string) (interface{}, error) { return nil, gae.ErrDSMetaFieldUnset }
-func (d *Doubler) SetMeta(string, interface{}) error   { return gae.ErrDSMetaFieldUnset }
+func (d *Doubler) GetMeta(string) (interface{}, error) { return nil, ErrMetaFieldUnset }
+func (d *Doubler) SetMeta(string, interface{}) error   { return ErrMetaFieldUnset }
 func (d *Doubler) Problem() error                      { return nil }
 
-var _ gae.DSPropertyLoadSaver = (*Doubler)(nil)
+var _ PropertyLoadSaver = (*Doubler)(nil)
 
 type Deriver struct {
         S, Derived, Ignored string
 }
 
-func (d *Deriver) Load(props gae.DSPropertyMap) error {
+func (d *Deriver) Load(props PropertyMap) error {
         for name, p := range props {
                 if name != "S" {
                         continue
                 }
                 d.S = p[0].Value().(string)
                 d.Derived = "derived+" + d.S
         }
         return nil
 }
 
-func (d *Deriver) Save(withMeta bool) (gae.DSPropertyMap, error) {
-        return map[string][]gae.DSProperty{
+func (d *Deriver) Save(withMeta bool) (PropertyMap, error) {
+        return map[string][]Property{
                 "S": {mp(d.S)},
         }, nil
 }
 
-func (d *Deriver) GetMeta(string) (interface{}, error) { return nil, gae.ErrDSMetaFieldUnset }
-func (d *Deriver) SetMeta(string, interface{}) error   { return gae.ErrDSMetaFieldUnset }
+func (d *Deriver) GetMeta(string) (interface{}, error) { return nil, ErrMetaFieldUnset }
+func (d *Deriver) SetMeta(string, interface{}) error   { return ErrMetaFieldUnset }
 func (d *Deriver) Problem() error                      { return nil }
 
-var _ gae.DSPropertyLoadSaver = (*Deriver)(nil)
+var _ PropertyLoadSaver = (*Deriver)(nil)
 
 type BK struct {
-        Key gae.BSKey
+        Key blobstore.Key
 }
 
 type Convertable []int64
 
-var _ gae.DSPropertyConverter = (*Convertable)(nil)
+var _ PropertyConverter = (*Convertable)(nil)
 
-func (c *Convertable) ToDSProperty() (ret gae.DSProperty, err error) {
+func (c *Convertable) ToProperty() (ret Property, err error) {
         buf := make([]string, len(*c))
         for i, v := range *c {
                 buf[i] = strconv.FormatInt(v, 10)
         }
-        err = ret.SetValue(strings.Join(buf, ","), gae.NoIndex)
+        err = ret.SetValue(strings.Join(buf, ","), NoIndex)
         return
 }
 
-func (c *Convertable) FromDSProperty(pv gae.DSProperty) error {
+func (c *Convertable) FromProperty(pv Property) error {
         if sval, ok := pv.Value().(string); ok {
                 for _, t := range strings.Split(sval, ",") {
                         ival, err := strconv.ParseInt(t, 10, 64)
                         if err != nil {
                                 return err
                         }
                         *c = append(*c, ival)
                 }
                 return nil
         }
         return fmt.Errorf("nope")
 }
 
 type Impossible struct {
         Nested []ImpossibleInner
 }
 
 type ImpossibleInner struct {
         Ints Convertable `gae:"wot"`
 }
 
 type Convertable2 struct {
         Data     string
         Exploded []string
 }
 
-func (c *Convertable2) ToDSProperty() (ret gae.DSProperty, err error) {
-        err = ret.SetValue(c.Data, gae.ShouldIndex)
+func (c *Convertable2) ToProperty() (ret Property, err error) {
+        err = ret.SetValue(c.Data, ShouldIndex)
         return
 }
 
-func (c *Convertable2) FromDSProperty(pv gae.DSProperty) error {
+func (c *Convertable2) FromProperty(pv Property) error {
         if sval, ok := pv.Value().(string); ok {
                 c.Data = sval
                 c.Exploded = []string{"turn", "down", "for", "what"}
                 return nil
         }
         return fmt.Errorf("nope")
 }
 
 type Impossible2 struct {
         Nested []ImpossibleInner2
 }
 
 type ImpossibleInner2 struct {
         Thingy Convertable2 `gae:"nerb"`
 }
 
 type JSONKVProp map[string]interface{}
 
-var _ gae.DSPropertyConverter = (*JSONKVProp)(nil)
+var _ PropertyConverter = (*JSONKVProp)(nil)
 
-func (j *JSONKVProp) ToDSProperty() (ret gae.DSProperty, err error) {
+func (j *JSONKVProp) ToProperty() (ret Property, err error) {
         data, err := json.Marshal(map[string]interface{}(*j))
         if err != nil {
                 return
         }
-        err = ret.SetValue(data, gae.NoIndex)
+        err = ret.SetValue(data, NoIndex)
         return
 }
 
-func (j *JSONKVProp) FromDSProperty(pv gae.DSProperty) error {
+func (j *JSONKVProp) FromProperty(pv Property) error {
         if bval, ok := pv.Value().([]byte); ok {
                 dec := json.NewDecoder(bytes.NewBuffer(bval))
                 dec.UseNumber()
                 return dec.Decode((*map[string]interface{})(j))
         }
         return fmt.Errorf("nope")
 }
 
 type Impossible3 struct {
         KMap JSONKVProp `gae:"kewelmap"`
 }
 
 type Complex complex128
 
-var _ gae.DSPropertyConverter = (*Complex)(nil)
+var _ PropertyConverter = (*Complex)(nil)
 
-func (c *Complex) ToDSProperty() (ret gae.DSProperty, err error) {
+func (c *Complex) ToProperty() (ret Property, err error) {
         // cheat hardkore and usurp GeoPoint so datastore will index these suckers
         // (note that this won't REALLY work, since GeoPoints are limited to a very
         // limited range of values, but it's nice to pretend ;)). You'd probably
         // really end up with a packed binary representation.
-        err = ret.SetValue(gae.DSGeoPoint{Lat: real(*c), Lng: imag(*c)}, gae.ShouldIndex)
+        err = ret.SetValue(GeoPoint{Lat: real(*c), Lng: imag(*c)}, ShouldIndex)
         return
 }
 
-func (c *Complex) FromDSProperty(p gae.DSProperty) error {
-        if gval, ok := p.Value().(gae.DSGeoPoint); ok {
+func (c *Complex) FromProperty(p Property) error {
+        if gval, ok := p.Value().(GeoPoint); ok {
                 *c = Complex(complex(gval.Lat, gval.Lng))
                 return nil
         }
         return fmt.Errorf("nope")
 }
 
 type Impossible4 struct {
         Values []Complex
 }
 
 type DerivedKey struct {
-        K *GenericDSKey
+        K *GenericKey
 }
 
 type IfaceKey struct {
-        K gae.DSKey
+        K Key
 }
 
 type testCase struct {
         desc          string
         src           interface{}
         want          interface{}
         plsErr        string
         saveErr       string
         actualNoIndex bool
         plsLoadErr    string
@@ skipping 45 matching lines @@
                 want: &G0{G: testGeoPt0},
         },
         {
                 desc:    "geopoint invalid",
                 src:     &G0{G: testBadGeoPt},
                 saveErr: "invalid GeoPoint value",
         },
         {
                 desc: "geopoint as props",
                 src:  &G0{G: testGeoPt0},
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "G": {mp(testGeoPt0)},
                 },
         },
         {
                 desc: "geopoint slice",
-                src:  &G1{G: []gae.DSGeoPoint{testGeoPt0, testGeoPt1}},
-                want: &G1{G: []gae.DSGeoPoint{testGeoPt0, testGeoPt1}},
+                src:  &G1{G: []GeoPoint{testGeoPt0, testGeoPt1}},
+                want: &G1{G: []GeoPoint{testGeoPt0, testGeoPt1}},
         },
         {
                 desc: "key",
                 src:  &K0{K: testKey1a},
                 want: &K0{K: testKey1b},
         },
         {
                 desc: "key with parent",
                 src:  &K0{K: testKey2a},
                 want: &K0{K: testKey2b},
         },
         {
                 desc: "nil key",
                 src:  &K0{},
                 want: &K0{},
         },
         {
                 desc: "all nil keys in slice",
-                src:  &K1{[]gae.DSKey{nil, nil}},
-                want: &K1{[]gae.DSKey{nil, nil}},
+                src:  &K1{[]Key{nil, nil}},
+                want: &K1{[]Key{nil, nil}},
         },
         {
                 desc: "some nil keys in slice",
-                src:  &K1{[]gae.DSKey{testKey1a, nil, testKey2a}},
-                want: &K1{[]gae.DSKey{testKey1b, nil, testKey2b}},
+                src:  &K1{[]Key{testKey1a, nil, testKey2a}},
+                want: &K1{[]Key{testKey1b, nil, testKey2b}},
         },
         {
                 desc:    "overflow",
                 src:     &O0{I: 1 << 48},
                 want:    &O1{},
                 loadErr: "overflow",
         },
         {
                 desc: "time",
                 src:  &T{T: time.Unix(1e9, 0).UTC()},
                 want: &T{T: time.Unix(1e9, 0).UTC()},
         },
         {
                 desc: "time as props",
                 src:  &T{T: time.Unix(1e9, 0).UTC()},
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "T": {mp(time.Unix(1e9, 0).UTC())},
                 },
         },
         {
                 desc:   "uint save",
                 src:    &U0{U: 1},
                 plsErr: `field "U" has invalid type: uint`,
         },
         {
                 desc:       "uint load",
@@ skipping 50 matching lines @@
                 want: &Y2{B: true, F: []int64{7}},
         },
         {
                 desc: "use convertable slice",
                 src:  &Impossible{[]ImpossibleInner{{Convertable{1, 5, 9}}, {Convertable{2, 4, 6}}}},
                 want: &Impossible{[]ImpossibleInner{{Convertable{1, 5, 9}}, {Convertable{2, 4, 6}}}},
         },
         {
                 desc: "use convertable slice (to map)",
                 src:  &Impossible{[]ImpossibleInner{{Convertable{1, 5, 9}}, {Convertable{2, 4, 6}}}},
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "Nested.wot": {mpNI("1,5,9"), mpNI("2,4,6")},
                 },
         },
         {
                 desc:    "convertable slice (bad load)",
-                src:     gae.DSPropertyMap{"Nested.wot": {mpNI([]byte("ohai"))}},
+                src:     PropertyMap{"Nested.wot": {mpNI([]byte("ohai"))}},
                 want:    &Impossible{[]ImpossibleInner{{}}},
                 loadErr: "nope",
         },
         {
                 desc: "use convertable struct",
                 src: &Impossible2{
                         []ImpossibleInner2{
                                 {Convertable2{"nerb", nil}},
                         },
                 },
@@ skipping 22 matching lines @@
         },
         {
                 desc: "convertable json KVMap (to map)",
                 src: &Impossible3{
                         JSONKVProp{
                                 "epic":    "success",
                                 "no_way!": []interface{}{true, "story"},
                                 "what":    []interface{}{"is", "really", 100},
                         },
                 },
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "kewelmap": {
                                 mpNI([]byte(
                                         `{"epic":"success","no_way!":[true,"story"],"what":["is","really",100]}`))},
                 },
         },
         {
                 desc: "convertable complex slice",
                 src: &Impossible4{
                         []Complex{complex(1, 2), complex(3, 4)},
                 },
                 want: &Impossible4{
                         []Complex{complex(1, 2), complex(3, 4)},
                 },
         },
         {
                 desc: "convertable complex slice (to map)",
                 src: &Impossible4{
                         []Complex{complex(1, 2), complex(3, 4)},
                 },
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "Values": {
-                                mp(gae.DSGeoPoint{Lat: 1, Lng: 2}), mp(gae.DSGeoPoint{Lat: 3, Lng: 4})},
+                                mp(GeoPoint{Lat: 1, Lng: 2}), mp(GeoPoint{Lat: 3, Lng: 4})},
                 },
         },
         {
                 desc:    "convertable complex slice (bad load)",
-                src:     gae.DSPropertyMap{"Values": {mp("hello")}},
+                src:     PropertyMap{"Values": {mp("hello")}},
                 want:    &Impossible4{[]Complex(nil)},
                 loadErr: "nope",
         },
         {
-                desc: "allow concrete gae.DSKey implementors (save)",
-                src:  &DerivedKey{testKey2a.(*GenericDSKey)},
+                desc: "allow concrete Key implementors (save)",
+                src:  &DerivedKey{testKey2a.(*GenericKey)},
                 want: &IfaceKey{testKey2b},
         },
         {
-                desc: "allow concrete gae.DSKey implementors (load)",
+                desc: "allow concrete Key implementors (load)",
                 src:  &IfaceKey{testKey2b},
-                want: &DerivedKey{testKey2a.(*GenericDSKey)},
+                want: &DerivedKey{testKey2a.(*GenericKey)},
         },
         {
                 desc:    "save []float64 load []int64",
                 src:     &Y0{B: true, F: []float64{7, 8, 9}},
                 want:    &Y2{B: true},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "single slice is too long",
                 src:     &Y0{F: make([]float64, maxIndexedProperties+1)},
@@ skipping 55 matching lines @@
                         makeUint8Slice(4),
                         makeUint8Slice(5),
                 }},
                 want: &B4{B: [][]byte{
                         makeUint8Slice(3),
                         makeUint8Slice(4),
                         makeUint8Slice(5),
                 }},
         },
         {
-                desc: "short gae.DSByteString",
-                src:  &B5{B: gae.DSByteString(makeUint8Slice(3))},
-                want: &B5{B: gae.DSByteString(makeUint8Slice(3))},
+                desc: "short ByteString",
+                src:  &B5{B: ByteString(makeUint8Slice(3))},
+                want: &B5{B: ByteString(makeUint8Slice(3))},
         },
         {
-                desc: "short gae.DSByteString as props",
-                src:  &B5{B: gae.DSByteString(makeUint8Slice(3))},
-                want: gae.DSPropertyMap{
-                        "B": {mp(gae.DSByteString(makeUint8Slice(3)))},
+                desc: "short ByteString as props",
+                src:  &B5{B: ByteString(makeUint8Slice(3))},
+                want: PropertyMap{
+                        "B": {mp(ByteString(makeUint8Slice(3)))},
                 },
         },
         {
                 desc: "[]byte must be noindex",
-                src: gae.DSPropertyMap{
+                src: PropertyMap{
                         "B": {mp(makeUint8Slice(3))},
                 },
                 actualNoIndex: true,
         },
         {
                 desc: "save tagged load props",
                 src:  &Tagged{A: 1, B: []int{21, 22, 23}, C: 3, D: 4, E: 5, I: 6, J: 7},
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         // A and B are renamed to a and b; A and C are noindex, I is ignored.
                         // Indexed properties are loaded before raw properties. Thus, the
                         // result is: b, b, b, D, E, a, c.
                         "b1": {
                                 mp(21),
                                 mp(22),
                                 mp(23),
                         },
                         "D": {mp(4)},
                         "E": {mp(5)},
                         "a": {mpNI(1)},
                         "C": {mpNI(3)},
                         "J": {mpNI(7)},
                 },
         },
         {
                 desc: "save tagged load tagged",
                 src:  &Tagged{A: 1, B: []int{21, 22, 23}, C: 3, D: 4, E: 5, I: 6, J: 7},
                 want: &Tagged{A: 1, B: []int{21, 22, 23}, C: 3, D: 4, E: 5, J: 7},
         },
         {
                 desc: "save props load tagged",
-                src: gae.DSPropertyMap{
+                src: PropertyMap{
                         "A": {mpNI(11)},
                         "a": {mpNI(12)},
                 },
                 want:    &Tagged{A: 12},
                 loadErr: `cannot load field "A"`,
         },
         {
                 desc:   "invalid tagged1",
                 src:    &InvalidTagged1{I: 1},
                 plsErr: `struct tag has invalid property name: "\t"`,
@@ skipping 20 matching lines @@
                 plsErr: `struct tag has repeated property name: "V.I"`,
         },
         {
                 desc: "doubler",
                 src:  &Doubler{S: "s", I: 1, B: true},
                 want: &Doubler{S: "ss", I: 2, B: true},
         },
         {
                 desc: "save struct load props",
                 src:  &X0{S: "s", I: 1},
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "S": {mp("s")},
                         "I": {mp(1)},
                 },
         },
         {
                 desc: "save props load struct",
-                src: gae.DSPropertyMap{
+                src: PropertyMap{
                         "S": {mp("s")},
                         "I": {mp(1)},
                 },
                 want: &X0{S: "s", I: 1},
         },
         {
                 desc: "nil-value props",
-                src: gae.DSPropertyMap{
+                src: PropertyMap{
                         "I": {mp(nil)},
                         "B": {mp(nil)},
                         "S": {mp(nil)},
                         "F": {mp(nil)},
                         "K": {mp(nil)},
                         "T": {mp(nil)},
                         "J": {
                                 mp(nil),
                                 mp(7),
                                 mp(nil),
                         },
                 },
                 want: &struct {
                         I int64
                         B bool
                         S string
                         F float64
-                        K gae.DSKey
+                        K Key
                         T time.Time
                         J []int64
                 }{
                         J: []int64{0, 7, 0},
                 },
         },
         {
                 desc: "save outer load props",
                 src: &Outer{
                         A: 1,
                         I: []Inner1{
                                 {10, "ten"},
                                 {20, "twenty"},
                                 {30, "thirty"},
                         },
                         J: Inner2{
                                 Y: 3.14,
                         },
                         Inner3: Inner3{
                                 Z: true,
                         },
                 },
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "A": {mp(1)},
                         "I.W": {
                                 mp(10),
                                 mp(20),
                                 mp(30),
                         },
                         "I.X": {
                                 mp("ten"),
                                 mp("twenty"),
                                 mp("thirty"),
                         },
                         "J.Y": {mp(3.14)},
                         "Z":   {mp(true)},
                 },
         },
         {
                 desc: "save props load outer-equivalent",
-                src: gae.DSPropertyMap{
+                src: PropertyMap{
                         "A": {mp(1)},
                         "I.W": {
                                 mp(10),
                                 mp(20),
                                 mp(30),
                         },
                         "I.X": {
                                 mp("ten"),
                                 mp("twenty"),
                                 mp("thirty"),
@@ skipping 29 matching lines @@
                                 Y: 3.14,
                         },
                         Inner3: Inner3{
                                 Z: true,
                         },
                 },
         },
         {
                 desc: "dotted names save",
                 src:  &Dotted{A: DottedA{B: DottedB{C: 88}}},
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "A0.A1.A2.B3.C4.C5": {mp(88)},
                 },
         },
         {
                 desc: "dotted names load",
-                src: gae.DSPropertyMap{
+                src: PropertyMap{
                         "A0.A1.A2.B3.C4.C5": {mp(99)},
                 },
                 want: &Dotted{A: DottedA{B: DottedB{C: 99}}},
         },
         {
                 desc: "save struct load deriver",
                 src:  &X0{S: "s", I: 1},
                 want: &Deriver{S: "s", Derived: "derived+s"},
         },
         {
@@ skipping 45 matching lines @@
                 want: &N0{
                         X0:       X0{S: "one", I: 2},
                         Nonymous: X0{S: "four", I: 5},
                         Other:    "other",
                 },
         },
         {
                 desc: "exotic types",
                 src: &ExoticTypes{
                         BS:   "sup",
-                        DSBS: gae.DSByteString("nerds"),
+                        DSBS: ByteString("nerds"),
                 },
                 want: &ExoticTypes{
                         BS:   "sup",
-                        DSBS: gae.DSByteString("nerds"),
+                        DSBS: ByteString("nerds"),
                 },
         },
         {
                 desc:   "underspecified types",
                 src:    &Underspecified{},
                 plsErr: "non-concrete interface",
         },
         {
                 desc: "mismatch (string)",
-                src: gae.DSPropertyMap{
+                src: PropertyMap{
                         "K": {mp(199)},
                         "S": {mp([]byte("cats"))},
-                        "F": {mp(gae.DSByteString("nurbs"))},
+                        "F": {mp(ByteString("nurbs"))},
                 },
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (float)",
-                src:     gae.DSPropertyMap{"F": {mp(gae.BSKey("wot"))}},
+                src:     PropertyMap{"F": {mp(blobstore.Key("wot"))}},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (float/overflow)",
-                src:     gae.DSPropertyMap{"F": {mp(math.MaxFloat64)}},
+                src:     PropertyMap{"F": {mp(math.MaxFloat64)}},
                 want:    &MismatchTypes{},
                 loadErr: "overflows",
         },
         {
                 desc:    "mismatch (key)",
-                src:     gae.DSPropertyMap{"K": {mp(false)}},
+                src:     PropertyMap{"K": {mp(false)}},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (bool)",
-                src:     gae.DSPropertyMap{"B": {mp(testKey0)}},
+                src:     PropertyMap{"B": {mp(testKey0)}},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (time)",
-                src:     gae.DSPropertyMap{"T": {mp(gae.DSGeoPoint{})}},
+                src:     PropertyMap{"T": {mp(GeoPoint{})}},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (geopoint)",
-                src:     gae.DSPropertyMap{"G": {mp(time.Now().UTC())}},
+                src:     PropertyMap{"G": {mp(time.Now().UTC())}},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc: "slice of structs",
                 src: &N1{
                         X0: X0{S: "one", I: 2, i: 3},
                         Nonymous: []X0{
                                 {S: "four", I: 5, i: 6},
                                 {S: "seven", I: 8, i: 9},
@@ skipping 90 matching lines @@
                         Blue: N1{
                                 X0: X0{S: "bleu"},
                                 Nonymous: []X0{
                                         {S: "blu0"},
                                         {S: "blu1"},
                                         {S: "blu2"},
                                         {S: "blu3"},
                                 },
                         },
                 },
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "red.S":            {mp("rouge")},
                         "red.I":            {mp(0)},
                         "red.Nonymous.S":   {mp("rosso0"), mp("rosso1")},
                         "red.Nonymous.I":   {mp(0), mp(0)},
                         "red.Other":        {mp("")},
                         "green.S":          {mp("vert")},
                         "green.I":          {mp(0)},
                         "green.Nonymous.S": {mp("verde0"), mp("verde1"), mp("verde2")},
                         "green.Nonymous.I": {mp(0), mp(0), mp(0)},
                         "green.Other":      {mp("")},
                         "Blue.S":           {mp("bleu")},
                         "Blue.I":           {mp(0)},
                         "Blue.Nonymous.S":  {mp("blu0"), mp("blu1"), mp("blu2"), mp("blu3")},
                         "Blue.Nonymous.I":  {mp(0), mp(0), mp(0), mp(0)},
                         "Blue.Other":       {mp("")},
                 },
         },
         {
                 desc: "save props load structs with ragged fields",
-                src: gae.DSPropertyMap{
+                src: PropertyMap{
                         "red.S":            {mp("rot")},
                         "green.Nonymous.I": {mp(10), mp(11), mp(12), mp(13)},
                         "Blue.Nonymous.S":  {mp("blau0"), mp("blau1"), mp("blau2")},
                         "Blue.Nonymous.I":  {mp(20), mp(21)},
                 },
                 want: &N2{
                         N1: N1{
                                 X0: X0{S: "rot"},
                         },
                         Green: N1{
@@ skipping 18 matching lines @@
                 src: &struct {
                         A struct {
                                 X string `gae:",noindex"`
                                 Y string
                         } `gae:",noindex"`
                         B struct {
                                 X string `gae:",noindex"`
                                 Y string
                         }
                 }{},
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "B.Y": {mp("")},
                         "A.X": {mpNI("")},
                         "A.Y": {mpNI("")},
                         "B.X": {mpNI("")},
                 },
         },
         {
                 desc: "embedded struct with name override",
                 src: &struct {
                         Inner1 `gae:"foo"`
                 }{},
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "foo.W": {mp(0)},
                         "foo.X": {mp("")},
                 },
         },
         {
                 desc:   "slice of slices",
                 src:    &SliceOfSlices{},
                 plsErr: `flattening nested structs leads to a slice of slices: field "S"`,
         },
         {
                 desc:   "recursive struct",
                 src:    &Recursive{},
                 plsErr: `field "R" is recursively defined`,
         },
         {
                 desc:   "mutually recursive struct",
                 src:    &MutuallyRecursive0{},
                 plsErr: `field "R" has problem: field "R" is recursively defined`,
         },
         {
                 desc: "non-exported struct fields",
                 src: &struct {
                         i, J int64
                 }{i: 1, J: 2},
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "J": {mp(2)},
                 },
         },
         {
                 desc: "json.RawMessage",
                 src: &struct {
                         J json.RawMessage
                 }{
                         J: json.RawMessage("rawr"),
                 },
-                want: gae.DSPropertyMap{
+                want: PropertyMap{
                         "J": {mp([]byte("rawr"))},
                 },
         },
         {
                 desc: "json.RawMessage to myBlob",
                 src: &struct {
                         B json.RawMessage
                 }{
                         B: json.RawMessage("rawr"),
                 },
@@ skipping 52 matching lines @@
 
         checkErr := func(actual interface{}, expected string) bool {
                 So(actual, ShouldErrLike, expected)
                 return expected != ""
         }
 
         Convey("Test round-trip", t, func() {
                 for _, tc := range testCases {
                         tc := tc
                         Convey(tc.desc, func() {
-                                pls, ok := tc.src.(gae.DSPropertyLoadSaver)
+                                pls, ok := tc.src.(PropertyLoadSaver)
                                 if !ok {
                                         pls = GetPLS(tc.src)
                                 }
                                 if checkErr(pls.Problem(), tc.plsErr) {
                                         return
                                 }
                                 So(pls, ShouldNotBeNil)
 
                                 savedProps, err := pls.Save(false)
                                 if checkErr(err, tc.saveErr) {
                                         return
                                 }
                                 So(savedProps, ShouldNotBeNil)
 
                                 if tc.actualNoIndex {
                                         for _, props := range savedProps {
-                                                So(props[0].IndexSetting(), ShouldEqual, gae.NoIndex)
+                                                So(props[0].IndexSetting(), ShouldEqual, NoIndex)
                                                 return
                                         }
                                         So(true, ShouldBeFalse) // shouldn't get here
                                 }
 
                                 var got interface{}
-                                if _, ok := tc.want.(gae.DSPropertyMap); ok {
-                                        pls = gae.DSPropertyMap{}
+                                if _, ok := tc.want.(PropertyMap); ok {
+                                        pls = PropertyMap{}
                                         got = pls
                                 } else {
                                         got = reflect.New(reflect.TypeOf(tc.want).Elem()).Interface()
-                                        if pls, ok = got.(gae.DSPropertyLoadSaver); !ok {
+                                        if pls, ok = got.(PropertyLoadSaver); !ok {
                                                 pls = GetPLS(got)
                                         }
                                 }
 
                                 if checkErr(pls.Problem(), tc.plsLoadErr) {
                                         return
                                 }
                                 So(pls, ShouldNotBeNil)
 
                                 err = pls.Load(savedProps)
@@ skipping 29 matching lines @@
 
                         val, err = pls.GetMeta("kind")
                         So(err, ShouldBeNil)
                         So(val, ShouldEqual, "whatnow")
                 })
 
                 Convey("Getting something not there is an error", func() {
                         o := &N0{ID: 100}
                         pls := GetPLS(o)
                         _, err := pls.GetMeta("wat")
-                        So(err, ShouldEqual, gae.ErrDSMetaFieldUnset)
+                        So(err, ShouldEqual, ErrMetaFieldUnset)
                 })
 
                 Convey("getting/setting from a bad struct is an error", func() {
                         o := &Recursive{}
                         pls := GetPLS(o)
                         _, err := pls.GetMeta("wat")
                         So(err, ShouldNotBeNil)
 
                         err = pls.SetMeta("wat", 100)
                         So(err, ShouldNotBeNil)
                 })
 
                 Convey("can assign values to exported special fields", func() {
                         o := &N0{ID: 100}
                         pls := GetPLS(o)
                         err := pls.SetMeta("id", int64(200))
                         So(err, ShouldBeNil)
                         So(o.ID, ShouldEqual, 200)
 
                 })
 
                 Convey("assigning to unsassiagnable fields is a simple error", func() {
                         o := &N0{ID: 100}
                         pls := GetPLS(o)
                         err := pls.SetMeta("kind", "hi")
                         So(err.Error(), ShouldContainSubstring, "unexported field")
 
                         err = pls.SetMeta("noob", "hi")
-                        So(err, ShouldEqual, gae.ErrDSMetaFieldUnset)
+                        So(err, ShouldEqual, ErrMetaFieldUnset)
                 })
         })
 
         Convey("StructPLS Miscellaneous", t, func() {
                 Convey("multiple overlapping fields is an error", func() {
                         o := &BadSpecial{}
                         pls := GetPLS(o)
                         err := pls.Load(nil)
                         So(err, ShouldErrLike, "multiple times")
                         e := pls.Problem()
                         _, err = pls.Save(true)
                         So(err, ShouldEqual, e)
                         err = pls.Load(nil)
                         So(err, ShouldEqual, e)
                 })
 
                 Convey("empty property names are invalid", func() {
                         So(validPropertyName(""), ShouldBeFalse)
                 })
 
                 Convey("attempting to get a PLS for a non *struct is an error", func() {
                         pls := GetPLS((*[]string)(nil))
-                        So(pls.Problem(), ShouldEqual, gae.ErrDSInvalidEntityType)
+                        So(pls.Problem(), ShouldEqual, ErrInvalidEntityType)
                 })
 
                 Convey("convertible meta default types", func() {
                         type OKDefaults struct {
                                 When   string `gae:"$when,tomorrow"`
                                 Amount int64  `gae:"$amt,100"`
                         }
                         pls := GetPLS(&OKDefaults{})
                         So(pls.Problem(), ShouldBeNil)
 
                         v, err := pls.GetMeta("when")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, "tomorrow")
 
                         v, err = pls.GetMeta("amt")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, int64(100))
                 })
 
                 Convey("meta fields can be saved", func() {
                         type OKDefaults struct {
                                 When   string `gae:"$when,tomorrow"`
                                 Amount int64  `gae:"$amt,100"`
                         }
                         pls := GetPLS(&OKDefaults{})
                         pm, err := pls.Save(true)
                         So(err, ShouldBeNil)
-                        So(pm, ShouldResemble, gae.DSPropertyMap{
-                                "$when": {gae.MkDSPropertyNI("tomorrow")},
-                                "$amt":  {gae.MkDSPropertyNI(100)},
+                        So(pm, ShouldResemble, PropertyMap{
+                                "$when": {mpNI("tomorrow")},
+                                "$amt":  {mpNI(100)},
                         })
 
                         v, err := pm.GetMeta("when")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, "tomorrow")
 
                         v, err = pm.GetMeta("amt")
                         So(err, ShouldBeNil)
                         So(v, ShouldEqual, int64(100))
                 })
@@ skipping 29 matching lines @@
 
                 Convey("Bad default meta type", func() {
                         type BadDefault struct {
                                 Val time.Time `gae:"$meta,tomorrow"`
                         }
                         pls := GetPLS(&BadDefault{})
                         So(pls.Problem().Error(), ShouldContainSubstring, "bad type")
                 })
         })
 }