LogDog: Project READ access for user endpoints.

appengine/logdog/coordinator/coordinatorTest/context.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 coordinatorTest
 
 import (
         "fmt"
 
         "github.com/golang/protobuf/proto"
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/appengine/logdog/coordinator"
         "github.com/luci/luci-go/appengine/logdog/coordinator/config"
         "github.com/luci/luci-go/appengine/tumble"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/clock/testclock"
         luciConfig "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/config/impl/memory"
         "github.com/luci/luci-go/common/gcloud/gs"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
-        configProto "github.com/luci/luci-go/common/proto/config"
         "github.com/luci/luci-go/common/proto/logdog/svcconfig"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/authtest"
         "github.com/luci/luci-go/server/logdog/storage"
         memoryStorage "github.com/luci/luci-go/server/logdog/storage/memory"
         "github.com/luci/luci-go/server/settings"
         "golang.org/x/net/context"
 )
 
 // Environment contains all of the testing facilities that are installed into
@@ skipping 48 matching lines @@
 
         var cfg svcconfig.Config
         e.modTextProtobuf(configSet, configPath, &cfg, func() {
                 if cfg.Coordinator == nil {
                         cfg.Coordinator = &svcconfig.Coordinator{}
                 }
                 fn(cfg.Coordinator)
         })
 }
 
+// ModProjectConfig loads the current configuration for the named project,
+// invokes the callback with its contents, and writes the result back to config.
+func (e *Environment) ModProjectConfig(proj luciConfig.ProjectName, fn func(*svcconfig.ProjectConfig)) {
+        configSet, configPath := config.ProjectConfigPath(proj)
+
+        var pcfg svcconfig.ProjectConfig
+        e.modTextProtobuf(configSet, configPath, &pcfg, func() {
+                fn(&pcfg)
+        })
+}
+
 // DrainTumbleAll drains all Tumble instances across all namespaces.
 func (e *Environment) DrainTumbleAll(c context.Context) {
         projects, err := luciConfig.Get(c).GetProjects()
         if err != nil {
                 panic(err)
         }
 
         for _, proj := range projects {
                 WithProjectNamespace(c, luciConfig.ProjectName(proj.ID), func(c context.Context) {
                         e.Tumble.Drain(c)
@@ skipping 11 matching lines @@
                 }
 
         case luciConfig.ErrNoConfig:
                 break
 
         default:
                 panic(err)
         }
 
         fn()
+        e.addConfigEntry(configSet, path, proto.MarshalTextString(msg))
+}
 
+func (e *Environment) addConfigEntry(configSet, path, content string) {
         cset := e.Config[configSet]
         if cset == nil {
                 cset = make(map[string]string)
                 e.Config[configSet] = cset
         }
-        cset[path] = proto.MarshalTextString(msg)
+        cset[path] = content
 }
 
 // Install creates a testing Context and installs common test facilities into
 // it, returning the Environment to which they're bound.
 func Install() (context.Context, *Environment) {
         e := Environment{
                 Config: make(map[string]memory.ConfigSet),
         }
 
         // Get our starting context. This installs, among other things, in-memory
@@ skipping 37 matching lines @@
         e.Clock = clock.Get(c).(testclock.TestClock)
 
         // Install GAE config service settings.
         c = settings.Use(c, settings.New(&settings.MemoryStorage{}))
 
         // Setup luci-config configuration.
         c = memory.Use(c, e.Config)
         e.ConfigIface = luciConfig.Get(c)
 
         // luci-config: Projects.
-        addProjectConfig := func(name luciConfig.ProjectName, localName string, access ...string) {
-                var cfg configProto.ProjectCfg
-                e.modTextProtobuf(fmt.Sprintf("projects/%s", name), "project.cfg", &cfg, func() {
-                        cfg.Name = &localName
-                        cfg.Access = access
+        addProjectConfig := func(proj luciConfig.ProjectName, access ...string) {
+                e.ModProjectConfig(proj, func(pcfg *svcconfig.ProjectConfig) {
+                        pcfg.ReaderAuthGroups = access
                 })
         }
-        addProjectConfig("proj-foo", "Foo Project", "group:all")
-        addProjectConfig("proj-bar", "Bar Project", "group:all")
-        addProjectConfig("proj-baz", "Baz Project", "group:all")
-        addProjectConfig("proj-qux", "Qux Project", "group:all")
-        addProjectConfig("proj-exclusive", "Exclusive Project", "group:auth")
+        addProjectConfig("proj-foo", "all")
+        addProjectConfig("proj-bar", "all")
+        addProjectConfig("proj-exclusive", "auth")
+
+        // Add a project without a LogDog project config.
+        e.addConfigEntry("projects/proj-unconfigured", "not-logdog.cfg", "junk")
+        e.addConfigEntry("projects/proj-malformed", svcconfig.ProjectConfigFilename, "!!! not a text protobuf !!!")
 
         // luci-config: Coordinator Defaults
         e.ModServiceConfig(c, func(cfg *svcconfig.Coordinator) {
                 *cfg = svcconfig.Coordinator{
                         AdminAuthGroup:   "admin",
                         ServiceAuthGroup: "services",
                 }
         })
 
         // Setup Tumble. This also adds the two Tumble indexes to datastore.
@@ skipping 27 matching lines @@
 }
 
 // WithProjectNamespace runs f in proj's namespace, bypassing authentication
 // checks.
 func WithProjectNamespace(c context.Context, proj luciConfig.ProjectName, f func(context.Context)) {
         if err := coordinator.WithProjectNamespaceNoAuth(&c, proj); err != nil {
                 panic(err)
         }
         f(c)
 }