Fix miscellaneous prod bugs.

service/datastore/properties.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.
 
 package datastore
 
 import (
         "errors"
         "fmt"
         "math"
         "reflect"
         "time"
 
         "github.com/luci/gae/service/blobstore"
 )
 
 var (
         minTime = time.Unix(int64(math.MinInt64)/1e6, (int64(math.MinInt64)%1e6)*1e3)
         maxTime = time.Unix(int64(math.MaxInt64)/1e6, (int64(math.MaxInt64)%1e6)*1e3)
+
+        utcTestTime = time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
 )
 
 // IndexSetting indicates whether or not a Property should be indexed by the
 // datastore.
 type IndexSetting bool
 
 // ShouldIndex is the default, which is why it must assume the zero value,
 // even though it's werid :(.
 const (
         ShouldIndex IndexSetting = false
@@ skipping 169 matching lines @@
         case string:
                 return PTString, nil
         case Key:
                 // TODO(riannucci): Check key for validity in its own namespace?
                 return PTKey, nil
         case time.Time:
                 err := error(nil)
                 if checkValid && (x.Before(minTime) || x.After(maxTime)) {
                         err = errors.New("time value out of range")
                 }
-                if checkValid && x.Location() != time.UTC {
-                        err = fmt.Errorf("time value has wrong Location: %s", x.Location())
+                if checkValid && !timeLocationIsUTC(x.Location()) {
+                        err = fmt.Errorf("time value has wrong Location: %v %v", x.Location())
                 }
                 return PTTime, err
         case GeoPoint:
                 err := error(nil)
                 if checkValid && !x.Valid() {
                         err = errors.New("invalid GeoPoint value")
                 }
                 return PTGeoPoint, err
         default:
                 return PTUnknown, fmt.Errorf("gae: Property has bad type %T", v)
         }
 }
 
+// timeLocationsEqual tests if two time.Location are equal.
+//
+// This is tricky using the standard time API, as time is implicitly normalized
+// to UTC and all equality checks are performed relative to that normalized
+// time. To compensate, we instantiate two new time.Time using the respective
+// Locations.
+func timeLocationIsUTC(l *time.Location) bool {
+        return time.Date(1970, 1, 1, 0, 0, 0, 0, l).Equal(utcTestTime)
+}
+
 // UpconvertUnderlyingType takes an object o, and attempts to convert it to
 // its native datastore-compatible type. e.g. int16 will convert to int64, and
 // `type Foo string` will convert to `string`.
 func UpconvertUnderlyingType(o interface{}) interface{} {
         if o == nil {
                 return o
         }
 
         v := reflect.ValueOf(o)
         t := v.Type()
@@ skipping 252 matching lines @@
         dflt = UpconvertUnderlyingType(dflt)
         cur, err := gm(key)
         if err != nil {
                 return dflt
         }
         if dflt != nil && reflect.TypeOf(cur) != reflect.TypeOf(dflt) {
                 return dflt
         }
         return cur
 }