luci_config: Request content only when desired.

luci_config/server/cfgclient/config_test.go

 // Copyright 2016 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 cfgclient
 
 import (
         "fmt"
         "net/url"
         "testing"
 
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/luci_config/server/cfgclient/backend"
 
         "golang.org/x/net/context"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 // testingBackend is a Backend implementation that ignores Authority.
 type testingBackend struct {
         serviceURL *url.URL
         err        error
         items      []*backend.Item
         url        url.URL
+        lastParams backend.Params
 }
 
 func (tb *testingBackend) ServiceURL(context.Context) url.URL { return *tb.serviceURL }
 
 func (tb *testingBackend) Get(c context.Context, configSet, path string, p backend.Params) (*backend.Item, error) {
+        tb.lastParams = p
         if err := tb.err; err != nil {
                 return nil, tb.err
         }
         if len(tb.items) == 0 {
                 return nil, ErrNoConfig
         }
         return tb.cloneItems()[0], nil
 }
 
 func (tb *testingBackend) GetAll(c context.Context, t backend.GetAllTarget, path string, p backend.Params) (
         []*backend.Item, error) {
 
+        tb.lastParams = p
         if err := tb.err; err != nil {
                 return nil, tb.err
         }
         return tb.cloneItems(), nil
 }
 
 func (tb *testingBackend) ConfigSetURL(c context.Context, configSet string, p backend.Params) (url.URL, error) {
+        tb.lastParams = p
         return tb.url, tb.err
 }
 
 func (tb *testingBackend) cloneItems() []*backend.Item {
         clones := make([]*backend.Item, len(tb.items))
         for i, it := range tb.items {
                 clone := *it
                 clones[i] = &clone
         }
         return clones
@@ skipping 97 matching lines @@
 
                 Convey(`Test nil resolver`, func() {
                         transformItems(func(i int, ci *backend.Item) {
                                 ci.Content = fmt.Sprintf("[%d]", i)
                         })
 
                         Convey(`Single`, func() {
                                 var meta Meta
                                 So(Get(c, AsService, "", "", nil, &meta), ShouldBeNil)
                                 So(meta, ShouldResemble, Meta{"projects/foo", "path", "####", "v1"})
+                                So(tb.lastParams.Content, ShouldBeFalse)
                         })
 
                         Convey(`Multi`, func() {
                                 var meta []*Meta
                                 So(Projects(c, AsService, "", nil, &meta), ShouldBeNil)
                                 So(meta, ShouldResemble, []*Meta{
                                         {"projects/foo", "path", "####", "v1"},
                                         {"projects/bar", "path", "####", "v1"},
                                 })
+                                So(tb.lastParams.Content, ShouldBeFalse)
                         })
                 })
 
                 Convey(`Projects with some errors returns a MultiError.`, func() {
                         testErr := errors.New("test error")
                         var (
                                 val  []string
                                 meta []*Meta
                         )
                         er := errorMultiResolver{
@@ skipping 27 matching lines @@
                                 panic(err)
                         }
 
                         tb.url = *u
                         uv, err := GetConfigSetURL(c, AsService, "")
                         So(err, ShouldBeNil)
                         So(uv, ShouldResemble, url.URL{Scheme: "https", Host: "example.com", Path: "/foo/bar"})
                 })
         })
 }