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 *modelInfoSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: names.NewUserTag("admin@local"),
}
s.st = &mockState{
uuid: coretesting.ModelTag.Id(),
}
s.st.model = &mockModel{
owner: names.NewUserTag("bob@local"),
cfg: coretesting.ModelConfig(c),
life: state.Dying,
status: status.StatusInfo{
Status: status.StatusDestroying,
Since: &time.Time{},
},
users: []*mockModelUser{{
userName: "******",
access: state.ModelAdminAccess,
}, {
userName: "******",
displayName: "Bob",
access: state.ModelReadAccess,
}, {
userName: "******",
displayName: "Charlotte",
access: state.ModelReadAccess,
}},
}
var err error
s.modelmanager, err = modelmanager.NewModelManagerAPI(s.st, &s.authorizer)
c.Assert(err, jc.ErrorIsNil)
}
func (s *InitializeSuite) TestModelConfigWithoutAgentVersion(c *gc.C) {
// admin-secret blocks Initialize.
good := testing.ModelConfig(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.ModelTag())
err = s.State.UpdateModelConfig(map[string]interface{}{}, []string{"agent-version"}, nil)
c.Assert(err, gc.ErrorMatches, "agent-version must always be set in state")
// ModelConfig remains inviolate.
cfg, err := s.State.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(cfg.AllAttrs(), gc.DeepEquals, good.AllAttrs())
}
func (s *ConfigSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
cfg, err := testing.ModelConfig(c).Apply(gce.ConfigAttrs)
c.Assert(err, jc.ErrorIsNil)
s.config = cfg
}
func (s *ProviderSuite) testOpenError(c *gc.C, spec environs.CloudSpec, expect string) {
_, err := s.provider.Open(environs.OpenParams{
Cloud: spec,
Config: coretesting.ModelConfig(c),
})
c.Assert(err, gc.ErrorMatches, expect)
}
func (s *ProviderSuite) TestOpen(c *gc.C) {
env, err := s.provider.Open(environs.OpenParams{
Cloud: s.spec,
Config: coretesting.ModelConfig(c),
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(env, gc.NotNil)
}
func (s *BaseSuite) initEnv(c *gc.C) {
cfg, err := testing.ModelConfig(c).Apply(ConfigAttrs)
c.Assert(err, jc.ErrorIsNil)
env, err := environs.New(cfg)
c.Assert(err, jc.ErrorIsNil)
s.Env = env.(*environ)
s.setConfig(c, cfg)
}
func (s *BaseSuiteUnpatched) NewConfig(c *gc.C, updates testing.Attrs) *config.Config {
var err error
cfg := testing.ModelConfig(c)
cfg, err = cfg.Apply(ConfigAttrs)
c.Assert(err, jc.ErrorIsNil)
cfg, err = cfg.Apply(updates)
c.Assert(err, jc.ErrorIsNil)
return cfg
}
func (s *InternalSuite) TestControllerValues(c *gc.C) {
config := testing.ModelConfig(c)
fields := migration.ControllerValues(config)
c.Assert(fields, jc.DeepEquals, map[string]interface{}{
"controller-uuid": "deadbeef-0bad-400d-8000-4b1d0d06f00d",
"state-port": 19034,
"api-port": 17777,
"ca-cert": testing.CACert,
})
}
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 (ts configTestSpec) newConfig(c *gc.C) *config.Config {
filename := ts.writeAuthFile(c)
attrs := ts.attrs()
if filename != "" {
attrs["auth-file"] = filename
}
cfg, err := testing.ModelConfig(c).Apply(attrs)
c.Assert(err, jc.ErrorIsNil)
return cfg
}
func (s *ProviderSuite) TestOpenUnknownRegion(c *gc.C) {
// This test shows that we do *not* check the region names against
// anything in the client. That means that when new regions are
// added to AWS, we'll be able to support them.
s.spec.Region = "foobar"
_, err := s.provider.Open(environs.OpenParams{
Cloud: s.spec,
Config: coretesting.ModelConfig(c),
})
c.Assert(err, jc.ErrorIsNil)
}
// Initialize initializes the state and returns it. If state was not
// already initialized, and cfg is nil, the minimal default model
// configuration will be used.
func Initialize(c *gc.C, owner names.UserTag, cfg *config.Config, policy state.Policy) *state.State {
if cfg == nil {
cfg = testing.ModelConfig(c)
}
mgoInfo := NewMongoInfo()
dialOpts := NewDialOpts()
st, err := state.Initialize(owner, mgoInfo, cfg, dialOpts, policy)
c.Assert(err, jc.ErrorIsNil)
return st
}
func (s *BaseSuite) initEnv(c *gc.C) {
cfg, err := testing.ModelConfig(c).Apply(ConfigAttrs())
c.Assert(err, jc.ErrorIsNil)
env, err := environs.New(environs.OpenParams{
Cloud: FakeCloudSpec(),
Config: cfg,
})
c.Assert(err, jc.ErrorIsNil)
s.Env = env.(*environ)
s.setConfig(c, cfg)
}
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 *InstancePollerSuite) TestModelConfigSuccess(c *gc.C) {
envConfig := coretesting.ModelConfig(c)
s.st.SetConfig(c, envConfig)
result, err := s.api.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.ModelConfigResult{
Config: envConfig.AllAttrs(),
})
s.st.CheckCallNames(c, "ModelConfig")
}
// InitializeWithArgs initializes the state and returns it. If state was not
// already initialized, and args.Config is nil, the minimal default model
// configuration will be used.
func InitializeWithArgs(c *gc.C, args InitializeArgs) *state.State {
if args.InitialConfig == nil {
args.InitialConfig = testing.ModelConfig(c)
}
mgoInfo := NewMongoInfo()
dialOpts := mongotest.DialOpts()
controllerCfg := testing.FakeControllerConfig()
st, err := state.Initialize(state.InitializeParams{
Clock: args.Clock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
CloudRegion: "dummy-region",
Config: args.InitialConfig,
Owner: args.Owner,
StorageProviderRegistry: StorageProviders(),
},
ControllerInheritedConfig: args.ControllerInheritedConfig,
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
Regions: []cloud.Region{
cloud.Region{
Name: "dummy-region",
Endpoint: "dummy-endpoint",
IdentityEndpoint: "dummy-identity-endpoint",
StorageEndpoint: "dummy-storage-endpoint",
},
cloud.Region{
Name: "nether-region",
Endpoint: "nether-endpoint",
IdentityEndpoint: "nether-identity-endpoint",
StorageEndpoint: "nether-storage-endpoint",
},
cloud.Region{
Name: "unused-region",
Endpoint: "unused-endpoint",
IdentityEndpoint: "unused-identity-endpoint",
StorageEndpoint: "unused-storage-endpoint",
},
},
RegionConfig: args.RegionConfig,
},
MongoInfo: mgoInfo,
MongoDialOpts: dialOpts,
NewPolicy: args.NewPolicy,
})
c.Assert(err, jc.ErrorIsNil)
return st
}
func (s *InstancePollerSuite) TestModelConfigSuccess(c *gc.C) {
var called int
expectedConfig := coretesting.ModelConfig(c)
expectedResults := params.ModelConfigResult{
Config: params.ModelConfig(expectedConfig.AllAttrs()),
}
apiCaller := successAPICaller(c, "ModelConfig", nil, expectedResults, &called)
api := instancepoller.NewAPI(apiCaller)
cfg, err := api.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(called, gc.Equals, 1)
c.Assert(cfg, jc.DeepEquals, expectedConfig)
}
func (s *InitializeSuite) TestInitialize(c *gc.C) {
cfg := testing.ModelConfig(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)
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)
c.Assert(cfg.AllAttrs(), gc.DeepEquals, initial)
// Check that the model has been created.
env, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.Tag(), gc.Equals, modelTag)
// 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 ModelUser created for the bootstrapped model.
modelUser, err := s.State.ModelUser(env.Owner())
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelUser.UserTag(), gc.Equals, owner)
c.Assert(modelUser.ModelTag(), gc.Equals, env.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.StateServerInfo()
c.Assert(err, jc.ErrorIsNil)
c.Assert(info, jc.DeepEquals, &state.StateServerInfo{ModelTag: modelTag})
}
func (s *BaseSuiteUnpatched) NewConfig(c *gc.C, updates testing.Attrs) *config.Config {
if updates == nil {
updates = make(testing.Attrs)
}
var err error
cfg := testing.ModelConfig(c)
cfg, err = cfg.Apply(ConfigAttrs)
c.Assert(err, jc.ErrorIsNil)
if raw := updates[cfgNamespace]; raw == nil || raw.(string) == "" {
updates[cfgNamespace] = cfg.Name()
}
cfg, err = cfg.Apply(updates)
c.Assert(err, jc.ErrorIsNil)
return cfg
}
func NewBaseConfig(c *gc.C) *config.Config {
var err error
cfg := testing.ModelConfig(c)
cfg, err = cfg.Apply(ConfigAttrs)
c.Assert(err, jc.ErrorIsNil)
cfg, err = cfg.Apply(map[string]interface{}{
// Default the namespace to the env name.
cfgNamespace: cfg.Name(),
})
c.Assert(err, jc.ErrorIsNil)
return cfg
}
func (s *ProviderSuite) TestOpenKnownRegionInvalidEndpoint(c *gc.C) {
s.PatchValue(&aws.Regions, map[string]aws.Region{
"us-east-1": {
EC2Endpoint: "https://testing.invalid",
},
})
s.spec.Endpoint = "https://us-east-1.aws.amazon.com/v1.2/"
env, err := s.provider.Open(environs.OpenParams{
Cloud: s.spec,
Config: coretesting.ModelConfig(c),
})
c.Assert(err, jc.ErrorIsNil)
ec2Client := ec2.EnvironEC2(env)
c.Assert(ec2Client.Region.EC2Endpoint, gc.Equals, "https://testing.invalid")
}
// Initialize initializes the state and returns it. If state was not
// already initialized, and cfg is nil, the minimal default model
// configuration will be used.
func Initialize(c *gc.C, owner names.UserTag, cfg *config.Config, controllerInheritedConfig map[string]interface{}, regionConfig cloud.RegionConfig, newPolicy state.NewPolicyFunc) *state.State {
if cfg == nil {
cfg = testing.ModelConfig(c)
}
mgoInfo := NewMongoInfo()
dialOpts := mongotest.DialOpts()
controllerCfg := testing.FakeControllerConfig()
st, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
CloudRegion: "dummy-region",
Config: cfg,
Owner: owner,
StorageProviderRegistry: StorageProviders(),
},
ControllerInheritedConfig: controllerInheritedConfig,
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
Regions: []cloud.Region{
cloud.Region{
Name: "dummy-region",
Endpoint: "dummy-endpoint",
IdentityEndpoint: "dummy-identity-endpoint",
StorageEndpoint: "dummy-storage-endpoint",
},
cloud.Region{
Name: "nether-region",
Endpoint: "nether-endpoint",
IdentityEndpoint: "nether-identity-endpoint",
StorageEndpoint: "nether-storage-endpoint",
},
},
RegionConfig: regionConfig,
},
MongoInfo: mgoInfo,
MongoDialOpts: dialOpts,
NewPolicy: newPolicy,
})
c.Assert(err, jc.ErrorIsNil)
return st
}
func (s *internalStateSuite) SetUpTest(c *gc.C) {
s.MgoSuite.SetUpTest(c)
s.BaseSuite.SetUpTest(c)
s.owner = names.NewLocalUserTag("test-admin")
// Copied from NewMongoInfo (due to import loops).
info := &mongo.MongoInfo{
Info: mongo.Info{
Addrs: []string{jujutesting.MgoServer.Addr()},
CACert: testing.CACert,
},
}
dialopts := mongotest.DialOpts()
st, err := Initialize(s.owner, info, testing.ModelConfig(c), dialopts, nil)
c.Assert(err, jc.ErrorIsNil)
s.state = st
s.AddCleanup(func(*gc.C) { s.state.Close() })
}
func (s *InitializeSuite) TestDoubleInitializeConfig(c *gc.C) {
cfg := testing.ModelConfig(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)
err = st.Close()
c.Check(err, jc.ErrorIsNil)
st, err = state.Initialize(owner, mgoInfo, cfg, dialOpts, state.Policy(nil))
c.Check(err, gc.ErrorMatches, "already initialized")
if !c.Check(st, gc.IsNil) {
err = st.Close()
c.Check(err, jc.ErrorIsNil)
}
}
func (s *internalStateSuite) SetUpTest(c *gc.C) {
s.MgoSuite.SetUpTest(c)
s.BaseSuite.SetUpTest(c)
s.owner = names.NewLocalUserTag("test-admin")
// Copied from NewMongoInfo (due to import loops).
info := &mongo.MongoInfo{
Info: mongo.Info{
Addrs: []string{jujutesting.MgoServer.Addr()},
CACert: testing.CACert,
},
}
modelCfg := testing.ModelConfig(c)
controllerCfg := testing.FakeControllerConfig()
st, err := Initialize(InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: ModelArgs{
CloudName: "dummy",
CloudRegion: "dummy-region",
Owner: s.owner,
Config: modelCfg,
StorageProviderRegistry: provider.CommonStorageProviders(),
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
Regions: []cloud.Region{
cloud.Region{
Name: "dummy-region",
},
},
},
MongoInfo: info,
MongoDialOpts: mongotest.DialOpts(),
NewPolicy: func(*State) Policy {
return internalStatePolicy{}
},
})
c.Assert(err, jc.ErrorIsNil)
s.state = st
s.AddCleanup(func(*gc.C) { s.state.Close() })
}
func (s *provisionerSuite) TestModelConfig(c *gc.C) {
inputCfg := coretesting.ModelConfig(c)
apiCaller := testing.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
c.Check(objType, gc.Equals, "StorageProvisioner")
c.Check(version, gc.Equals, 0)
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "ModelConfig")
c.Assert(result, gc.FitsTypeOf, ¶ms.ModelConfigResult{})
*(result.(*params.ModelConfigResult)) = params.ModelConfigResult{
Config: inputCfg.AllAttrs(),
}
return nil
})
st, err := storageprovisioner.NewState(apiCaller, names.NewMachineTag("123"))
c.Assert(err, jc.ErrorIsNil)
outputCfg, err := st.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(outputCfg.AllAttrs(), jc.DeepEquals, inputCfg.AllAttrs())
}
func (s *InternalSuite) TestUpdateConfigFromProvider(c *gc.C) {
controllerConfig := testing.ModelConfig(c)
configAttrs := testing.FakeConfig()
configAttrs["type"] = "dummy"
// Fake the "state-id" so the provider thinks it is prepared already.
configAttrs["state-id"] = "42"
// We need to specify a valid provider type, so we use dummy.
// The dummy provider grabs the UUID from the controller config
// and returns it in the map with the key "controller-uuid", similar
// to what the azure provider will need to do.
model := description.NewModel(description.ModelArgs{
Owner: names.NewUserTag("test-admin"),
Config: configAttrs,
})
err := migration.UpdateConfigFromProvider(model, controllerConfig)
c.Assert(err, jc.ErrorIsNil)
modelConfig := model.Config()
c.Assert(modelConfig["controller-uuid"], gc.Equals, controllerConfig.UUID())
}
func (s *upgradeModelConfigSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.stub = testing.Stub{}
s.cfg = coretesting.ModelConfig(c)
s.registry = &mockProviderRegistry{
providers: make(map[string]environs.EnvironProvider),
}
s.reader = environConfigFunc(func() (*config.Config, error) {
s.stub.AddCall("ModelConfig")
return s.cfg, s.stub.NextErr()
})
s.updater = updateModelConfigFunc(func(
update map[string]interface{}, remove []string, validate state.ValidateConfigFunc,
) error {
s.stub.AddCall("UpdateModelConfig", update, remove, validate)
return s.stub.NextErr()
})
}