github.com/Pankov404/juju@v0.0.0-20150703034450-be266991dceb/cmd/envcmd/environmentcommand_test.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package envcmd_test
     5  
     6  import (
     7  	"io"
     8  	"io/ioutil"
     9  	"os"
    10  	"testing"
    11  
    12  	"github.com/juju/cmd"
    13  	"github.com/juju/cmd/cmdtesting"
    14  	"github.com/juju/errors"
    15  	gitjujutesting "github.com/juju/testing"
    16  	jc "github.com/juju/testing/checkers"
    17  	gc "gopkg.in/check.v1"
    18  
    19  	"github.com/juju/juju/cmd/envcmd"
    20  	"github.com/juju/juju/environs/configstore"
    21  	"github.com/juju/juju/juju/osenv"
    22  	coretesting "github.com/juju/juju/testing"
    23  	"github.com/juju/juju/version"
    24  )
    25  
    26  type EnvironmentCommandSuite struct {
    27  	coretesting.FakeJujuHomeSuite
    28  }
    29  
    30  func (s *EnvironmentCommandSuite) SetUpTest(c *gc.C) {
    31  	s.FakeJujuHomeSuite.SetUpTest(c)
    32  	s.PatchEnvironment("JUJU_CLI_VERSION", "")
    33  }
    34  
    35  var _ = gc.Suite(&EnvironmentCommandSuite{})
    36  
    37  func Test(t *testing.T) { gc.TestingT(t) }
    38  
    39  func (s *EnvironmentCommandSuite) TestReadCurrentEnvironmentUnset(c *gc.C) {
    40  	env := envcmd.ReadCurrentEnvironment()
    41  	c.Assert(env, gc.Equals, "")
    42  }
    43  
    44  func (s *EnvironmentCommandSuite) TestReadCurrentEnvironmentSet(c *gc.C) {
    45  	err := envcmd.WriteCurrentEnvironment("fubar")
    46  	c.Assert(err, jc.ErrorIsNil)
    47  	env := envcmd.ReadCurrentEnvironment()
    48  	c.Assert(env, gc.Equals, "fubar")
    49  }
    50  
    51  func (s *EnvironmentCommandSuite) TestGetDefaultEnvironment(c *gc.C) {
    52  	env, err := envcmd.GetDefaultEnvironment()
    53  	c.Assert(env, gc.Equals, "erewhemos")
    54  	c.Assert(err, jc.ErrorIsNil)
    55  }
    56  
    57  func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentNothingSet(c *gc.C) {
    58  	envPath := gitjujutesting.HomePath(".juju", "environments.yaml")
    59  	err := os.Remove(envPath)
    60  	c.Assert(err, jc.ErrorIsNil)
    61  	env, err := envcmd.GetDefaultEnvironment()
    62  	c.Assert(env, gc.Equals, "")
    63  	c.Assert(err, jc.ErrorIsNil)
    64  }
    65  
    66  func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentCurrentEnvironmentSet(c *gc.C) {
    67  	err := envcmd.WriteCurrentEnvironment("fubar")
    68  	c.Assert(err, jc.ErrorIsNil)
    69  	env, err := envcmd.GetDefaultEnvironment()
    70  	c.Assert(env, gc.Equals, "fubar")
    71  	c.Assert(err, jc.ErrorIsNil)
    72  }
    73  
    74  func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentJujuEnvSet(c *gc.C) {
    75  	os.Setenv(osenv.JujuEnvEnvKey, "magic")
    76  	env, err := envcmd.GetDefaultEnvironment()
    77  	c.Assert(env, gc.Equals, "magic")
    78  	c.Assert(err, jc.ErrorIsNil)
    79  }
    80  
    81  func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentBothSet(c *gc.C) {
    82  	os.Setenv(osenv.JujuEnvEnvKey, "magic")
    83  	err := envcmd.WriteCurrentEnvironment("fubar")
    84  	c.Assert(err, jc.ErrorIsNil)
    85  	env, err := envcmd.GetDefaultEnvironment()
    86  	c.Assert(env, gc.Equals, "magic")
    87  	c.Assert(err, jc.ErrorIsNil)
    88  }
    89  
    90  func (s *EnvironmentCommandSuite) TestWriteAddsNewline(c *gc.C) {
    91  	err := envcmd.WriteCurrentEnvironment("fubar")
    92  	c.Assert(err, jc.ErrorIsNil)
    93  	current, err := ioutil.ReadFile(envcmd.GetCurrentEnvironmentFilePath())
    94  	c.Assert(err, jc.ErrorIsNil)
    95  	c.Assert(string(current), gc.Equals, "fubar\n")
    96  }
    97  
    98  func (*EnvironmentCommandSuite) TestErrorWritingFile(c *gc.C) {
    99  	// Can't write a file over a directory.
   100  	os.MkdirAll(envcmd.GetCurrentEnvironmentFilePath(), 0777)
   101  	err := envcmd.WriteCurrentEnvironment("fubar")
   102  	c.Assert(err, gc.ErrorMatches, "unable to write to the environment file: .*")
   103  }
   104  
   105  func (s *EnvironmentCommandSuite) TestEnvironCommandInitExplicit(c *gc.C) {
   106  	// Take environment name from command line arg.
   107  	testEnsureEnvName(c, "explicit", "-e", "explicit")
   108  }
   109  
   110  func (s *EnvironmentCommandSuite) TestEnvironCommandInitMultipleConfigs(c *gc.C) {
   111  	// Take environment name from the default.
   112  	coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
   113  	testEnsureEnvName(c, coretesting.SampleEnvName)
   114  }
   115  
   116  func (s *EnvironmentCommandSuite) TestEnvironCommandInitSingleConfig(c *gc.C) {
   117  	// Take environment name from the one and only environment,
   118  	// even if it is not explicitly marked as default.
   119  	coretesting.WriteEnvironments(c, coretesting.SingleEnvConfigNoDefault)
   120  	testEnsureEnvName(c, coretesting.SampleEnvName)
   121  }
   122  
   123  func (s *EnvironmentCommandSuite) TestEnvironCommandInitEnvFile(c *gc.C) {
   124  	// If there is a current-environment file, use that.
   125  	err := envcmd.WriteCurrentEnvironment("fubar")
   126  	c.Assert(err, jc.ErrorIsNil)
   127  	testEnsureEnvName(c, "fubar")
   128  }
   129  
   130  func (s *EnvironmentCommandSuite) TestEnvironCommandInitNoEnvFile(c *gc.C) {
   131  	envPath := gitjujutesting.HomePath(".juju", "environments.yaml")
   132  	err := os.Remove(envPath)
   133  	c.Assert(err, jc.ErrorIsNil)
   134  	testEnsureEnvName(c, "")
   135  }
   136  
   137  func (s *EnvironmentCommandSuite) TestEnvironCommandInitMultipleConfigNoDefault(c *gc.C) {
   138  	// If there are multiple environments but no default, the connection name is empty.
   139  	coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfigNoDefault)
   140  	testEnsureEnvName(c, "")
   141  }
   142  
   143  func (s *EnvironmentCommandSuite) TestBootstrapContext(c *gc.C) {
   144  	ctx := envcmd.BootstrapContext(&cmd.Context{})
   145  	c.Assert(ctx.ShouldVerifyCredentials(), jc.IsTrue)
   146  }
   147  
   148  func (s *EnvironmentCommandSuite) TestBootstrapContextNoVerify(c *gc.C) {
   149  	ctx := envcmd.BootstrapContextNoVerify(&cmd.Context{})
   150  	c.Assert(ctx.ShouldVerifyCredentials(), jc.IsFalse)
   151  }
   152  
   153  func (s *EnvironmentCommandSuite) TestCompatVersion(c *gc.C) {
   154  	s.PatchEnvironment(osenv.JujuCLIVersion, "2")
   155  	cmd, err := initTestCommand(c)
   156  	c.Assert(err, jc.ErrorIsNil)
   157  	c.Assert(cmd.CompatVersion(), gc.Equals, 2)
   158  }
   159  
   160  func (s *EnvironmentCommandSuite) TestCompatVersionDefault(c *gc.C) {
   161  	cmd, err := initTestCommand(c)
   162  	c.Assert(err, jc.ErrorIsNil)
   163  	c.Assert(cmd.CompatVersion(), gc.Equals, 1)
   164  }
   165  
   166  func (s *EnvironmentCommandSuite) TestCompatVersionInvalid(c *gc.C) {
   167  	s.PatchEnvironment(osenv.JujuCLIVersion, "invalid")
   168  	cmd, err := initTestCommand(c)
   169  	c.Assert(err, jc.ErrorIsNil)
   170  	c.Assert(cmd.CompatVersion(), gc.Equals, 1)
   171  }
   172  
   173  type testCommand struct {
   174  	envcmd.EnvCommandBase
   175  }
   176  
   177  func (c *testCommand) Info() *cmd.Info {
   178  	panic("should not be called")
   179  }
   180  
   181  func (c *testCommand) Run(ctx *cmd.Context) error {
   182  	panic("should not be called")
   183  }
   184  
   185  func initTestCommand(c *gc.C, args ...string) (*testCommand, error) {
   186  	cmd := new(testCommand)
   187  	wrapped := envcmd.Wrap(cmd)
   188  	return cmd, cmdtesting.InitCommand(wrapped, args)
   189  }
   190  
   191  func testEnsureEnvName(c *gc.C, expect string, args ...string) {
   192  	cmd, err := initTestCommand(c, args...)
   193  	c.Assert(err, jc.ErrorIsNil)
   194  	c.Assert(cmd.ConnectionName(), gc.Equals, expect)
   195  }
   196  
   197  type ConnectionEndpointSuite struct {
   198  	coretesting.FakeJujuHomeSuite
   199  	store    configstore.Storage
   200  	endpoint configstore.APIEndpoint
   201  }
   202  
   203  var _ = gc.Suite(&ConnectionEndpointSuite{})
   204  
   205  func (s *ConnectionEndpointSuite) SetUpTest(c *gc.C) {
   206  	s.FakeHomeSuite.SetUpTest(c)
   207  	s.store = configstore.NewMem()
   208  	s.PatchValue(envcmd.GetConfigStore, func() (configstore.Storage, error) {
   209  		return s.store, nil
   210  	})
   211  	newInfo := s.store.CreateInfo("env-name")
   212  	newInfo.SetAPICredentials(configstore.APICredentials{
   213  		User:     "foo",
   214  		Password: "foopass",
   215  	})
   216  	s.endpoint = configstore.APIEndpoint{
   217  		Addresses:   []string{"0.1.2.3"},
   218  		Hostnames:   []string{"foo.invalid"},
   219  		CACert:      "certificated",
   220  		EnvironUUID: "fake-uuid",
   221  	}
   222  	newInfo.SetAPIEndpoint(s.endpoint)
   223  	err := newInfo.Write()
   224  	c.Assert(err, jc.ErrorIsNil)
   225  }
   226  
   227  func (s *ConnectionEndpointSuite) TestAPIEndpointInStoreCached(c *gc.C) {
   228  	cmd, err := initTestCommand(c, "-e", "env-name")
   229  	c.Assert(err, jc.ErrorIsNil)
   230  	endpoint, err := cmd.ConnectionEndpoint(false)
   231  	c.Assert(err, jc.ErrorIsNil)
   232  	c.Assert(endpoint, gc.DeepEquals, s.endpoint)
   233  }
   234  
   235  func (s *ConnectionEndpointSuite) TestAPIEndpointForEnvSuchName(c *gc.C) {
   236  	cmd, err := initTestCommand(c, "-e", "no-such-env")
   237  	c.Assert(err, jc.ErrorIsNil)
   238  	_, err = cmd.ConnectionEndpoint(false)
   239  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
   240  	c.Assert(err, gc.ErrorMatches, `environment "no-such-env" not found`)
   241  }
   242  
   243  func (s *ConnectionEndpointSuite) TestAPIEndpointRefresh(c *gc.C) {
   244  	newEndpoint := configstore.APIEndpoint{
   245  		Addresses:   []string{"0.1.2.3"},
   246  		Hostnames:   []string{"foo.example.com"},
   247  		CACert:      "certificated",
   248  		EnvironUUID: "fake-uuid",
   249  	}
   250  	s.PatchValue(envcmd.EndpointRefresher, func(_ *envcmd.EnvCommandBase) (io.Closer, error) {
   251  		info, err := s.store.ReadInfo("env-name")
   252  		info.SetAPIEndpoint(newEndpoint)
   253  		err = info.Write()
   254  		c.Assert(err, jc.ErrorIsNil)
   255  		return new(closer), nil
   256  	})
   257  
   258  	cmd, err := initTestCommand(c, "-e", "env-name")
   259  	c.Assert(err, jc.ErrorIsNil)
   260  	endpoint, err := cmd.ConnectionEndpoint(true)
   261  	c.Assert(err, jc.ErrorIsNil)
   262  	c.Assert(endpoint, gc.DeepEquals, newEndpoint)
   263  }
   264  
   265  type closer struct{}
   266  
   267  func (*closer) Close() error {
   268  	return nil
   269  }
   270  
   271  type EnvironmentVersionSuite struct {
   272  	fake *fakeEnvGetter
   273  }
   274  
   275  var _ = gc.Suite(&EnvironmentVersionSuite{})
   276  
   277  type fakeEnvGetter struct {
   278  	agentVersion interface{}
   279  	err          error
   280  }
   281  
   282  func (g *fakeEnvGetter) EnvironmentGet() (map[string]interface{}, error) {
   283  	if g.err != nil {
   284  		return nil, g.err
   285  	} else if g.agentVersion == nil {
   286  		return map[string]interface{}{}, nil
   287  	} else {
   288  		return map[string]interface{}{
   289  			"agent-version": g.agentVersion,
   290  		}, nil
   291  	}
   292  }
   293  
   294  func (s *EnvironmentVersionSuite) SetUpTest(*gc.C) {
   295  	s.fake = new(fakeEnvGetter)
   296  }
   297  
   298  func (s *EnvironmentVersionSuite) TestApiCallFails(c *gc.C) {
   299  	s.fake.err = errors.New("boom")
   300  	_, err := envcmd.GetEnvironmentVersion(s.fake)
   301  	c.Assert(err, gc.ErrorMatches, "unable to retrieve environment config: boom")
   302  }
   303  
   304  func (s *EnvironmentVersionSuite) TestNoVersion(c *gc.C) {
   305  	_, err := envcmd.GetEnvironmentVersion(s.fake)
   306  	c.Assert(err, gc.ErrorMatches, "version not found in environment config")
   307  }
   308  
   309  func (s *EnvironmentVersionSuite) TestInvalidVersionType(c *gc.C) {
   310  	s.fake.agentVersion = 99
   311  	_, err := envcmd.GetEnvironmentVersion(s.fake)
   312  	c.Assert(err, gc.ErrorMatches, "invalid environment version type in config")
   313  }
   314  
   315  func (s *EnvironmentVersionSuite) TestInvalidVersion(c *gc.C) {
   316  	s.fake.agentVersion = "a.b.c"
   317  	_, err := envcmd.GetEnvironmentVersion(s.fake)
   318  	c.Assert(err, gc.ErrorMatches, "unable to parse environment version: .+")
   319  }
   320  
   321  func (s *EnvironmentVersionSuite) TestSuccess(c *gc.C) {
   322  	vs := "1.22.1"
   323  	s.fake.agentVersion = vs
   324  	v, err := envcmd.GetEnvironmentVersion(s.fake)
   325  	c.Assert(err, jc.ErrorIsNil)
   326  	c.Assert(v.Compare(version.MustParse(vs)), gc.Equals, 0)
   327  }