Move "common/config" common types into cfgtypes.

logdog/appengine/coordinator/hierarchy/hierarchy_test.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 hierarchy
 
 import (
         "fmt"
         "testing"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
-        luciConfig "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/logdog/appengine/coordinator"
         ct "github.com/luci/luci-go/logdog/appengine/coordinator/coordinatorTest"
         "github.com/luci/luci-go/logdog/common/types"
+        "github.com/luci/luci-go/luci_config/common/cfgtypes"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestHierarchy(t *testing.T) {
         t.Parallel()
 
         Convey(`With a testing configuration`, t, func() {
                 c, env := ct.Install()
@@ skipping 117 matching lines @@
                         r.PathBase = "foo"
                         lv.pathBase = "foo"
                         So(get(), lv.shouldHaveComponents)
 
                         r.PathBase = "foo/+/bar"
                         lv.pathBase = "foo/+/bar"
                         So(get(), lv.shouldHaveComponents)
                 })
 
                 Convey(`Can register a hierarchy of name components in multiple namespaces.`, func() {
-                        for _, proj := range []luciConfig.ProjectName{
+                        for _, proj := range []cfgtypes.ProjectName{
                                 "proj-foo", "proj-bar", "proj-exclusive",
                         } {
                                 // Bypass access check.
                                 ic := info.MustNamespace(c, coordinator.ProjectNamespace(proj))
 
                                 for _, p := range []types.StreamPath{
                                         "foo/+/baz",
                                         "foo/+/qux",
                                         "foo/+/qux",
                                         "foo/+/qux/2468",
@@ skipping 15 matching lines @@
                                                 if err := c.Put(ic); err != nil {
                                                         panic(err)
                                                 }
                                         }
                                 }
                         }
                         ds.GetTestable(c).CatchupIndexes()
 
                         Convey(`Can list the hierarchy immediate paths (discrete).`, func() {
                                 r.Project = "proj-foo"
-                                lv.project = luciConfig.ProjectName(r.Project)
+                                lv.project = cfgtypes.ProjectName(r.Project)
 
                                 list := func(b string) *List {
                                         r.Project = "proj-foo"
                                         r.PathBase = b
 
                                         // Set up our validator for these query results.
                                         lv.pathBase = types.StreamPath(r.PathBase)
                                         return get()
                                 }
 
                                 So(list(""), lv.shouldHaveComponents, "bar", "foo")
                                 So(list("foo"), lv.shouldHaveComponents, "+", "bar")
                                 So(list("foo/+"), lv.shouldHaveComponents, "14$", "001337$", "bar$", "baz$", "qux$", "bar", "qux")
                                 So(list("foo/+/bar"), lv.shouldHaveComponents, "baz$")
                                 So(list("foo/bar"), lv.shouldHaveComponents, "+")
                                 So(list("foo/bar/+"), lv.shouldHaveComponents, "baz$")
                                 So(list("bar"), lv.shouldHaveComponents, "+")
                                 So(list("bar/+"), lv.shouldHaveComponents, "baz$", "baz")
                                 So(list("baz"), lv.shouldHaveComponents)
                         })
 
                         Convey(`Performing discrete queries`, func() {
                                 r.Project = "proj-foo"
-                                lv.project = luciConfig.ProjectName(r.Project)
+                                lv.project = cfgtypes.ProjectName(r.Project)
 
                                 Convey(`When listing "proj-foo/foo/+"`, func() {
                                         r.PathBase = "foo/+"
                                         lv.pathBase = types.StreamPath(r.PathBase)
 
                                         Convey(`Can list the first 2 elements.`, func() {
                                                 r.Limit = 2
                                                 So(get(), lv.shouldHaveComponents, "14$", "001337$")
                                         })
 
@@ skipping 30 matching lines @@
                                                 }
                                                 r.Next = l.Next
                                         }
                                 })
                         })
                 })
         })
 }
 
 type listValidator struct {
-        project  luciConfig.ProjectName
+        project  cfgtypes.ProjectName
         pathBase types.StreamPath
 }
 
 func (lv *listValidator) shouldHaveComponents(actual interface{}, expected ...interface{}) string {
         a, ok := actual.(*List)
         if !ok {
                 return fmt.Sprintf("Actual value must be a *List, not %T", actual)
         }
 
         // The project and path base components should match.
@@ skipping 28 matching lines @@
 func norm(c []*ListComponent) []string {
         result := make([]string, len(c))
         for i, e := range c {
                 result[i] = e.Name
                 if e.Stream {
                         result[i] += "$"
                 }
         }
         return result
 }