← Back to branch summary

~rogpeppe/juju-core/themue-058-debug-log-api

« back to all changes in this revision

Viewing changes to state/apiserver/machine/agent_test.go

  • Committer: Frank Mueller
  • Date: 2014-01-21 08:46:24 UTC
  • mfrom: (2152.1.76 juju-core)
  • Revision ID: frank.mueller@canonical.com-20140121084624-rv32dv6ufzul9h1b
debugger: merged trunk and added access to debugger API facade

Show diffs side-by-side

added added

removed removed

Lines of Context:
state/apiserver/machine/agent_test.go
1
 
package machine_test
2
 
 
3
 
import (
4
 
        gc "launchpad.net/gocheck"
5
 
 
6
 
        "launchpad.net/juju-core/state/api/params"
7
 
        "launchpad.net/juju-core/state/apiserver/machine"
8
 
        apiservertesting "launchpad.net/juju-core/state/apiserver/testing"
9
 
)
10
 
 
11
 
type agentSuite struct {
12
 
        commonSuite
13
 
        agent *machine.AgentAPI
14
 
}
15
 
 
16
 
var _ = gc.Suite(&agentSuite{})
17
 
 
18
 
func (s *agentSuite) SetUpTest(c *gc.C) {
19
 
        s.commonSuite.SetUpTest(c)
20
 
 
21
 
        // Create a machiner API for machine 1.
22
 
        api, err := machine.NewAgentAPI(s.State, s.authorizer)
23
 
        c.Assert(err, gc.IsNil)
24
 
        s.agent = api
25
 
}
26
 
 
27
 
func (s *agentSuite) TestAgentFailsWithNonMachineAgentUser(c *gc.C) {
28
 
        auth := s.authorizer
29
 
        auth.MachineAgent = false
30
 
        api, err := machine.NewAgentAPI(s.State, auth)
31
 
        c.Assert(err, gc.NotNil)
32
 
        c.Assert(api, gc.IsNil)
33
 
        c.Assert(err, gc.ErrorMatches, "permission denied")
34
 
}
35
 
 
36
 
func (s *agentSuite) TestGetMachines(c *gc.C) {
37
 
        err := s.machine1.Destroy()
38
 
        c.Assert(err, gc.IsNil)
39
 
        results := s.agent.GetMachines(params.Entities{
40
 
                Entities: []params.Entity{
41
 
                        {Tag: "machine-1"},
42
 
                        {Tag: "machine-0"},
43
 
                        {Tag: "machine-42"},
44
 
                },
45
 
        })
46
 
        c.Assert(results, gc.DeepEquals, params.MachineAgentGetMachinesResults{
47
 
                Machines: []params.MachineAgentGetMachinesResult{
48
 
                        {
49
 
                                Life: "dying",
50
 
                                Jobs: []params.MachineJob{params.JobHostUnits},
51
 
                        },
52
 
                        {Error: apiservertesting.ErrUnauthorized},
53
 
                        {Error: apiservertesting.ErrUnauthorized},
54
 
                },
55
 
        })
56
 
}
57
 
 
58
 
func (s *agentSuite) TestGetNotFoundMachine(c *gc.C) {
59
 
        err := s.machine1.Destroy()
60
 
        c.Assert(err, gc.IsNil)
61
 
        err = s.machine1.EnsureDead()
62
 
        c.Assert(err, gc.IsNil)
63
 
        err = s.machine1.Remove()
64
 
        c.Assert(err, gc.IsNil)
65
 
        results := s.agent.GetMachines(params.Entities{
66
 
                Entities: []params.Entity{{Tag: "machine-1"}},
67
 
        })
68
 
        c.Assert(err, gc.IsNil)
69
 
        c.Assert(results, gc.DeepEquals, params.MachineAgentGetMachinesResults{
70
 
                Machines: []params.MachineAgentGetMachinesResult{{
71
 
                        Error: &params.Error{
72
 
                                Code:    params.CodeNotFound,
73
 
                                Message: "machine 1 not found",
74
 
                        },
75
 
                }},
76
 
        })
77
 
}
78
 
 
79
 
func (s *agentSuite) TestSetPasswords(c *gc.C) {
80
 
        results, err := s.agent.SetPasswords(params.PasswordChanges{
81
 
                Changes: []params.PasswordChange{
82
 
                        {Tag: "machine-0", Password: "xxx-12345678901234567890"},
83
 
                        {Tag: "machine-1", Password: "yyy-12345678901234567890"},
84
 
                        {Tag: "machine-42", Password: "zzz-12345678901234567890"},
85
 
                },
86
 
        })
87
 
        c.Assert(err, gc.IsNil)
88
 
        c.Assert(results, gc.DeepEquals, params.ErrorResults{
89
 
                Results: []params.ErrorResult{
90
 
                        {apiservertesting.ErrUnauthorized},
91
 
                        {nil},
92
 
                        {apiservertesting.ErrUnauthorized},
93
 
                },
94
 
        })
95
 
        err = s.machine1.Refresh()
96
 
        c.Assert(err, gc.IsNil)
97
 
        changed := s.machine1.PasswordValid("yyy-12345678901234567890")
98
 
        c.Assert(changed, gc.Equals, true)
99
 
}