func (s *loginSuite) TestMachineLoginOtherModelNotProvisioned(c *gc.C) {
info, cleanup := s.setupServer(c)
defer cleanup()
envOwner := s.Factory.MakeUser(c, nil)
envState := s.Factory.MakeModel(c, &factory.ModelParams{
Owner: envOwner.UserTag(),
ConfigAttrs: map[string]interface{}{
"controller": false,
},
})
defer envState.Close()
f2 := factory.NewFactory(envState)
machine, password := f2.MakeUnprovisionedMachineReturningPassword(c, &factory.MachineParams{})
info.ModelTag = envState.ModelTag()
st := s.openAPIWithoutLogin(c, info)
defer st.Close()
// If the agent attempts Login before the provisioner has recorded
// the machine's nonce in state, then the agent should get back an
// error with code "not provisioned".
err := st.Login(machine.Tag(), password, "nonce", nil)
c.Assert(err, gc.ErrorMatches, `machine 0 not provisioned \(not provisioned\)`)
c.Assert(err, jc.Satisfies, params.IsCodeNotProvisioned)
}
func (s *loginSuite) TestOtherEnvironmentFromControllerOtherNotProvisioned(c *gc.C) {
info, cleanup := s.setupServer(c)
defer cleanup()
managerMachine, password := s.Factory.MakeMachineReturningPassword(c, &factory.MachineParams{
Jobs: []state.MachineJob{state.JobManageModel},
})
// Create a hosted model with an unprovisioned machine that has the
// same tag as the manager machine.
hostedModelState := s.Factory.MakeModel(c, nil)
defer hostedModelState.Close()
f2 := factory.NewFactory(hostedModelState)
workloadMachine, _ := f2.MakeUnprovisionedMachineReturningPassword(c, &factory.MachineParams{})
c.Assert(managerMachine.Tag(), gc.Equals, workloadMachine.Tag())
info.ModelTag = hostedModelState.ModelTag()
st := s.openAPIWithoutLogin(c, info)
defer st.Close()
// The fact that the machine with the same tag in the hosted
// model is unprovisioned should not cause the login to fail
// with "not provisioned", because the passwords don't match.
err := st.Login(managerMachine.Tag(), password, "nonce", nil)
c.Assert(err, jc.ErrorIsNil)
}
func (s *loginSuite) TestMachineLoginOtherModel(c *gc.C) {
// User credentials are checked against a global user list.
// Machine credentials are checked against environment specific
// machines, so this makes sure that the credential checking is
// using the correct state connection.
info, cleanup := s.setupServer(c)
defer cleanup()
envOwner := s.Factory.MakeUser(c, nil)
envState := s.Factory.MakeModel(c, &factory.ModelParams{
Owner: envOwner.UserTag(),
ConfigAttrs: map[string]interface{}{
"controller": false,
},
})
defer envState.Close()
f2 := factory.NewFactory(envState)
machine, password := f2.MakeMachineReturningPassword(c, &factory.MachineParams{
Nonce: "nonce",
})
info.ModelTag = envState.ModelTag()
st := s.openAPIWithoutLogin(c, info)
defer st.Close()
err := st.Login(machine.Tag(), password, "nonce", nil)
c.Assert(err, jc.ErrorIsNil)
}
func (s *EnvUserSuite) TestCaseInsensitiveLookupInMultiEnvirons(c *gc.C) {
assertIsolated := func(st1, st2 *state.State, usernames ...string) {
f := factory.NewFactory(st1)
expectedUser := f.MakeEnvUser(c, &factory.EnvUserParams{User: usernames[0]})
// assert case insensitive lookup for each username
for _, username := range usernames {
userTag := names.NewUserTag(username)
obtainedUser, err := st1.EnvironmentUser(userTag)
c.Assert(err, jc.ErrorIsNil)
c.Assert(obtainedUser, gc.DeepEquals, expectedUser)
_, err = st2.EnvironmentUser(userTag)
c.Assert(errors.IsNotFound(err), jc.IsTrue)
}
}
otherSt := s.Factory.MakeEnvironment(c, nil)
defer otherSt.Close()
assertIsolated(s.State, otherSt,
"Bob@UbuntuOne",
"bob@ubuntuone",
"BOB@UBUNTUONE",
)
assertIsolated(otherSt, s.State,
"Sam@UbuntuOne",
"sam@ubuntuone",
"SAM@UBUNTUONE",
)
}
func (s *CleanupSuite) TestCleanupControllerModels(c *gc.C) {
s.assertDoesNotNeedCleanup(c)
// Create a non-empty hosted model.
otherSt := s.Factory.MakeModel(c, nil)
defer otherSt.Close()
factory.NewFactory(otherSt).MakeService(c, nil)
otherEnv, err := otherSt.Model()
c.Assert(err, jc.ErrorIsNil)
s.assertDoesNotNeedCleanup(c)
// Destroy the controller and check the model is unaffected, but a
// cleanup for the model and services has been scheduled.
controllerEnv, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
err = controllerEnv.DestroyIncludingHosted()
c.Assert(err, jc.ErrorIsNil)
// Two cleanups should be scheduled. One to destroy the hosted
// models, the other to destroy the controller model's
// services.
s.assertCleanupCount(c, 1)
err = otherEnv.Refresh()
c.Assert(err, jc.ErrorIsNil)
c.Assert(otherEnv.Life(), gc.Equals, state.Dying)
s.assertDoesNotNeedCleanup(c)
}
func (s *metricsAdderIntegrationSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
f := factory.NewFactory(s.State)
machine0 := f.MakeMachine(c, &factory.MachineParams{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
})
meteredCharm := f.MakeCharm(c, &factory.CharmParams{
Name: "metered",
URL: "cs:quantal/metered",
})
meteredService := f.MakeService(c, &factory.ServiceParams{
Charm: meteredCharm,
})
meteredUnit := f.MakeUnit(c, &factory.UnitParams{
Service: meteredService,
SetCharmURL: true,
Machine: machine0,
})
state, _ := s.OpenAPIAsNewMachine(c)
s.adder = metricsadder.NewClient(state)
s.unitTag = meteredUnit.Tag()
}
func (s *destroyTwoEnvironmentsSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
_, err := s.State.AddUser("jess", "jess", "", "test")
c.Assert(err, jc.ErrorIsNil)
s.otherEnvOwner = names.NewUserTag("jess")
s.otherState = factory.NewFactory(s.State).MakeEnvironment(c, &factory.EnvParams{
Owner: s.otherEnvOwner,
Prepare: true,
ConfigAttrs: jujutesting.Attrs{
"state-server": false,
},
})
s.AddCleanup(func(*gc.C) { s.otherState.Close() })
// get the client for the other environment
auth := apiservertesting.FakeAuthorizer{
Tag: s.otherEnvOwner,
EnvironManager: false,
}
s.otherEnvClient, err = client.NewClient(s.otherState, common.NewResources(), auth)
c.Assert(err, jc.ErrorIsNil)
s.metricSender = &testMetricSender{}
s.PatchValue(common.SendMetrics, s.metricSender.SendMetrics)
}
func (s *ModelSuite) TestDestroyControllerAndHostedModels(c *gc.C) {
st2 := s.Factory.MakeModel(c, nil)
defer st2.Close()
factory.NewFactory(st2).MakeService(c, nil)
controllerEnv, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(controllerEnv.DestroyIncludingHosted(), jc.ErrorIsNil)
env, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.Life(), gc.Equals, state.Dying)
assertNeedsCleanup(c, s.State)
assertCleanupRuns(c, s.State)
// Cleanups for hosted model enqueued by controller model cleanups.
assertNeedsCleanup(c, st2)
assertCleanupRuns(c, st2)
env2, err := st2.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env2.Life(), gc.Equals, state.Dying)
c.Assert(st2.ProcessDyingModel(), jc.ErrorIsNil)
c.Assert(env2.Refresh(), jc.ErrorIsNil)
c.Assert(env2.Life(), gc.Equals, state.Dead)
c.Assert(s.State.ProcessDyingModel(), jc.ErrorIsNil)
c.Assert(env.Refresh(), jc.ErrorIsNil)
c.Assert(env2.Life(), gc.Equals, state.Dead)
}
func (s *JujuConnSuite) SetUpTest(c *gc.C) {
s.MgoSuite.SetUpTest(c)
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
s.setUpConn(c)
s.Factory = factory.NewFactory(s.State)
}
func (s *userManagerSuite) TestUserInfoUserExists(c *gc.C) {
foobar := "foobar"
fooTag := names.NewUserTag(foobar)
userFactory := factory.NewFactory(s.State, c)
userFactory.MakeUser(factory.UserParams{Username: foobar, DisplayName: "Foo Bar"})
args := params.Entities{
Entities: []params.Entity{{Tag: fooTag.String()}},
}
results, err := s.usermanager.UserInfo(args)
c.Assert(err, gc.IsNil)
expected := params.UserInfoResults{
Results: []params.UserInfoResult{
{
Result: ¶ms.UserInfo{
Username: "******",
DisplayName: "Foo Bar",
CreatedBy: "admin",
DateCreated: time.Time{},
LastConnection: time.Time{},
},
},
},
}
// set DateCreated to nil as we cannot know the exact time user was created
results.Results[0].Result.DateCreated = time.Time{}
c.Assert(results, gc.DeepEquals, expected)
}
func (s *loginSuite) TestMachineLoginOtherEnvironment(c *gc.C) {
// User credentials are checked against a global user list.
// Machine credentials are checked against environment specific
// machines, so this makes sure that the credential checking is
// using the correct state connection.
info, cleanup := s.setupServerWithValidator(c, nil)
defer cleanup()
envOwner := s.Factory.MakeUser(c, nil)
envState := s.Factory.MakeEnvironment(c, &factory.EnvParams{
Owner: envOwner.UserTag(),
ConfigAttrs: map[string]interface{}{
"state-server": false,
},
Prepare: true,
})
defer envState.Close()
f2 := factory.NewFactory(envState)
machine, password := f2.MakeMachineReturningPassword(c, &factory.MachineParams{
Nonce: "nonce",
})
info.EnvironTag = envState.EnvironTag()
st, err := api.Open(info, fastDialOpts)
c.Assert(err, jc.ErrorIsNil)
defer st.Close()
err = st.Login(machine.Tag(), password, "nonce")
c.Assert(err, jc.ErrorIsNil)
}
func (s *destroyControllerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.BlockHelper = commontesting.NewBlockHelper(s.APIState)
s.AddCleanup(func(*gc.C) { s.BlockHelper.Close() })
resources := common.NewResources()
s.AddCleanup(func(_ *gc.C) { resources.StopAll() })
authoriser := apiservertesting.FakeAuthorizer{
Tag: s.AdminUserTag(c),
}
controller, err := controller.NewControllerAPI(s.State, resources, authoriser)
c.Assert(err, jc.ErrorIsNil)
s.controller = controller
s.otherEnvOwner = names.NewUserTag("jess@dummy")
s.otherState = factory.NewFactory(s.State).MakeModel(c, &factory.ModelParams{
Name: "dummytoo",
Owner: s.otherEnvOwner,
Prepare: true,
ConfigAttrs: testing.Attrs{
"state-server": false,
},
})
s.AddCleanup(func(c *gc.C) { s.otherState.Close() })
s.otherModelUUID = s.otherState.ModelUUID()
}
func (s *ModelSuite) assertDyingEnvironTransitionDyingToDead(c *gc.C, st *state.State) {
// Add a service to prevent the model from transitioning directly to Dead.
// Add the service before getting the Model, otherwise we'll have to run
// the transaction twice, and hit the hook point too early.
svc := factory.NewFactory(st).MakeService(c, nil)
env, err := st.Model()
c.Assert(err, jc.ErrorIsNil)
// ProcessDyingModel is called by a worker after Destroy is called. To
// avoid a race, we jump the gun here and test immediately after the
// environement was set to dead.
defer state.SetAfterHooks(c, st, func() {
c.Assert(env.Refresh(), jc.ErrorIsNil)
c.Assert(env.Life(), gc.Equals, state.Dying)
err := svc.Destroy()
c.Assert(err, jc.ErrorIsNil)
c.Assert(st.ProcessDyingModel(), jc.ErrorIsNil)
c.Assert(env.Refresh(), jc.ErrorIsNil)
c.Assert(env.Life(), gc.Equals, state.Dead)
}).Check()
c.Assert(env.Destroy(), jc.ErrorIsNil)
}
func (s *ModelSuite) TestDestroyControllerRemoveEmptyAddNonEmptyModel(c *gc.C) {
st2 := s.Factory.MakeModel(c, nil)
defer st2.Close()
// Simulate an empty model being removed, and a new non-empty
// model being added, just before the remove txn is called.
defer state.SetBeforeHooks(c, s.State, func() {
// Destroy the empty model, which should move it right
// along to Dead, and then remove it.
model, err := st2.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(model.Destroy(), jc.ErrorIsNil)
err = st2.RemoveAllModelDocs()
c.Assert(err, jc.ErrorIsNil)
// Add a new, non-empty model. This should still prevent
// the controller from being destroyed.
st3 := s.Factory.MakeModel(c, nil)
defer st3.Close()
factory.NewFactory(st3).MakeService(c, nil)
}).Check()
env, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.Destroy(), gc.ErrorMatches, "failed to destroy model: hosting 1 other models")
}
func (s *MetricSuite) TestMetricsAcrossEnvironments(c *gc.C) {
now := state.NowToTheSecond().Add(-48 * time.Hour)
m := state.Metric{"pings", "5", now}
m1, err := s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: s.unit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
st := s.Factory.MakeEnvironment(c, nil)
defer st.Close()
f := factory.NewFactory(st)
meteredCharm := f.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "cs:quantal/metered"})
service := f.MakeService(c, &factory.ServiceParams{Charm: meteredCharm})
unit := f.MakeUnit(c, &factory.UnitParams{Service: service, SetCharmURL: true})
m2, err := s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: unit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
batches, err := s.State.MetricBatches()
c.Assert(err, jc.ErrorIsNil)
c.Assert(batches, gc.HasLen, 2)
unsent, err := s.State.CountOfUnsentMetrics()
c.Assert(err, jc.ErrorIsNil)
c.Assert(unsent, gc.Equals, 2)
toSend, err := s.State.MetricsToSend(10)
c.Assert(err, jc.ErrorIsNil)
c.Assert(toSend, gc.HasLen, 2)
err = m1.SetSent(time.Now().Add(-25 * time.Hour))
c.Assert(err, jc.ErrorIsNil)
err = m2.SetSent(time.Now().Add(-25 * time.Hour))
c.Assert(err, jc.ErrorIsNil)
sent, err := s.State.CountOfSentMetrics()
c.Assert(err, jc.ErrorIsNil)
c.Assert(sent, gc.Equals, 2)
err = s.State.CleanupOldMetrics()
c.Assert(err, jc.ErrorIsNil)
batches, err = s.State.MetricBatches()
c.Assert(err, jc.ErrorIsNil)
c.Assert(batches, gc.HasLen, 0)
}
func (s *JujuConnSuite) SetUpTest(c *gc.C) {
s.MgoSuite.SetUpTest(c)
s.FakeJujuHomeSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
s.PatchValue(&configstore.DefaultAdminUsername, dummy.AdminUserTag().Name())
s.setUpConn(c)
s.Factory = factory.NewFactory(s.State)
}
func (s *watcherSuite) TestWatchMachineStorage(c *gc.C) {
registry.RegisterProvider(
"envscoped",
&dummy.StorageProvider{
StorageScope: storage.ScopeEnviron,
},
)
registry.RegisterEnvironStorageProviders("dummy", "envscoped")
defer registry.RegisterProvider("envscoped", nil)
f := factory.NewFactory(s.BackingState)
f.MakeMachine(c, &factory.MachineParams{
Volumes: []state.MachineVolumeParams{{
Volume: state.VolumeParams{
Pool: "envscoped",
Size: 1024,
},
}},
})
var results params.MachineStorageIdsWatchResults
args := params.Entities{Entities: []params.Entity{{
Tag: s.State.EnvironTag().String(),
}}}
err := s.stateAPI.APICall(
"StorageProvisioner",
s.stateAPI.BestFacadeVersion("StorageProvisioner"),
"", "WatchVolumeAttachments", args, &results)
c.Assert(err, jc.ErrorIsNil)
c.Assert(results.Results, gc.HasLen, 1)
result := results.Results[0]
c.Assert(result.Error, gc.IsNil)
w := watcher.NewVolumeAttachmentsWatcher(s.stateAPI, result)
select {
case changes, ok := <-w.Changes():
c.Assert(ok, jc.IsTrue)
c.Assert(changes, jc.SameContents, []params.MachineStorageId{{
MachineTag: "machine-1",
AttachmentTag: "volume-0",
}})
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for change")
}
select {
case <-w.Changes():
c.Fatalf("received unexpected change")
case <-time.After(coretesting.ShortWait):
}
statetesting.AssertStop(c, w)
select {
case _, ok := <-w.Changes():
c.Assert(ok, jc.IsFalse)
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for watcher channel to be closed")
}
}
func (s *actionSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.BlockHelper = commontesting.NewBlockHelper(s.APIState)
s.AddCleanup(func(*gc.C) { s.BlockHelper.Close() })
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.AdminUserTag(c),
}
var err error
s.action, err = action.NewActionAPI(s.State, nil, s.authorizer)
c.Assert(err, jc.ErrorIsNil)
factory := jujuFactory.NewFactory(s.State)
s.charm = factory.MakeCharm(c, &jujuFactory.CharmParams{
Name: "wordpress",
})
s.dummy = factory.MakeService(c, &jujuFactory.ServiceParams{
Name: "dummy",
Charm: factory.MakeCharm(c, &jujuFactory.CharmParams{
Name: "dummy",
}),
Creator: s.AdminUserTag(c),
})
s.wordpress = factory.MakeService(c, &jujuFactory.ServiceParams{
Name: "wordpress",
Charm: s.charm,
Creator: s.AdminUserTag(c),
})
s.machine0 = factory.MakeMachine(c, &jujuFactory.MachineParams{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits, state.JobManageModel},
})
s.wordpressUnit = factory.MakeUnit(c, &jujuFactory.UnitParams{
Service: s.wordpress,
Machine: s.machine0,
})
mysqlCharm := factory.MakeCharm(c, &jujuFactory.CharmParams{
Name: "mysql",
})
s.mysql = factory.MakeService(c, &jujuFactory.ServiceParams{
Name: "mysql",
Charm: mysqlCharm,
Creator: s.AdminUserTag(c),
})
s.machine1 = factory.MakeMachine(c, &jujuFactory.MachineParams{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
})
s.mysqlUnit = factory.MakeUnit(c, &jujuFactory.UnitParams{
Service: s.mysql,
Machine: s.machine1,
})
s.resources = common.NewResources()
s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() })
}
func (s *MeterStateSuite) SetUpTest(c *gc.C) {
s.ConnSuite.SetUpTest(c)
s.factory = factory.NewFactory(s.State)
s.unit = s.factory.MakeUnit(c, nil)
c.Assert(s.unit.Series(), gc.Equals, "quantal")
var err error
s.metricsManager, err = s.State.MetricsManager()
c.Assert(err, jc.ErrorIsNil)
}
func (s *StateSuite) SetUpTest(c *gc.C) {
s.MgoSuite.SetUpTest(c)
s.BaseSuite.SetUpTest(c)
s.Owner = names.NewLocalUserTag("test-admin")
s.State = Initialize(c, s.Owner, s.InitialConfig, s.ControllerInheritedConfig, s.RegionConfig, s.NewPolicy)
s.AddCleanup(func(*gc.C) { s.State.Close() })
s.Factory = factory.NewFactory(s.State)
}
func (s *controllerSuite) TestDestroyController(c *gc.C) {
st := s.Factory.MakeModel(c, &factory.ModelParams{Name: "foo"})
factory.NewFactory(st).MakeMachine(c, nil) // make it non-empty
st.Close()
sysManager := s.OpenAPI(c)
err := sysManager.DestroyController(false)
c.Assert(err, gc.ErrorMatches, `failed to destroy model: hosting 1 other models \(controller has hosted models\)`)
}
func (s *StateSuite) SetUpTest(c *gc.C) {
s.MgoSuite.SetUpTest(c)
s.BaseSuite.SetUpTest(c)
s.Owner = names.NewLocalUserTag("test-admin")
s.State = Initialize(c, s.Owner, nil, s.Policy)
s.AddCleanup(func(*gc.C) { s.State.Close() })
s.Factory = factory.NewFactory(s.State)
}
func (s *ModelSuite) TestDestroyControllerNonEmptyModelFails(c *gc.C) {
st2 := s.Factory.MakeModel(c, nil)
defer st2.Close()
factory.NewFactory(st2).MakeService(c, nil)
env, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.Destroy(), gc.ErrorMatches, "failed to destroy model: hosting 1 other models")
}
func (s *AgentAuthenticatorSuite) TestFindEntityAuthenticator(c *gc.C) {
fact := factory.NewFactory(s.State)
user := fact.MakeUser(c, &factory.UserParams{Password: "******"})
authenticator, err := authentication.FindEntityAuthenticator(user)
c.Assert(err, jc.ErrorIsNil)
c.Assert(authenticator, gc.NotNil)
err = authenticator.Authenticate(user, "password", "nonce")
c.Assert(err, jc.ErrorIsNil)
}
func (s *factorySuite) SetUpTest(c *gc.C) {
s.NewPolicy = func(*state.State) state.Policy {
return &statetesting.MockPolicy{
GetStorageProviderRegistry: func() (storage.ProviderRegistry, error) {
return provider.CommonStorageProviders(), nil
},
}
}
s.StateSuite.SetUpTest(c)
s.Factory = factory.NewFactory(s.State)
}
func (s *ModelStatusSuite) TestGetSetStatusDying(c *gc.C) {
// Add a machine to the model to ensure it is non-empty
// when we destroy; this prevents the model from advancing
// directly to Dead.
factory.NewFactory(s.st).MakeMachine(c, nil)
err := s.model.Destroy()
c.Assert(err, jc.ErrorIsNil)
s.checkGetSetStatus(c)
}
func (s *metricsAdderSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.factory = jujuFactory.NewFactory(s.State)
s.machine0 = s.factory.MakeMachine(c, &jujuFactory.MachineParams{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits, state.JobManageModel},
})
s.machine1 = s.factory.MakeMachine(c, &jujuFactory.MachineParams{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
})
mysqlCharm := s.factory.MakeCharm(c, &jujuFactory.CharmParams{
Name: "mysql",
})
s.mysql = s.factory.MakeService(c, &jujuFactory.ServiceParams{
Name: "mysql",
Charm: mysqlCharm,
Creator: s.AdminUserTag(c),
})
s.mysqlUnit = s.factory.MakeUnit(c, &jujuFactory.UnitParams{
Service: s.mysql,
Machine: s.machine0,
})
s.meteredCharm = s.factory.MakeCharm(c, &jujuFactory.CharmParams{
Name: "metered",
URL: "cs:quantal/metered",
})
s.meteredService = s.factory.MakeService(c, &jujuFactory.ServiceParams{
Charm: s.meteredCharm,
})
s.meteredUnit = s.factory.MakeUnit(c, &jujuFactory.UnitParams{
Service: s.meteredService,
SetCharmURL: true,
Machine: s.machine1,
})
// Create a FakeAuthorizer so we can check permissions,
// set up assuming unit 0 has logged in.
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: names.NewMachineTag("1"),
}
// Create the resource registry separately to track invocations to
// Register.
s.resources = common.NewResources()
s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() })
adder, err := metricsadder.NewMetricsAdderAPI(s.State, s.resources, s.authorizer)
c.Assert(err, jc.ErrorIsNil)
s.adder = adder
}
func (s *ModelSuite) TestDestroyControllerNonEmptyModelRace(c *gc.C) {
// Simulate an empty model being added just before the
// remove txn is called.
defer state.SetBeforeHooks(c, s.State, func() {
st := s.Factory.MakeModel(c, nil)
defer st.Close()
factory.NewFactory(st).MakeService(c, nil)
}).Check()
env, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.Destroy(), gc.ErrorMatches, "failed to destroy model: hosting 1 other models")
}
func (s *meterStatusIntegrationSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
f := factory.NewFactory(s.State)
s.unit = f.MakeUnit(c, nil)
password, err := utils.RandomPassword()
c.Assert(err, jc.ErrorIsNil)
err = s.unit.SetPassword(password)
c.Assert(err, jc.ErrorIsNil)
state := s.OpenAPIAs(c, s.unit.UnitTag(), password)
s.status = meterstatus.NewClient(state, s.unit.UnitTag())
c.Assert(s.status, gc.NotNil)
}
func (s *ModelSuite) TestDestroyModelAddMachineConcurrently(c *gc.C) {
st := s.Factory.MakeModel(c, nil)
defer st.Close()
m, err := st.Model()
c.Assert(err, jc.ErrorIsNil)
defer state.SetBeforeHooks(c, st, func() {
factory.NewFactory(st).MakeMachine(c, nil)
}).Check()
c.Assert(m.Destroy(), jc.ErrorIsNil)
c.Assert(m.Refresh(), jc.ErrorIsNil)
c.Assert(m.Life(), gc.Equals, state.Dying)
}
