func (*NetworkSuite) TestInitializeFromConfig(c *gc.C) {
c.Check(network.PreferIPv6(), jc.IsFalse)
envConfig := testing.CustomModelConfig(c, testing.Attrs{
"prefer-ipv6": true,
})
network.SetPreferIPv6(envConfig.PreferIPv6())
c.Check(network.PreferIPv6(), jc.IsTrue)
envConfig = testing.CustomModelConfig(c, testing.Attrs{
"prefer-ipv6": false,
})
network.SetPreferIPv6(envConfig.PreferIPv6())
c.Check(network.PreferIPv6(), jc.IsFalse)
}
func (s *Suite) SetUpTest(c *gc.C) {
// Set up InitialConfig with a dummy provider configuration. This
// is required to allow model import test to work.
env, err := environs.Prepare(
modelcmd.BootstrapContext(testing.Context(c)),
jujuclienttesting.NewMemStore(),
environs.PrepareParams{
ControllerName: "dummycontroller",
BaseConfig: dummy.SampleConfig(),
CloudName: "dummy",
},
)
c.Assert(err, jc.ErrorIsNil)
s.InitialConfig = testing.CustomModelConfig(c, env.Config().AllAttrs())
// The call up to StateSuite's SetUpTest uses s.InitialConfig so
// it has to happen here.
s.StateSuite.SetUpTest(c)
s.resources = common.NewResources()
s.AddCleanup(func(*gc.C) { s.resources.StopAll() })
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.Owner,
}
}
func (sb *stubBackend) ModelConfig() (*config.Config, error) {
sb.MethodCall(sb, "ModelConfig")
if err := sb.NextErr(); err != nil {
return nil, err
}
return coretesting.CustomModelConfig(sb.c, sb.configAttrs), nil
}
func (s *ModelSuite) TestNewModelSameUserSameNameFails(c *gc.C) {
cfg, _ := s.createTestModelConfig(c)
owner := s.Factory.MakeUser(c, nil).UserTag()
// Create the first model.
_, st1, err := s.State.NewModel(state.ModelArgs{
CloudName: "dummy",
CloudRegion: "dummy-region",
Config: cfg,
Owner: owner,
StorageProviderRegistry: storage.StaticProviderRegistry{},
})
c.Assert(err, jc.ErrorIsNil)
defer st1.Close()
// Attempt to create another model with a different UUID but the
// same owner and name as the first.
newUUID, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
cfg2 := testing.CustomModelConfig(c, testing.Attrs{
"name": cfg.Name(),
"uuid": newUUID.String(),
})
_, _, err = s.State.NewModel(state.ModelArgs{
CloudName: "dummy",
CloudRegion: "dummy-region",
Config: cfg2,
Owner: owner,
StorageProviderRegistry: storage.StaticProviderRegistry{},
})
errMsg := fmt.Sprintf("model %q for %s already exists", cfg2.Name(), owner.Canonical())
c.Assert(err, gc.ErrorMatches, errMsg)
c.Assert(errors.IsAlreadyExists(err), jc.IsTrue)
// Remove the first model.
env1, err := st1.Model()
c.Assert(err, jc.ErrorIsNil)
err = env1.Destroy()
c.Assert(err, jc.ErrorIsNil)
// Destroy only sets the model to dying and RemoveAllModelDocs can
// only be called on a dead model. Normally, the environ's lifecycle
// would be set to dead after machines and services have been cleaned up.
err = state.SetModelLifeDead(st1, env1.ModelTag().Id())
c.Assert(err, jc.ErrorIsNil)
err = st1.RemoveAllModelDocs()
c.Assert(err, jc.ErrorIsNil)
// We should now be able to create the other model.
env2, st2, err := s.State.NewModel(state.ModelArgs{
CloudName: "dummy",
CloudRegion: "dummy-region",
Config: cfg2,
Owner: owner,
StorageProviderRegistry: storage.StaticProviderRegistry{},
})
c.Assert(err, jc.ErrorIsNil)
defer st2.Close()
c.Assert(env2, gc.NotNil)
c.Assert(st2, gc.NotNil)
}
func (*volumesSuite) TestVolumeParamsStorageTags(c *gc.C) {
volumeTag := names.NewVolumeTag("100")
storageTag := names.NewStorageTag("mystore/0")
unitTag := names.NewUnitTag("mysql/123")
p, err := storagecommon.VolumeParams(
&fakeVolume{tag: volumeTag, params: &state.VolumeParams{
Pool: "loop", Size: 1024,
}},
&fakeStorageInstance{tag: storageTag, owner: unitTag},
testing.CustomModelConfig(c, nil),
&fakePoolManager{},
)
c.Assert(err, jc.ErrorIsNil)
c.Assert(p, jc.DeepEquals, params.VolumeParams{
VolumeTag: "volume-100",
Provider: "loop",
Size: 1024,
Tags: map[string]string{
tags.JujuController: testing.ModelTag.Id(),
tags.JujuModel: testing.ModelTag.Id(),
tags.JujuStorageInstance: "mystore/0",
tags.JujuStorageOwner: "mysql/123",
},
})
}
// MakeModel creates an model with specified params,
// filling in sane defaults for missing values. If params is nil,
// defaults are used for all values.
//
// By default the new model shares the same owner as the calling
// Factory's model.
func (factory *Factory) MakeModel(c *gc.C, params *ModelParams) *state.State {
if params == nil {
params = new(ModelParams)
}
if params.Name == "" {
params.Name = uniqueString("testenv")
}
if params.Owner == nil {
origEnv, err := factory.st.Model()
c.Assert(err, jc.ErrorIsNil)
params.Owner = origEnv.Owner()
}
// It only makes sense to make an model with the same provider
// as the initial model, or things will break elsewhere.
currentCfg, err := factory.st.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
uuid, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": params.Name,
"uuid": uuid.String(),
"type": currentCfg.Type(),
"state-port": currentCfg.StatePort(),
"api-port": currentCfg.APIPort(),
}.Merge(params.ConfigAttrs))
_, st, err := factory.st.NewModel(state.ModelArgs{
Config: cfg,
Owner: params.Owner.(names.UserTag),
})
c.Assert(err, jc.ErrorIsNil)
return st
}
func (*volumesSuite) testVolumeParams(c *gc.C, volumeParams *state.VolumeParams, info *state.VolumeInfo) {
tag := names.NewVolumeTag("100")
p, err := storagecommon.VolumeParams(
&fakeVolume{tag: tag, params: volumeParams, info: info},
nil, // StorageInstance
testing.ModelTag.Id(),
testing.ControllerTag.Id(),
testing.CustomModelConfig(c, testing.Attrs{
"resource-tags": "a=b c=",
}),
&fakePoolManager{},
provider.CommonStorageProviders(),
)
c.Assert(err, jc.ErrorIsNil)
c.Assert(p, jc.DeepEquals, params.VolumeParams{
VolumeTag: "volume-100",
Provider: "loop",
Size: 1024,
Tags: map[string]string{
tags.JujuController: testing.ControllerTag.Id(),
tags.JujuModel: testing.ModelTag.Id(),
"a": "b",
"c": "",
},
})
}
func (s *ModelConfigSourceSuite) TestNewModelConfigForksControllerValue(c *gc.C) {
uuid, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": "another",
"uuid": uuid.String(),
})
owner := names.NewUserTag("test@remote")
_, st, err := s.State.NewModel(state.ModelArgs{
Config: cfg, Owner: owner, CloudName: "dummy", CloudRegion: "nether-region",
StorageProviderRegistry: storage.StaticProviderRegistry{},
})
c.Assert(err, jc.ErrorIsNil)
defer st.Close()
modelCfg, err := st.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelCfg.AllAttrs()["apt-mirror"], gc.Equals, "http://mirror")
// Change the local controller settings and ensure the model setting stays the same.
localCloudSettings, err := s.State.ReadSettings(state.GlobalSettingsC, state.ControllerInheritedSettingsGlobalKey)
c.Assert(err, jc.ErrorIsNil)
localCloudSettings.Set("apt-mirror", "http://anothermirror")
_, err = localCloudSettings.Write()
c.Assert(err, jc.ErrorIsNil)
modelCfg, err = st.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelCfg.AllAttrs()["apt-mirror"], gc.Equals, "http://mirror")
}
func (s *binaryStorageSuite) SetUpTest(c *gc.C) {
s.ConnSuite.SetUpTest(c)
// Store the controller UUID.
model, err := s.State.ControllerModel()
c.Assert(err, jc.ErrorIsNil)
s.controllerUUID = model.UUID()
// Create a new model and store its UUID.
s.modelUUID = utils.MustNewUUID().String()
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": "new-model",
"uuid": s.modelUUID,
})
_, s.st, err = s.State.NewModel(state.ModelArgs{
CloudName: "dummy",
CloudRegion: "dummy-region",
Config: cfg,
Owner: names.NewLocalUserTag("test-admin"),
StorageProviderRegistry: storage.StaticProviderRegistry{},
})
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(*gc.C) {
s.st.Close()
})
}
// createTestEnvConfig returns a new model config and its UUID for testing.
func (s *ModelSuite) createTestEnvConfig(c *gc.C) (*config.Config, string) {
uuid, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
return testing.CustomModelConfig(c, testing.Attrs{
"name": "testing",
"uuid": uuid.String(),
}), uuid.String()
}
// newModelConfig returns an environment config map with the supplied attrs
// (on top of some default set), or fails the test.
func newModelConfig(c *gc.C, extraAttrs coretesting.Attrs) map[string]interface{} {
attrs := dummy.SampleConfig()
attrs["broken"] = ""
attrs["state-id"] = "42"
for k, v := range extraAttrs {
attrs[k] = v
}
return coretesting.CustomModelConfig(c, attrs).AllAttrs()
}
func (*instancecfgSuite) TestInstanceTagsUserSpecified(c *gc.C) {
cfg := testing.CustomModelConfig(c, testing.Attrs{
"resource-tags": "a=b c=",
})
testInstanceTags(c, cfg, nil, map[string]string{
"juju-model-uuid": testing.ModelTag.Id(),
"a": "b",
"c": "",
})
}
func (s *ImportSuite) SetUpTest(c *gc.C) {
// Specify the config to use for the controller model before calling
// SetUpTest of the StateSuite, otherwise we get testing.ModelConfig(c).
// The default provider type specified in the testing.ModelConfig function
// is one that isn't registered as a valid provider. For our tests here we
// need a real registered provider, so we use the dummy provider.
// NOTE: make a better test provider.
s.InitialConfig = testing.CustomModelConfig(c, dummy.SampleConfig())
s.StateSuite.SetUpTest(c)
}
func createTestModelConfig(c *gc.C, controllerUUID string) (*config.Config, string) {
uuid, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
if controllerUUID == "" {
controllerUUID = uuid.String()
}
return testing.CustomModelConfig(c, testing.Attrs{
"name": "testing",
"uuid": uuid.String(),
}), uuid.String()
}
// NewStateForModelNamed returns an new model with the given modelName, which
// has a unique UUID, and does not need to be closed when the test completes.
func (s *ConnSuite) NewStateForModelNamed(c *gc.C, modelName string) *state.State {
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": modelName,
"uuid": utils.MustNewUUID().String(),
})
otherOwner := names.NewLocalUserTag("test-admin")
_, otherState, err := s.State.NewModel(cfg, otherOwner)
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(*gc.C) { otherState.Close() })
return otherState
}
func (s *blockSuite) createTestEnv(c *gc.C) (*state.Model, *state.State) {
uuid, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": "testing",
"uuid": uuid.String(),
})
owner := names.NewUserTag("test@remote")
env, st, err := s.State.NewModel(state.ModelArgs{Config: cfg, Owner: owner})
c.Assert(err, jc.ErrorIsNil)
return env, st
}
func (*instancecfgSuite) TestInstanceTagsStateServer(c *gc.C) {
cfg := testing.CustomModelConfig(c, testing.Attrs{})
stateServerJobs := []multiwatcher.MachineJob{multiwatcher.JobManageModel}
nonStateServerJobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits}
testInstanceTags(c, cfg, stateServerJobs, map[string]string{
"juju-model-uuid": testing.ModelTag.Id(),
"juju-is-state": "true",
})
testInstanceTags(c, cfg, nonStateServerJobs, map[string]string{
"juju-model-uuid": testing.ModelTag.Id(),
})
}
// NewStateForModelNamed returns an new model with the given modelName, which
// has a unique UUID, and does not need to be closed when the test completes.
func (s *ConnWithWallClockSuite) NewStateForModelNamed(c *gc.C, modelName string) *state.State {
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": modelName,
"uuid": utils.MustNewUUID().String(),
})
otherOwner := names.NewLocalUserTag("test-admin")
_, otherState, err := s.State.NewModel(state.ModelArgs{
CloudName: "dummy", CloudRegion: "dummy-region", Config: cfg, Owner: otherOwner,
StorageProviderRegistry: storage.StaticProviderRegistry{},
})
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(*gc.C) { otherState.Close() })
return otherState
}
func (s *AnnotationsEnvSuite) createTestEnv(c *gc.C) (*state.Model, *state.State) {
uuid, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": "testing",
"uuid": uuid.String(),
})
owner := names.NewUserTag("test@remote")
env, st, err := s.State.NewModel(state.ModelArgs{
CloudName: "dummy", CloudRegion: "dummy-region", Config: cfg, Owner: owner,
StorageProviderRegistry: storage.StaticProviderRegistry{},
})
c.Assert(err, jc.ErrorIsNil)
return env, st
}
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 *ModelUserSuite) newEnvWithOwner(c *gc.C, name string, owner names.UserTag) *state.Model {
// Don't use the factory to call MakeModel because it may at some
// time in the future be modified to do additional things. Instead call
// the state method directly to create an model to make sure that
// the owner is able to access the model.
uuid, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": name,
"uuid": uuid.String(),
})
model, st, err := s.State.NewModel(cfg, owner)
c.Assert(err, jc.ErrorIsNil)
defer st.Close()
return model
}
func (s *Suite) SetUpTest(c *gc.C) {
// Set up InitialConfig with a dummy provider configuration. This
// is required to allow model import test to work.
s.InitialConfig = testing.CustomModelConfig(c, dummy.SampleConfig())
// The call up to StateSuite's SetUpTest uses s.InitialConfig so
// it has to happen here.
s.StateSuite.SetUpTest(c)
s.resources = common.NewResources()
s.AddCleanup(func(*gc.C) { s.resources.StopAll() })
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.Owner,
AdminTag: s.Owner,
}
}
// MakeModel creates an model with specified params,
// filling in sane defaults for missing values. If params is nil,
// defaults are used for all values.
//
// By default the new model shares the same owner as the calling
// Factory's model.
func (factory *Factory) MakeModel(c *gc.C, params *ModelParams) *state.State {
if params == nil {
params = new(ModelParams)
}
if params.Name == "" {
params.Name = uniqueString("testenv")
}
if params.CloudName == "" {
params.CloudName = "dummy"
}
if params.CloudRegion == "" {
params.CloudRegion = "dummy-region"
}
if params.Owner == nil {
origEnv, err := factory.st.Model()
c.Assert(err, jc.ErrorIsNil)
params.Owner = origEnv.Owner()
}
if params.StorageProviderRegistry == nil {
params.StorageProviderRegistry = provider.CommonStorageProviders()
}
// It only makes sense to make an model with the same provider
// as the initial model, or things will break elsewhere.
currentCfg, err := factory.st.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
uuid, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": params.Name,
"uuid": uuid.String(),
"type": currentCfg.Type(),
}.Merge(params.ConfigAttrs))
_, st, err := factory.st.NewModel(state.ModelArgs{
CloudName: params.CloudName,
CloudRegion: params.CloudRegion,
CloudCredential: params.CloudCredential,
Config: cfg,
Owner: params.Owner.(names.UserTag),
StorageProviderRegistry: params.StorageProviderRegistry,
})
c.Assert(err, jc.ErrorIsNil)
return st
}
func (s *binaryStorageSuite) SetUpTest(c *gc.C) {
s.ConnSuite.SetUpTest(c)
// Store the controller UUID.
model, err := s.State.ControllerModel()
c.Assert(err, jc.ErrorIsNil)
s.controllerUUID = model.UUID()
// Create a new model and store its UUID.
s.modelUUID = utils.MustNewUUID().String()
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": "new-model",
"uuid": s.modelUUID,
})
_, s.st, err = s.State.NewModel(cfg, names.NewLocalUserTag("test-admin"))
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(*gc.C) {
s.st.Close()
})
}
func (s *modelStatusSuite) SetUpTest(c *gc.C) {
// Initial config needs to be set before the StateSuite SetUpTest.
s.InitialConfig = testing.CustomModelConfig(c, testing.Attrs{
"name": "controller",
})
s.StateSuite.SetUpTest(c)
s.resources = common.NewResources()
s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() })
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.Owner,
AdminTag: s.Owner,
}
controller, err := controller.NewControllerAPI(s.State, s.resources, s.authorizer)
c.Assert(err, jc.ErrorIsNil)
s.controller = controller
loggo.GetLogger("juju.apiserver.controller").SetLogLevel(loggo.TRACE)
}
func (s *ImportSuite) SetUpTest(c *gc.C) {
// Specify the config to use for the controller model before calling
// SetUpTest of the StateSuite, otherwise we get testing.ModelConfig(c).
// The default provider type specified in the testing.ModelConfig function
// is one that isn't registered as a valid provider. For our tests here we
// need a real registered provider, so we use the dummy provider.
// NOTE: make a better test provider.
env, err := environs.Prepare(
modelcmd.BootstrapContext(testing.Context(c)),
jujuclienttesting.NewMemStore(),
environs.PrepareParams{
ControllerName: "dummycontroller",
BaseConfig: dummy.SampleConfig(),
CloudName: "dummy",
},
)
c.Assert(err, jc.ErrorIsNil)
s.InitialConfig = testing.CustomModelConfig(c, env.Config().AllAttrs())
s.StateSuite.SetUpTest(c)
}
// MakeModel creates an model with specified params,
// filling in sane defaults for missing values. If params is nil,
// defaults are used for all values.
//
// By default the new model shares the same owner as the calling
// Factory's model.
func (factory *Factory) MakeModel(c *gc.C, params *ModelParams) *state.State {
if params == nil {
params = new(ModelParams)
}
if params.Name == "" {
params.Name = uniqueString("testenv")
}
if params.Owner == nil {
origEnv, err := factory.st.Model()
c.Assert(err, jc.ErrorIsNil)
params.Owner = origEnv.Owner()
}
// It only makes sense to make an model with the same provider
// as the initial model, or things will break elsewhere.
currentCfg, err := factory.st.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
uuid, err := utils.NewUUID()
c.Assert(err, jc.ErrorIsNil)
cfg := testing.CustomModelConfig(c, testing.Attrs{
"name": params.Name,
"uuid": uuid.String(),
"type": currentCfg.Type(),
"state-port": currentCfg.StatePort(),
"api-port": currentCfg.APIPort(),
}.Merge(params.ConfigAttrs))
_, st, err := factory.st.NewModel(cfg, params.Owner.(names.UserTag))
c.Assert(err, jc.ErrorIsNil)
if params.Prepare {
// Prepare the environment.
provider, err := environs.Provider(cfg.Type())
c.Assert(err, jc.ErrorIsNil)
env, err := provider.PrepareForBootstrap(envtesting.BootstrapContext(c), cfg)
c.Assert(err, jc.ErrorIsNil)
// Now save the config back.
err = st.UpdateModelConfig(env.Config().AllAttrs(), nil, nil)
c.Assert(err, jc.ErrorIsNil)
}
return st
}
func (sb *StubBacking) SetUp(c *gc.C, envName string, withZones, withSpaces, withSubnets SetUpFlag) {
// This method must be called at the beginning of each test, which
// needs access to any of the mocks, to reset the recorded calls
// and errors, as well as to initialize the mocks as needed.
ResetStub(sb.Stub)
// Make sure we use the stub provider.
extraAttrs := coretesting.Attrs{
"uuid": utils.MustNewUUID().String(),
"type": StubProviderType,
"name": envName,
}
sb.EnvConfig = coretesting.CustomModelConfig(c, extraAttrs)
sb.Zones = []providercommon.AvailabilityZone{}
if withZones {
sb.Zones = make([]providercommon.AvailabilityZone, len(ProviderInstance.Zones))
copy(sb.Zones, ProviderInstance.Zones)
}
sb.Spaces = []networkingcommon.BackingSpace{}
if withSpaces {
// Note that full subnet data is generated from the SubnetIds in
// FakeSpace.Subnets().
sb.Spaces = []networkingcommon.BackingSpace{
&FakeSpace{
SpaceName: "default",
SubnetIds: []string{"192.168.0.0/24", "192.168.3.0/24"},
NextErr: sb.NextErr},
&FakeSpace{
SpaceName: "dmz",
SubnetIds: []string{"192.168.1.0/24"},
NextErr: sb.NextErr},
&FakeSpace{
SpaceName: "private",
SubnetIds: []string{"192.168.2.0/24"},
NextErr: sb.NextErr},
&FakeSpace{
SpaceName: "private",
SubnetIds: []string{"192.168.2.0/24"},
NextErr: sb.NextErr}, // duplicates are ignored when caching spaces.
}
}
sb.Subnets = []networkingcommon.BackingSubnet{}
if withSubnets {
info0 := networkingcommon.BackingSubnetInfo{
CIDR: ProviderInstance.Subnets[0].CIDR,
ProviderId: ProviderInstance.Subnets[0].ProviderId,
AllocatableIPLow: ProviderInstance.Subnets[0].AllocatableIPLow.String(),
AllocatableIPHigh: ProviderInstance.Subnets[0].AllocatableIPHigh.String(),
AvailabilityZones: ProviderInstance.Subnets[0].AvailabilityZones,
SpaceName: "private",
}
info1 := networkingcommon.BackingSubnetInfo{
CIDR: ProviderInstance.Subnets[1].CIDR,
ProviderId: ProviderInstance.Subnets[1].ProviderId,
AvailabilityZones: ProviderInstance.Subnets[1].AvailabilityZones,
SpaceName: "dmz",
}
sb.Subnets = []networkingcommon.BackingSubnet{
&FakeSubnet{info0},
&FakeSubnet{info1},
}
}
}
// newModelConfig returns an environment config map with the supplied attrs
// (on top of some default set), or fails the test.
func newModelConfig(c *gc.C, extraAttrs coretesting.Attrs) map[string]interface{} {
return coretesting.CustomModelConfig(c, extraAttrs).AllAttrs()
}