impl/prod: Embed AppEngine SDK into Context.

impl/prod/everything_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 // +build appengine
 
 package prod
 
 import (
         "testing"
         "time"
 
         "github.com/luci/gae/service/blobstore"
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         mc "github.com/luci/gae/service/memcache"
 
         "github.com/luci/luci-go/common/logging"
 
         "golang.org/x/net/context"
         "google.golang.org/appengine/aetest"
+        "google.golang.org/appengine/datastore"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 var (
         mp   = ds.MkProperty
         mpNI = ds.MkPropertyNI
 )
 
 type TestStruct struct {
@@ skipping 242 matching lines @@
                 Convey("memcache: Set (nil) is the same as Set ([]byte{})", func() {
                         So(mc.Set(ctx, mc.NewItem(ctx, "bob")), ShouldBeNil) // normally would panic because Value is nil
 
                         bob, err := mc.GetKey(ctx, "bob")
                         So(err, ShouldBeNil)
                         So(bob.Value(), ShouldResemble, []byte{})
                 })
         })
 }
 
+func TestRawAppEngineAccess(t *testing.T) {
+        t.Parallel()
+
+        Convey("An AppEngine testing instance bound to a Context with services installed", t, func() {
+                inst, err := aetest.NewInstance(&aetest.Options{
+                        StronglyConsistentDatastore: true,
+                })
+                So(err, ShouldBeNil)
+                defer inst.Close()
+
+                req, err := inst.NewRequest("GET", "/", nil)
+                So(err, ShouldBeNil)
+
+                ctx := Use(context.Background(), req)
+
+                Convey("Can issue a raw datastore Put/Get", func() {
+                        key := datastore.NewKey(ctx, "Test", "foo", 0, nil)
+                        obj := struct {
+                                A string
+                                B int64
+                                C time.Time
+                        }{"bar", 1337, ds.RoundTime(time.Date(1938, time.January, 1, 1, 1, 1, 1, time.UTC))}
+                        _, err := datastore.Put(ctx, key, &obj)
+                        So(err, ShouldBeNil)
+
+                        other := obj
+                        other.A, other.B, other.C = "", 0, time.Time{}
+                        So(datastore.Get(ctx, key, &other), ShouldBeNil)
+                        So(other, ShouldResemble, obj)
+                })
+        })
+}
+
 func BenchmarkTransactionsParallel(b *testing.B) {
         type Counter struct {
                 ID    int `gae:"$id"`
                 Count int
         }
 
         inst, err := aetest.NewInstance(&aetest.Options{
                 StronglyConsistentDatastore: true,
         })
         if err != nil {
@@ skipping 23 matching lines @@
                                 default:
                                         return err
                                 }
                         }, &ds.TransactionOptions{Attempts: 9999999})
                         if err != nil {
                                 b.Fatalf("failed to run transaction: %v", err)
                         }
                 }
         })
 }