LogDog: Add project support to Storage.

server/logdog/storage/bigtable/storage_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.
 
 package bigtable
 
 import (
         "bytes"
         "fmt"
         "testing"
         "time"
 
         "github.com/luci/gkvlite"
+        "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/logdog/types"
         "github.com/luci/luci-go/common/recordio"
         "github.com/luci/luci-go/server/logdog/storage"
         "golang.org/x/net/context"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 // btTableTest is an in-memory implementation of btTable interface for testing.
@@ skipping 144 matching lines @@
                 s := newBTStorage(context.Background(), Options{
                         Project:  "test-project",
                         Zone:     "test-zone",
                         Cluster:  "test-cluster",
                         LogTable: "test-log-table",
                 }, nil, nil)
 
                 s.raw = &bt
                 defer s.Close()
 
+                project := config.ProjectName("test-project")
                 get := func(path string, index int, limit int) ([]string, error) {
                         req := storage.GetRequest{
-                                Path:  types.StreamPath(path),
-                                Index: types.MessageIndex(index),
-                                Limit: limit,
+                                Project: project,
+                                Path:    types.StreamPath(path),
+                                Index:   types.MessageIndex(index),
+                                Limit:   limit,
                         }
                         got := []string{}
                         err := s.Get(req, func(idx types.MessageIndex, d []byte) bool {
                                 got = append(got, string(d))
                                 return true
                         })
                         return got, err
                 }
 
                 put := func(path string, index int, d ...string) error {
                         data := make([][]byte, len(d))
                         for i, v := range d {
                                 data[i] = []byte(v)
                         }
 
                         return s.Put(storage.PutRequest{
-                                Path:   types.StreamPath(path),
-                                Index:  types.MessageIndex(index),
-                                Values: data,
+                                Project: project,
+                                Path:    types.StreamPath(path),
+                                Index:   types.MessageIndex(index),
+                                Values:  data,
                         })
                 }
 
-                ekey := func(p string, v, c int64) string {
-                        return newRowKey(p, v, c).encode()
+                ekey := func(path string, v, c int64) string {
+                        return newRowKey(string(project), path, v, c).encode()
                 }
                 records := func(s ...string) []byte {
                         buf := bytes.Buffer{}
                         w := recordio.NewWriter(&buf)
 
                         for _, v := range s {
                                 if _, err := w.Write([]byte(v)); err != nil {
                                         panic(err)
                                 }
                                 if err := w.Flush(); err != nil {
@@ skipping 73 matching lines @@
 
                                 Convey(`Will fetch {} for INVALID.`, func() {
                                         got, err := get("INVALID", 0, 0)
                                         So(err, ShouldBeNil)
                                         So(got, ShouldResemble, []string{})
                                 })
                         })
 
                         Convey(`Testing "Tail"...`, func() {
                                 tail := func(path string) (string, error) {
-                                        got, _, err := s.Tail(types.StreamPath(path))
+                                        got, _, err := s.Tail(project, types.StreamPath(path))
                                         return string(got), err
                                 }
 
                                 Convey(`A tail request for "A" returns A{4}.`, func() {
                                         got, err := tail("A")
                                         So(err, ShouldBeNil)
                                         So(got, ShouldEqual, "4")
                                 })
 
                                 Convey(`A tail request for "B" returns B{13}.`, func() {
@@ skipping 11 matching lines @@
         })
 }
 
 func TestStorage(t *testing.T) {
         testStorageImpl(t, false)
 }
 
 func TestStorageLegacy(t *testing.T) {
         testStorageImpl(t, true)
 }