func (s *InitializeSuite) TestInitializeWithInvalidCredentialType(c *gc.C) {
owner := names.NewLocalUserTag("initialize-admin")
modelCfg := testing.ModelConfig(c)
controllerCfg := testing.FakeControllerConfig()
credentialTag := names.NewCloudCredentialTag("dummy/" + owner.Canonical() + "/borken")
_, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
Owner: owner,
Config: modelCfg,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{
cloud.AccessKeyAuthType, cloud.OAuth1AuthType,
},
},
CloudCredentials: map[names.CloudCredentialTag]cloud.Credential{
credentialTag: cloud.NewCredential(cloud.UserPassAuthType, nil),
},
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
})
c.Assert(err, gc.ErrorMatches,
`validating initialization args: validating cloud credentials: credential "dummy/initialize-admin@local/borken" with auth-type "userpass" is not supported \(expected one of \["access-key" "oauth1"\]\)`,
)
}
func (s *InitializeSuite) TestEnvironConfigWithoutAgentVersion(c *gc.C) {
// admin-secret blocks Initialize.
good := testing.EnvironConfig(c)
attrs := good.AllAttrs()
delete(attrs, "agent-version")
bad, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
owner := names.NewLocalUserTag("initialize-admin")
_, err = state.Initialize(owner, statetesting.NewMongoInfo(), bad, statetesting.NewDialOpts(), state.Policy(nil))
c.Assert(err, gc.ErrorMatches, "agent-version must always be set in state")
st := statetesting.Initialize(c, owner, good, nil)
// yay side effects
st.Close()
s.openState(c, st.EnvironTag())
err = s.State.UpdateEnvironConfig(map[string]interface{}{}, []string{"agent-version"}, nil)
c.Assert(err, gc.ErrorMatches, "agent-version must always be set in state")
// EnvironConfig remains inviolate.
cfg, err := s.State.EnvironConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(cfg.AllAttrs(), gc.DeepEquals, good.AllAttrs())
}
func (s *InitializeSuite) openState(c *gc.C, environTag names.EnvironTag) {
st, err := state.Open(
environTag,
statetesting.NewMongoInfo(),
statetesting.NewDialOpts(),
state.Policy(nil),
)
c.Assert(err, jc.ErrorIsNil)
s.State = st
}
func (s *InitializeSuite) TestInitializeWithCloudRegionHits(c *gc.C) {
cfg := testing.ModelConfig(c)
uuid := cfg.UUID()
controllerInheritedConfigIn := map[string]interface{}{
"no-proxy": "local",
}
// Phony region-config
regionInheritedConfigIn := cloud.RegionConfig{
"a-region": cloud.Attrs{
"no-proxy": "a-value",
},
"b-region": cloud.Attrs{
"no-proxy": "b-value",
},
}
owner := names.NewLocalUserTag("initialize-admin")
controllerCfg := testing.FakeControllerConfig()
st, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
Owner: owner,
Config: cfg,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
RegionConfig: regionInheritedConfigIn, // Init with phony region-config
},
ControllerInheritedConfig: controllerInheritedConfigIn,
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, gc.NotNil)
modelTag := st.ModelTag()
c.Assert(modelTag.Id(), gc.Equals, uuid)
err = st.Close()
c.Assert(err, jc.ErrorIsNil)
s.openState(c, modelTag)
var attrs map[string]interface{}
for r := range regionInheritedConfigIn {
rspec := &environs.RegionSpec{Cloud: "dummy", Region: r}
got, err := s.State.ComposeNewModelConfig(attrs, rspec)
c.Check(err, jc.ErrorIsNil)
c.Assert(got["no-proxy"], gc.Equals, regionInheritedConfigIn[r]["no-proxy"])
}
}
func (s *InitializeSuite) TestInitializeWithCloudRegionConfig(c *gc.C) {
cfg := testing.ModelConfig(c)
uuid := cfg.UUID()
// Phony region-config
regionInheritedConfigIn := cloud.RegionConfig{
"a-region": cloud.Attrs{
"a-key": "a-value",
},
"b-region": cloud.Attrs{
"b-key": "b-value",
},
}
owner := names.NewLocalUserTag("initialize-admin")
controllerCfg := testing.FakeControllerConfig()
st, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
Owner: owner,
Config: cfg,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
RegionConfig: regionInheritedConfigIn, // Init with phony region-config
},
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, gc.NotNil)
modelTag := st.ModelTag()
c.Assert(modelTag.Id(), gc.Equals, uuid)
err = st.Close()
c.Assert(err, jc.ErrorIsNil)
s.openState(c, modelTag)
for k := range regionInheritedConfigIn {
// Query for config for each region
regionInheritedConfig, err := state.ReadSettings(
s.State, state.GlobalSettingsC,
"dummy#"+k)
c.Assert(err, jc.ErrorIsNil)
c.Assert(
cloud.Attrs(regionInheritedConfig.Map()),
jc.DeepEquals,
regionInheritedConfigIn[k])
}
}
func (s *InitializeSuite) openState(c *gc.C, modelTag names.ModelTag) {
st, err := state.Open(
modelTag,
testing.ControllerTag,
statetesting.NewMongoInfo(),
mongotest.DialOpts(),
state.NewPolicyFunc(nil),
)
c.Assert(err, jc.ErrorIsNil)
s.State = st
}
func (s *InitializeSuite) TestInitializeWithControllerInheritedConfig(c *gc.C) {
cfg := testing.ModelConfig(c)
uuid := cfg.UUID()
initial := cfg.AllAttrs()
controllerInheritedConfigIn := map[string]interface{}{
"default-series": initial["default-series"],
}
owner := names.NewLocalUserTag("initialize-admin")
controllerCfg := testing.FakeControllerConfig()
st, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
Owner: owner,
Config: cfg,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
},
ControllerInheritedConfig: controllerInheritedConfigIn,
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, gc.NotNil)
modelTag := st.ModelTag()
c.Assert(modelTag.Id(), gc.Equals, uuid)
err = st.Close()
c.Assert(err, jc.ErrorIsNil)
s.openState(c, modelTag)
controllerInheritedConfig, err := state.ReadSettings(s.State, state.GlobalSettingsC, state.ControllerInheritedSettingsGlobalKey)
c.Assert(err, jc.ErrorIsNil)
c.Assert(controllerInheritedConfig.Map(), jc.DeepEquals, controllerInheritedConfigIn)
expected := cfg.AllAttrs()
for k, v := range config.ConfigDefaults() {
if _, ok := expected[k]; !ok {
expected[k] = v
}
}
// Config as read from state has resources tags coerced to a map.
expected["resource-tags"] = map[string]string{}
cfg, err = s.State.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(cfg.AllAttrs(), jc.DeepEquals, expected)
}
func (s *InitializeSuite) TestDoubleInitializeConfig(c *gc.C) {
cfg := testing.EnvironConfig(c)
owner := names.NewLocalUserTag("initialize-admin")
mgoInfo := statetesting.NewMongoInfo()
dialOpts := statetesting.NewDialOpts()
st, err := state.Initialize(owner, mgoInfo, cfg, dialOpts, state.Policy(nil))
c.Assert(err, jc.ErrorIsNil)
st.Close()
_, err = state.Initialize(owner, mgoInfo, cfg, dialOpts, state.Policy(nil))
c.Assert(err, gc.ErrorMatches, "already initialized")
}
func (s *InitializeSuite) TestInitialize(c *gc.C) {
cfg := testing.EnvironConfig(c)
uuid, _ := cfg.UUID()
initial := cfg.AllAttrs()
owner := names.NewLocalUserTag("initialize-admin")
st, err := state.Initialize(owner, statetesting.NewMongoInfo(), cfg, statetesting.NewDialOpts(), nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, gc.NotNil)
envTag := st.EnvironTag()
c.Assert(envTag.Id(), gc.Equals, uuid)
err = st.Close()
c.Assert(err, jc.ErrorIsNil)
s.openState(c, envTag)
cfg, err = s.State.EnvironConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(cfg.AllAttrs(), gc.DeepEquals, initial)
// Check that the environment has been created.
env, err := s.State.Environment()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.Tag(), gc.Equals, envTag)
// Check that the owner has been created.
c.Assert(env.Owner(), gc.Equals, owner)
// Check that the owner can be retrieved by the tag.
entity, err := s.State.FindEntity(env.Owner())
c.Assert(err, jc.ErrorIsNil)
c.Assert(entity.Tag(), gc.Equals, owner)
// Check that the owner has an EnvUser created for the bootstrapped environment.
envUser, err := s.State.EnvironmentUser(env.Owner())
c.Assert(err, jc.ErrorIsNil)
c.Assert(envUser.UserTag(), gc.Equals, owner)
c.Assert(envUser.EnvironmentTag(), gc.Equals, env.Tag())
// Check that the environment can be found through the tag.
entity, err = s.State.FindEntity(envTag)
c.Assert(err, jc.ErrorIsNil)
cons, err := s.State.EnvironConstraints()
c.Assert(err, jc.ErrorIsNil)
c.Assert(&cons, jc.Satisfies, constraints.IsEmpty)
addrs, err := s.State.APIHostPorts()
c.Assert(err, jc.ErrorIsNil)
c.Assert(addrs, gc.HasLen, 0)
info, err := s.State.StateServerInfo()
c.Assert(err, jc.ErrorIsNil)
c.Assert(info, jc.DeepEquals, &state.StateServerInfo{EnvironmentTag: envTag})
}
func (r *RestoreSuite) TestNewConnection(c *gc.C) {
server := &gitjujutesting.MgoInstance{}
err := server.Start(coretesting.Certs)
c.Assert(err, jc.ErrorIsNil)
defer server.DestroyWithLog()
st := statetesting.Initialize(c, names.NewLocalUserTag("test-admin"), nil, nil)
c.Assert(st.Close(), jc.ErrorIsNil)
r.PatchValue(&mongoDefaultDialOpts, statetesting.NewDialOpts)
r.PatchValue(&environsNewStatePolicy, func() state.Policy { return nil })
st, err = newStateConnection(st.ModelTag(), statetesting.NewMongoInfo())
c.Assert(err, jc.ErrorIsNil)
c.Assert(st.Close(), jc.ErrorIsNil)
}
func (s *InitializeSuite) testBadModelConfig(c *gc.C, update map[string]interface{}, remove []string, expect string) {
good := testing.CustomModelConfig(c, testing.Attrs{"uuid": testing.ModelTag.Id()})
bad, err := good.Apply(update)
c.Assert(err, jc.ErrorIsNil)
bad, err = bad.Remove(remove)
c.Assert(err, jc.ErrorIsNil)
owner := names.NewLocalUserTag("initialize-admin")
controllerCfg := testing.FakeControllerConfig()
args := state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
CloudRegion: "dummy-region",
Owner: owner,
Config: bad,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
Regions: []cloud.Region{{Name: "dummy-region"}},
},
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
}
_, err = state.Initialize(args)
c.Assert(err, gc.ErrorMatches, expect)
args.ControllerModelArgs.Config = good
st, err := state.Initialize(args)
c.Assert(err, jc.ErrorIsNil)
st.Close()
s.openState(c, st.ModelTag())
err = s.State.UpdateModelConfig(update, remove, nil)
c.Assert(err, gc.ErrorMatches, expect)
// ModelConfig remains inviolate.
cfg, err := s.State.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
goodWithDefaults, err := config.New(config.UseDefaults, good.AllAttrs())
c.Assert(err, jc.ErrorIsNil)
c.Assert(cfg.AllAttrs(), jc.DeepEquals, goodWithDefaults.AllAttrs())
}
func (s *ModelConfigSourceSuite) TestUpdateModelConfigDefaults(c *gc.C) {
// Set up values that will be removed.
attrs := map[string]interface{}{
"http-proxy": "http://http-proxy",
"https-proxy": "https://https-proxy",
}
err := s.State.UpdateModelConfigDefaultValues(attrs, nil, nil)
c.Assert(err, jc.ErrorIsNil)
attrs = map[string]interface{}{
"apt-mirror": "http://different-mirror",
}
err = s.State.UpdateModelConfigDefaultValues(attrs, []string{"http-proxy", "https-proxy"}, nil)
c.Assert(err, jc.ErrorIsNil)
info := statetesting.NewMongoInfo()
anotherState, err := state.Open(s.modelTag, s.State.ControllerTag(), info, mongotest.DialOpts(), state.NewPolicyFunc(nil))
c.Assert(err, jc.ErrorIsNil)
defer anotherState.Close()
cfg, err := anotherState.ModelConfigDefaultValues()
c.Assert(err, jc.ErrorIsNil)
expectedValues := make(config.ModelDefaultAttributes)
for attr, val := range config.ConfigDefaults() {
expectedValues[attr] = config.AttributeDefaultValues{
Default: val,
}
}
delete(expectedValues, "http-mirror")
delete(expectedValues, "https-mirror")
expectedValues["apt-mirror"] = config.AttributeDefaultValues{
Controller: "http://different-mirror",
Default: "",
Regions: []config.RegionDefaultValue{{
Name: "dummy-region",
Value: "http://dummy-mirror",
}}}
expectedValues["no-proxy"] = config.AttributeDefaultValues{
Default: "",
Regions: []config.RegionDefaultValue{{
Name: "dummy-region",
Value: "dummy-proxy",
}}}
c.Assert(cfg, jc.DeepEquals, expectedValues)
}
func (s *ModelCloudValidationSuite) initializeState(
c *gc.C,
regions []cloud.Region,
authTypes []cloud.AuthType,
credentials map[names.CloudCredentialTag]cloud.Credential,
) (*state.State, names.UserTag) {
owner := names.NewUserTag("test@remote")
cfg, _ := createTestModelConfig(c, "")
var controllerRegion string
var controllerCredential names.CloudCredentialTag
if len(regions) > 0 {
controllerRegion = regions[0].Name
}
if len(credentials) > 0 {
// pick an arbitrary credential
for controllerCredential = range credentials {
}
}
controllerCfg := testing.FakeControllerConfig()
st, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
Owner: owner,
Config: cfg,
CloudName: "dummy",
CloudRegion: controllerRegion,
CloudCredential: controllerCredential,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: authTypes,
Regions: regions,
},
CloudCredentials: credentials,
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
})
c.Assert(err, jc.ErrorIsNil)
return st, owner
}
func (r *RestoreSuite) TestNewConnection(c *gc.C) {
server := &gitjujutesting.MgoInstance{}
err := server.Start(coretesting.Certs)
c.Assert(err, jc.ErrorIsNil)
defer server.DestroyWithLog()
st := statetesting.InitializeWithArgs(c,
statetesting.InitializeArgs{
Owner: names.NewLocalUserTag("test-admin"),
Clock: gitjujutesting.NewClock(coretesting.NonZeroTime()),
})
c.Assert(st.Close(), jc.ErrorIsNil)
r.PatchValue(&mongoDefaultDialOpts, mongotest.DialOpts)
r.PatchValue(&environsGetNewPolicyFunc, func(
func(*state.State) (environs.Environ, error),
) state.NewPolicyFunc {
return nil
})
st, err = newStateConnection(st.ControllerTag(), st.ModelTag(), statetesting.NewMongoInfo())
c.Assert(err, jc.ErrorIsNil)
c.Assert(st.Close(), jc.ErrorIsNil)
}
func (s *InitializeSuite) TestEnvironConfigWithAdminSecret(c *gc.C) {
// admin-secret blocks Initialize.
good := testing.EnvironConfig(c)
badUpdateAttrs := map[string]interface{}{"admin-secret": "foo"}
bad, err := good.Apply(badUpdateAttrs)
owner := names.NewLocalUserTag("initialize-admin")
_, err = state.Initialize(owner, statetesting.NewMongoInfo(), bad, statetesting.NewDialOpts(), state.Policy(nil))
c.Assert(err, gc.ErrorMatches, "admin-secret should never be written to the state")
// admin-secret blocks UpdateEnvironConfig.
st := statetesting.Initialize(c, owner, good, nil)
st.Close()
s.openState(c, st.EnvironTag())
err = s.State.UpdateEnvironConfig(badUpdateAttrs, nil, nil)
c.Assert(err, gc.ErrorMatches, "admin-secret should never be written to the state")
// EnvironConfig remains inviolate.
cfg, err := s.State.EnvironConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(cfg.AllAttrs(), gc.DeepEquals, good.AllAttrs())
}
func (s *InitializeSuite) TestDoubleInitializeConfig(c *gc.C) {
cfg := testing.ModelConfig(c)
owner := names.NewLocalUserTag("initialize-admin")
mgoInfo := statetesting.NewMongoInfo()
dialOpts := mongotest.DialOpts()
controllerCfg := testing.FakeControllerConfig()
args := state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
Owner: owner,
Config: cfg,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
},
MongoInfo: mgoInfo,
MongoDialOpts: dialOpts,
}
st, err := state.Initialize(args)
c.Assert(err, jc.ErrorIsNil)
err = st.Close()
c.Check(err, jc.ErrorIsNil)
st, err = state.Initialize(args)
c.Check(err, gc.ErrorMatches, "already initialized")
if !c.Check(st, gc.IsNil) {
err = st.Close()
c.Check(err, jc.ErrorIsNil)
}
}
func (s *InitializeSuite) TestCloudConfigWithForbiddenValues(c *gc.C) {
badAttrNames := []string{
"admin-secret",
"ca-private-key",
config.AgentVersionKey,
}
for _, attr := range controller.ControllerOnlyConfigAttributes {
badAttrNames = append(badAttrNames, attr)
}
modelCfg := testing.ModelConfig(c)
controllerCfg := testing.FakeControllerConfig()
args := state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
Owner: names.NewLocalUserTag("initialize-admin"),
Config: modelCfg,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
},
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
}
for _, badAttrName := range badAttrNames {
badAttrs := map[string]interface{}{badAttrName: "foo"}
args.ControllerInheritedConfig = badAttrs
_, err := state.Initialize(args)
c.Assert(err, gc.ErrorMatches, "local cloud config cannot contain .*")
}
}
func (s *InitializeSuite) openState(c *gc.C) {
st, err := state.Open(statetesting.NewMongoInfo(), statetesting.NewDialOpts(), state.Policy(nil))
c.Assert(err, jc.ErrorIsNil)
s.State = st
}
func (s *ModelConfigSourceSuite) TestUpdateModelConfigRegionDefaults(c *gc.C) {
// The test env is setup with dummy/dummy-region having a no-proxy
// dummy-proxy value and nether-region with a nether-proxy value.
//
// First we change the no-proxy setting in dummy-region
attrs := map[string]interface{}{
"no-proxy": "changed-proxy",
}
rspec, err := environs.NewRegionSpec("dummy", "dummy-region")
c.Assert(err, jc.ErrorIsNil)
err = s.State.UpdateModelConfigDefaultValues(attrs, nil, rspec)
c.Assert(err, jc.ErrorIsNil)
// Then check in another state.
info := statetesting.NewMongoInfo()
anotherState, err := state.Open(s.modelTag, s.State.ControllerTag(), info, mongotest.DialOpts(), state.NewPolicyFunc(nil))
c.Assert(err, jc.ErrorIsNil)
defer anotherState.Close()
cfg, err := anotherState.ModelConfigDefaultValues()
c.Assert(err, jc.ErrorIsNil)
expectedValues := make(config.ModelDefaultAttributes)
for attr, val := range config.ConfigDefaults() {
expectedValues[attr] = config.AttributeDefaultValues{
Default: val,
}
}
expectedValues["http-proxy"] = config.AttributeDefaultValues{
Controller: "http://proxy",
Default: "",
}
expectedValues["apt-mirror"] = config.AttributeDefaultValues{
Controller: "http://mirror",
Default: "",
Regions: []config.RegionDefaultValue{{
Name: "dummy-region",
Value: "http://dummy-mirror",
}}}
expectedValues["no-proxy"] = config.AttributeDefaultValues{
Default: "",
Regions: []config.RegionDefaultValue{{
Name: "dummy-region",
Value: "changed-proxy",
}}}
c.Assert(cfg, jc.DeepEquals, expectedValues)
// remove the dummy-region setting
err = s.State.UpdateModelConfigDefaultValues(nil, []string{"no-proxy"}, rspec)
// and check again
cfg, err = anotherState.ModelConfigDefaultValues()
c.Assert(err, jc.ErrorIsNil)
cfg, err = anotherState.ModelConfigDefaultValues()
c.Assert(err, jc.ErrorIsNil)
expectedValues = make(config.ModelDefaultAttributes)
for attr, val := range config.ConfigDefaults() {
expectedValues[attr] = config.AttributeDefaultValues{
Default: val,
}
}
expectedValues["http-proxy"] = config.AttributeDefaultValues{
Controller: "http://proxy",
Default: "",
}
expectedValues["apt-mirror"] = config.AttributeDefaultValues{
Controller: "http://mirror",
Default: "",
Regions: []config.RegionDefaultValue{{
Name: "dummy-region",
Value: "http://dummy-mirror",
}}}
c.Assert(cfg, jc.DeepEquals, expectedValues)
}
func (s *InitializeSuite) TestInitialize(c *gc.C) {
cfg := testing.ModelConfig(c)
uuid := cfg.UUID()
owner := names.NewLocalUserTag("initialize-admin")
userPassCredentialTag := names.NewCloudCredentialTag(
"dummy/" + owner.Canonical() + "/some-credential",
)
emptyCredentialTag := names.NewCloudCredentialTag(
"dummy/" + owner.Canonical() + "/empty-credential",
)
userpassCredential := cloud.NewCredential(
cloud.UserPassAuthType,
map[string]string{
"username": "******",
"password": "******",
},
)
userpassCredential.Label = userPassCredentialTag.Name()
emptyCredential := cloud.NewEmptyCredential()
emptyCredential.Label = emptyCredentialTag.Name()
cloudCredentialsIn := map[names.CloudCredentialTag]cloud.Credential{
userPassCredentialTag: userpassCredential,
emptyCredentialTag: emptyCredential,
}
controllerCfg := testing.FakeControllerConfig()
st, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
Owner: owner,
Config: cfg,
CloudName: "dummy",
CloudRegion: "dummy-region",
CloudCredential: userPassCredentialTag,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{
cloud.EmptyAuthType, cloud.UserPassAuthType,
},
Regions: []cloud.Region{{Name: "dummy-region"}},
},
CloudCredentials: cloudCredentialsIn,
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, gc.NotNil)
modelTag := st.ModelTag()
c.Assert(modelTag.Id(), gc.Equals, uuid)
err = st.Close()
c.Assert(err, jc.ErrorIsNil)
s.openState(c, modelTag)
cfg, err = s.State.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
expected := cfg.AllAttrs()
for k, v := range config.ConfigDefaults() {
if _, ok := expected[k]; !ok {
expected[k] = v
}
}
c.Assert(cfg.AllAttrs(), jc.DeepEquals, expected)
// Check that the model has been created.
model, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(model.Tag(), gc.Equals, modelTag)
c.Assert(model.CloudRegion(), gc.Equals, "dummy-region")
// Check that the owner has been created.
c.Assert(model.Owner(), gc.Equals, owner)
// Check that the owner can be retrieved by the tag.
entity, err := s.State.FindEntity(model.Owner())
c.Assert(err, jc.ErrorIsNil)
c.Assert(entity.Tag(), gc.Equals, owner)
// Check that the owner has an ModelUser created for the bootstrapped model.
modelUser, err := s.State.UserAccess(model.Owner(), model.Tag())
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelUser.UserTag, gc.Equals, owner)
c.Assert(modelUser.Object, gc.Equals, model.Tag())
// Check that the model can be found through the tag.
entity, err = s.State.FindEntity(modelTag)
c.Assert(err, jc.ErrorIsNil)
cons, err := s.State.ModelConstraints()
c.Assert(err, jc.ErrorIsNil)
c.Assert(&cons, jc.Satisfies, constraints.IsEmpty)
addrs, err := s.State.APIHostPorts()
c.Assert(err, jc.ErrorIsNil)
c.Assert(addrs, gc.HasLen, 0)
info, err := s.State.ControllerInfo()
c.Assert(err, jc.ErrorIsNil)
c.Assert(info, jc.DeepEquals, &state.ControllerInfo{ModelTag: modelTag, CloudName: "dummy"})
// Check that the model's cloud and credential names are as
// expected, and the owner's cloud credentials are initialised.
c.Assert(model.Cloud(), gc.Equals, "dummy")
credentialTag, ok := model.CloudCredential()
c.Assert(ok, jc.IsTrue)
c.Assert(credentialTag, gc.Equals, userPassCredentialTag)
cloudCredentials, err := s.State.CloudCredentials(model.Owner(), "dummy")
c.Assert(err, jc.ErrorIsNil)
expectedCred := make(map[string]cloud.Credential, len(cloudCredentialsIn))
for tag, cred := range cloudCredentialsIn {
expectedCred[tag.Canonical()] = cred
}
c.Assert(cloudCredentials, jc.DeepEquals, expectedCred)
}