Add testable interface for datastore.

impl/memory/datastore.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 memory
 
 import (
         "errors"
+        "fmt"
 
         "golang.org/x/net/context"
 
         ds "github.com/luci/gae/service/datastore"
 )
 
 //////////////////////////////////// public ////////////////////////////////////
 
 // useRDS adds a gae.Datastore implementation to context, accessible
 // by gae.GetDS(c)
@@ skipping 42 matching lines @@
         d.data.delMulti(keys, cb)
         return nil
 }
 
 func (d *dsImpl) NewQuery(kind string) ds.Query {
         return &queryImpl{ns: d.ns, kind: kind}
 }
 
 func (d *dsImpl) Run(q ds.Query, cb ds.RawRunCB) error {
         return nil
-        /*
-                rq := q.(*queryImpl)
-                rq = rq.normalize().checkCorrectness(d.ns, false)
-                return &queryIterImpl{rq}
-        */
+}
+
+func (d *dsImpl) AddIndexes(idxs ...*ds.IndexDefinition) {
+        for _, i := range idxs {
+                if !i.Compound() {
+                        panic(fmt.Errorf("Attempted to add non-compound index: %s", i))
+                }
+        }
+
+        d.data.Lock()
+        defer d.data.Unlock()
+        addIndex(d.data.store, d.ns, idxs)
+}
+
+func (d *dsImpl) TakeIndexSnapshot() ds.TestingSnapshot {
+        return d.data.takeSnapshot()
+}
+
+func (d *dsImpl) SetIndexSnapshot(snap ds.TestingSnapshot) {
+        d.data.setSnapshot(snap.(*memStore))
+}
+
+func (d *dsImpl) CatchupIndexes() {
+        d.data.catchupIndexes()
+}
+
+func (d *dsImpl) Testable() ds.Testable {
+        return d
 }
 
 ////////////////////////////////// txnDsImpl ///////////////////////////////////
 
 type txnDsImpl struct {
         data *txnDataStoreData
         ns   string
 }
 
 var _ ds.RawInterface = (*txnDsImpl)(nil)
@@ skipping 21 matching lines @@
 
 func (d *txnDsImpl) DeleteMulti(keys []ds.Key, cb ds.DeleteMultiCB) error {
         return d.data.run(func() error {
                 return d.data.delMulti(keys, cb)
         })
 }
 
 func (d *txnDsImpl) Run(q ds.Query, cb ds.RawRunCB) error {
         rq := q.(*queryImpl)
         if rq.ancestor == nil {
-                return errors.New("memory: queries in transactions only support ancestor queries")
+                return errors.New("gae/impl/memory: queries in transactions only support ancestor queries")
         }
+        if rq.eventualConsistency {
+                rq = rq.clone()
+                rq.eventualConsistency = false
+        }
+        // TODO(riannucci): use head instead of snap for indexes
         panic("NOT IMPLEMENTED")
 }
 
 func (*txnDsImpl) RunInTransaction(func(c context.Context) error, *ds.TransactionOptions) error {
         return errors.New("datastore: nested transactions are not supported")
 }
 
 func (d *txnDsImpl) NewQuery(kind string) ds.Query {
         return &queryImpl{ns: d.ns, kind: kind}
 }
+
+func (*txnDsImpl) Testable() ds.Testable {
+        return nil
+}