Move "common/config" common types into cfgtypes.

logdog/appengine/coordinator/coordinatorTest/context.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.
 
 package coordinatorTest
 
 import (
         "fmt"
         "strings"
         "time"
 
         "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/data/caching/cacheContext"
         "github.com/luci/luci-go/common/gcloud/gs"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         "github.com/luci/luci-go/common/proto/google"
         "github.com/luci/luci-go/logdog/api/config/svcconfig"
         "github.com/luci/luci-go/logdog/appengine/coordinator"
         "github.com/luci/luci-go/logdog/appengine/coordinator/config"
         "github.com/luci/luci-go/logdog/common/storage/archive"
         "github.com/luci/luci-go/logdog/common/storage/bigtable"
+        "github.com/luci/luci-go/luci_config/common/cfgtypes"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/authtest"
         "github.com/luci/luci-go/server/auth/identity"
         "github.com/luci/luci-go/server/settings"
         "github.com/luci/luci-go/tumble"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
 
         "github.com/golang/protobuf/proto"
@@ skipping 53 matching lines @@
 // LeaveAllGroups clears all auth groups that the user is currently a member of.
 func (e *Environment) LeaveAllGroups() {
         e.AuthState.IdentityGroups = nil
         e.JoinGroup("all")
 }
 
 // ClearCoordinatorConfig removes the Coordinator configuration entry,
 // simulating a missing config.
 func (e *Environment) ClearCoordinatorConfig(c context.Context) {
         configSet, _ := config.ServiceConfigPath(c)
-        delete(e.Config, configSet)
+        delete(e.Config, string(configSet))
 }
 
 // ModServiceConfig loads the current service configuration, invokes the
 // callback with its contents, and writes the result back to config.
 func (e *Environment) ModServiceConfig(c context.Context, fn func(*svcconfig.Config)) {
         configSet, configPath := config.ServiceConfigPath(c)
 
         var cfg svcconfig.Config
         e.modTextProtobuf(c, configSet, configPath, &cfg, func() {
                 fn(&cfg)
         })
 }
 
 // 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(c context.Context, proj luciConfig.ProjectName, fn func(*svcconfig.ProjectConfig)) {
-        configSet, configPath := luciConfig.ProjectConfigSet(proj), config.ProjectConfigPath(c)
+func (e *Environment) ModProjectConfig(c context.Context, proj cfgtypes.ProjectName, fn func(*svcconfig.ProjectConfig)) {
+        configSet, configPath := cfgtypes.ProjectConfigSet(proj), config.ProjectConfigPath(c)
 
         var pcfg svcconfig.ProjectConfig
         e.modTextProtobuf(c, configSet, configPath, &pcfg, func() {
                 fn(&pcfg)
         })
 }
 
 // IterateTumbleAll iterates all Tumble instances across all namespaces.
 func (e *Environment) IterateTumbleAll(c context.Context) {
         projects, err := luciConfig.GetProjects(c)
         if err != nil {
                 panic(err)
         }
 
         for _, proj := range projects {
-                WithProjectNamespace(c, luciConfig.ProjectName(proj.ID), func(c context.Context) {
+                WithProjectNamespace(c, cfgtypes.ProjectName(proj.ID), func(c context.Context) {
                         e.Tumble.Iterate(c)
                 })
         }
 }
 
-func (e *Environment) modTextProtobuf(c context.Context, configSet, path string, msg proto.Message, fn func()) {
-        cfg, err := e.ConfigIface.GetConfig(c, configSet, path, false)
+func (e *Environment) modTextProtobuf(c context.Context, configSet cfgtypes.ConfigSet, path string, msg proto.Message, fn func()) {
+        cfg, err := e.ConfigIface.GetConfig(c, string(configSet), path, false)
 
         switch err {
         case nil:
                 if err := proto.UnmarshalText(cfg.Content, msg); err != nil {
                         panic(err)
                 }
 
         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]
+func (e *Environment) addConfigEntry(configSet cfgtypes.ConfigSet, path, content string) {
+        cset := e.Config[string(configSet)]
         if cset == nil {
                 cset = make(map[string]string)
-                e.Config[configSet] = cset
+                e.Config[string(configSet)] = cset
         }
         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),
                 GSClient: GSClient{},
@@ skipping 49 matching lines @@
 
         // Install GAE config service settings.
         c = settings.Use(c, settings.New(&settings.MemoryStorage{}))
 
         // Setup luci-config configuration.
         e.ConfigIface = memory.New(e.Config)
         c = luciConfig.SetImplementation(c, e.ConfigIface)
 
         // luci-config: Projects.
         projectName := info.AppID(c)
-        addProjectConfig := func(proj luciConfig.ProjectName, access ...string) {
+        addProjectConfig := func(proj cfgtypes.ProjectName, access ...string) {
                 e.ModProjectConfig(c, proj, func(pcfg *svcconfig.ProjectConfig) {
                         for _, a := range access {
                                 parts := strings.SplitN(a, ":", 2)
                                 group, field := parts[0], &pcfg.ReaderAuthGroups
                                 if len(parts) == 2 {
                                         switch parts[1] {
                                         case "R":
                                                 break
                                         case "W":
                                                 field = &pcfg.WriterAuthGroups
                                         default:
                                                 panic(a)
                                         }
                                 }
                                 *field = append(*field, group)
                         }
                 })
         }
         addProjectConfig("proj-foo", "all:R", "all:W")
         addProjectConfig("proj-bar", "all:R", "auth:W")
         addProjectConfig("proj-exclusive", "auth:R", "auth:W")
 
         // Add a project without a LogDog project config.
         e.addConfigEntry("projects/proj-unconfigured", "not-logdog.cfg", "junk")
 
-        configSet, configPath := luciConfig.ProjectConfigSet("proj-malformed"), config.ProjectConfigPath(c)
+        configSet, configPath := cfgtypes.ProjectConfigSet("proj-malformed"), config.ProjectConfigPath(c)
         e.addConfigEntry(configSet, configPath, "!!! not a text protobuf !!!")
 
         // luci-config: Coordinator Defaults
         e.ModServiceConfig(c, func(cfg *svcconfig.Config) {
                 cfg.Transport = &svcconfig.Transport{
                         Type: &svcconfig.Transport_Pubsub{
                                 Pubsub: &svcconfig.Transport_PubSub{
                                         Project: projectName,
                                         Topic:   "test-topic",
                                 },
@@ skipping 51 matching lines @@
                         return &e.ArchivalPublisher, nil
                 },
         }
         c = coordinator.WithServices(c, &e.Services)
 
         return cacheContext.Wrap(c), &e
 }
 
 // WithProjectNamespace runs f in proj's namespace, bypassing authentication
 // checks.
-func WithProjectNamespace(c context.Context, proj luciConfig.ProjectName, f func(context.Context)) {
+func WithProjectNamespace(c context.Context, proj cfgtypes.ProjectName, f func(context.Context)) {
         if err := coordinator.WithProjectNamespace(&c, proj, coordinator.NamespaceAccessAllTesting); err != nil {
                 panic(err)
         }
         f(c)
 }