func (OpenSuite) TestNewFromNameGetDefault(c *C) { defer testing.MakeFakeHome(c, testing.SingleEnvConfig, testing.SampleCertName).Restore() e, err := environs.NewFromName("") c.Assert(err, IsNil) c.Assert(e.Name(), Equals, "erewhemos") }
func (*SwitchSimpleSuite) TestShowsJujuEnv(c *C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfig).Restore() os.Setenv("JUJU_ENV", "using-env") context, err := testing.RunCommand(c, &SwitchCommand{}, nil) c.Assert(err, IsNil) c.Assert(testing.Stdout(context), Equals, "Current environment: \"using-env\" (from JUJU_ENV)\n") }
func (*SwitchSimpleSuite) TestSettingWritesFile(c *C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfig).Restore() context, err := testing.RunCommand(c, &SwitchCommand{}, []string{"erewhemos-2"}) c.Assert(err, IsNil) c.Assert(testing.Stdout(context), Equals, "Changed default environment from \"erewhemos\" to \"erewhemos-2\"\n") c.Assert(readCurrentEnvironment(), Equals, "erewhemos-2") }
func (*SwitchSimpleSuite) TestListEnvironments(c *C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfig).Restore() context, err := testing.RunCommand(c, &SwitchCommand{}, []string{"--list"}) c.Assert(err, IsNil) c.Assert(testing.Stdout(context), Matches, "Current environment: \"erewhemos\"(.|\n)*") c.Assert(testing.Stdout(context), Matches, "(.|\n)*"+expectedEnvironments) }
func (s *syncToolsSuite) SetUpTest(c *C) { s.LoggingSuite.SetUpTest(c) s.origVersion = version.Current // It's important that this be v1 to match the test data. version.Current.Number = version.MustParse("1.2.3") // Create a target environments.yaml and make sure its environment is empty. s.home = testing.MakeFakeHome(c, ` environments: test-target: type: dummy state-server: false authorized-keys: "not-really-one" `) var err error s.targetEnv, err = environs.NewFromName("test-target") c.Assert(err, IsNil) envtesting.RemoveAllTools(c, s.targetEnv) // Create a source storage. s.storage, err = envtesting.NewEC2HTTPTestStorage("127.0.0.1") c.Assert(err, IsNil) // Create a local tools directory. s.localStorage = c.MkDir() // Populate both with the public tools. for _, vers := range vAll { s.storage.PutBinary(vers) putBinary(c, s.localStorage, vers) } s.origLocation = defaultToolsLocation defaultToolsLocation = s.storage.Location() }
func (*SwitchSimpleSuite) TestCurrentEnvironmentHasPrecidence(c *C) { home := testing.MakeFakeHome(c, testing.MultipleEnvConfig) defer home.Restore() home.AddFiles(c, []testing.TestFile{{".juju/current-environment", "fubar"}}) context, err := testing.RunCommand(c, &SwitchCommand{}, nil) c.Assert(err, IsNil) c.Assert(testing.Stdout(context), Equals, "Current environment: \"fubar\"\n") }
// makeEmptyFakeHome creates a faked home without tools. func makeEmptyFakeHome(c *gc.C) (environs.Environ, *coretesting.FakeHome) { fake := coretesting.MakeFakeHome(c, envConfig) dummy.Reset() env, err := environs.NewFromName("peckham") c.Assert(err, gc.IsNil) envtesting.RemoveAllTools(c, env) return env, fake }
func (*SwitchSimpleSuite) TestJujuEnvOverCurrentEnvironment(c *C) { home := testing.MakeFakeHome(c, testing.MultipleEnvConfig) defer home.Restore() home.AddFiles(c, []testing.TestFile{{".juju/current-environment", "fubar"}}) os.Setenv("JUJU_ENV", "using-env") context, err := testing.RunCommand(c, &SwitchCommand{}, nil) c.Assert(err, IsNil) c.Assert(testing.Stdout(context), Equals, "Current environment: \"using-env\" (from JUJU_ENV)\n") }
func (s *verifyStorageSuite) TestVerifyStorageFails(c *C) { defer testing.MakeFakeHome(c, existingEnv, "existing").Restore() environ, err := environs.NewFromName("test") c.Assert(err, IsNil) storage := environ.Storage() someError := errors.Unauthorizedf("you shall not pass") dummy.Poison(storage, "bootstrap-verify", someError) err = environs.VerifyStorage(storage) c.Assert(err, Equals, environs.VerifyStorageError) }
func (*EnvironsCertSuite) TestEnsureCertificate(c *C) { defer testing.MakeFakeHome(c, testing.SingleEnvConfig).Restore() env, err := environs.NewFromName(testing.SampleEnvName) c.Assert(err, IsNil) writeCalled := false created, err := environs.EnsureCertificate(env, func(name string, cert, key []byte) error { writeCalled = true return nil }) c.Assert(err, IsNil) c.Assert(created, Equals, environs.CertCreated) c.Assert(writeCalled, Equals, true) }
// Without the write (-w) option, any existing environmens.yaml file is preserved and the boilerplate is // written to stdout. func (*InitSuite) TestPrintBoilerplate(c *C) { defer testing.MakeFakeHome(c, existingEnv, "existing").Restore() ctx := testing.Context(c) code := cmd.Main(&InitCommand{}, ctx, nil) c.Check(code, Equals, 0) errOut := ctx.Stdout.(*bytes.Buffer).String() strippedOut := strings.Replace(errOut, "\n", "", -1) c.Check(strippedOut, Matches, ".*## This is the Juju config file, which you can use.*") environpath := testing.HomePath(".juju", "environments.yaml") data, err := ioutil.ReadFile(environpath) c.Assert(err, IsNil) c.Assert(string(data), Equals, existingEnv) }
func (*InitSuite) TestExistingEnvironmentNotOverwritten(c *C) { defer testing.MakeFakeHome(c, existingEnv, "existing").Restore() ctx := testing.Context(c) code := cmd.Main(&InitCommand{}, ctx, []string{"-w"}) c.Check(code, Equals, 0) errOut := ctx.Stdout.(*bytes.Buffer).String() strippedOut := strings.Replace(errOut, "\n", "", -1) c.Check(strippedOut, Matches, ".*A juju environment configuration already exists.*") environpath := testing.HomePath(".juju", "environments.yaml") data, err := ioutil.ReadFile(environpath) c.Assert(err, IsNil) c.Assert(string(data), Equals, existingEnv) }
func (s *checkEnvironmentSuite) TestCheckEnvironment(c *C) { defer testing.MakeFakeHome(c, checkEnv, "existing").Restore() environ, err := environs.NewFromName("test") c.Assert(err, IsNil) // VerifyStorage is sufficient for our tests and much simpler // than Bootstrap which calls it. storage := environ.Storage() err = environs.VerifyStorage(storage) c.Assert(err, IsNil) err = environs.CheckEnvironment(environ) c.Assert(err, IsNil) }
func (s *verifyStorageSuite) TestVerifyStorage(c *C) { defer testing.MakeFakeHome(c, existingEnv, "existing").Restore() environ, err := environs.NewFromName("test") c.Assert(err, IsNil) storage := environ.Storage() err = environs.VerifyStorage(storage) c.Assert(err, IsNil) reader, err := storage.Get("bootstrap-verify") c.Assert(err, IsNil) defer reader.Close() contents, err := ioutil.ReadAll(reader) c.Assert(err, IsNil) c.Check(string(contents), Equals, "juju-core storage writing verified: ok\n") }
func (s *syncToolsSuite) SetUpTest(c *gc.C) { s.LoggingSuite.SetUpTest(c) // Create a target environments.yaml and make sure its environment is empty. s.home = coretesting.MakeFakeHome(c, ` environments: test-target: type: dummy state-server: false authorized-keys: "not-really-one" `) var err error s.targetEnv, err = environs.NewFromName("test-target") c.Assert(err, gc.IsNil) envtesting.RemoveAllTools(c, s.targetEnv) s.origSyncTools = syncTools }
func (s *checkEnvironmentSuite) TestCheckEnvironmentBadContent(c *C) { defer testing.MakeFakeHome(c, checkEnv, "existing").Restore() environ, err := environs.NewFromName("test") c.Assert(err, IsNil) // We mock a bad (eg. from a Python-juju environment) bootstrap-verify. storage := environ.Storage() content := "bad verification content" reader := strings.NewReader(content) err = storage.Put("bootstrap-verify", reader, int64(len(content))) c.Assert(err, IsNil) // When the bootstrap-verify file contains unexpected content, // we get an InvalidEnvironmentError. err = environs.CheckEnvironment(environ) c.Assert(err, Equals, environs.InvalidEnvironmentError) }
func (s *checkEnvironmentSuite) TestCheckEnvironmentGetFails(c *C) { defer testing.MakeFakeHome(c, checkEnv, "existing").Restore() environ, err := environs.NewFromName("test") c.Assert(err, IsNil) // VerifyStorage is sufficient for our tests and much simpler // than Bootstrap which calls it. storage := environ.Storage() err = environs.VerifyStorage(storage) c.Assert(err, IsNil) // When fetching the verification file from storage fails, // we get an InvalidEnvironmentError. someError := errors.Unauthorizedf("you shall not pass") dummy.Poison(storage, "bootstrap-verify", someError) err = environs.CheckEnvironment(environ) c.Assert(err, Equals, someError) }
func (*EnvironsCertSuite) TestEnsureCertificateMissingKey(c *C) { defer testing.MakeFakeHome(c, testing.SingleEnvConfig).Restore() envName := testing.SampleEnvName keyPath := testing.HomePath(".juju", envName+"-cert.pem") ioutil.WriteFile(keyPath, []byte(testing.CACert), 0600) // Need to create the environment after the cert has been written. env, err := environs.NewFromName(envName) c.Assert(err, IsNil) writeCalled := false _, err = environs.EnsureCertificate(env, func(name string, cert, key []byte) error { writeCalled = true return nil }) c.Assert(err, ErrorMatches, "environment configuration with a certificate but no CA private key") c.Assert(writeCalled, Equals, false) }
func (s *checkEnvironmentSuite) TestCheckEnvironmentFileNotFound(c *C) { defer testing.MakeFakeHome(c, checkEnv, "existing").Restore() environ, err := environs.NewFromName("test") c.Assert(err, IsNil) // VerifyStorage is sufficient for our tests and much simpler // than Bootstrap which calls it. storage := environ.Storage() err = environs.VerifyStorage(storage) c.Assert(err, IsNil) // When the bootstrap-verify file does not exist, it still believes // the environment is a juju-core one because earlier versions // did not create that file. err = storage.Remove("bootstrap-verify") c.Assert(err, IsNil) err = environs.CheckEnvironment(environ) c.Assert(err, IsNil) }
func (*SwitchSimpleSuite) TestTooManyParams(c *C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfig).Restore() _, err := testing.RunCommand(c, &SwitchCommand{}, []string{"foo", "bar"}) c.Assert(err, ErrorMatches, `unrecognized args: ."bar".`) }
func (test bootstrapTest) run(c *C) { defer testing.MakeFakeHome(c, envConfig).Restore() dummy.Reset() env, err := environs.NewFromName("peckham") c.Assert(err, IsNil) envtesting.RemoveAllTools(c, env) if test.version != "" { origVersion := version.Current version.Current = version.MustParseBinary(test.version) defer func() { version.Current = origVersion }() } uploadCount := len(test.uploads) if uploadCount == 0 { usefulVersion := version.Current usefulVersion.Series = env.Config().DefaultSeries() envtesting.UploadFakeToolsVersion(c, env.Storage(), usefulVersion) } // Run command and check for uploads. opc, errc := runCommand(new(BootstrapCommand), test.args...) if uploadCount > 0 { for i := 0; i < uploadCount; i++ { c.Check((<-opc).(dummy.OpPutFile).Env, Equals, "peckham") } list, err := environs.FindAvailableTools(env, version.Current.Major) c.Check(err, IsNil) c.Logf("found: " + list.String()) urls := list.URLs() c.Check(urls, HasLen, len(test.uploads)) for _, v := range test.uploads { c.Logf("seeking: " + v) vers := version.MustParseBinary(v) _, found := urls[vers] c.Check(found, Equals, true) } } // Check for remaining operations/errors. if test.err != "" { c.Check(<-errc, ErrorMatches, test.err) return } if !c.Check(<-errc, IsNil) { return } opPutBootstrapVerifyFile := (<-opc).(dummy.OpPutFile) c.Check(opPutBootstrapVerifyFile.Env, Equals, "peckham") c.Check(opPutBootstrapVerifyFile.FileName, Equals, "bootstrap-verify") opBootstrap := (<-opc).(dummy.OpBootstrap) c.Check(opBootstrap.Env, Equals, "peckham") c.Check(opBootstrap.Constraints, DeepEquals, test.constraints) // Check a CA cert/key was generated by reloading the environment. env, err = environs.NewFromName("peckham") c.Assert(err, IsNil) _, hasCert := env.Config().CACert() c.Check(hasCert, Equals, true) _, hasKey := env.Config().CAPrivateKey() c.Check(hasKey, Equals, true) }
func (*SwitchSimpleSuite) TestNoDefault(c *C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfigNoDefault).Restore() context, err := testing.RunCommand(c, &SwitchCommand{}, nil) c.Assert(err, IsNil) c.Assert(testing.Stdout(context), Equals, "Current environment: <not specified>\n") }
func (s *CmdSuite) SetUpTest(c *C) { s.JujuConnSuite.SetUpTest(c) s.home = coretesting.MakeFakeHome(c, envConfig, "peckham", "walthamstow", "brokenenv") }
func (*SwitchSimpleSuite) TestSettingWhenJujuEnvSet(c *C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfig).Restore() os.Setenv("JUJU_ENV", "using-env") _, err := testing.RunCommand(c, &SwitchCommand{}, []string{"erewhemos-2"}) c.Assert(err, ErrorMatches, `Cannot switch when JUJU_ENV is overriding the environment \(set to "using-env"\)`) }
func (*SwitchSimpleSuite) TestSettingToUnknown(c *C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfig).Restore() _, err := testing.RunCommand(c, &SwitchCommand{}, []string{"unknown"}) c.Assert(err, ErrorMatches, `"unknown" is not a name of an existing defined environment`) }
func (*SwitchSimpleSuite) TestShowsDefault(c *C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfig).Restore() context, err := testing.RunCommand(c, &SwitchCommand{}, nil) c.Assert(err, IsNil) c.Assert(testing.Stdout(context), Equals, "Current environment: \"erewhemos\"\n") }
func (OpenSuite) TestNewFromNameNoDefault(c *C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfigNoDefault, testing.SampleCertName).Restore() _, err := environs.NewFromName("") c.Assert(err, ErrorMatches, "no default environment found") }
func (s *ValidateMetadataSuite) SetUpTest(c *gc.C) { s.home = coretesting.MakeFakeHome(c, metadataTestEnvConfig) }