func (s *AgentToolsSuite) TestUpdateToolsAvailabilityNoMatches(c *gc.C) {
fakeModelConfig := func(_ *state.Model) (*config.Config, error) {
sConfig := coretesting.FakeConfig()
sConfig = sConfig.Merge(coretesting.Attrs{
"agent-version": "2.5.0",
})
return config.New(config.NoDefaults, sConfig)
}
s.PatchValue(&modelConfig, fakeModelConfig)
// No new tools available.
fakeToolFinder := func(_ environs.Environ, _ int, _ int, _ string, _ coretools.Filter) (coretools.List, error) {
return nil, errors.NotFoundf("tools")
}
// Update should never be called.
fakeUpdate := func(_ *state.Model, v version.Number) error {
c.Fail()
return nil
}
cfg, err := config.New(config.NoDefaults, coretesting.FakeConfig())
c.Assert(err, jc.ErrorIsNil)
err = updateToolsAvailability(&mockState{configGetter{cfg}}, getDummyEnviron, fakeToolFinder, fakeUpdate)
c.Assert(err, jc.ErrorIsNil)
}
func (s *AgentToolsSuite) TestUpdateToolsAvailability(c *gc.C) {
fakeModelConfig := func(_ *state.Model) (*config.Config, error) {
sConfig := coretesting.FakeConfig()
sConfig = sConfig.Merge(coretesting.Attrs{
"agent-version": "2.5.0",
})
return config.New(config.NoDefaults, sConfig)
}
s.PatchValue(&modelConfig, fakeModelConfig)
fakeToolFinder := func(_ environs.Environ, _ int, _ int, _ string, _ coretools.Filter) (coretools.List, error) {
ver := version.Binary{Number: version.Number{Major: 2, Minor: 5, Patch: 2}}
olderVer := version.Binary{Number: version.Number{Major: 2, Minor: 5, Patch: 1}}
t := coretools.Tools{Version: ver, URL: "http://example.com", Size: 1}
tOld := coretools.Tools{Version: olderVer, URL: "http://example.com", Size: 1}
return coretools.List{&t, &tOld}, nil
}
var ver version.Number
fakeUpdate := func(_ *state.Model, v version.Number) error {
ver = v
return nil
}
cfg, err := config.New(config.NoDefaults, coretesting.FakeConfig())
c.Assert(err, jc.ErrorIsNil)
err = updateToolsAvailability(&mockState{configGetter{cfg}}, getDummyEnviron, fakeToolFinder, fakeUpdate)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ver, gc.Not(gc.Equals), version.Zero)
c.Assert(ver, gc.Equals, version.Number{Major: 2, Minor: 5, Patch: 2})
}
func (suite *EnvironProviderSuite) TestCredentialsSetup(c *gc.C) {
attrs := testing.FakeConfig().Merge(testing.Attrs{
"type": "maas",
})
config, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
cfg, err := providerInstance.BootstrapConfig(environs.BootstrapConfigParams{
Config: config,
CloudEndpoint: "http://maas.testing.invalid/maas/",
Credentials: cloud.NewCredential(
cloud.OAuth1AuthType,
map[string]string{
"maas-oauth": "aa:bb:cc",
},
),
})
c.Assert(err, jc.ErrorIsNil)
attrs = cfg.UnknownAttrs()
server, ok := attrs["maas-server"]
c.Assert(ok, jc.IsTrue)
c.Assert(server, gc.Equals, "http://maas.testing.invalid/maas/")
oauth, ok := attrs["maas-oauth"]
c.Assert(ok, jc.IsTrue)
c.Assert(oauth, gc.Equals, "aa:bb:cc")
}
func (s *AgentToolsSuite) TestCheckTools(c *gc.C) {
sConfig := coretesting.FakeConfig()
sConfig = sConfig.Merge(coretesting.Attrs{
"agent-version": "2.5.0",
})
cfg, err := config.New(config.NoDefaults, sConfig)
c.Assert(err, jc.ErrorIsNil)
var (
calledWithMajor, calledWithMinor int
)
fakeToolFinder := func(e environs.Environ, maj int, min int, stream string, filter coretools.Filter) (coretools.List, error) {
calledWithMajor = maj
calledWithMinor = min
ver := version.Binary{Number: version.Number{Major: maj, Minor: min}}
t := coretools.Tools{Version: ver, URL: "http://example.com", Size: 1}
c.Assert(calledWithMajor, gc.Equals, 2)
c.Assert(calledWithMinor, gc.Equals, 5)
c.Assert(stream, gc.Equals, "released")
return coretools.List{&t}, nil
}
ver, err := checkToolsAvailability(getDummyEnviron, cfg, fakeToolFinder)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ver, gc.Not(gc.Equals), version.Zero)
c.Assert(ver, gc.Equals, version.Number{Major: 2, Minor: 5, Patch: 0})
}
func (suite *EnvironProviderSuite) TestUnknownAttrsContainAgentName(c *gc.C) {
attrs := testing.FakeConfig().Merge(testing.Attrs{
"type": "maas",
})
config, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
cfg, err := providerInstance.BootstrapConfig(environs.BootstrapConfigParams{
Config: config,
CloudEndpoint: "http://maas.testing.invalid/maas/",
Credentials: cloud.NewCredential(
cloud.OAuth1AuthType,
map[string]string{
"maas-oauth": "aa:bb:cc",
},
),
})
c.Assert(err, jc.ErrorIsNil)
unknownAttrs := cfg.UnknownAttrs()
c.Assert(unknownAttrs["maas-server"], gc.Equals, "http://maas.testing.invalid/maas/")
uuid, ok := unknownAttrs["maas-agent-name"]
c.Assert(ok, jc.IsTrue)
c.Assert(uuid, jc.Satisfies, utils.IsValidUUIDString)
}
func GetFakeConfig() coretesting.Attrs {
return coretesting.FakeConfig().Merge(coretesting.Attrs{
"name": "joyent-test-model",
"type": "joyent",
"agent-version": coretesting.FakeVersionNumber.String(),
})
}
func (s *ConfigSuite) TestPrepareSetsDefaultBlockSource(c *gc.C) {
s.PatchValue(&verifyCredentials, func(*environ) error { return nil })
attrs := testing.FakeConfig().Merge(testing.Attrs{
"type": "ec2",
})
config, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
cfg, err := providerInstance.BootstrapConfig(environs.BootstrapConfigParams{
Config: config,
CloudRegion: "test",
Credentials: cloud.NewCredential(
cloud.AccessKeyAuthType,
map[string]string{
"access-key": "x",
"secret-key": "y",
},
),
})
c.Assert(err, jc.ErrorIsNil)
source, ok := cfg.StorageDefaultBlockSource()
c.Assert(ok, jc.IsTrue)
c.Assert(source, gc.Equals, "ebs")
}
func (*environSuite) TestSetConfigAllowsEmptyFromNilAgentName(c *gc.C) {
// bug #1256179 is that when using an older version of Juju (<1.16.2)
// we didn't include maas-agent-name in the database, so it was 'nil'
// in the OldConfig. However, when setting an environment, we would set
// it to "" (because maasModelConfig.Validate ensures it is a 'valid'
// string). We can't create that from NewEnviron or newConfig because
// both of them Validate the contents. 'cmd/juju/model
// SetEnvironmentCommand' instead uses conn.State.ModelConfig() which
// just reads the content of the database into a map, so we just create
// the map ourselves.
// Even though we use 'nil' here, it actually stores it as "" because
// 1.16.2 already validates the value
baseCfg := getSimpleTestConfig(c, coretesting.Attrs{"maas-agent-name": ""})
c.Check(baseCfg.UnknownAttrs()["maas-agent-name"], gc.Equals, "")
env, err := maas.NewEnviron(baseCfg)
c.Assert(err, jc.ErrorIsNil)
provider := env.Provider()
attrs := coretesting.FakeConfig()
// These are attrs we need to make it a valid Config, but would usually
// be set by other infrastructure
attrs["type"] = "maas"
nilCfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
validatedConfig, err := provider.Validate(baseCfg, nilCfg)
c.Assert(err, jc.ErrorIsNil)
c.Check(validatedConfig.UnknownAttrs()["maas-agent-name"], gc.Equals, "")
// However, you can't set it to an actual value if you haven't been using a value
valueCfg := getSimpleTestConfig(c, coretesting.Attrs{"maas-agent-name": "agent-name"})
_, err = provider.Validate(valueCfg, nilCfg)
c.Check(err, gc.ErrorMatches, ".*cannot change maas-agent-name.*")
}
func (s *AgentToolsSuite) TestCheckToolsNonReleasedStream(c *gc.C) {
sConfig := coretesting.FakeConfig()
sConfig = sConfig.Merge(coretesting.Attrs{
"agent-version": "2.5-alpha1",
"agent-stream": "proposed",
})
cfg, err := config.New(config.NoDefaults, sConfig)
c.Assert(err, jc.ErrorIsNil)
fakeNewEnvirons := func(*config.Config) (environs.Environ, error) {
return dummyEnviron{}, nil
}
s.PatchValue(&newEnvirons, fakeNewEnvirons)
var (
calledWithMajor, calledWithMinor int
calledWithStreams []string
)
fakeToolFinder := func(e environs.Environ, maj int, min int, stream string, filter coretools.Filter) (coretools.List, error) {
calledWithMajor = maj
calledWithMinor = min
calledWithStreams = append(calledWithStreams, stream)
if stream == "released" {
return nil, coretools.ErrNoMatches
}
ver := version.Binary{Number: version.Number{Major: maj, Minor: min}}
t := coretools.Tools{Version: ver, URL: "http://example.com", Size: 1}
c.Assert(calledWithMajor, gc.Equals, 2)
c.Assert(calledWithMinor, gc.Equals, 5)
return coretools.List{&t}, nil
}
ver, err := checkToolsAvailability(cfg, fakeToolFinder)
c.Assert(err, jc.ErrorIsNil)
c.Assert(calledWithStreams, gc.DeepEquals, []string{"released", "proposed"})
c.Assert(ver, gc.Not(gc.Equals), version.Zero)
c.Assert(ver, gc.Equals, version.Number{Major: 2, Minor: 5, Patch: 0})
}
func (s *environBrokerSuite) TestStartInstanceOpensAPIPort(c *gc.C) {
s.FakeEnviron.Spec = s.spec
s.FakeEnviron.Inst = s.BaseInstance
s.FakeEnviron.Hwc = s.hardware
// Get the API port from the fake environment config used to
// "bootstrap".
envConfig := testing.FakeConfig()
apiPort, ok := envConfig["api-port"].(int)
c.Assert(ok, jc.IsTrue)
c.Assert(apiPort, gc.Not(gc.Equals), 0)
// When StateServingInfo is not nil, verify OpenPorts was called
// for the API port.
s.StartInstArgs.InstanceConfig.StateServingInfo = ¶ms.StateServingInfo{
APIPort: apiPort,
}
result, err := s.Env.StartInstance(s.StartInstArgs)
c.Assert(err, jc.ErrorIsNil)
c.Check(result.Instance, gc.DeepEquals, s.Instance)
c.Check(result.Hardware, gc.DeepEquals, s.hardware)
called, calls := s.FakeConn.WasCalled("OpenPorts")
c.Check(called, gc.Equals, true)
c.Check(calls, gc.HasLen, 1)
c.Check(calls[0].FirewallName, gc.Equals, gce.GlobalFirewallName(s.Env))
expectPorts := []network.PortRange{{
FromPort: apiPort,
ToPort: apiPort,
Protocol: "tcp",
}}
c.Check(calls[0].PortRanges, jc.DeepEquals, expectPorts)
}
func (suite *maas2Suite) makeEnviron(c *gc.C, controller gomaasapi.Controller) *maasEnviron {
if controller != nil {
suite.injectController(controller)
}
testAttrs := coretesting.Attrs{}
for k, v := range maasEnvAttrs {
testAttrs[k] = v
}
testAttrs["agent-version"] = version.Current.String()
cred := cloud.NewCredential(cloud.OAuth1AuthType, map[string]string{
"maas-oauth": "a:b:c",
})
cloud := environs.CloudSpec{
Type: "maas",
Name: "maas",
Endpoint: "http://any-old-junk.invalid/",
Credential: &cred,
}
attrs := coretesting.FakeConfig().Merge(testAttrs)
suite.controllerUUID = coretesting.FakeControllerConfig().ControllerUUID()
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
env, err := NewEnviron(cloud, cfg)
c.Assert(err, jc.ErrorIsNil)
c.Assert(env, gc.NotNil)
return env
}
func ConfigAttrs() testing.Attrs {
return testing.FakeConfig().Merge(testing.Attrs{
"type": "vsphere",
"uuid": "2d02eeac-9dbb-11e4-89d3-123b93f75cba",
"external-network": "",
})
}
func testConfig(c *gc.C) *config.Config {
cfg, err := config.New(config.UseDefaults, coretesting.FakeConfig().Merge(coretesting.Attrs{
"type": "mock",
}))
c.Assert(err, jc.ErrorIsNil)
return cfg
}
func (s *updaterSuite) TestCheckTools(c *gc.C) {
sConfig := coretesting.FakeConfig()
sConfig = sConfig.Merge(coretesting.Attrs{
"agent-version": "2.5.0",
})
cfg, err := config.New(config.NoDefaults, sConfig)
c.Assert(err, jc.ErrorIsNil)
fakeNewEnvirons := func(*config.Config) (environs.Environ, error) {
return dummyEnviron{}, nil
}
s.PatchValue(&newEnvirons, fakeNewEnvirons)
var (
calledWithEnviron environs.Environ
calledWithMajor, calledWithMinor int
calledWithFilter coretools.Filter
)
fakeToolFinder := func(e environs.Environ, maj int, min int, _ string, filter coretools.Filter) (coretools.List, error) {
calledWithEnviron = e
calledWithMajor = maj
calledWithMinor = min
calledWithFilter = filter
ver := version.Binary{Number: version.Number{Major: maj, Minor: min}}
t := coretools.Tools{Version: ver, URL: "http://example.com", Size: 1}
c.Assert(calledWithMajor, gc.Equals, 2)
c.Assert(calledWithMinor, gc.Equals, 5)
return coretools.List{&t}, nil
}
ver, err := checkToolsAvailability(cfg, fakeToolFinder)
c.Assert(err, jc.ErrorIsNil)
c.Assert(ver, gc.Not(gc.Equals), version.Zero)
c.Assert(ver, gc.Equals, version.Number{Major: 2, Minor: 5, Patch: 0})
}
func (suite *environSuite) assertGetImageMetadataSources(c *gc.C, stream, officialSourcePath string) {
// Make an env configured with the stream.
testAttrs := maasEnvAttrs
testAttrs = testAttrs.Merge(coretesting.Attrs{
"maas-server": suite.testMAASObject.TestServer.URL,
})
if stream != "" {
testAttrs = testAttrs.Merge(coretesting.Attrs{
"image-stream": stream,
})
}
attrs := coretesting.FakeConfig().Merge(testAttrs)
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := NewEnviron(cfg)
c.Assert(err, gc.IsNil)
// Add a dummy file to storage so we can use that to check the
// obtained source later.
data := makeRandomBytes(10)
stor := NewStorage(env)
err = stor.Put("images/filename", bytes.NewBuffer([]byte(data)), int64(len(data)))
c.Assert(err, gc.IsNil)
sources, err := imagemetadata.GetMetadataSources(env)
c.Assert(err, gc.IsNil)
c.Assert(len(sources), gc.Equals, 2)
assertSourceContents(c, sources[0], "filename", data)
url, err := sources[1].URL("")
c.Assert(err, gc.IsNil)
c.Assert(url, gc.Equals, fmt.Sprintf("http://cloud-images.ubuntu.com/%s/", officialSourcePath))
}
func (s *updaterSuite) TestUpdateToolsAvailabilityNoMatches(c *gc.C) {
fakeNewEnvirons := func(*config.Config) (environs.Environ, error) {
return dummyEnviron{}, nil
}
s.PatchValue(&newEnvirons, fakeNewEnvirons)
fakeEnvConfig := func(_ *state.Environment) (*config.Config, error) {
sConfig := coretesting.FakeConfig()
sConfig = sConfig.Merge(coretesting.Attrs{
"agent-version": "2.5.0",
})
return config.New(config.NoDefaults, sConfig)
}
s.PatchValue(&envConfig, fakeEnvConfig)
// No new tools available.
fakeToolFinder := func(_ environs.Environ, _ int, _ int, _ string, _ coretools.Filter) (coretools.List, error) {
return nil, errors.NotFoundf("tools")
}
// Update should never be called.
fakeUpdate := func(_ *state.Environment, v version.Number) error {
c.Fail()
return nil
}
err := updateToolsAvailability(&envGetter{}, fakeToolFinder, fakeUpdate)
c.Assert(err, jc.ErrorIsNil)
}
func registerAmazonTests() {
// The following attributes hold the environment configuration
// for running the amazon EC2 integration tests.
//
// This is missing keys for security reasons; set the following
// environment variables to make the Amazon testing work:
// access-key: $AWS_ACCESS_KEY_ID
// secret-key: $AWS_SECRET_ACCESS_KEY
attrs := coretesting.FakeConfig().Merge(map[string]interface{}{
"name": "sample-" + uniqueName,
"type": "ec2",
"control-bucket": "juju-test-" + uniqueName,
"admin-secret": "for real",
"firewall-mode": config.FwInstance,
"agent-version": coretesting.FakeVersionNumber.String(),
})
gc.Suite(&LiveTests{
LiveTests: jujutest.LiveTests{
TestConfig: attrs,
Attempt: *ec2.ShortAttempt,
CanOpenState: true,
HasProvisioner: true,
},
})
}
func (t configTest) check(c *gc.C) {
credential := cloud.NewCredential(
cloud.AccessKeyAuthType,
map[string]string{
"access-key": "x",
"secret-key": "y",
},
)
cloudSpec := environs.CloudSpec{
Type: "ec2",
Name: "ec2test",
Region: "us-east-1",
Credential: &credential,
}
attrs := testing.FakeConfig().Merge(testing.Attrs{
"type": "ec2",
}).Merge(t.config)
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
e, err := environs.New(environs.OpenParams{
Cloud: cloudSpec,
Config: cfg,
})
if t.change != nil {
c.Assert(err, jc.ErrorIsNil)
// Testing a change in configuration.
var old, changed, valid *config.Config
ec2env := e.(*environ)
old = ec2env.ecfg().Config
changed, err = old.Apply(t.change)
c.Assert(err, jc.ErrorIsNil)
// Keep err for validation below.
valid, err = providerInstance.Validate(changed, old)
if err == nil {
err = ec2env.SetConfig(valid)
}
}
if t.err != "" {
c.Check(err, gc.ErrorMatches, t.err)
return
}
c.Assert(err, jc.ErrorIsNil)
ecfg := e.(*environ).ecfg()
c.Assert(ecfg.Name(), gc.Equals, "testenv")
c.Assert(ecfg.vpcID(), gc.Equals, t.vpcID)
c.Assert(ecfg.forceVPCID(), gc.Equals, t.forceVPCID)
if t.firewallMode != "" {
c.Assert(ecfg.FirewallMode(), gc.Equals, t.firewallMode)
}
for name, expect := range t.expect {
actual, found := ecfg.UnknownAttrs()[name]
c.Check(found, jc.IsTrue)
c.Check(actual, gc.Equals, expect)
}
}
func (e *minModelWorkersEnviron) Config() *config.Config {
attrs := coretesting.FakeConfig()
cfg, err := config.New(config.NoDefaults, attrs)
if err != nil {
panic(err)
}
return cfg
}
func (t configTest) check(c *gc.C) {
attrs := testing.FakeConfig().Merge(testing.Attrs{
"type": "ec2",
}).Merge(t.config)
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
e, err := environs.New(cfg)
if t.change != nil {
c.Assert(err, jc.ErrorIsNil)
// Testing a change in configuration.
var old, changed, valid *config.Config
ec2env := e.(*environ)
old = ec2env.ecfg().Config
changed, err = old.Apply(t.change)
c.Assert(err, jc.ErrorIsNil)
// Keep err for validation below.
valid, err = providerInstance.Validate(changed, old)
if err == nil {
err = ec2env.SetConfig(valid)
}
}
if t.err != "" {
c.Check(err, gc.ErrorMatches, t.err)
return
}
c.Assert(err, jc.ErrorIsNil)
ecfg := e.(*environ).ecfg()
c.Assert(ecfg.Name(), gc.Equals, "testenv")
if t.region != "" {
c.Assert(ecfg.region(), gc.Equals, t.region)
}
if t.accessKey != "" {
c.Assert(ecfg.accessKey(), gc.Equals, t.accessKey)
c.Assert(ecfg.secretKey(), gc.Equals, t.secretKey)
expected := map[string]string{
"access-key": t.accessKey,
"secret-key": t.secretKey,
}
c.Assert(err, jc.ErrorIsNil)
actual, err := e.Provider().SecretAttrs(ecfg.Config)
c.Assert(err, jc.ErrorIsNil)
c.Assert(expected, gc.DeepEquals, actual)
} else {
c.Assert(ecfg.accessKey(), gc.DeepEquals, testAuth.AccessKey)
c.Assert(ecfg.secretKey(), gc.DeepEquals, testAuth.SecretKey)
}
if t.firewallMode != "" {
c.Assert(ecfg.FirewallMode(), gc.Equals, t.firewallMode)
}
for name, expect := range t.expect {
actual, found := ecfg.UnknownAttrs()[name]
c.Check(found, jc.IsTrue)
c.Check(actual, gc.Equals, expect)
}
}
func validAttrs() testing.Attrs {
return testing.FakeConfig().Merge(testing.Attrs{
"type": "cloudsigma",
"username": "******",
"password": "******",
"region": "zrh",
"uuid": "f54aac3a-9dcd-4a0c-86b5-24091478478c",
})
}
func (backend *mockBackend) ModelConfig() (*config.Config, error) {
backend.stub.AddCall("ModelConfig")
attrs := testing.FakeConfig()
attrs["proxy-ssh"] = backend.proxySSH
conf, err := config.New(config.NoDefaults, attrs)
if err != nil {
return nil, errors.Trace(err)
}
return conf, nil
}
func validAttrs() testing.Attrs {
return testing.FakeConfig().Merge(testing.Attrs{
"type": "cloudsigma",
"username": "******",
"password": "******",
"region": "zrh",
"endpoint": "https://0.1.2.3:2000/api/2.0/",
"uuid": "f54aac3a-9dcd-4a0c-86b5-24091478478c",
})
}
func (suite *EnvironProviderSuite) TestPrepareConfig(c *gc.C) {
attrs := testing.FakeConfig().Merge(testing.Attrs{"type": "maas"})
config, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
_, err = providerInstance.PrepareConfig(environs.PrepareConfigParams{
Config: config,
Cloud: suite.cloudSpec(),
})
c.Assert(err, jc.ErrorIsNil)
}
func validAttrs() coretesting.Attrs {
return coretesting.FakeConfig().Merge(coretesting.Attrs{
"type": "joyent",
"sdc-user": "******",
"sdc-key-id": "00:11:22:33:44:55:66:77:88:99:aa:bb:cc:dd:ee:ff",
"sdc-url": "test://test.api.joyentcloud.com",
"private-key": testPrivateKey,
"algorithm": "rsa-sha256",
})
}
func testConfig(c *gc.C, stateServer bool, vers version.Binary) *config.Config {
testConfig, err := config.New(config.UseDefaults, coretesting.FakeConfig())
c.Assert(err, jc.ErrorIsNil)
testConfig, err = testConfig.Apply(map[string]interface{}{
"type": "sshinit_test",
"default-series": vers.Series,
"agent-version": vers.Number.String(),
})
c.Assert(err, jc.ErrorIsNil)
return testConfig
}
func dummyConfig(c *gc.C) *config.Config {
testConfig, err := config.New(config.UseDefaults, coretesting.FakeConfig())
c.Assert(err, jc.ErrorIsNil)
testConfig, err = testConfig.Apply(map[string]interface{}{
"type": "dummy",
"state-server": false,
"agent-version": version.Current.String(),
})
c.Assert(err, jc.ErrorIsNil)
return testConfig
}
// If settings are provided, don't overwrite with defaults.
func (s *configSuite) TestLocalRespectsUpgradeSettings(c *gc.C) {
minAttrs := testing.FakeConfig().Merge(testing.Attrs{
"lxc-clone": true,
"enable-os-upgrades": true,
"enable-os-updates": true,
})
testConfig, err := config.New(config.NoDefaults, minAttrs)
c.Assert(err, jc.ErrorIsNil)
c.Check(testConfig.EnableOSRefreshUpdate(), jc.IsTrue)
c.Check(testConfig.EnableOSUpgrade(), jc.IsTrue)
}
func (s *ConfigDeprecationSuite) setupEnv(c *gc.C, deprecatedKey, value string) {
s.setupEnvCredentials()
attrs := testing.FakeConfig().Merge(testing.Attrs{
"name": "testenv",
"type": "openstack",
"control-bucket": "x",
deprecatedKey: value,
})
_, err := environs.NewFromAttrs(attrs)
c.Assert(err, gc.IsNil)
}
func (*instancecfgSuite) TestInstanceTagsNoUUID(c *gc.C) {
attrsWithoutUUID := testing.FakeConfig()
delete(attrsWithoutUUID, "uuid")
cfgWithoutUUID, err := config.New(config.NoDefaults, attrsWithoutUUID)
c.Assert(err, jc.ErrorIsNil)
testInstanceTags(c,
cfgWithoutUUID,
[]multiwatcher.MachineJob(nil),
map[string]string{"juju-env-uuid": ""},
)
}