← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/api/provisioner/provisioner_test.go
97
97
 
98
98
        machineStatus, info, err := apiMachine.Status()
99
99
        c.Assert(err, jc.ErrorIsNil)
100
 
        c.Assert(machineStatus, gc.Equals, status.StatusPending)
 
100
        c.Assert(machineStatus, gc.Equals, status.Pending)
101
101
        c.Assert(info, gc.Equals, "")
102
102
 
103
 
        err = apiMachine.SetStatus(status.StatusStarted, "blah", nil)
 
103
        err = apiMachine.SetStatus(status.Started, "blah", nil)
104
104
        c.Assert(err, jc.ErrorIsNil)
105
105
 
106
106
        machineStatus, info, err = apiMachine.Status()
107
107
        c.Assert(err, jc.ErrorIsNil)
108
 
        c.Assert(machineStatus, gc.Equals, status.StatusStarted)
 
108
        c.Assert(machineStatus, gc.Equals, status.Started)
109
109
        c.Assert(info, gc.Equals, "blah")
110
110
        statusInfo, err := s.machine.Status()
111
111
        c.Assert(err, jc.ErrorIsNil)
118
118
 
119
119
        instanceStatus, info, err := apiMachine.InstanceStatus()
120
120
        c.Assert(err, jc.ErrorIsNil)
121
 
        c.Assert(instanceStatus, gc.Equals, status.StatusPending)
 
121
        c.Assert(instanceStatus, gc.Equals, status.Pending)
122
122
        c.Assert(info, gc.Equals, "")
123
 
        err = apiMachine.SetInstanceStatus(status.StatusStarted, "blah", nil)
 
123
        err = apiMachine.SetInstanceStatus(status.Started, "blah", nil)
124
124
        c.Assert(err, jc.ErrorIsNil)
125
125
        instanceStatus, info, err = apiMachine.InstanceStatus()
126
126
        c.Assert(err, jc.ErrorIsNil)
127
 
        c.Assert(instanceStatus, gc.Equals, status.StatusStarted)
 
127
        c.Assert(instanceStatus, gc.Equals, status.Started)
128
128
        c.Assert(info, gc.Equals, "blah")
129
129
        statusInfo, err := s.machine.InstanceStatus()
130
130
        c.Assert(err, jc.ErrorIsNil)
135
135
        apiMachine, err := s.provisioner.Machine(s.machine.Tag().(names.MachineTag))
136
136
        c.Assert(err, jc.ErrorIsNil)
137
137
 
138
 
        err = apiMachine.SetStatus(status.StatusError, "blah", map[string]interface{}{"foo": "bar"})
 
138
        err = apiMachine.SetStatus(status.Error, "blah", map[string]interface{}{"foo": "bar"})
139
139
        c.Assert(err, jc.ErrorIsNil)
140
140
 
141
141
        machineStatus, info, err := apiMachine.Status()
142
142
        c.Assert(err, jc.ErrorIsNil)
143
 
        c.Assert(machineStatus, gc.Equals, status.StatusError)
 
143
        c.Assert(machineStatus, gc.Equals, status.Error)
144
144
        c.Assert(info, gc.Equals, "blah")
145
145
        statusInfo, err := s.machine.Status()
146
146
        c.Assert(err, jc.ErrorIsNil)
152
152
        c.Assert(err, jc.ErrorIsNil)
153
153
        now := time.Now()
154
154
        sInfo := status.StatusInfo{
155
 
                Status:  status.StatusError,
 
155
                Status:  status.Error,
156
156
                Message: "blah",
157
157
                Data:    map[string]interface{}{"transient": true},
158
158
                Since:   &now,
280
280
        c.Assert(err, gc.ErrorMatches, "machine 1 not provisioned")
281
281
        c.Assert(instanceId, gc.Equals, instance.Id(""))
282
282
 
283
 
        hwChars := instance.MustParseHardware("cpu-cores=123", "mem=4G")
 
283
        hwChars := instance.MustParseHardware("cores=123", "mem=4G")
284
284
 
285
285
        volumes := []params.Volume{{
286
286
                VolumeTag: "volume-1-0",
415
415
                SpaceName:        "{{if (lt . 2)}}space1{{else}}space2{{end}}",
416
416
        })
417
417
 
418
 
        cons := constraints.MustParse("cpu-cores=12 mem=8G spaces=^space1,space2")
 
418
        cons := constraints.MustParse("cores=12 mem=8G spaces=^space1,space2")
419
419
        template := state.MachineTemplate{
420
420
                Series:      "quantal",
421
421
                Jobs:        []state.MachineJob{state.JobHostUnits},
474
474
 
475
475
        // Change something other than the containers and make sure it's
476
476
        // not detected.
477
 
        err = apiMachine.SetStatus(status.StatusStarted, "not really", nil)
 
477
        err = apiMachine.SetStatus(status.Started, "not really", nil)
478
478
        c.Assert(err, jc.ErrorIsNil)
479
479
        wc.AssertNoChange()
480
480