← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/api/provisioner/provisioner_test.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/api/provisioner/provisioner_test.go
17
17
        "github.com/juju/utils"
18
18
        "github.com/juju/utils/arch"
19
19
        "github.com/juju/utils/series"
 
20
        "github.com/juju/version"
20
21
        gc "gopkg.in/check.v1"
21
22
 
22
23
        "github.com/juju/juju/api"
32
33
        "github.com/juju/juju/mongo"
33
34
        "github.com/juju/juju/network"
34
35
        "github.com/juju/juju/state"
 
36
        "github.com/juju/juju/status"
35
37
        "github.com/juju/juju/storage/poolmanager"
36
38
        "github.com/juju/juju/storage/provider"
37
39
        coretools "github.com/juju/juju/tools"
38
 
        "github.com/juju/juju/version"
 
40
        jujuversion "github.com/juju/juju/version"
39
41
        "github.com/juju/juju/watcher/watchertest"
40
42
)
41
43
 
117
119
        apiMachine, err := s.provisioner.Machine(s.machine.Tag().(names.MachineTag))
118
120
        c.Assert(err, jc.ErrorIsNil)
119
121
 
120
 
        status, info, err := apiMachine.Status()
 
122
        machineStatus, info, err := apiMachine.Status()
121
123
        c.Assert(err, jc.ErrorIsNil)
122
 
        c.Assert(status, gc.Equals, params.StatusPending)
 
124
        c.Assert(machineStatus, gc.Equals, status.StatusPending)
123
125
        c.Assert(info, gc.Equals, "")
124
126
 
125
 
        err = apiMachine.SetStatus(params.StatusStarted, "blah", nil)
 
127
        err = apiMachine.SetStatus(status.StatusStarted, "blah", nil)
126
128
        c.Assert(err, jc.ErrorIsNil)
127
129
 
128
 
        status, info, err = apiMachine.Status()
 
130
        machineStatus, info, err = apiMachine.Status()
129
131
        c.Assert(err, jc.ErrorIsNil)
130
 
        c.Assert(status, gc.Equals, params.StatusStarted)
 
132
        c.Assert(machineStatus, gc.Equals, status.StatusStarted)
131
133
        c.Assert(info, gc.Equals, "blah")
132
134
        statusInfo, err := s.machine.Status()
133
135
        c.Assert(err, jc.ErrorIsNil)
134
136
        c.Assert(statusInfo.Data, gc.HasLen, 0)
135
137
}
136
138
 
 
139
func (s *provisionerSuite) TestGetSetInstanceStatus(c *gc.C) {
 
140
        apiMachine, err := s.provisioner.Machine(s.machine.Tag().(names.MachineTag))
 
141
        c.Assert(err, jc.ErrorIsNil)
 
142
 
 
143
        instanceStatus, info, err := apiMachine.InstanceStatus()
 
144
        c.Assert(err, jc.ErrorIsNil)
 
145
        c.Assert(instanceStatus, gc.Equals, status.StatusPending)
 
146
        c.Assert(info, gc.Equals, "")
 
147
        err = apiMachine.SetInstanceStatus(status.StatusStarted, "blah", nil)
 
148
        c.Assert(err, jc.ErrorIsNil)
 
149
        instanceStatus, info, err = apiMachine.InstanceStatus()
 
150
        c.Assert(err, jc.ErrorIsNil)
 
151
        c.Assert(instanceStatus, gc.Equals, status.StatusStarted)
 
152
        c.Assert(info, gc.Equals, "blah")
 
153
        statusInfo, err := s.machine.InstanceStatus()
 
154
        c.Assert(err, jc.ErrorIsNil)
 
155
        c.Assert(statusInfo.Data, gc.HasLen, 0)
 
156
}
 
157
 
137
158
func (s *provisionerSuite) TestGetSetStatusWithData(c *gc.C) {
138
159
        apiMachine, err := s.provisioner.Machine(s.machine.Tag().(names.MachineTag))
139
160
        c.Assert(err, jc.ErrorIsNil)
140
161
 
141
 
        err = apiMachine.SetStatus(params.StatusError, "blah", map[string]interface{}{"foo": "bar"})
 
162
        err = apiMachine.SetStatus(status.StatusError, "blah", map[string]interface{}{"foo": "bar"})
142
163
        c.Assert(err, jc.ErrorIsNil)
143
164
 
144
 
        status, info, err := apiMachine.Status()
 
165
        machineStatus, info, err := apiMachine.Status()
145
166
        c.Assert(err, jc.ErrorIsNil)
146
 
        c.Assert(status, gc.Equals, params.StatusError)
 
167
        c.Assert(machineStatus, gc.Equals, status.StatusError)
147
168
        c.Assert(info, gc.Equals, "blah")
148
169
        statusInfo, err := s.machine.Status()
149
170
        c.Assert(err, jc.ErrorIsNil)
153
174
func (s *provisionerSuite) TestMachinesWithTransientErrors(c *gc.C) {
154
175
        machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
155
176
        c.Assert(err, jc.ErrorIsNil)
156
 
        err = machine.SetStatus(state.StatusError, "blah", map[string]interface{}{"transient": true})
 
177
        err = machine.SetStatus(status.StatusError, "blah", map[string]interface{}{"transient": true})
157
178
        c.Assert(err, jc.ErrorIsNil)
158
179
        machines, info, err := s.provisioner.MachinesWithTransientErrors()
159
180
        c.Assert(err, jc.ErrorIsNil)
547
568
 
548
569
        // Change something other than the containers and make sure it's
549
570
        // not detected.
550
 
        err = apiMachine.SetStatus(params.StatusStarted, "not really", nil)
 
571
        err = apiMachine.SetStatus(status.StatusStarted, "not really", nil)
551
572
        c.Assert(err, jc.ErrorIsNil)
552
573
        wc.AssertNoChange()
553
574
 
799
820
 
800
821
func (s *provisionerSuite) testFindTools(c *gc.C, matchArch bool, apiError, logicError error) {
801
822
        current := version.Binary{
802
 
                Number: version.Current,
 
823
                Number: jujuversion.Current,
803
824
                Arch:   arch.HostArch(),
804
825
                Series: series.HostSeries(),
805
826
        }
816
837
                called = true
817
838
                c.Assert(request, gc.Equals, "FindTools")
818
839
                expected := params.FindToolsParams{
819
 
                        Number:       version.Current,
 
840
                        Number:       jujuversion.Current,
820
841
                        Series:       series.HostSeries(),
821
842
                        Arch:         a,
822
843
                        MinorVersion: -1,
830
851
                }
831
852
                return apiError
832
853
        })
833
 
        apiList, err := s.provisioner.FindTools(version.Current, series.HostSeries(), a)
 
854
        apiList, err := s.provisioner.FindTools(jujuversion.Current, series.HostSeries(), a)
834
855
        c.Assert(called, jc.IsTrue)
835
856
        if apiError != nil {
836
857
                c.Assert(err, gc.Equals, apiError)