func (*NetworkSuite) TestInitializeFromConfig(c *gc.C) { c.Check(network.GetPreferIPv6(), jc.IsFalse) envConfig := testing.CustomEnvironConfig(c, testing.Attrs{ "prefer-ipv6": true, }) network.InitializeFromConfig(envConfig) c.Check(network.GetPreferIPv6(), jc.IsTrue) envConfig = testing.CustomEnvironConfig(c, testing.Attrs{ "prefer-ipv6": false, }) network.InitializeFromConfig(envConfig) c.Check(network.GetPreferIPv6(), jc.IsFalse) }
func (s *EnvironSuite) TestNewEnvironmentSameUserSameNameFails(c *gc.C) { cfg, _ := s.createTestEnvConfig(c) owner := s.factory.MakeUser(c, nil).UserTag() // Create the first environment. _, st1, err := s.State.NewEnvironment(cfg, owner) c.Assert(err, jc.ErrorIsNil) defer st1.Close() // Attempt to create another environment with a different UUID but the // same owner and name as the first. newUUID, err := utils.NewUUID() c.Assert(err, jc.ErrorIsNil) cfg2 := testing.CustomEnvironConfig(c, testing.Attrs{ "name": cfg.Name(), "uuid": newUUID.String(), }) _, _, err = s.State.NewEnvironment(cfg2, owner) errMsg := fmt.Sprintf("environment %q for %s already exists", cfg2.Name(), owner.Username()) c.Assert(err, gc.ErrorMatches, errMsg) c.Assert(errors.IsAlreadyExists(err), jc.IsTrue) // Remove the first environment. err = st1.RemoveAllEnvironDocs() c.Assert(err, jc.ErrorIsNil) // We should now be able to create the other environment. env2, st2, err := s.State.NewEnvironment(cfg2, owner) c.Assert(err, jc.ErrorIsNil) defer st2.Close() c.Assert(env2, gc.NotNil) c.Assert(st2, gc.NotNil) }
func (s *tagsSuite) TestAddInstanceTagsDoesNotSupportTagging(c *gc.C) { env := &testEnviron{cfg: testing.CustomEnvironConfig(c, nil)} err := upgrades.AddInstanceTags(env, []*state.Machine{ s.stateServer, s.unprovisioned, s.provisioned, s.container, }) c.Assert(err, jc.ErrorIsNil) }
func (s *tagsSuite) TestAddInstanceTagsSupportsTagging(c *gc.C) { env := &testEnvironWithTagging{ testEnviron: testEnviron{ cfg: testing.CustomEnvironConfig(c, testing.Attrs{ "resource-tags": "abc=123", }), }, } err := upgrades.AddInstanceTags(env, []*state.Machine{ s.stateServer, s.unprovisioned, s.provisioned, s.container, }) c.Assert(err, jc.ErrorIsNil) c.Assert(env.calls, jc.DeepEquals, []tagInstanceArgs{{ "inst-0", map[string]string{ "juju-is-state": "true", "juju-env-uuid": testing.EnvironmentTag.Id(), "abc": "123", }, }, { "inst-1", map[string]string{ "juju-env-uuid": testing.EnvironmentTag.Id(), "abc": "123", }, }}) }
// createTestEnvConfig returns a new environment config and its UUID for testing. func (s *EnvironSuite) createTestEnvConfig(c *gc.C) (*config.Config, string) { uuid, err := utils.NewUUID() c.Assert(err, jc.ErrorIsNil) return testing.CustomEnvironConfig(c, testing.Attrs{ "name": "testing", "uuid": uuid.String(), }), uuid.String() }
// newEnvironConfig returns an environment config map with the supplied attrs // (on top of some default set), or fails the test. func newEnvironConfig(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.CustomEnvironConfig(c, attrs).AllAttrs() }
func (*instancecfgSuite) TestInstanceTagsUserSpecified(c *gc.C) { cfg := testing.CustomEnvironConfig(c, testing.Attrs{ "resource-tags": "a=b c=", }) testInstanceTags(c, cfg, nil, map[string]string{ "juju-env-uuid": testing.EnvironmentTag.Id(), "a": "b", "c": "", }) }
func (*instancecfgSuite) TestInstanceTagsStateServer(c *gc.C) { cfg := testing.CustomEnvironConfig(c, testing.Attrs{}) stateServerJobs := []multiwatcher.MachineJob{multiwatcher.JobManageEnviron} nonStateServerJobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits} testInstanceTags(c, cfg, stateServerJobs, map[string]string{ "juju-env-uuid": testing.EnvironmentTag.Id(), "juju-is-state": "true", }) testInstanceTags(c, cfg, nonStateServerJobs, map[string]string{ "juju-env-uuid": testing.EnvironmentTag.Id(), }) }
func (s *blockSuite) createTestEnv(c *gc.C) (*state.Environment, *state.State) { uuid, err := utils.NewUUID() c.Assert(err, jc.ErrorIsNil) cfg := testing.CustomEnvironConfig(c, testing.Attrs{ "name": "testing", "uuid": uuid.String(), }) owner := names.NewUserTag("test@remote") env, st, err := s.State.NewEnvironment(cfg, owner) c.Assert(err, jc.ErrorIsNil) return env, st }
func (s *EnvUserSuite) newEnvWithOwner(c *gc.C, name string, owner names.UserTag) *state.Environment { // Don't use the factory to call MakeEnvironment because it may at some // time in the future be modified to do additional things. Instead call // the state method directly to create an environment to make sure that // the owner is able to access the environment. uuid, err := utils.NewUUID() c.Assert(err, jc.ErrorIsNil) cfg := testing.CustomEnvironConfig(c, testing.Attrs{ "name": name, "uuid": uuid.String(), }) env, st, err := s.State.NewEnvironment(cfg, owner) c.Assert(err, jc.ErrorIsNil) defer st.Close() return env }
// SetConfig changes the stored environment config with the given // extraAttrs and triggers a change for the watcher. func (s *fakeState) SetConfig(c *gc.C, extraAttrs coretesting.Attrs) { s.mu.Lock() defer s.mu.Unlock() attrs := dummy.SampleConfig() for k, v := range extraAttrs { attrs[k] = v } // Simulate it's prepared. attrs["broken"] = "" attrs["state-id"] = "42" s.config = coretesting.CustomEnvironConfig(c, attrs).AllAttrs() s.changes <- struct{}{} }
func (s *EnvironSuite) TestNewEnvironmentSameUserSameNameFails(c *gc.C) { cfg, _ := s.createTestEnvConfig(c) owner := s.Factory.MakeUser(c, nil).UserTag() // Create the first environment. _, st1, err := s.State.NewEnvironment(cfg, owner) c.Assert(err, jc.ErrorIsNil) defer st1.Close() // Attempt to create another environment with a different UUID but the // same owner and name as the first. newUUID, err := utils.NewUUID() c.Assert(err, jc.ErrorIsNil) cfg2 := testing.CustomEnvironConfig(c, testing.Attrs{ "name": cfg.Name(), "uuid": newUUID.String(), }) _, _, err = s.State.NewEnvironment(cfg2, owner) errMsg := fmt.Sprintf("environment %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 environment. env1, err := st1.Environment() c.Assert(err, jc.ErrorIsNil) err = env1.Destroy() c.Assert(err, jc.ErrorIsNil) // Destroy only sets the environment to dying and RemoveAllEnvironDocs can // only be called on a dead environment. Normally, the environ's lifecycle // would be set to dead after machines and services have been cleaned up. err = state.SetEnvLifeDead(st1, env1.EnvironTag().Id()) c.Assert(err, jc.ErrorIsNil) err = st1.RemoveAllEnvironDocs() c.Assert(err, jc.ErrorIsNil) // We should now be able to create the other environment. env2, st2, err := s.State.NewEnvironment(cfg2, owner) c.Assert(err, jc.ErrorIsNil) defer st2.Close() c.Assert(env2, gc.NotNil) c.Assert(st2, gc.NotNil) }
// MakeEnvironment creates an environment with specified params, // filling in sane defaults for missing values. If params is nil, // defaults are used for all values. // // By default the new enviroment shares the same owner as the calling // Factory's environment. func (factory *Factory) MakeEnvironment(c *gc.C, params *EnvParams) *state.State { if params == nil { params = new(EnvParams) } if params.Name == "" { params.Name = uniqueString("testenv") } if params.Owner == nil { origEnv, err := factory.st.Environment() c.Assert(err, jc.ErrorIsNil) params.Owner = origEnv.Owner() } // It only makes sense to make an environment with the same provider // as the initial environment, or things will break elsewhere. currentCfg, err := factory.st.EnvironConfig() c.Assert(err, jc.ErrorIsNil) uuid, err := utils.NewUUID() c.Assert(err, jc.ErrorIsNil) cfg := testing.CustomEnvironConfig(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.NewEnvironment(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.UpdateEnvironConfig(env.Config().AllAttrs(), nil, nil) c.Assert(err, jc.ErrorIsNil) } return st }
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}, &fakeStorageInstance{tag: storageTag, owner: unitTag}, testing.CustomEnvironConfig(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.JujuEnv: testing.EnvironmentTag.Id(), tags.JujuStorageInstance: "mystore/0", tags.JujuStorageOwner: "mysql/123", }, }) }
func (*volumesSuite) testVolumeParams(c *gc.C, provisioned bool) { tag := names.NewVolumeTag("100") p, err := storagecommon.VolumeParams( &fakeVolume{tag: tag, provisioned: provisioned}, nil, // StorageInstance testing.CustomEnvironConfig(c, testing.Attrs{ "resource-tags": "a=b c=", }), &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.JujuEnv: testing.EnvironmentTag.Id(), "a": "b", "c": "", }, }) }
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.CustomEnvironConfig(c, extraAttrs) sb.Zones = []providercommon.AvailabilityZone{} if withZones { sb.Zones = make([]providercommon.AvailabilityZone, len(ProviderInstance.Zones)) copy(sb.Zones, ProviderInstance.Zones) } sb.Spaces = []common.BackingSpace{} if withSpaces { // Note that full subnet data is generated from the SubnetIds in // FakeSpace.Subnets(). sb.Spaces = []common.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 = []common.BackingSubnet{} if withSubnets { info0 := common.BackingSubnetInfo{ CIDR: ProviderInstance.Subnets[0].CIDR, ProviderId: string(ProviderInstance.Subnets[0].ProviderId), AllocatableIPLow: ProviderInstance.Subnets[0].AllocatableIPLow.String(), AllocatableIPHigh: ProviderInstance.Subnets[0].AllocatableIPHigh.String(), AvailabilityZones: ProviderInstance.Subnets[0].AvailabilityZones, SpaceName: "private", } info1 := common.BackingSubnetInfo{ CIDR: ProviderInstance.Subnets[1].CIDR, ProviderId: string(ProviderInstance.Subnets[1].ProviderId), AvailabilityZones: ProviderInstance.Subnets[1].AvailabilityZones, SpaceName: "dmz", } sb.Subnets = []common.BackingSubnet{ &FakeSubnet{info0}, &FakeSubnet{info1}, } } }