← Back to branch summary

~rogpeppe/juju-core/azure

« back to all changes in this revision

Viewing changes to cmd/juju/addunit_test.go

[r=wallyworld] add-unit supports the force-machine argument

Semantics are the same as for deploy. Only one unit
can be added with force-machine, or else an error
occurs.

https://codereview.appspot.com/10962046/

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmd/juju/addunit_test.go
6
6
import (
7
7
        . "launchpad.net/gocheck"
8
8
        "launchpad.net/juju-core/charm"
 
9
        "launchpad.net/juju-core/instance"
9
10
        jujutesting "launchpad.net/juju-core/juju/testing"
 
11
        "launchpad.net/juju-core/state"
10
12
        "launchpad.net/juju-core/testing"
11
13
)
12
14
 
16
18
 
17
19
var _ = Suite(&AddUnitSuite{})
18
20
 
 
21
var initAddUnitErrorTests = []struct {
 
22
        args []string
 
23
        err  string
 
24
}{
 
25
        {
 
26
                args: []string{"some-service-name", "-n", "0"},
 
27
                err:  `--num-units must be a positive integer`,
 
28
        }, {
 
29
                args: []string{"some-service-name", "--force-machine", "bigglesplop"},
 
30
                err:  `invalid --force-machine parameter "bigglesplop"`,
 
31
        }, {
 
32
                args: []string{"some-service-name", "-n", "2", "--force-machine", "123"},
 
33
                err:  `cannot use --num-units > 1 with --force-machine`,
 
34
        },
 
35
}
 
36
 
 
37
func (s *AddUnitSuite) TestInitErrors(c *C) {
 
38
        for i, t := range initAddUnitErrorTests {
 
39
                c.Logf("test %d", i)
 
40
                err := testing.InitCommand(&AddUnitCommand{}, t.args)
 
41
                c.Check(err, ErrorMatches, t.err)
 
42
        }
 
43
}
 
44
 
19
45
func runAddUnit(c *C, args ...string) error {
20
46
        _, err := testing.RunCommand(c, &AddUnitCommand{}, args)
21
47
        return err
22
48
}
23
49
 
24
 
func (s *AddUnitSuite) TestAddUnit(c *C) {
 
50
func (s *AddUnitSuite) setupService(c *C) *charm.URL {
25
51
        testing.Charms.BundlePath(s.SeriesPath, "dummy")
26
52
        err := runDeploy(c, "local:dummy", "some-service-name")
27
53
        c.Assert(err, IsNil)
28
54
        curl := charm.MustParseURL("local:precise/dummy-1")
29
55
        s.AssertService(c, "some-service-name", curl, 1, 0)
30
 
 
31
 
        err = runAddUnit(c, "some-service-name")
 
56
        return curl
 
57
}
 
58
 
 
59
func (s *AddUnitSuite) TestAddUnit(c *C) {
 
60
        curl := s.setupService(c)
 
61
 
 
62
        err := runAddUnit(c, "some-service-name")
32
63
        c.Assert(err, IsNil)
33
64
        s.AssertService(c, "some-service-name", curl, 2, 0)
34
65
 
36
67
        c.Assert(err, IsNil)
37
68
        s.AssertService(c, "some-service-name", curl, 4, 0)
38
69
}
 
70
 
 
71
// assertForceMachine ensures that the result of assigning a unit with --force-machine
 
72
// is as expected.
 
73
func (s *AddUnitSuite) assertForceMachine(c *C, svc *state.Service, expectedNumMachines, unitNum int, machineId string) {
 
74
        units, err := svc.AllUnits()
 
75
        c.Assert(err, IsNil)
 
76
        c.Assert(units, HasLen, expectedNumMachines)
 
77
        mid, err := units[unitNum].AssignedMachineId()
 
78
        c.Assert(err, IsNil)
 
79
        c.Assert(mid, Equals, machineId)
 
80
}
 
81
 
 
82
func (s *AddUnitSuite) TestForceMachine(c *C) {
 
83
        curl := s.setupService(c)
 
84
        machine, err := s.State.AddMachine("precise", state.JobHostUnits)
 
85
        c.Assert(err, IsNil)
 
86
        machine2, err := s.State.AddMachine("precise", state.JobHostUnits)
 
87
        c.Assert(err, IsNil)
 
88
 
 
89
        err = runAddUnit(c, "some-service-name", "--force-machine", machine2.Id())
 
90
        c.Assert(err, IsNil)
 
91
        err = runAddUnit(c, "some-service-name", "--force-machine", machine.Id())
 
92
        c.Assert(err, IsNil)
 
93
        svc, _ := s.AssertService(c, "some-service-name", curl, 3, 0)
 
94
        s.assertForceMachine(c, svc, 3, 1, machine2.Id())
 
95
        s.assertForceMachine(c, svc, 3, 2, machine.Id())
 
96
}
 
97
 
 
98
func (s *AddUnitSuite) TestForceMachineExistingContainer(c *C) {
 
99
        curl := s.setupService(c)
 
100
        machine, err := s.State.AddMachine("precise", state.JobHostUnits)
 
101
        c.Assert(err, IsNil)
 
102
        params := &state.AddMachineParams{
 
103
                ParentId:      machine.Id(),
 
104
                Series:        "precise",
 
105
                ContainerType: instance.LXC,
 
106
                Jobs:          []state.MachineJob{state.JobHostUnits},
 
107
        }
 
108
        container, err := s.State.AddMachineWithConstraints(params)
 
109
        c.Assert(err, IsNil)
 
110
 
 
111
        err = runAddUnit(c, "some-service-name", "--force-machine", container.Id())
 
112
        c.Assert(err, IsNil)
 
113
        err = runAddUnit(c, "some-service-name", "--force-machine", machine.Id())
 
114
        c.Assert(err, IsNil)
 
115
        svc, _ := s.AssertService(c, "some-service-name", curl, 3, 0)
 
116
        s.assertForceMachine(c, svc, 3, 1, container.Id())
 
117
        s.assertForceMachine(c, svc, 3, 2, machine.Id())
 
118
}
 
119
 
 
120
func (s *AddUnitSuite) TestForceMachineNewContainer(c *C) {
 
121
        curl := s.setupService(c)
 
122
        machine, err := s.State.AddMachine("precise", state.JobHostUnits)
 
123
        c.Assert(err, IsNil)
 
124
 
 
125
        err = runAddUnit(c, "some-service-name", "--force-machine", "lxc:"+machine.Id())
 
126
        c.Assert(err, IsNil)
 
127
        err = runAddUnit(c, "some-service-name", "--force-machine", machine.Id())
 
128
        c.Assert(err, IsNil)
 
129
        svc, _ := s.AssertService(c, "some-service-name", curl, 3, 0)
 
130
        s.assertForceMachine(c, svc, 3, 1, machine.Id()+"/lxc/0")
 
131
        s.assertForceMachine(c, svc, 3, 2, machine.Id())
 
132
}