func (s *SwitchSimpleSuite) TestCurrentControllerHasPrecedence(c *gc.C) {
testing.WriteEnvironments(c, testing.MultipleEnvConfig)
envcmd.WriteCurrentController("fubar")
context, err := testing.RunCommand(c, newSwitchCommand())
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(context), gc.Equals, "fubar (controller)\n")
}
func (s *NewAPIClientSuite) TestWithBootstrapConfigTakesPrecedence(c *gc.C) {
s.PatchValue(&version.Current, coretesting.FakeVersionNumber)
// We want to make sure that the code is using the bootstrap
// config rather than information from environments.yaml,
// even when there is an entry in environments.yaml
// We can do that by changing the info bootstrap config
// so it has a different environment name.
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
store := configstore.NewMem()
s.bootstrapEnv(c, coretesting.SampleModelName, store)
info, err := store.ReadInfo(coretesting.SampleModelName)
c.Assert(err, jc.ErrorIsNil)
envName2 := coretesting.SampleCertName + "-2"
info2 := store.CreateInfo(envName2)
info2.SetBootstrapConfig(info.BootstrapConfig())
err = info2.Write()
c.Assert(err, jc.ErrorIsNil)
// Now we have info for envName2 which will actually
// cause a connection to the originally bootstrapped
// state.
apiOpen := func(*api.Info, api.DialOpts) (api.Connection, error) {
return mockedAPIState(noFlags), nil
}
st, err := juju.NewAPIFromStore(envName2, store, apiOpen)
c.Check(err, jc.ErrorIsNil)
st.Close()
}
func (*OpenSuite) TestConfigForNameDefault(c *gc.C) {
testing.WriteEnvironments(c, testing.SingleEnvConfig)
cfg, source, err := environs.ConfigForName("", configstore.NewMem())
c.Assert(err, gc.IsNil)
c.Assert(cfg.Name(), gc.Equals, "erewhemos")
c.Assert(source, gc.Equals, environs.ConfigFromEnvirons)
}
func (s *ValidateImageMetadataSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.metadataDir = c.MkDir()
coretesting.WriteEnvironments(c, metadataTestEnvConfig)
s.PatchEnvironment("AWS_ACCESS_KEY_ID", "access")
s.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "secret")
}
func (*SwitchSimpleSuite) TestShowsJujuEnv(c *gc.C) {
testing.WriteEnvironments(c, testing.MultipleEnvConfig)
os.Setenv("JUJU_ENV", "using-env")
context, err := testing.RunCommand(c, newSwitchCommand())
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(context), gc.Equals, "using-env\n")
}
func (*SwitchSimpleSuite) TestSettingWritesFile(c *gc.C) {
testing.WriteEnvironments(c, testing.MultipleEnvConfig)
context, err := testing.RunCommand(c, &SwitchCommand{}, "erewhemos-2")
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(context), gc.Equals, "erewhemos -> erewhemos-2\n")
c.Assert(envcmd.ReadCurrentEnvironment(), gc.Equals, "erewhemos-2")
}
func (s *SwitchSimpleSuite) TestCurrentEnvironmentHasPrecidence(c *gc.C) {
testing.WriteEnvironments(c, testing.MultipleEnvConfig)
s.FakeHomeSuite.Home.AddFiles(c, gitjujutesting.TestFile{".juju/current-environment", "fubar"})
context, err := testing.RunCommand(c, &SwitchCommand{})
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(context), gc.Equals, "fubar\n")
}
func (*SwitchSimpleSuite) TestListEnvironmentsOSJujuEnvSet(c *gc.C) {
testing.WriteEnvironments(c, testing.MultipleEnvConfig)
os.Setenv("JUJU_ENV", "using-env")
context, err := testing.RunCommand(c, newSwitchCommand(), "--list")
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(context), gc.Equals, expectedEnvironments)
}
func (s *ImageMetadataSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.dir = c.MkDir()
// Create a fake certificate so azure test environment can be opened.
testing.WriteEnvironments(c, metadataTestEnvConfig)
s.PatchEnvironment("AWS_ACCESS_KEY_ID", "access")
s.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "secret")
}
func (s *SwitchSimpleSuite) TestJujuEnvOverCurrentEnvironment(c *gc.C) {
testing.WriteEnvironments(c, testing.MultipleEnvConfig)
s.FakeHomeSuite.Home.AddFiles(c, gitjujutesting.TestFile{".juju/current-environment", "fubar"})
os.Setenv("JUJU_ENV", "using-env")
context, err := testing.RunCommand(c, newSwitchCommand())
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(context), gc.Equals, "using-env\n")
}
func (*SwitchSimpleSuite) TestSettingWritesFile(c *gc.C) {
testing.WriteEnvironments(c, testing.MultipleEnvConfig)
context, err := testing.RunCommand(c, newSwitchCommand(), "erewhemos-2")
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stderr(context), gc.Equals, "-> erewhemos-2\n")
currentEnv, err := modelcmd.ReadCurrentModel()
c.Assert(err, jc.ErrorIsNil)
c.Assert(currentEnv, gc.Equals, "erewhemos-2")
}
func (s *datasourceSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
testing.WriteEnvironments(c, existingEnv)
environ, err := environs.PrepareFromName("test", testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
s.stor = environ.Storage()
s.baseURL, err = s.stor.URL("")
c.Assert(err, gc.IsNil)
}
func (s *NewAPIClientSuite) TestNameNotDefault(c *gc.C) {
envName := coretesting.SampleCertName + "-2"
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig, envName)
s.bootstrapEnv(c, envName, defaultConfigStore(c))
apiclient, err := juju.NewAPIClientFromName(envName)
c.Assert(err, jc.ErrorIsNil)
defer apiclient.Close()
assertEnvironmentName(c, apiclient, envName)
}
func (s *EnvironmentCommandSuite) TestEnvironCommandInit(c *gc.C) {
// Take environment name from command line arg.
testEnsureEnvName(c, "explicit", "-e", "explicit")
// Take environment name from the default.
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
testEnsureEnvName(c, coretesting.SampleEnvName)
// Take environment name from the one and only environment,
// even if it is not explicitly marked as default.
coretesting.WriteEnvironments(c, coretesting.SingleEnvConfigNoDefault)
testEnsureEnvName(c, coretesting.SampleEnvName)
// If there is a current-environment file, use that.
err := envcmd.WriteCurrentEnvironment("fubar")
c.Assert(err, gc.IsNil)
testEnsureEnvName(c, "fubar")
}
func (s *NewConnSuite) TestNewConnFromNameNotDefault(c *gc.C) {
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
// The default environment is "erewhemos", so make sure we get what we ask for.
const envName = "erewhemos-2"
bootstrapEnv(c, envName, defaultConfigStore(c))
conn, err := juju.NewConnFromName(envName)
c.Assert(err, gc.IsNil)
defer assertClose(c, conn)
c.Assert(conn.Environ.Name(), gc.Equals, envName)
}
func (s *BootstrapSuite) TestBootstrapSetsCurrentEnvironment(c *gc.C) {
const envName = "devenv"
s.patchVersionAndSeries(c, envName)
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
ctx, err := coretesting.RunCommand(c, newBootstrapCommand(), "-e", "devenv", "--auto-upgrade")
c.Assert(coretesting.Stderr(ctx), jc.Contains, "-> devenv")
currentEnv, err := envcmd.ReadCurrentEnvironment()
c.Assert(err, jc.ErrorIsNil)
c.Assert(currentEnv, gc.Equals, "devenv")
}
func (s *ValidateImageMetadataSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.metadataDir = c.MkDir()
coretesting.WriteEnvironments(c, metadataTestEnvConfig)
s.PatchEnvironment("AWS_ACCESS_KEY_ID", "access")
s.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "secret")
// All of the following are recognized as fallbacks by goamz.
s.PatchEnvironment("AWS_ACCESS_KEY", "")
s.PatchEnvironment("AWS_SECRET_KEY", "")
s.PatchEnvironment("EC2_ACCESS_KEY", "")
s.PatchEnvironment("EC2_SECRET_KEY", "")
}
// resetJujuHome restores an new, clean Juju home environment without tools.
func resetJujuHome(c *gc.C, envName string) environs.Environ {
jenvDir := gitjujutesting.HomePath(".juju", "environments")
err := os.RemoveAll(jenvDir)
c.Assert(err, jc.ErrorIsNil)
coretesting.WriteEnvironments(c, envConfig)
dummy.Reset()
store, err := configstore.Default()
c.Assert(err, jc.ErrorIsNil)
env, err := environs.PrepareFromName(envName, envcmd.BootstrapContext(cmdtesting.NullContext(c)), store)
c.Assert(err, jc.ErrorIsNil)
return env
}
// resetJujuHome restores an new, clean Juju home environment without tools.
func resetJujuHome(c *gc.C) environs.Environ {
jenvDir := gitjujutesting.HomePath(".juju", "environments")
err := os.RemoveAll(jenvDir)
c.Assert(err, gc.IsNil)
coretesting.WriteEnvironments(c, envConfig)
dummy.Reset()
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
env, err := environs.PrepareFromName("peckham", cmdtesting.NullContext(c), store)
c.Assert(err, gc.IsNil)
envtesting.RemoveAllTools(c, env)
return env
}
func (s *SwitchSimpleSuite) TestListEnvironmentsWithConfigstore(c *gc.C) {
memstore := configstore.NewMem()
s.PatchValue(&configstore.Default, func() (configstore.Storage, error) {
return memstore, nil
})
info := memstore.CreateInfo("testing")
err := info.Write()
testing.WriteEnvironments(c, testing.MultipleEnvConfig)
context, err := testing.RunCommand(c, newSwitchCommand(), "--list")
c.Assert(err, jc.ErrorIsNil)
expected := expectedEnvironments + "testing\n"
c.Assert(testing.Stdout(context), gc.Equals, expected)
}
func (s *ImageMetadataSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.dir = c.MkDir()
// Create a fake certificate so azure test environment can be opened.
certfile, err := ioutil.TempFile(s.dir, "")
c.Assert(err, jc.ErrorIsNil)
filename := certfile.Name()
err = ioutil.WriteFile(filename, []byte(testCert), 0644)
c.Assert(err, jc.ErrorIsNil)
envConfig := strings.Replace(metadataTestEnvConfig, "/home/me/azure.pem", filename, -1)
testing.WriteEnvironments(c, envConfig)
s.PatchEnvironment("AWS_ACCESS_KEY_ID", "access")
s.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "secret")
}
// An existing environments.yaml will not be overwritten without
// the explicit -f option.
func (*InitSuite) TestExistingEnvironmentNotOverwritten(c *gc.C) {
testing.WriteEnvironments(c, existingEnv)
ctx := testing.Context(c)
code := cmd.Main(&initCommand{}, ctx, nil)
c.Check(code, gc.Equals, 1)
errOut := ctx.Stderr.(*bytes.Buffer).String()
strippedOut := strings.Replace(errOut, "\n", "", -1)
c.Check(strippedOut, gc.Matches, ".*A juju environment configuration already exists.*")
environpath := gitjujutesting.HomePath(".juju", "environments.yaml")
data, err := ioutil.ReadFile(environpath)
c.Assert(err, jc.ErrorIsNil)
c.Assert(string(data), gc.Equals, existingEnv)
}
func (s *EnvironmentCommandSuite) TestEnvironCommandInitErrors(c *gc.C) {
envPath := gitjujutesting.HomePath(".juju", "environments.yaml")
err := os.Remove(envPath)
c.Assert(err, gc.IsNil)
cmd := envcmd.Wrap(new(testCommand))
err = cmdtesting.InitCommand(cmd, nil)
c.Assert(err, jc.Satisfies, environs.IsNoEnv)
// If there are multiple environments but no default,
// an error should be returned.
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfigNoDefault)
err = cmdtesting.InitCommand(cmd, nil)
c.Assert(err, gc.Equals, envcmd.ErrNoEnvironmentSpecified)
}
// An existing environments.yaml will be overwritten when -f is
// given explicitly.
func (*InitSuite) TestExistingEnvironmentOverwritten(c *gc.C) {
testing.WriteEnvironments(c, existingEnv)
ctx := testing.Context(c)
code := cmd.Main(&initCommand{}, ctx, []string{"-f"})
c.Check(code, gc.Equals, 0)
stdOut := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(stdOut, "\n", "", -1)
c.Check(strippedOut, gc.Matches, ".*A boilerplate environment configuration file has been written.*")
environpath := gitjujutesting.HomePath(".juju", "environments.yaml")
data, err := ioutil.ReadFile(environpath)
c.Assert(err, jc.ErrorIsNil)
strippedData := strings.Replace(string(data), "\n", "", -1)
c.Assert(strippedData, gc.Matches, ".*# This is the Juju config file, which you can use.*")
}
func (s *ImageMetadataSuite) TestImageMetadataFilesLatestLts(c *gc.C) {
envConfig := strings.Replace(metadataTestEnvConfig, "default-series: precise", "", -1)
testing.WriteEnvironments(c, envConfig)
ctx := testing.Context(c)
code := cmd.Main(
envcmd.Wrap(&ImageMetadataCommand{}), ctx, []string{
"-d", s.dir, "-i", "1234", "-r", "region", "-a", "arch", "-u", "endpoint"})
c.Assert(code, gc.Equals, 0)
out := testing.Stdout(ctx)
expected := expectedMetadata{
series: config.LatestLtsSeries(),
arch: "arch",
}
s.assertCommandOutput(c, expected, out, defaultIndexFileName, defaultImageFileName)
}
func (s *syncToolsSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
// Create a target environments.yaml and make sure its environment is empty.
coretesting.WriteEnvironments(c, `
environments:
test-target:
type: dummy
state-server: false
authorized-keys: "not-really-one"
`)
var err error
s.configStore, err = configstore.Default()
c.Assert(err, gc.IsNil)
s.origSyncTools = syncTools
}
func (s *NewAPIClientSuite) TestNameDefault(c *gc.C) {
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
// The connection logic should not delay the config connection
// at all when there is no environment info available.
// Make sure of that by providing a suitably long delay
// and checking that the connection happens within that
// time.
s.PatchValue(juju.ProviderConnectDelay, coretesting.LongWait)
s.bootstrapEnv(c, coretesting.SampleEnvName, defaultConfigStore(c))
startTime := time.Now()
apiclient, err := juju.NewAPIClientFromName("")
c.Assert(err, jc.ErrorIsNil)
defer apiclient.Close()
c.Assert(time.Since(startTime), jc.LessThan, coretesting.LongWait)
// We should get the default sample environment if we ask for ""
assertEnvironmentName(c, apiclient, coretesting.SampleEnvName)
}
func (s *syncSuite) setUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
s.origVersion = version.Current
// It's important that this be v1.8.x to match the test data.
version.Current.Number = version.MustParse("1.8.3")
// Create a target environments.yaml.
envConfig := `
environments:
test-target:
type: dummy
state-server: false
authorized-keys: "not-really-one"
`
coretesting.WriteEnvironments(c, envConfig)
var err error
s.targetEnv, err = environs.PrepareFromName("test-target", coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
envtesting.RemoveAllTools(c, s.targetEnv)
// Create a source storage.
baseDir := c.MkDir()
stor, err := filestorage.NewFileStorageWriter(baseDir)
c.Assert(err, gc.IsNil)
s.storage = stor
// Create a local tools directory.
s.localStorage = c.MkDir()
// Populate both local and default tools locations with the public tools.
versionStrings := make([]string, len(vAll))
for i, vers := range vAll {
versionStrings[i] = vers.String()
}
toolstesting.MakeTools(c, baseDir, "releases", versionStrings)
toolstesting.MakeTools(c, s.localStorage, "releases", versionStrings)
// Switch the default tools location.
baseURL, err := s.storage.URL(storage.BaseToolsPath)
c.Assert(err, gc.IsNil)
s.PatchValue(&envtools.DefaultBaseURL, baseURL)
}
func (*NewAPIClientSuite) TestWithBootstrapConfigTakesPrecedence(c *gc.C) {
// We want to make sure that the code is using the bootstrap
// config rather than information from environments.yaml,
// even when there is an entry in environments.yaml
// We can do that by changing the info bootstrap config
// so it has a different environment name.
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
store := configstore.NewMem()
bootstrapEnv(c, coretesting.SampleEnvName, store)
info, err := store.ReadInfo(coretesting.SampleEnvName)
c.Assert(err, gc.IsNil)
envName2 := coretesting.SampleCertName + "-2"
info2, err := store.CreateInfo(envName2)
c.Assert(err, gc.IsNil)
info2.SetBootstrapConfig(info.BootstrapConfig())
err = info2.Write()
c.Assert(err, gc.IsNil)
// Now we have info for envName2 which will actually
// cause a connection to the originally bootstrapped
// state.
apiOpen := func(*api.Info, api.DialOpts) (juju.APIState, error) {
return mockedAPIState(noFlags), nil
}
st, err := juju.NewAPIFromStore(envName2, store, apiOpen)
c.Check(err, gc.IsNil)
st.Close()
// Sanity check that connecting to the envName2
// but with no info fails.
// Currently this panics with an "environment not prepared" error.
// Disable for now until an upcoming branch fixes it.
// err = info2.Destroy()
// c.Assert(err, gc.IsNil)
// st, err = juju.NewAPIFromStore(envName2, store)
// if err == nil {
// st.Close()
// }
// c.Assert(err, gc.ErrorMatches, "fooobie")
}
func (s *BootstrapSuite) TestCheckProviderProvisional(c *gc.C) {
coretesting.WriteEnvironments(c, provisionalEnvs)
err := checkProviderType("devenv")
c.Assert(err, jc.ErrorIsNil)
for name, flag := range provisionalProviders {
// vsphere is disabled for gccgo. See lp:1440940.
if name == "vsphere" && runtime.Compiler == "gccgo" {
continue
}
c.Logf(" - trying %q -", name)
err := checkProviderType(name)
c.Check(err, gc.ErrorMatches, ".* provider is provisional .* set JUJU_DEV_FEATURE_FLAGS=.*")
err = os.Setenv(osenv.JujuFeatureFlagEnvKey, flag)
c.Assert(err, jc.ErrorIsNil)
err = checkProviderType(name)
c.Check(err, jc.ErrorIsNil)
}
}
