Panic when non-runtime-handleable type errors occur

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 389 matching lines @@
                                 So(ds.PutMulti(fplss), ShouldErrLike, "PutMulti fail all")
                         })
 
                         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), ShouldErrLike, "invalid Put input type")
+                                So(func() { ds.Put(cs) }, ShouldPanicLike,
+                                        "invalid Put input type (datastore.CommonStruct): not a pointer")
                         })
 
                         Convey("get with *Key is an error", func() {
-                                So(ds.Get(&Key{}), ShouldErrLike, "invalid Get input type: *datastore.Key")
+                                So(func() { ds.Get(&Key{}) }, ShouldPanicLike,
+                                        "invalid Get input type (*datastore.Key): not user datatype")
                         })
 
                         Convey("struct with no $kind is an error", func() {
                                 s := MGSWithNoKind{}
                                 So(ds.Put(&s), ShouldErrLike, "unable to extract $kind")
                         })
 
                         Convey("struct with invalid but non-nil key is an error", func() {
                                 type BadParent struct {
                                         ID     int64 `gae:"$id"`
@@ skipping 220 matching lines @@
                                 So(ds.GetMulti(fplss).Error(), ShouldEqual, "GetMulti fail all")
                         })
 
                         Convey("get multi error for individual failures", func() {
                                 fplss := []FakePLS{{IntID: 1}, {IntID: 2, Kind: "Fail"}}
                                 So(ds.GetMulti(fplss), ShouldResemble, errors.MultiError{nil, errors.New("GetMulti fail")})
                         })
 
                         Convey("get with non-modifiable type is an error", func() {
                                 cs := CommonStruct{}
-                                So(ds.Get(cs), ShouldErrLike, "invalid Get input type")
+                                So(func() { ds.Get(cs) }, ShouldPanicLike,
+                                        "invalid Get input type (datastore.CommonStruct): not a pointer")
+                        })
+
+                        Convey("get with nil is an error", func() {
+                                So(func() { ds.Get(nil) }, ShouldPanicLike,
+                                        "invalid Get input type (<nil>): no type information")
+                        })
+
+                        Convey("get with ptr-to-nonstruct is an error", func() {
+                                val := 100
+                                So(func() { ds.Get(&val) }, ShouldPanicLike,
+                                        "invalid Get input type (*int): does not point to a struct")
                         })
 
                         Convey("failure to save metadata is no problem though", func() {
                                 // It just won't save the key
                                 cs := &FakePLS{IntID: 10, failSetMeta: true}
                                 So(ds.Get(cs), ShouldBeNil)
                         })
                 })
 
                 Convey("ok", func() {
@@ skipping 28 matching lines @@
         Convey("Test GetAll", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
                 ds := Get(c)
                 So(ds, ShouldNotBeNil)
 
                 q := NewQuery("").Limit(5)
 
                 Convey("bad", func() {
                         Convey("nil target", func() {
-                                So(ds.GetAll(q, (*[]PropertyMap)(nil)), ShouldErrLike, "dst: <nil>")
+                                So(func() { ds.GetAll(q, (*[]PropertyMap)(nil)) }, ShouldPanicLike,
+                                        "invalid GetAll dst: <nil>")
                         })
 
                         Convey("bad type", func() {
                                 output := 100
                                 So(func() { ds.GetAll(q, &output) }, ShouldPanicLike,
                                         "invalid argument type: expected slice, got int")
                         })
 
                         Convey("bad type (non pointer)", func() {
-                                So(ds.GetAll(q, "moo"), ShouldErrLike, "must have a ptr-to-slice")
+                                So(func() { ds.GetAll(q, "moo") }, ShouldPanicLike,
+                                        "invalid GetAll dst: must have a ptr-to-slice")
                         })
 
                         Convey("bad type (underspecified)", func() {
                                 output := []PropertyLoadSaver(nil)
-                                So(ds.GetAll(q, &output), ShouldErrLike, "invalid GetAll input type")
+                                So(func() { ds.GetAll(q, &output) }, ShouldPanicLike,
+                                        "invalid GetAll dst (non-concrete element type): *[]datastore.PropertyLoadSaver")
                         })
                 })
 
                 Convey("ok", func() {
                         Convey("*[]S", func() {
                                 output := []CommonStruct(nil)
                                 So(ds.GetAll(q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, o := range output {
                                         So(o.ID, ShouldEqual, i+1)
@@ skipping 537 matching lines @@
                         Convey("extra field with bad type", func() {
                                 type Bad struct {
                                         A int64 `gae:",extra"`
                                 }
                                 So(func() { GetPLS(&Bad{}) }, ShouldPanicLike,
                                         "struct 'extra' field has invalid type int64")
                         })
                 })
         })
 }