Implement projection queries correctly.

service/datastore/pls_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 datastore
 
 import (
         "bytes"
@@ skipping 53 matching lines @@
         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   = GeoPoint{Lat: 1.2, Lng: 3.4}
         testGeoPt1   = GeoPoint{Lat: 5, Lng: 10}
         testBadGeoPt = GeoPoint{Lat: 1000, Lng: 34}
 )
 
 type B0 struct {
-        B []byte
+        B []byte `gae:",noindex"`
 }
 
 type B1 struct {
         B []int8
 }
 
 type B2 struct {
         B myBlob
 }
 
 type B3 struct {
         B []myByte
 }
 
 type B4 struct {
-        B [][]byte
+        B [][]byte `gae:",noindex"`
 }
 
 type B5 struct {
-        B ByteString
+        B []byte
 }
 
 type C0 struct {
         I int
         C chan int
 }
 
 type C1 struct {
         I int
         C *chan int
@@ skipping 208 matching lines @@
         I int
         R []MutuallyRecursive1
 }
 
 type MutuallyRecursive1 struct {
         I int
         R []MutuallyRecursive0
 }
 
 type ExoticTypes struct {
-        BS   blobstore.Key
-        DSBS ByteString
+        BS blobstore.Key
 }
 
 type Underspecified struct {
         Iface PropertyConverter
 }
 
 type MismatchTypes struct {
         S  string
         B  bool
         F  float32
@@ skipping 307 matching lines @@
 
 type DerivedKey struct {
         K *genericKey
 }
 
 type IfaceKey struct {
         K Key
 }
 
 type testCase struct {
-        desc          string
-        src           interface{}
-        want          interface{}
-        plsErr        string
-        saveErr       string
-        actualNoIndex bool
-        plsLoadErr    string
-        loadErr       string
+        desc       string
+        src        interface{}
+        want       interface{}
+        plsErr     string
+        saveErr    string
+        plsLoadErr string
+        loadErr    string
 }
 
 var testCases = []testCase{
         {
                 desc:   "chan save fails",
                 src:    &C0{I: -1},
                 plsErr: `field "C" has invalid type: chan int`,
         },
         {
                 desc:   "*chan save fails",
@@ skipping 317 matching lines @@
                         makeUint8Slice(4),
                         makeUint8Slice(5),
                 }},
                 want: &B4{B: [][]byte{
                         makeUint8Slice(3),
                         makeUint8Slice(4),
                         makeUint8Slice(5),
                 }},
         },
         {
-                desc: "short ByteString",
-                src:  &B5{B: ByteString(makeUint8Slice(3))},
-                want: &B5{B: ByteString(makeUint8Slice(3))},
+                desc: "short []byte",
+                src:  &B5{B: makeUint8Slice(3)},
+                want: &B5{B: makeUint8Slice(3)},
         },
         {
                 desc: "short ByteString as props",
-                src:  &B5{B: ByteString(makeUint8Slice(3))},
+                src:  &B5{B: makeUint8Slice(3)},
                 want: PropertyMap{
-                        "B": {mp(ByteString(makeUint8Slice(3)))},
+                        "B": {mp(makeUint8Slice(3))},
                 },
         },
         {
-                desc: "[]byte must be noindex",
-                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: 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),
@@ skipping 241 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: ByteString("nerds"),
+                        BS: "sup",
                 },
                 want: &ExoticTypes{
-                        BS:   "sup",
-                        DSBS: ByteString("nerds"),
+                        BS: "sup",
                 },
         },
         {
                 desc:   "underspecified types",
                 src:    &Underspecified{},
                 plsErr: "non-concrete interface",
         },
         {
                 desc: "mismatch (string)",
                 src: PropertyMap{
                         "K": {mp(199)},
                         "S": {mp([]byte("cats"))},
-                        "F": {mp(ByteString("nurbs"))},
+                        "F": {mp("nurbs")},
                 },
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
         {
                 desc:    "mismatch (float)",
                 src:     PropertyMap{"F": {mp(blobstore.Key("wot"))}},
                 want:    &MismatchTypes{},
                 loadErr: "type mismatch",
         },
@@ skipping 294 matching lines @@
                                         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, NoIndex)
-                                                return
-                                        }
-                                        So(true, ShouldBeFalse) // shouldn't get here
-                                }
-
                                 var got interface{}
                                 if _, ok := tc.want.(PropertyMap); ok {
                                         pls = PropertyMap{}
                                         got = pls
                                 } else {
                                         got = reflect.New(reflect.TypeOf(tc.want).Elem()).Interface()
                                         if pls, ok = got.(PropertyLoadSaver); !ok {
                                                 pls = GetPLS(got)
                                         }
                                 }
@@ skipping 214 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")
                 })
         })
 }