Decouple PLS from MGS.

service/datastore/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 datastore
 
 import (
         "fmt"
@@ skipping 223 matching lines @@
         return ErrMetaFieldUnset
 }
 
 func (f *FakePLS) Problem() error {
         if f.failProblem {
                 return errors.New("FakePLS.Problem")
         }
         return nil
 }
 
+type MGSWithNoKind struct {
+        S string
+}
+
+func (s *MGSWithNoKind) GetMetaDefault(key string, dflt interface{}) interface{} {
+        return GetMetaDefaultImpl(s.GetMeta, key, dflt)
+}
+
+func (s *MGSWithNoKind) GetMeta(key string) (interface{}, error) {
+        return nil, ErrMetaFieldUnset
+}
+
+func (s *MGSWithNoKind) GetAllMeta() PropertyMap {
+        return PropertyMap{}
+}
+
+func (s *MGSWithNoKind) SetMeta(key string, val interface{}) error {
+        return ErrMetaFieldUnset
+}
+
+var _ MetaGetterSetter = (*MGSWithNoKind)(nil)
+
 func TestKeyForObj(t *testing.T) {
         t.Parallel()
 
         Convey("Test interface.KeyForObj", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
                 ds := Get(c)
 
                 k := ds.MakeKey("Hello", "world")
 
@@ skipping 115 matching lines @@
 
                         Convey("get multi error for individual failures", func() {
                                 fplss := []FakePLS{{}, {Kind: "Fail"}}
                                 So(ds.PutMulti(fplss), ShouldResemble, errors.MultiError{nil, errors.New("PutMulti fail")})
                         })
 
                         Convey("put with non-modifyable type is an error", func() {
                                 cs := CommonStruct{}
                                 So(ds.Put(cs).Error(), ShouldContainSubstring, "invalid Put input type")
                         })
+
+                        Convey("struct with no $kind is an error", func() {
+                                s := MGSWithNoKind{}
+                                So(ds.Put(&s).Error(), ShouldContainSubstring, "unable to extract $kind")
+                        })
                 })
 
                 Convey("ok", func() {
                         Convey("[]S", func() {
                                 css := make([]CommonStruct, 7)
                                 for i := range css {
                                         if i == 4 {
                                                 css[i].ID = 200
                                         }
                                         css[i].Value = int64(i)
@@ skipping 499 matching lines @@
                                 So(ds.Run(q, func(k *Key, _ CursorCB) bool {
                                         So(k.IntID(), ShouldEqual, i+1)
                                         i++
                                         return true
                                 }), ShouldBeNil)
                         })
 
                 })
         })
 }