github.com/altoros/juju-vmware@v0.0.0-20150312064031-f19ae857ccca/apiserver/common/environwatcher_test.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package common_test
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"github.com/juju/names"
    10  	jc "github.com/juju/testing/checkers"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/apiserver/common"
    14  	"github.com/juju/juju/apiserver/params"
    15  	apiservertesting "github.com/juju/juju/apiserver/testing"
    16  	"github.com/juju/juju/cmd/envcmd"
    17  	"github.com/juju/juju/environs"
    18  	"github.com/juju/juju/environs/config"
    19  	"github.com/juju/juju/environs/configstore"
    20  	"github.com/juju/juju/provider/dummy"
    21  	"github.com/juju/juju/state"
    22  	"github.com/juju/juju/testing"
    23  )
    24  
    25  type environWatcherSuite struct {
    26  	testing.BaseSuite
    27  
    28  	testingEnvConfig *config.Config
    29  }
    30  
    31  var _ = gc.Suite(&environWatcherSuite{})
    32  
    33  type fakeEnvironAccessor struct {
    34  	envConfig      *config.Config
    35  	envConfigError error
    36  }
    37  
    38  func (*fakeEnvironAccessor) WatchForEnvironConfigChanges() state.NotifyWatcher {
    39  	changes := make(chan struct{}, 1)
    40  	// Simulate initial event.
    41  	changes <- struct{}{}
    42  	return &fakeNotifyWatcher{changes}
    43  }
    44  
    45  func (f *fakeEnvironAccessor) EnvironConfig() (*config.Config, error) {
    46  	if f.envConfigError != nil {
    47  		return nil, f.envConfigError
    48  	}
    49  	return f.envConfig, nil
    50  }
    51  
    52  func (s *environWatcherSuite) TearDownTest(c *gc.C) {
    53  	dummy.Reset()
    54  	s.BaseSuite.TearDownTest(c)
    55  }
    56  
    57  func (s *environWatcherSuite) TestWatchSuccess(c *gc.C) {
    58  	resources := common.NewResources()
    59  	s.AddCleanup(func(_ *gc.C) { resources.StopAll() })
    60  	e := common.NewEnvironWatcher(
    61  		&fakeEnvironAccessor{},
    62  		resources,
    63  		nil,
    64  	)
    65  	result, err := e.WatchForEnvironConfigChanges()
    66  	c.Assert(err, jc.ErrorIsNil)
    67  	c.Assert(result, gc.DeepEquals, params.NotifyWatchResult{"1", nil})
    68  	c.Assert(resources.Count(), gc.Equals, 1)
    69  }
    70  
    71  func (*environWatcherSuite) TestEnvironConfigSuccess(c *gc.C) {
    72  	authorizer := apiservertesting.FakeAuthorizer{
    73  		Tag:            names.NewMachineTag("0"),
    74  		EnvironManager: true,
    75  	}
    76  	testingEnvConfig := testingEnvConfig(c)
    77  	e := common.NewEnvironWatcher(
    78  		&fakeEnvironAccessor{envConfig: testingEnvConfig},
    79  		nil,
    80  		authorizer,
    81  	)
    82  	result, err := e.EnvironConfig()
    83  	c.Assert(err, jc.ErrorIsNil)
    84  	// Make sure we can read the secret attribute (i.e. it's not masked).
    85  	c.Check(result.Config["secret"], gc.Equals, "pork")
    86  	c.Check(map[string]interface{}(result.Config), jc.DeepEquals, testingEnvConfig.AllAttrs())
    87  }
    88  
    89  func (*environWatcherSuite) TestEnvironConfigFetchError(c *gc.C) {
    90  	authorizer := apiservertesting.FakeAuthorizer{
    91  		Tag:            names.NewMachineTag("0"),
    92  		EnvironManager: true,
    93  	}
    94  	e := common.NewEnvironWatcher(
    95  		&fakeEnvironAccessor{
    96  			envConfigError: fmt.Errorf("pow"),
    97  		},
    98  		nil,
    99  		authorizer,
   100  	)
   101  	_, err := e.EnvironConfig()
   102  	c.Assert(err, gc.ErrorMatches, "pow")
   103  }
   104  
   105  func (*environWatcherSuite) TestEnvironConfigMaskedSecrets(c *gc.C) {
   106  	authorizer := apiservertesting.FakeAuthorizer{
   107  		Tag:            names.NewMachineTag("0"),
   108  		EnvironManager: false,
   109  	}
   110  	testingEnvConfig := testingEnvConfig(c)
   111  	e := common.NewEnvironWatcher(
   112  		&fakeEnvironAccessor{envConfig: testingEnvConfig},
   113  		nil,
   114  		authorizer,
   115  	)
   116  	result, err := e.EnvironConfig()
   117  	c.Assert(err, jc.ErrorIsNil)
   118  	// Make sure the secret attribute is masked.
   119  	c.Check(result.Config["secret"], gc.Equals, "not available")
   120  	// And only that is masked.
   121  	result.Config["secret"] = "pork"
   122  	c.Check(map[string]interface{}(result.Config), jc.DeepEquals, testingEnvConfig.AllAttrs())
   123  }
   124  
   125  func testingEnvConfig(c *gc.C) *config.Config {
   126  	cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
   127  	c.Assert(err, jc.ErrorIsNil)
   128  	env, err := environs.Prepare(cfg, envcmd.BootstrapContext(testing.Context(c)), configstore.NewMem())
   129  	c.Assert(err, jc.ErrorIsNil)
   130  	return env.Config()
   131  }