func (s *unitUpgraderSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) s.resources = common.NewResources() s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() }) // Create a machine and unit to work with var err error _, err = s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, gc.IsNil) svc := s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress")) s.rawUnit, err = svc.AddUnit() c.Assert(err, gc.IsNil) // Assign the unit to the machine. s.rawMachine, err = s.rawUnit.AssignToCleanMachine() c.Assert(err, gc.IsNil) // The default auth is as the unit agent s.authorizer = apiservertesting.FakeAuthorizer{ Tag: s.rawUnit.Tag(), LoggedIn: true, UnitAgent: true, } s.upgrader, err = upgrader.NewUnitUpgraderAPI(s.State, s.resources, s.authorizer) c.Assert(err, gc.IsNil) }
func (s *environmentSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) var err error s.machine0, err = s.State.AddMachine("quantal", state.JobHostUnits, state.JobManageEnviron) c.Assert(err, gc.IsNil) s.authorizer = apiservertesting.FakeAuthorizer{ Tag: s.machine0.Tag(), LoggedIn: true, MachineAgent: true, Entity: s.machine0, } s.resources = common.NewResources() s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() }) s.api, err = environment.NewEnvironmentAPI( s.State, s.resources, s.authorizer, ) c.Assert(err, gc.IsNil) s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest( s.api, s.State, s.resources, commontesting.NoSecrets) }
func (s *networkerSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) s.setUpNetworks(c) s.setUpMachine(c) s.setUpContainers(c) // Create a FakeAuthorizer so we can check permissions, // set up assuming we logged in as a machine agent. s.authorizer = apiservertesting.FakeAuthorizer{ LoggedIn: true, MachineAgent: true, Tag: s.machine.Tag(), } // Create the resource registry separately to track invocations to // Register. s.resources = common.NewResources() // Create a networker API for the machine. var err error s.networker, err = networker.NewNetworkerAPI( s.State, s.resources, s.authorizer, ) c.Assert(err, gc.IsNil) }
func (s *deployerSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) // The two known machines now contain the following units: // machine 0 (not authorized): mysql/1 (principal1) // machine 1 (authorized): mysql/0 (principal0), logging/0 (subordinate0) var err error s.machine0, err = s.State.AddMachine("quantal", state.JobManageEnviron, state.JobHostUnits) c.Assert(err, gc.IsNil) s.machine1, err = s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, gc.IsNil) s.service0 = s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql")) s.service1 = s.AddTestingService(c, "logging", s.AddTestingCharm(c, "logging")) eps, err := s.State.InferEndpoints([]string{"mysql", "logging"}) c.Assert(err, gc.IsNil) rel, err := s.State.AddRelation(eps...) c.Assert(err, gc.IsNil) s.principal0, err = s.service0.AddUnit() c.Assert(err, gc.IsNil) err = s.principal0.AssignToMachine(s.machine1) c.Assert(err, gc.IsNil) s.principal1, err = s.service0.AddUnit() c.Assert(err, gc.IsNil) err = s.principal1.AssignToMachine(s.machine0) c.Assert(err, gc.IsNil) relUnit0, err := rel.Unit(s.principal0) c.Assert(err, gc.IsNil) err = relUnit0.EnterScope(nil) c.Assert(err, gc.IsNil) s.subordinate0, err = s.service1.Unit("logging/0") c.Assert(err, gc.IsNil) // Create a FakeAuthorizer so we can check permissions, // set up assuming machine 1 has logged in. s.authorizer = apiservertesting.FakeAuthorizer{ Tag: names.NewMachineTag(s.machine1.Id()).String(), LoggedIn: true, MachineAgent: true, } // Create the resource registry separately to track invocations to // Register. s.resources = common.NewResources() // Create a deployer API for machine 1. deployer, err := deployer.NewDeployerAPI( s.State, s.resources, s.authorizer, ) c.Assert(err, gc.IsNil) s.deployer = deployer }
func (s *agentSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) var err error s.machine0, err = s.State.AddMachine("quantal", state.JobManageEnviron) c.Assert(err, gc.IsNil) s.machine1, err = s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, gc.IsNil) template := state.MachineTemplate{ Series: "quantal", Jobs: []state.MachineJob{state.JobHostUnits}, } s.container, err = s.State.AddMachineInsideMachine(template, s.machine1.Id(), instance.LXC) c.Assert(err, gc.IsNil) s.resources = common.NewResources() s.AddCleanup(func(*gc.C) { s.resources.StopAll() }) // Create a FakeAuthorizer so we can check permissions, // set up assuming machine 1 has logged in. s.authorizer = apiservertesting.FakeAuthorizer{ Tag: s.machine1.Tag(), LoggedIn: true, MachineAgent: true, } // Create a machiner API for machine 1. s.agent, err = agent.NewAPI(s.State, s.resources, s.authorizer) c.Assert(err, gc.IsNil) }
func (*agentEntityWatcherSuite) TestWatch(c *gc.C) { st := &fakeState{ entities: map[string]entityWithError{ "x0": &fakeAgentEntityWatcher{fetchError: "x0 fails"}, "x1": &fakeAgentEntityWatcher{}, "x2": &fakeAgentEntityWatcher{}, }, } getCanWatch := func() (common.AuthFunc, error) { return func(tag string) bool { switch tag { case "x0", "x1": return true } return false }, nil } resources := common.NewResources() a := common.NewAgentEntityWatcher(st, resources, getCanWatch) entities := params.Entities{[]params.Entity{ {"x0"}, {"x1"}, {"x2"}, {"x3"}, }} result, err := a.Watch(entities) c.Assert(err, gc.IsNil) c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{ Results: []params.NotifyWatchResult{ {Error: ¶ms.Error{Message: "x0 fails"}}, {"1", nil}, {Error: apiservertesting.ErrUnauthorized}, {Error: apiservertesting.ErrUnauthorized}, }, }) }
func (resourceSuite) TestStringResource(c *gc.C) { rs := common.NewResources() r1 := common.StringResource("foobar") id := rs.Register(r1) c.Check(rs.Get(id), gc.Equals, r1) asStr := rs.Get(id).(common.StringResource).String() c.Check(asStr, gc.Equals, "foobar") }
func (resourceSuite) TestRegisterNamedIntegerStart(c *gc.C) { rs := common.NewResources() defer rs.StopAll() r1 := &fakeResource{} err := rs.RegisterNamed("1fake", r1) c.Assert(err, gc.IsNil) c.Check(rs.Count(), gc.Equals, 1) c.Check(rs.Get("1fake"), gc.Equals, r1) }
// TestingSrvRoot gives you an srvRoot that is *barely* connected to anything. // Just enough to let you probe some of the interfaces of srvRoot, but not // enough to actually do any RPC calls func TestingSrvRoot(st *state.State) *srvRoot { return &srvRoot{ state: st, rpcConn: nil, resources: common.NewResources(), entity: nil, objectCache: make(map[objectKey]reflect.Value), } }
func (resourceSuite) TestRegisterNamedIntegerName(c *gc.C) { rs := common.NewResources() defer rs.StopAll() r1 := &fakeResource{} err := rs.RegisterNamed("1", r1) c.Check(err, gc.ErrorMatches, `RegisterNamed does not allow integer names: "1"`) c.Check(rs.Count(), gc.Equals, 0) c.Check(rs.Get("fake1"), gc.IsNil) }
// newSrvRoot creates the client's connection representation // and starts a ping timeout for the monitoring of this // connection. func newSrvRoot(root *initialRoot, entity taggedAuthenticator) *srvRoot { r := &srvRoot{ srv: root.srv, rpcConn: root.rpcConn, resources: common.NewResources(), entity: entity, } r.resources.RegisterNamed("dataDir", common.StringResource(r.srv.dataDir)) r.clientAPI.API = client.NewAPI(r.srv.state, r.resources, r) return r }
// newSrvRoot creates the client's connection representation // and starts a ping timeout for the monitoring of this // connection. func newSrvRoot(root *initialRoot, entity state.Entity) *srvRoot { r := &srvRoot{ state: root.srv.state, rpcConn: root.rpcConn, resources: common.NewResources(), entity: entity, objectCache: make(map[objectKey]reflect.Value), } r.resources.RegisterNamed("dataDir", common.StringResource(root.srv.dataDir)) return r }
func (resourceSuite) TestStop(c *gc.C) { rs := common.NewResources() r1 := &fakeResource{} rs.Register(r1) r2 := &fakeResource{} rs.Register(r2) rs.Stop("1") c.Assert(r1.stopped, gc.Equals, true) c.Assert(rs.Get("1"), gc.IsNil) c.Assert(r2.stopped, gc.Equals, false) c.Assert(rs.Get("2"), gc.Equals, r2) c.Assert(rs.Count(), gc.Equals, 1) }
func (*agentEntityWatcherSuite) TestWatchError(c *gc.C) { getCanWatch := func() (common.AuthFunc, error) { return nil, fmt.Errorf("pow") } resources := common.NewResources() a := common.NewAgentEntityWatcher( &fakeState{}, resources, getCanWatch, ) _, err := a.Watch(params.Entities{[]params.Entity{{"x0"}}}) c.Assert(err, gc.ErrorMatches, "pow") }
func (s *charmVersionSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) s.CharmSuite.SetUpTest(c) s.resources = common.NewResources() s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() }) s.authoriser = apiservertesting.FakeAuthorizer{ LoggedIn: true, EnvironManager: true, } var err error s.charmrevisionupdater, err = charmrevisionupdater.NewCharmRevisionUpdaterAPI(s.State, s.resources, s.authoriser) c.Assert(err, gc.IsNil) }
func (s *rsyslogSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) s.authorizer = apiservertesting.FakeAuthorizer{ LoggedIn: true, EnvironManager: true, MachineAgent: true, } s.resources = common.NewResources() api, err := rsyslog.NewRsyslogAPI(s.State, s.resources, s.authorizer) c.Assert(err, gc.IsNil) s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest( api, s.State, s.resources, commontesting.NoSecrets) }
func (resourceSuite) TestRegisterNamedRepeatedName(c *gc.C) { rs := common.NewResources() defer rs.StopAll() r1 := &fakeResource{} r2 := &fakeResource{} err := rs.RegisterNamed("fake1", r1) c.Assert(err, gc.IsNil) c.Check(rs.Count(), gc.Equals, 1) err = rs.RegisterNamed("fake1", r2) c.Check(err, gc.ErrorMatches, `resource "fake1" already registered`) c.Check(rs.Count(), gc.Equals, 1) c.Check(rs.Get("fake1"), gc.Equals, r1) }
func (*environMachinesWatcherSuite) TestWatchGetAuthError(c *gc.C) { getCanWatch := func() (common.AuthFunc, error) { return nil, fmt.Errorf("pow") } resources := common.NewResources() e := common.NewEnvironMachinesWatcher( &fakeEnvironMachinesWatcher{}, resources, getCanWatch, ) _, err := e.WatchEnvironMachines() c.Assert(err, gc.ErrorMatches, "pow") c.Assert(resources.Count(), gc.Equals, 0) }
func (s *keyManagerSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) s.resources = common.NewResources() s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() }) s.authoriser = apiservertesting.FakeAuthorizer{ Tag: "user-admin", LoggedIn: true, Client: true, } var err error s.keymanager, err = keymanager.NewKeyManagerAPI(s.State, s.resources, s.authoriser) c.Assert(err, gc.IsNil) }
func (resourceSuite) TestRegisterGetCount(c *gc.C) { rs := common.NewResources() r1 := &fakeResource{} id := rs.Register(r1) c.Assert(id, gc.Equals, "1") c.Assert(rs.Get("1"), gc.Equals, r1) c.Assert(rs.Count(), gc.Equals, 1) r2 := &fakeResource{} id = rs.Register(r2) c.Assert(id, gc.Equals, "2") c.Assert(rs.Get("2"), gc.Equals, r2) c.Assert(rs.Count(), gc.Equals, 2) }
func (*agentEntityWatcherSuite) TestWatchNoArgsNoError(c *gc.C) { getCanWatch := func() (common.AuthFunc, error) { return nil, fmt.Errorf("pow") } resources := common.NewResources() a := common.NewAgentEntityWatcher( &fakeState{}, resources, getCanWatch, ) result, err := a.Watch(params.Entities{}) c.Assert(err, gc.IsNil) c.Assert(result.Results, gc.HasLen, 0) }
func (s *environWatcherSuite) TestWatchGetAuthError(c *gc.C) { getCanWatch := func() (common.AuthFunc, error) { return nil, fmt.Errorf("pow") } resources := common.NewResources() s.AddCleanup(func(_ *gc.C) { resources.StopAll() }) e := common.NewEnvironWatcher( &fakeEnvironAccessor{}, resources, getCanWatch, nil, ) _, err := e.WatchForEnvironConfigChanges() c.Assert(err, gc.ErrorMatches, "pow") c.Assert(resources.Count(), gc.Equals, 0) }
func (s *machinerSuite) SetUpTest(c *gc.C) { s.commonSuite.SetUpTest(c) // Create the resource registry separately to track invocations to // Register. s.resources = common.NewResources() // Create a machiner API for machine 1. machiner, err := machine.NewMachinerAPI( s.State, s.resources, s.authorizer, ) c.Assert(err, gc.IsNil) s.machiner = machiner }
func (*environMachinesWatcherSuite) TestWatchAuthError(c *gc.C) { getCanWatch := func() (common.AuthFunc, error) { return func(tag string) bool { return false }, nil } resources := common.NewResources() e := common.NewEnvironMachinesWatcher( &fakeEnvironMachinesWatcher{}, resources, getCanWatch, ) _, err := e.WatchEnvironMachines() c.Assert(err, gc.ErrorMatches, "permission denied") c.Assert(resources.Count(), gc.Equals, 0) }
func (s *firewallerSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) // Reset previous machines and units (if any) and create 3 // machines for the tests. s.machines = nil s.units = nil // Note that the specific machine ids allocated are assumed // to be numerically consecutive from zero. for i := 0; i <= 2; i++ { machine, err := s.State.AddMachine("quantal", state.JobHostUnits) c.Check(err, gc.IsNil) s.machines = append(s.machines, machine) } // Create a service and three units for these machines. s.charm = s.AddTestingCharm(c, "wordpress") s.service = s.AddTestingService(c, "wordpress", s.charm) // Add the rest of the units and assign them. for i := 0; i <= 2; i++ { unit, err := s.service.AddUnit() c.Check(err, gc.IsNil) err = unit.AssignToMachine(s.machines[i]) c.Check(err, gc.IsNil) s.units = append(s.units, unit) } // Create a FakeAuthorizer so we can check permissions, // set up assuming we logged in as the environment manager. s.authorizer = apiservertesting.FakeAuthorizer{ LoggedIn: true, EnvironManager: true, } // Create the resource registry separately to track invocations to // Register. s.resources = common.NewResources() // Create a firewaller API for the machine. firewallerAPI, err := firewaller.NewFirewallerAPI( s.State, s.resources, s.authorizer, ) c.Assert(err, gc.IsNil) s.firewaller = firewallerAPI s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(s.firewaller, s.State, s.resources, commontesting.HasSecrets) }
func (*environMachinesWatcherSuite) TestWatchEnvironMachines(c *gc.C) { getCanWatch := func() (common.AuthFunc, error) { return func(tag string) bool { return true }, nil } resources := common.NewResources() e := common.NewEnvironMachinesWatcher( &fakeEnvironMachinesWatcher{initial: []string{"foo"}}, resources, getCanWatch, ) result, err := e.WatchEnvironMachines() c.Assert(err, gc.IsNil) c.Assert(result, jc.DeepEquals, params.StringsWatchResult{"1", []string{"foo"}, nil}) c.Assert(resources.Count(), gc.Equals, 1) }
func (*environWatcherSuite) TestWatchSuccess(c *gc.C) { getCanWatch := func() (common.AuthFunc, error) { return func(tag string) bool { return true }, nil } resources := common.NewResources() e := common.NewEnvironWatcher( &fakeEnvironAccessor{}, resources, getCanWatch, nil, ) result, err := e.WatchForEnvironConfigChanges() c.Assert(err, gc.IsNil) c.Assert(result, gc.DeepEquals, params.NotifyWatchResult{"1", nil}) c.Assert(resources.Count(), gc.Equals, 1) }
func (*environWatcherSuite) TestWatchAuthError(c *gc.C) { getCanWatch := func() (common.AuthFunc, error) { return func(tag string) bool { return false }, nil } resources := common.NewResources() e := common.NewEnvironWatcher( &fakeEnvironAccessor{}, resources, getCanWatch, nil, ) result, err := e.WatchForEnvironConfigChanges() c.Assert(err, gc.ErrorMatches, "permission denied") c.Assert(result, gc.DeepEquals, params.NotifyWatchResult{}) c.Assert(resources.Count(), gc.Equals, 0) }
func (s *uniterSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) s.wpCharm = s.AddTestingCharm(c, "wordpress") // Create two machines, two services and add a unit to each service. var err error s.machine0, err = s.State.AddMachine("quantal", state.JobHostUnits, state.JobManageEnviron) c.Assert(err, gc.IsNil) s.machine1, err = s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, gc.IsNil) s.wordpress = s.AddTestingService(c, "wordpress", s.wpCharm) s.mysql = s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql")) s.wordpressUnit, err = s.wordpress.AddUnit() c.Assert(err, gc.IsNil) s.mysqlUnit, err = s.mysql.AddUnit() c.Assert(err, gc.IsNil) // Assign each unit to each machine. err = s.wordpressUnit.AssignToMachine(s.machine0) c.Assert(err, gc.IsNil) err = s.mysqlUnit.AssignToMachine(s.machine1) c.Assert(err, gc.IsNil) // Create a FakeAuthorizer so we can check permissions, // set up assuming unit 0 has logged in. s.authorizer = apiservertesting.FakeAuthorizer{ Tag: s.wordpressUnit.Tag(), LoggedIn: true, UnitAgent: true, Entity: s.wordpressUnit, } // Create the resource registry separately to track invocations to // Register. s.resources = common.NewResources() // Create a uniter API for unit 0. s.uniter, err = uniter.NewUniterAPI( s.State, s.resources, s.authorizer, ) c.Assert(err, gc.IsNil) s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(s.uniter, s.State, s.resources, commontesting.NoSecrets) }
func (s *loggerSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) s.resources = common.NewResources() s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() }) // Create a machine to work with var err error s.rawMachine, err = s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, gc.IsNil) // The default auth is as the machine agent s.authorizer = apiservertesting.FakeAuthorizer{ Tag: s.rawMachine.Tag(), LoggedIn: true, MachineAgent: true, } s.logger, err = logger.NewLoggerAPI(s.State, s.resources, s.authorizer) c.Assert(err, gc.IsNil) }