github.com/rogpeppe/juju@v0.0.0-20140613142852-6337964b789e/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/ioutil"
     8  	"os"
     9  	"testing"
    10  
    11  	"github.com/juju/cmd"
    12  	gitjujutesting "github.com/juju/testing"
    13  	jc "github.com/juju/testing/checkers"
    14  	"launchpad.net/gnuflag"
    15  	gc "launchpad.net/gocheck"
    16  
    17  	"github.com/juju/juju/cmd/envcmd"
    18  	"github.com/juju/juju/environs"
    19  	"github.com/juju/juju/juju/osenv"
    20  	coretesting "github.com/juju/juju/testing"
    21  )
    22  
    23  type EnvironmentCommandSuite struct {
    24  	coretesting.FakeJujuHomeSuite
    25  }
    26  
    27  var _ = gc.Suite(&EnvironmentCommandSuite{})
    28  
    29  func Test(t *testing.T) { gc.TestingT(t) }
    30  
    31  func (s *EnvironmentCommandSuite) TestReadCurrentEnvironmentUnset(c *gc.C) {
    32  	env := envcmd.ReadCurrentEnvironment()
    33  	c.Assert(env, gc.Equals, "")
    34  }
    35  
    36  func (s *EnvironmentCommandSuite) TestReadCurrentEnvironmentSet(c *gc.C) {
    37  	err := envcmd.WriteCurrentEnvironment("fubar")
    38  	c.Assert(err, gc.IsNil)
    39  	env := envcmd.ReadCurrentEnvironment()
    40  	c.Assert(env, gc.Equals, "fubar")
    41  }
    42  
    43  func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentNothingSet(c *gc.C) {
    44  	envPath := gitjujutesting.HomePath(".juju", "environments.yaml")
    45  	err := os.Remove(envPath)
    46  	c.Assert(err, gc.IsNil)
    47  	env, err := envcmd.GetDefaultEnvironment()
    48  	c.Assert(env, gc.Equals, "")
    49  	c.Assert(err, jc.Satisfies, environs.IsNoEnv)
    50  }
    51  
    52  func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentCurrentEnvironmentSet(c *gc.C) {
    53  	err := envcmd.WriteCurrentEnvironment("fubar")
    54  	c.Assert(err, gc.IsNil)
    55  	env, err := envcmd.GetDefaultEnvironment()
    56  	c.Assert(env, gc.Equals, "fubar")
    57  	c.Assert(err, gc.IsNil)
    58  }
    59  
    60  func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentJujuEnvSet(c *gc.C) {
    61  	os.Setenv(osenv.JujuEnvEnvKey, "magic")
    62  	env, err := envcmd.GetDefaultEnvironment()
    63  	c.Assert(env, gc.Equals, "magic")
    64  	c.Assert(err, gc.IsNil)
    65  }
    66  
    67  func (s *EnvironmentCommandSuite) TestGetDefaultEnvironmentBothSet(c *gc.C) {
    68  	os.Setenv(osenv.JujuEnvEnvKey, "magic")
    69  	err := envcmd.WriteCurrentEnvironment("fubar")
    70  	c.Assert(err, gc.IsNil)
    71  	env, err := envcmd.GetDefaultEnvironment()
    72  	c.Assert(env, gc.Equals, "magic")
    73  	c.Assert(err, gc.IsNil)
    74  }
    75  
    76  func (s *EnvironmentCommandSuite) TestWriteAddsNewline(c *gc.C) {
    77  	err := envcmd.WriteCurrentEnvironment("fubar")
    78  	c.Assert(err, gc.IsNil)
    79  	current, err := ioutil.ReadFile(envcmd.GetCurrentEnvironmentFilePath())
    80  	c.Assert(err, gc.IsNil)
    81  	c.Assert(string(current), gc.Equals, "fubar\n")
    82  }
    83  
    84  func (*EnvironmentCommandSuite) TestErrorWritingFile(c *gc.C) {
    85  	// Can't write a file over a directory.
    86  	os.MkdirAll(envcmd.GetCurrentEnvironmentFilePath(), 0777)
    87  	err := envcmd.WriteCurrentEnvironment("fubar")
    88  	c.Assert(err, gc.ErrorMatches, "unable to write to the environment file: .*")
    89  }
    90  
    91  func (s *EnvironmentCommandSuite) TestEnvironCommandInit(c *gc.C) {
    92  	// Take environment name from command line arg.
    93  	cmd, envName := prepareEnvCommand(c, "explicit")
    94  	err := cmd.Init(nil)
    95  	c.Assert(err, gc.IsNil)
    96  	c.Assert(*envName, gc.Equals, "explicit")
    97  
    98  	// Take environment name from the default.
    99  	coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
   100  	testEnsureEnvName(c, coretesting.SampleEnvName)
   101  
   102  	// Take environment name from the one and only environment,
   103  	// even if it is not explicitly marked as default.
   104  	coretesting.WriteEnvironments(c, coretesting.SingleEnvConfigNoDefault)
   105  	testEnsureEnvName(c, coretesting.SampleEnvName)
   106  
   107  	// If there is a current-environment file, use that.
   108  	err = envcmd.WriteCurrentEnvironment("fubar")
   109  	testEnsureEnvName(c, "fubar")
   110  }
   111  
   112  func (s *EnvironmentCommandSuite) TestEnvironCommandInitErrors(c *gc.C) {
   113  	envPath := gitjujutesting.HomePath(".juju", "environments.yaml")
   114  	err := os.Remove(envPath)
   115  	c.Assert(err, gc.IsNil)
   116  	cmd, _ := prepareEnvCommand(c, "")
   117  	err = cmd.Init(nil)
   118  	c.Assert(err, jc.Satisfies, environs.IsNoEnv)
   119  
   120  	// If there are multiple environments but no default,
   121  	// an error should be returned.
   122  	coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfigNoDefault)
   123  	cmd, _ = prepareEnvCommand(c, "")
   124  	err = cmd.Init(nil)
   125  	c.Assert(err, gc.Equals, envcmd.ErrNoEnvironmentSpecified)
   126  }
   127  
   128  type testCommand struct {
   129  	envcmd.EnvCommandBase
   130  }
   131  
   132  func (c *testCommand) Info() *cmd.Info {
   133  	panic("should not be called")
   134  }
   135  
   136  func (c *testCommand) Run(ctx *cmd.Context) error {
   137  	panic("should not be called")
   138  }
   139  
   140  // prepareEnvCommand prepares a Command for a call to Init,
   141  // returning the Command and a pointer to a string that will
   142  // contain the environment name after the Command's Init method
   143  // has been called.
   144  func prepareEnvCommand(c *gc.C, name string) (cmd.Command, *string) {
   145  	var flags gnuflag.FlagSet
   146  	var cmd testCommand
   147  	wrapped := envcmd.Wrap(&cmd)
   148  	wrapped.SetFlags(&flags)
   149  	var args []string
   150  	if name != "" {
   151  		args = []string{"-e", name}
   152  	}
   153  	err := flags.Parse(false, args)
   154  	c.Assert(err, gc.IsNil)
   155  	return wrapped, &cmd.EnvName
   156  }
   157  
   158  func testEnsureEnvName(c *gc.C, expect string) {
   159  	cmd, envName := prepareEnvCommand(c, "")
   160  	err := cmd.Init(nil)
   161  	c.Assert(err, gc.IsNil)
   162  	c.Assert(*envName, gc.Equals, expect)
   163  }