func (*OpenSuite) TestPrepareGeneratesDifferentAdminSecrets(c *gc.C) { baselineAttrs := dummy.SampleConfig().Merge(testing.Attrs{ "state-server": false, "name": "erewhemos", }).Delete( "admin-secret", ) cfg, err := config.New(config.NoDefaults, baselineAttrs) c.Assert(err, gc.IsNil) ctx := testing.Context(c) env0, err := environs.Prepare(cfg, ctx, configstore.NewMem()) c.Assert(err, gc.IsNil) adminSecret0 := env0.Config().AdminSecret() c.Assert(adminSecret0, gc.HasLen, 32) c.Assert(adminSecret0, gc.Matches, "^[0-9a-f]*$") env1, err := environs.Prepare(cfg, ctx, configstore.NewMem()) c.Assert(err, gc.IsNil) adminSecret1 := env1.Config().AdminSecret() c.Assert(adminSecret1, gc.HasLen, 32) c.Assert(adminSecret1, gc.Matches, "^[0-9a-f]*$") c.Assert(adminSecret1, gc.Not(gc.Equals), adminSecret0) }
func testingEnvConfig(c *gc.C) *config.Config { cfg, err := config.New(config.NoDefaults, dummy.SampleConfig()) c.Assert(err, gc.IsNil) env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) return env.Config() }
func (*OpenSuite) TestConfigForNameDefault(c *gc.C) { defer testing.MakeFakeHome(c, testing.SingleEnvConfig, testing.SampleCertName).Restore() 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 (*NewAPIConnSuite) TestNewConn(c *gc.C) { cfg, err := config.New(config.NoDefaults, dummy.SampleConfig()) c.Assert(err, gc.IsNil) ctx := coretesting.Context(c) env, err := environs.Prepare(cfg, ctx, configstore.NewMem()) c.Assert(err, gc.IsNil) envtesting.UploadFakeTools(c, env.Storage()) err = bootstrap.Bootstrap(ctx, env, environs.BootstrapParams{}) c.Assert(err, gc.IsNil) cfg = env.Config() cfg, err = cfg.Apply(map[string]interface{}{ "secret": "fnord", }) c.Assert(err, gc.IsNil) err = env.SetConfig(cfg) c.Assert(err, gc.IsNil) conn, err := juju.NewAPIConn(env, api.DefaultDialOpts()) c.Assert(err, gc.IsNil) c.Assert(conn.Environ, gc.Equals, env) c.Assert(conn.State, gc.NotNil) // the secrets will not be updated, as they already exist attrs, err := conn.State.Client().EnvironmentGet() c.Assert(attrs["secret"], gc.Equals, "pork") c.Assert(conn.Close(), gc.IsNil) }
func (s *ConfigSuite) TestFirewallMode(c *gc.C) { for i, test := range firewallModeTests { c.Logf("test %d: %s", i, test.configFirewallMode) attrs := dummy.SampleConfig() if test.configFirewallMode != "" { attrs = attrs.Merge(testing.Attrs{ "firewall-mode": test.configFirewallMode, }) } cfg, err := config.New(config.NoDefaults, attrs) if err != nil { c.Assert(err, gc.ErrorMatches, test.errorMsg) continue } ctx := testing.Context(c) env, err := environs.Prepare(cfg, ctx, configstore.NewMem()) if test.errorMsg != "" { c.Assert(err, gc.ErrorMatches, test.errorMsg) continue } c.Assert(err, gc.IsNil) defer env.Destroy() firewallMode := env.Config().FirewallMode() c.Assert(firewallMode, gc.Equals, test.firewallMode) s.TearDownTest(c) } }
func (*OpenSuite) TestConfigForNameNoDefault(c *gc.C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfigNoDefault, testing.SampleCertName).Restore() cfg, source, err := environs.ConfigForName("", configstore.NewMem()) c.Assert(err, gc.ErrorMatches, "no default environment found") c.Assert(cfg, gc.IsNil) c.Assert(source, gc.Equals, environs.ConfigFromEnvirons) }
// MakeConfig creates a functional environConfig for a test. func MakeConfig(c *gc.C, attrs testing.Attrs) *environConfig { cfg, err := config.New(config.NoDefaults, attrs) c.Assert(err, gc.IsNil) env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) return env.(*joyentEnviron).Ecfg() }
func (t *ProviderSuite) assertGetImageMetadataSources(c *gc.C, stream, officialSourcePath string) { // Make an env configured with the stream. envAttrs := localConfigAttrs if stream != "" { envAttrs = envAttrs.Merge(coretesting.Attrs{ "image-stream": stream, }) } cfg, err := config.New(config.NoDefaults, envAttrs) c.Assert(err, gc.IsNil) env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) c.Assert(env, gc.NotNil) sources, err := imagemetadata.GetMetadataSources(env) c.Assert(err, gc.IsNil) c.Assert(len(sources), gc.Equals, 2) var urls = make([]string, len(sources)) for i, source := range sources { url, err := source.URL("") c.Assert(err, gc.IsNil) urls[i] = url } // The control bucket URL contains the bucket name. c.Check(strings.Contains(urls[0], ec2.ControlBucketName(env)+"/images"), jc.IsTrue) c.Assert(urls[1], gc.Equals, fmt.Sprintf("http://cloud-images.ubuntu.com/%s/", officialSourcePath)) }
func (*OpenSuite) TestDestroy(c *gc.C) { cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge( testing.Attrs{ "state-server": false, "name": "erewhemos", }, )) c.Assert(err, gc.IsNil) store := configstore.NewMem() // Prepare the environment and sanity-check that // the config storage info has been made. ctx := testing.Context(c) e, err := environs.Prepare(cfg, ctx, store) c.Assert(err, gc.IsNil) _, err = store.ReadInfo(e.Name()) c.Assert(err, gc.IsNil) err = environs.Destroy(e, store) c.Assert(err, gc.IsNil) // Check that the environment has actually been destroyed // and that the config info has been destroyed too. _, _, err = e.StateInfo() c.Assert(err, gc.ErrorMatches, "environment has been destroyed") _, err = store.ReadInfo(e.Name()) c.Assert(err, jc.Satisfies, errors.IsNotFound) }
func (s *StorageSuite) SetUpTest(c *gc.C) { s.LoggingSuite.SetUpTest(c) cfg, err := config.New(config.NoDefaults, dummy.SampleConfig()) c.Assert(err, gc.IsNil) s.env, err = environs.Prepare(cfg, testing.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) s.dataDir = c.MkDir() }
func (s *datasourceSuite) SetUpTest(c *gc.C) { s.home = testing.MakeFakeHome(c, existingEnv, "existing") 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 (*OpenSuite) TestNewFromNameWithInvalidEnvironConfig(c *gc.C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfigNoDefault, testing.SampleCertName).Restore() store := configstore.NewMem() e, err := environs.NewFromName("erewhemos", store) c.Assert(err, gc.Equals, environs.ErrNotBootstrapped) c.Assert(e, gc.IsNil) }
func (*OpenSuite) TestPrepareFromName(c *gc.C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfigNoDefault, testing.SampleCertName).Restore() ctx := testing.Context(c) e, err := environs.PrepareFromName("erewhemos", ctx, configstore.NewMem()) c.Assert(err, gc.IsNil) c.Assert(e.Name(), gc.Equals, "erewhemos") // Check we can access storage ok, which implies the environment has been prepared. c.Assert(e.Storage(), gc.NotNil) }
func (s *uploadSuite) SetUpTest(c *gc.C) { s.LoggingSuite.SetUpTest(c) s.ToolsFixture.SetUpTest(c) // We only want to use simplestreams to find any synced tools. cfg, err := config.New(config.NoDefaults, dummy.SampleConfig()) c.Assert(err, gc.IsNil) s.env, err = environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) }
func (s *SimpleStreamsToolsSuite) resetEnv(c *gc.C, attrs map[string]interface{}) { version.Current = s.origCurrentVersion dummy.Reset() cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(attrs)) c.Assert(err, gc.IsNil) env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) s.env = env s.removeTools(c) }
func (*OpenSuite) TestNewFromName(c *gc.C) { defer testing.MakeFakeHome(c, testing.MultipleEnvConfigNoDefault, testing.SampleCertName).Restore() store := configstore.NewMem() ctx := testing.Context(c) e, err := environs.PrepareFromName("erewhemos", ctx, store) c.Assert(err, gc.IsNil) e, err = environs.NewFromName("erewhemos", store) c.Assert(err, gc.IsNil) c.Assert(e.Name(), gc.Equals, "erewhemos") }
func (*OpenSuite) TestNewDummyEnviron(c *gc.C) { // matches *Settings.Map() cfg, err := config.New(config.NoDefaults, dummySampleConfig()) c.Assert(err, gc.IsNil) ctx := testing.Context(c) env, err := environs.Prepare(cfg, ctx, configstore.NewMem()) c.Assert(err, gc.IsNil) envtesting.UploadFakeTools(c, env.Storage()) err = bootstrap.Bootstrap(ctx, env, environs.BootstrapParams{}) c.Assert(err, gc.IsNil) }
func bootstrapEnv(c *gc.C, envName string, store configstore.Storage) { if store == nil { store = configstore.NewMem() } ctx := coretesting.Context(c) env, err := environs.PrepareFromName(envName, ctx, store) c.Assert(err, gc.IsNil) envtesting.UploadFakeTools(c, env.Storage()) err = bootstrap.Bootstrap(ctx, env, environs.BootstrapParams{}) c.Assert(err, gc.IsNil) }
func (s *verifyStorageSuite) TestVerifyStorageFails(c *gc.C) { defer testing.MakeFakeHome(c, existingEnv, "existing").Restore() ctx := testing.Context(c) environ, err := environs.PrepareFromName("test", ctx, configstore.NewMem()) c.Assert(err, gc.IsNil) stor := environ.Storage() someError := errors.Unauthorizedf("you shall not pass") dummy.Poison(stor, environs.VerificationFilename, someError) err = environs.VerifyStorage(stor) c.Assert(err, gc.Equals, environs.VerifyStorageError) }
func (s *bootstrapSuite) TestBootstrapTools(c *gc.C) { allTests := append(envtesting.BootstrapToolsTests, bootstrapSetAgentVersionTests...) // version.Current is set in the loop so ensure it is restored later. s.PatchValue(&version.Current, version.Current) for i, test := range allTests { c.Logf("\ntest %d: %s", i, test.Info) dummy.Reset() attrs := dummy.SampleConfig().Merge(coretesting.Attrs{ "state-server": false, "development": test.Development, "default-series": test.DefaultSeries, }) if test.AgentVersion != version.Zero { attrs["agent-version"] = test.AgentVersion.String() } cfg, err := config.New(config.NoDefaults, attrs) c.Assert(err, gc.IsNil) env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) envtesting.RemoveAllTools(c, env) version.Current = test.CliVersion envtesting.AssertUploadFakeToolsVersions(c, env.Storage(), test.Available...) // Remove the default tools URL from the search path, just look in cloud storage. s.PatchValue(&envtools.DefaultBaseURL, "") cons := constraints.Value{} if test.Arch != "" { cons = constraints.MustParse("arch=" + test.Arch) } err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{Constraints: cons}) if test.Err != "" { c.Check(err, gc.NotNil) if err != nil { stripped := strings.Replace(err.Error(), "\n", "", -1) c.Check(stripped, gc.Matches, ".*"+stripped) } continue } else { c.Check(err, gc.IsNil) } unique := map[version.Number]bool{} for _, expected := range test.Expect { unique[expected.Number] = true } for expectAgentVersion := range unique { agentVersion, ok := env.Config().AgentVersion() c.Check(ok, gc.Equals, true) c.Check(agentVersion, gc.Equals, expectAgentVersion) } } }
func (t *localNonUSEastSuite) SetUpTest(c *gc.C) { t.LoggingSuite.SetUpTest(c) t.srv.config = &s3test.Config{ Send409Conflict: true, } t.srv.startServer(c) cfg, err := config.New(config.NoDefaults, localConfigAttrs) c.Assert(err, gc.IsNil) env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) t.env = env }
func (s *URLsSuite) env(c *gc.C, toolsMetadataURL string) environs.Environ { attrs := dummy.SampleConfig() if toolsMetadataURL != "" { attrs = attrs.Merge(testing.Attrs{ "tools-metadata-url": toolsMetadataURL, }) } cfg, err := config.New(config.NoDefaults, attrs) c.Assert(err, gc.IsNil) env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem()) c.Assert(err, gc.IsNil) return env }
func (s *NewAPIClientSuite) TestWithSlowInfoConnect(c *gc.C) { defer coretesting.MakeSampleHome(c).Restore() store := configstore.NewMem() bootstrapEnv(c, coretesting.SampleEnvName, store) setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid") infoOpenedState := &mockAPIState{} infoEndpointOpened := make(chan struct{}) cfgOpenedState := &mockAPIState{} // On a sample run with no delay, the logic took 45ms to run, so // we make the delay slightly more than that, so that if the // logic doesn't delay at all, the test will fail reasonably consistently. s.PatchValue(juju.ProviderConnectDelay, 50*time.Millisecond) apiOpen := func(info *api.Info, opts api.DialOpts) (juju.APIState, error) { if info.Addrs[0] == "infoapi.invalid" { infoEndpointOpened <- struct{}{} return infoOpenedState, nil } return cfgOpenedState, nil } stateClosed := make(chan juju.APIState) infoOpenedState.close = func(st juju.APIState) error { stateClosed <- st return nil } cfgOpenedState.close = infoOpenedState.close startTime := time.Now() st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen) c.Assert(err, gc.IsNil) // The connection logic should wait for some time before opening // the API from the configuration. c.Assert(time.Since(startTime), jc.GreaterThan, *juju.ProviderConnectDelay) c.Assert(st, gc.Equals, cfgOpenedState) select { case <-infoEndpointOpened: case <-time.After(coretesting.LongWait): c.Errorf("api never opened via info") } // Check that the ignored state was closed. select { case st := <-stateClosed: c.Assert(st, gc.Equals, infoOpenedState) case <-time.After(coretesting.LongWait): c.Errorf("timed out waiting for state to be closed") } }
func (*ConfigSuite) TestSecretAttrs(c *gc.C) { attrs := dummy.SampleConfig().Delete("secret") cfg, err := config.New(config.NoDefaults, attrs) c.Assert(err, gc.IsNil) ctx := testing.Context(c) env, err := environs.Prepare(cfg, ctx, configstore.NewMem()) c.Assert(err, gc.IsNil) defer env.Destroy() expected := map[string]string{ "secret": "pork", } actual, err := env.Provider().SecretAttrs(cfg) c.Assert(err, gc.IsNil) c.Assert(actual, gc.DeepEquals, expected) }
// newConfigStore returns a storage that contains information // for the environment name. func newConfigStore(envName string, info *environInfo) configstore.Storage { store := configstore.NewMem() newInfo, err := store.CreateInfo(envName) if err != nil { panic(err) } newInfo.SetAPICredentials(info.creds) newInfo.SetAPIEndpoint(info.endpoint) newInfo.SetBootstrapConfig(info.bootstrapConfig) err = newInfo.Write() if err != nil { panic(err) } return store }
func (s *checkEnvironmentSuite) TestCheckEnvironment(c *gc.C) { defer testing.MakeFakeHome(c, checkEnv, "existing").Restore() ctx := testing.Context(c) environ, err := environs.PrepareFromName("test", ctx, configstore.NewMem()) c.Assert(err, gc.IsNil) // VerifyStorage is sufficient for our tests and much simpler // than Bootstrap which calls it. stor := environ.Storage() err = environs.VerifyStorage(stor) c.Assert(err, gc.IsNil) err = environs.CheckEnvironment(environ) c.Assert(err, gc.IsNil) }
func (*OpenSuite) TestPrepare(c *gc.C) { baselineAttrs := dummy.SampleConfig().Merge(testing.Attrs{ "state-server": false, "name": "erewhemos", }).Delete( "ca-cert", "ca-private-key", "admin-secret", ) cfg, err := config.New(config.NoDefaults, baselineAttrs) c.Assert(err, gc.IsNil) store := configstore.NewMem() ctx := testing.Context(c) env, err := environs.Prepare(cfg, ctx, store) c.Assert(err, gc.IsNil) // Check we can access storage ok, which implies the environment has been prepared. c.Assert(env.Storage(), gc.NotNil) // Check that the environment info file was correctly created. info, err := store.ReadInfo("erewhemos") c.Assert(err, gc.IsNil) c.Assert(info.Initialized(), jc.IsTrue) c.Assert(info.BootstrapConfig(), gc.DeepEquals, env.Config().AllAttrs()) c.Logf("bootstrap config: %#v", info.BootstrapConfig()) // Check that an admin-secret was chosen. adminSecret := env.Config().AdminSecret() c.Assert(adminSecret, gc.HasLen, 32) c.Assert(adminSecret, gc.Matches, "^[0-9a-f]*$") // Check that the CA cert was generated. cfgCertPEM, cfgCertOK := env.Config().CACert() cfgKeyPEM, cfgKeyOK := env.Config().CAPrivateKey() c.Assert(cfgCertOK, gc.Equals, true) c.Assert(cfgKeyOK, gc.Equals, true) // Check the common name of the generated cert caCert, _, err := cert.ParseCertAndKey(cfgCertPEM, cfgKeyPEM) c.Assert(err, gc.IsNil) c.Assert(caCert.Subject.CommonName, gc.Equals, `juju-generated CA for environment "`+testing.SampleEnvName+`"`) // Check we can call Prepare again. env, err = environs.Prepare(cfg, ctx, store) c.Assert(err, gc.IsNil) c.Assert(env.Name(), gc.Equals, "erewhemos") c.Assert(env.Storage(), gc.NotNil) c.Assert(env.Config().AllAttrs(), gc.DeepEquals, info.BootstrapConfig()) }
func (s *ConnSuite) SetUpTest(c *gc.C) { s.LoggingSuite.SetUpTest(c) s.MgoSuite.SetUpTest(c) s.ToolsFixture.SetUpTest(c) cfg, err := config.New(config.NoDefaults, dummy.SampleConfig()) c.Assert(err, gc.IsNil) ctx := coretesting.Context(c) environ, err := environs.Prepare(cfg, ctx, configstore.NewMem()) c.Assert(err, gc.IsNil) envtesting.UploadFakeTools(c, environ.Storage()) err = bootstrap.Bootstrap(ctx, environ, environs.BootstrapParams{}) c.Assert(err, gc.IsNil) s.conn, err = juju.NewConn(environ) c.Assert(err, gc.IsNil) s.repo = &charm.LocalRepository{Path: c.MkDir()} }
func (s *NewAPIClientSuite) TestBothError(c *gc.C) { defer coretesting.MakeSampleHome(c).Restore() store := configstore.NewMem() bootstrapEnv(c, coretesting.SampleEnvName, store) setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid") s.PatchValue(juju.ProviderConnectDelay, 0*time.Second) apiOpen := func(info *api.Info, opts api.DialOpts) (juju.APIState, error) { if info.Addrs[0] == "infoapi.invalid" { return nil, fmt.Errorf("info connect failed") } return nil, fmt.Errorf("config connect failed") } st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen) c.Check(err, gc.ErrorMatches, "config connect failed") c.Check(st, gc.IsNil) }
func (*OpenSuite) TestPrepareWithMissingKey(c *gc.C) { cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Delete("ca-cert", "ca-private-key").Merge( testing.Attrs{ "state-server": false, "name": "erewhemos", "ca-cert": string(testing.CACert), }, )) c.Assert(err, gc.IsNil) store := configstore.NewMem() env, err := environs.Prepare(cfg, testing.Context(c), store) c.Assert(err, gc.ErrorMatches, "cannot ensure CA certificate: environment configuration with a certificate but no CA private key") c.Assert(env, gc.IsNil) // Ensure that the config storage info is cleaned up. _, err = store.ReadInfo(cfg.Name()) c.Assert(err, jc.Satisfies, errors.IsNotFound) }