LogDog: Add project namespace to logs endpoint.

appengine/logdog/coordinator/endpoints/logs/query_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 logs
 
 import (
         "fmt"
         "sort"
         "testing"
         "time"
 
         "github.com/luci/gae/filter/featureBreaker"
         "github.com/luci/gae/impl/memory"
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/appengine/logdog/coordinator"
         ct "github.com/luci/luci-go/appengine/logdog/coordinator/coordinatorTest"
         "github.com/luci/luci-go/common/api/logdog_coordinator/logs/v1"
         "github.com/luci/luci-go/common/clock/testclock"
+        "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logdog/types"
         "github.com/luci/luci-go/common/proto/google"
         "github.com/luci/luci-go/common/proto/logdog/logpb"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/authtest"
         "golang.org/x/net/context"
 
-        "github.com/luci/luci-go/common/logging/gologger"
-
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func shouldHaveLogPaths(actual interface{}, expected ...interface{}) string {
         resp := actual.(*logdog.QueryResponse)
         var paths []string
         if len(resp.Streams) > 0 {
                 paths = make([]string, len(resp.Streams))
                 for i, s := range resp.Streams {
@@ skipping 20 matching lines @@
 
         return ShouldResemble(paths, exp)
 }
 
 func TestQuery(t *testing.T) {
         t.Parallel()
 
         Convey(`With a testing configuration, a Query request`, t, func() {
                 c, tc := testclock.UseTime(context.Background(), testclock.TestTimeLocal)
                 c = memory.Use(c)
-                c = gologger.StdConfig.Use(c)
                 c, fb := featureBreaker.FilterRDS(c, nil)
 
-                di := ds.Get(c)
-
                 // Add LogStream indexes.
                 //
                 // These should be kept in sync with the "query endpoint" indexes in the
                 // vmuser module's "index.yaml" file.
                 indexDefs := [][]string{
                         {"Prefix", "-Created"},
                         {"Name", "-Created"},
                         {"State", "-Created"},
                         {"Purged", "-Created"},
                         {"ProtoVersion", "-Created"},
@@ skipping 10 matching lines @@
                         cols := make([]ds.IndexColumn, len(id))
                         for j, ic := range id {
                                 var err error
                                 cols[j], err = ds.ParseIndexColumn(ic)
                                 if err != nil {
                                         panic(fmt.Errorf("failed to parse index %q: %s", ic, err))
                                 }
                         }
                         indexes[i] = &ds.IndexDefinition{Kind: "LogStream", SortBy: cols}
                 }
-                di.Testable().AddIndexes(indexes...)
-                di.Testable().Consistent(true)
+                ds.Get(c).Testable().AddIndexes(indexes...)
+                ds.Get(c).Testable().Consistent(true)
 
                 fs := authtest.FakeState{}
                 c = auth.WithState(c, &fs)
 
                 svcStub := ct.Services{}
                 svcStub.InitConfig()
                 svcStub.ServiceConfig.Coordinator.AdminAuthGroup = "test-administrators"
                 c = coordinator.WithServices(c, &svcStub)
 
                 var svrBase server
                 svr := newService(&svrBase)
 
+                // di is a datastore bound to the test project namespace.
+                const project = "test-project"
+                if err := coordinator.WithProjectNamespace(&c, config.ProjectName(project)); err != nil {
+                        panic(err)
+                }
+                di := ds.Get(c)
+
+                // Stock query request, will be modified by each test.
                 req := logdog.QueryRequest{
-                        Tags: map[string]string{},
+                        Project: project,
+                        Tags:    map[string]string{},
                 }
 
                 // Install a set of stock log streams to query against.
                 var streamPaths []string
                 var purgedStreamPaths []string
                 streams := map[string]*coordinator.LogStream{}
                 descs := map[string]*logpb.LogStreamDescriptor{}
                 for i, v := range []types.StreamPath{
                         "testing/+/foo",
                         "testing/+/foo/bar",
@@ skipping 49 matching lines @@
 
                                         case "datagram":
                                                 ls.StreamType = logpb.StreamType_DATAGRAM
 
                                         case "binary":
                                                 ls.StreamType = logpb.StreamType_BINARY
                                         }
                                 }
                         }
 
-                        if err := ds.Get(c).Put(ls); err != nil {
+                        if err := di.Put(ls); err != nil {
                                 panic(fmt.Errorf("failed to put log stream %d: %v", i, err))
                         }
 
                         descs[string(v)] = desc
                         streams[string(v)] = ls
                         if !ls.Purged {
                                 streamPaths = append(streamPaths, string(v))
                         }
                         purgedStreamPaths = append(purgedStreamPaths, string(v))
                         tc.Add(time.Second)
@@ skipping 10 matching lines @@
                 }
                 invert(streamPaths)
                 invert(purgedStreamPaths)
 
                 Convey(`An empty query will return all log streams.`, func() {
                         resp, err := svr.Query(c, &req)
                         So(err, ShouldBeRPCOK)
                         So(resp, shouldHaveLogPaths, streamPaths)
                 })
 
+                Convey(`An empty query to a different project return no log streams.`, func() {
+                        req.Project = "does-not-exist"
+
+                        resp, err := svr.Query(c, &req)
+                        So(err, ShouldBeRPCOK)
+                        So(resp, shouldHaveLogPaths)
+                })
+
                 Convey(`An empty query will include purged streams if admin.`, func() {
                         fs.IdentityGroups = []string{"test-administrators"}
 
                         resp, err := svr.Query(c, &req)
                         So(err, ShouldBeRPCOK)
                         So(resp, shouldHaveLogPaths, purgedStreamPaths)
                 })
 
                 Convey(`A query with an invalid path will return BadRequest error.`, func() {
                         req.Path = "***"
@@ skipping 283 matching lines @@
 
                         Convey(`When an invalid tag is specified, returns BadRequest error`, func() {
                                 req.Tags["+++not a valid tag+++"] = ""
 
                                 _, err := svr.Query(c, &req)
                                 So(err, ShouldBeRPCInvalidArgument, "invalid tag constraint")
                         })
                 })
         })
 }