// 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 (s *ListSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.SetFeatureFlags(feature.JES)
s.store = configstore.NewMem()
var envList = []struct {
name string
serverUUID string
envUUID string
}{
{
name: "test1",
serverUUID: "test1-uuid",
envUUID: "test1-uuid",
}, {
name: "test2",
serverUUID: "test1-uuid",
envUUID: "test2-uuid",
}, {
name: "test3",
envUUID: "test3-uuid",
},
}
for _, env := range envList {
info := s.store.CreateInfo(env.name)
info.SetAPIEndpoint(configstore.APIEndpoint{
Addresses: []string{"localhost"},
CACert: testing.CACert,
EnvironUUID: env.envUUID,
ServerUUID: env.serverUUID,
})
err := info.Write()
c.Assert(err, jc.ErrorIsNil)
}
}
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 (s *createSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.SetFeatureFlags(feature.JES)
s.fake = &fakeCreateClient{}
store := configstore.Default
s.AddCleanup(func(*gc.C) {
configstore.Default = store
})
s.store = configstore.NewMem()
configstore.Default = func() (configstore.Storage, error) {
return s.store, nil
}
// Set up the current environment, and write just enough info
// so we don't try to refresh
envName := "test-master"
s.serverUUID = "fake-server-uuid"
info := s.store.CreateInfo(envName)
info.SetAPIEndpoint(configstore.APIEndpoint{
Addresses: []string{"localhost"},
CACert: testing.CACert,
EnvironUUID: s.serverUUID,
ServerUUID: s.serverUUID,
})
info.SetAPICredentials(configstore.APICredentials{User: "******", Password: "******"})
err := info.Write()
c.Assert(err, jc.ErrorIsNil)
s.server = info
err = envcmd.WriteCurrentEnvironment(envName)
c.Assert(err, jc.ErrorIsNil)
}
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.Config().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.StateServerInstances()
c.Assert(err, gc.ErrorMatches, "environment has been destroyed")
_, err = store.ReadInfo(e.Config().Name())
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
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) TestNewFromNameWithInvalidEnvironConfig(c *gc.C) {
store := configstore.NewMem()
e, err := environs.NewFromName("erewhemos", store)
c.Assert(err, gc.Equals, environs.ErrNotBootstrapped)
c.Assert(e, gc.IsNil)
}
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 (*NewAPIStateSuite) TestNewAPIState(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)
st, err := juju.NewAPIState(env, api.DialOpts{})
c.Assert(st, gc.NotNil)
// the secrets will not be updated, as they already exist
attrs, err := st.Client().EnvironmentGet()
c.Assert(attrs["secret"], gc.Equals, "pork")
c.Assert(st.Close(), gc.IsNil)
}
func (s *NewAPIClientSuite) bootstrapEnv(c *gc.C, envName string, store configstore.Storage) {
if store == nil {
store = configstore.NewMem()
}
ctx := envtesting.BootstrapContext(c)
c.Logf("env name: %s", envName)
env, err := environs.PrepareFromName(envName, ctx, store)
c.Assert(err, jc.ErrorIsNil)
storageDir := c.MkDir()
s.PatchValue(&envtools.DefaultBaseURL, storageDir)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.UploadFakeTools(c, stor, "released", "released")
err = bootstrap.Bootstrap(ctx, env, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
info, err := store.ReadInfo(envName)
c.Assert(err, jc.ErrorIsNil)
creds := info.APICredentials()
creds.User = dummy.AdminUserTag().Name()
c.Logf("set creds: %#v", creds)
info.SetAPICredentials(creds)
err = info.Write()
c.Assert(err, jc.ErrorIsNil)
c.Logf("creds: %#v", info.APICredentials())
info, err = store.ReadInfo(envName)
c.Assert(err, jc.ErrorIsNil)
c.Logf("read creds: %#v", info.APICredentials())
c.Logf("store: %#v", store)
}
func (cs *NewAPIStateSuite) TestNewAPIState(c *gc.C) {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
c.Assert(err, jc.ErrorIsNil)
ctx := envtesting.BootstrapContext(c)
env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
storageDir := c.MkDir()
cs.PatchValue(&envtools.DefaultBaseURL, storageDir)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.UploadFakeTools(c, stor, "released", "released")
err = bootstrap.Bootstrap(ctx, env, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
cfg = env.Config()
cfg, err = cfg.Apply(map[string]interface{}{
"secret": "fnord",
})
c.Assert(err, jc.ErrorIsNil)
err = env.SetConfig(cfg)
c.Assert(err, jc.ErrorIsNil)
st, err := juju.NewAPIState(dummy.AdminUserTag(), env, api.DialOpts{})
c.Assert(st, gc.NotNil)
// the secrets will not be updated, as they already exist
attrs, err := st.Client().EnvironmentGet()
c.Assert(attrs["secret"], gc.Equals, "pork")
c.Assert(st.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)
}
}
// testingEnvConfig prepares an environment configuration using
// the dummy provider.
func testingEnvConfig(c *gc.C) *config.Config {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
c.Assert(err, jc.ErrorIsNil)
env, err := environs.Prepare(cfg, envcmd.BootstrapContext(testing.Context(c)), configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
return env.Config()
}
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 (t *Tests) SetUpTest(c *gc.C) {
storageDir := c.MkDir()
t.DefaultBaseURL = "file://" + storageDir + "/tools"
t.ToolsFixture.SetUpTest(c)
t.UploadFakeToolsToDirectory(c, storageDir, "released", "released")
t.ConfigStore = configstore.NewMem()
}
func (s *BaseSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
memstore := configstore.NewMem()
s.PatchValue(&configstore.Default, func() (configstore.Storage, error) {
return memstore, nil
})
os.Setenv(osenv.JujuModelEnvKey, "testing")
info := memstore.CreateInfo("testing")
info.SetBootstrapConfig(map[string]interface{}{"random": "extra data"})
info.SetAPIEndpoint(configstore.APIEndpoint{
Addresses: []string{"127.0.0.1:12345"},
Hostnames: []string{"localhost:12345"},
CACert: testing.CACert,
ModelUUID: testing.ModelTag.Id(),
})
info.SetAPICredentials(configstore.APICredentials{
User: "******",
Password: "******",
})
err := info.Write()
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(user.ReadPassword, func() (string, error) {
return "sekrit", nil
})
err = modelcmd.WriteCurrentController("testing")
c.Assert(err, jc.ErrorIsNil)
}
func (*OpenSuite) TestPrepareFromName(c *gc.C) {
ctx := testing.Context(c)
e, err := environs.PrepareFromName("erewhemos", ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
c.Assert(e.Config().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 *StorageSuite) SetUpTest(c *gc.C) {
s.BaseSuite.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 (t *LiveTests) TestBootstrapWithDefaultSeries(c *gc.C) {
if !t.HasProvisioner {
c.Skip("HasProvisioner is false; cannot test deployment")
}
current := version.Current
other := current
other.Series = "quantal"
if current == other {
other.Series = "precise"
}
dummyCfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(coretesting.Attrs{
"state-server": false,
"name": "dummy storage",
}))
dummyenv, err := environs.Prepare(dummyCfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
defer dummyenv.Destroy()
t.Destroy(c)
attrs := t.TestConfig.Merge(coretesting.Attrs{"default-series": other.Series})
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), t.ConfigStore)
c.Assert(err, gc.IsNil)
defer environs.Destroy(env, t.ConfigStore)
currentName := envtools.StorageName(current)
otherName := envtools.StorageName(other)
envStorage := env.Storage()
dummyStorage := dummyenv.Storage()
defer envStorage.Remove(otherName)
_, err = sync.Upload(dummyStorage, ¤t.Number)
c.Assert(err, gc.IsNil)
// This will only work while cross-compiling across releases is safe,
// which depends on external elements. Tends to be safe for the last
// few releases, but we may have to refactor some day.
err = storageCopy(dummyStorage, currentName, envStorage, otherName)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
st := t.Env.(testing.GetStater).GetStateInAPIServer()
// Wait for machine agent to come up on the bootstrap
// machine and ensure it deployed the proper series.
m0, err := st.Machine("0")
c.Assert(err, gc.IsNil)
mw0 := newMachineToolWaiter(m0)
defer mw0.Stop()
waitAgentTools(c, mw0, other)
}
func (s *uploadSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.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 *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 *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, jc.ErrorIsNil)
env, err := environs.Prepare(cfg, envtesting.BootstrapContext(c), configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
s.env = env
s.removeTools(c)
}
func (s *verifyStorageSuite) TestVerifyStorageFails(c *gc.C) {
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 (*OpenSuite) TestNewFromName(c *gc.C) {
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.Config().Name(), gc.Equals, "erewhemos")
}
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 (*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)
}
// newConfigStore returns a storage that contains information
// for the environment name.
func newConfigStore(envName string, info *environInfo) configstore.Storage {
store := configstore.NewMem()
newInfo := store.CreateInfo(envName)
newInfo.SetAPICredentials(info.creds)
newInfo.SetAPIEndpoint(info.endpoint)
newInfo.SetBootstrapConfig(info.bootstrapConfig)
err := newInfo.Write()
if err != nil {
panic(err)
}
return store
}
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",
"uuid",
)
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 that a uuid was chosen.
uuid, exists := env.Config().UUID()
c.Assert(exists, gc.Equals, true)
c.Assert(uuid, gc.Matches, `[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}`)
// Check we can call Prepare again.
env, err = environs.Prepare(cfg, ctx, store)
c.Assert(err, gc.IsNil)
c.Assert(env.Storage(), gc.NotNil)
c.Assert(env.Config().AllAttrs(), gc.DeepEquals, info.BootstrapConfig())
}
func testConfig(c *gc.C) *config.Config {
attrs := coretesting.FakeConfig().Merge(coretesting.Attrs{
"type": "mock",
"controller": true,
"state-id": "1",
})
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
_, err = environs.Prepare(cfg, envtesting.BootstrapContext(c), configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
return cfg
}
func (s *bootstrapSuite) TestBootstrapTools(c *gc.C) {
s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(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)
}
}
}