← Back to branch summary

~james-page/ubuntu/wily/juju-core/mir-fixes

« back to all changes in this revision

Viewing changes to src/launchpad.net/juju-core/state/api/provisioner/provisioner_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-03-28 08:58:42 UTC
  • mfrom: (1.1.21)
  • Revision ID: package-import@ubuntu.com-20140328085842-cyzrgc120bdfxwj0
Tags: 1.17.7-0ubuntu1
https://launchpad.net/bugs/1294776
https://launchpad.net/bugs/1297077
* New upstream point release, including fixes for:
  - no debug log with all providers on Ubuntu 14.04 (LP: #1294776).
* d/control: Add cpu-checker dependency to juju-local (LP: #1297077).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/state/api/provisioner/provisioner_test.go
15
15
        "launchpad.net/juju-core/juju/testing"
16
16
        "launchpad.net/juju-core/state"
17
17
        "launchpad.net/juju-core/state/api"
18
 
        commontesting "launchpad.net/juju-core/state/api/common/testing"
19
18
        "launchpad.net/juju-core/state/api/params"
20
19
        "launchpad.net/juju-core/state/api/provisioner"
 
20
        apitesting "launchpad.net/juju-core/state/api/testing"
21
21
        statetesting "launchpad.net/juju-core/state/testing"
22
22
        coretesting "launchpad.net/juju-core/testing"
23
23
        "launchpad.net/juju-core/tools"
31
31
 
32
32
type provisionerSuite struct {
33
33
        testing.JujuConnSuite
34
 
        *commontesting.EnvironWatcherTest
 
34
        *apitesting.EnvironWatcherTests
 
35
        *apitesting.APIAddresserTests
35
36
 
36
37
        st      *api.State
37
38
        machine *state.Machine
55
56
        c.Assert(err, gc.IsNil)
56
57
        s.st = s.OpenAPIAsMachine(c, s.machine.Tag(), password, "fake_nonce")
57
58
        c.Assert(s.st, gc.NotNil)
 
59
        err = s.machine.SetAddresses(instance.NewAddresses([]string{"0.1.2.3"}))
 
60
        c.Assert(err, gc.IsNil)
58
61
 
59
62
        // Create the provisioner API facade.
60
63
        s.provisioner = s.st.Provisioner()
61
64
        c.Assert(s.provisioner, gc.NotNil)
62
65
 
63
 
        s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(s.provisioner, s.State, s.BackingState, commontesting.HasSecrets)
 
66
        s.EnvironWatcherTests = apitesting.NewEnvironWatcherTests(s.provisioner, s.BackingState, apitesting.HasSecrets)
 
67
        s.APIAddresserTests = apitesting.NewAPIAddresserTests(s.provisioner, s.BackingState)
64
68
}
65
69
 
66
70
func (s *provisionerSuite) TestMachineTagAndId(c *gc.C) {
84
88
        c.Assert(status, gc.Equals, params.StatusPending)
85
89
        c.Assert(info, gc.Equals, "")
86
90
 
87
 
        err = apiMachine.SetStatus(params.StatusStarted, "blah")
 
91
        err = apiMachine.SetStatus(params.StatusStarted, "blah", nil)
88
92
        c.Assert(err, gc.IsNil)
89
93
 
90
94
        status, info, err = apiMachine.Status()
91
95
        c.Assert(err, gc.IsNil)
92
96
        c.Assert(status, gc.Equals, params.StatusStarted)
93
97
        c.Assert(info, gc.Equals, "blah")
 
98
        _, _, data, err := s.machine.Status()
 
99
        c.Assert(err, gc.IsNil)
 
100
        c.Assert(data, gc.HasLen, 0)
 
101
}
 
102
 
 
103
func (s *provisionerSuite) TestGetSetStatusWithData(c *gc.C) {
 
104
        apiMachine, err := s.provisioner.Machine(s.machine.Tag())
 
105
        c.Assert(err, gc.IsNil)
 
106
 
 
107
        err = apiMachine.SetStatus(params.StatusError, "blah", params.StatusData{"foo": "bar"})
 
108
        c.Assert(err, gc.IsNil)
 
109
 
 
110
        status, info, err := apiMachine.Status()
 
111
        c.Assert(err, gc.IsNil)
 
112
        c.Assert(status, gc.Equals, params.StatusError)
 
113
        c.Assert(info, gc.Equals, "blah")
 
114
        _, _, data, err := s.machine.Status()
 
115
        c.Assert(err, gc.IsNil)
 
116
        c.Assert(data, gc.DeepEquals, params.StatusData{"foo": "bar"})
 
117
}
 
118
 
 
119
func (s *provisionerSuite) TestMachinesWithTransientErrors(c *gc.C) {
 
120
        machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
 
121
        c.Assert(err, gc.IsNil)
 
122
        err = machine.SetStatus(params.StatusError, "blah", params.StatusData{"transient": true})
 
123
        c.Assert(err, gc.IsNil)
 
124
        machines, info, err := s.provisioner.MachinesWithTransientErrors()
 
125
        c.Assert(err, gc.IsNil)
 
126
        c.Assert(machines, gc.HasLen, 1)
 
127
        c.Assert(machines[0].Id(), gc.Equals, "1")
 
128
        c.Assert(info, gc.HasLen, 1)
 
129
        c.Assert(info[0], gc.DeepEquals, params.StatusResult{
 
130
                Id:     "1",
 
131
                Life:   "alive",
 
132
                Status: "error",
 
133
                Info:   "blah",
 
134
                Data:   params.StatusData{"transient": true},
 
135
        })
94
136
}
95
137
 
96
138
func (s *provisionerSuite) TestEnsureDeadAndRemove(c *gc.C) {
250
292
 
251
293
        // Change something other than the containers and make sure it's
252
294
        // not detected.
253
 
        err = apiMachine.SetStatus(params.StatusStarted, "not really")
 
295
        err = apiMachine.SetStatus(params.StatusStarted, "not really", nil)
254
296
        c.Assert(err, gc.IsNil)
255
297
        wc.AssertNoChange()
256
298
 
338
380
        c.Assert(addresses, gc.DeepEquals, stateAddresses)
339
381
}
340
382
 
341
 
func (s *provisionerSuite) TestAPIAddresses(c *gc.C) {
342
 
        err := s.machine.SetAddresses([]instance.Address{
343
 
                instance.NewAddress("0.1.2.3"),
344
 
        })
345
 
        c.Assert(err, gc.IsNil)
346
 
 
347
 
        apiAddresses, err := s.State.APIAddressesFromMachines()
348
 
        c.Assert(err, gc.IsNil)
349
 
 
350
 
        addresses, err := s.provisioner.APIAddresses()
351
 
        c.Assert(err, gc.IsNil)
352
 
        c.Assert(addresses, gc.DeepEquals, apiAddresses)
353
 
}
354
 
 
355
383
func (s *provisionerSuite) TestContainerConfig(c *gc.C) {
356
384
        result, err := s.provisioner.ContainerConfig()
357
385
        c.Assert(err, gc.IsNil)
360
388
        c.Assert(result.SSLHostnameVerification, jc.IsTrue)
361
389
}
362
390
 
363
 
func (s *provisionerSuite) TestCACert(c *gc.C) {
364
 
        caCert, err := s.provisioner.CACert()
365
 
        c.Assert(err, gc.IsNil)
366
 
        c.Assert(caCert, gc.DeepEquals, s.State.CACert())
367
 
}
368
 
 
369
391
func (s *provisionerSuite) TestToolsWrongMachine(c *gc.C) {
370
392
        tools, err := s.provisioner.Tools("42")
371
393
        c.Assert(err, gc.ErrorMatches, "permission denied")