~rogpeppe/juju-core/438-local-instance-Addresses

« back to all changes in this revision

Viewing changes to mstate/machine_test.go

mstate: refactor tests like in state.

Tests are refactored into multiple suites to be compatible with
state. See issue 6348053. After mstate replaces state I plan to reverse
the dependencies between suites. Right now each suite embeds an UtilSuite
and has to call UtilSuite.SetUpTest resulting in error prone duplicate
code. Keeping the multiple suites as containers for data and embedding
all suites into a StateSuite shared by all tests is a better design. We
will keep tests in separate files.

R=niemeyer
CC=
https://codereview.appspot.com/6381045

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
package mstate_test
 
2
 
 
3
import (
 
4
        "labix.org/v2/mgo/bson"
 
5
        . "launchpad.net/gocheck"
 
6
        state "launchpad.net/juju-core/mstate"
 
7
        "sort"
 
8
)
 
9
 
 
10
type MachineSuite struct {
 
11
        UtilSuite
 
12
        machine *state.Machine
 
13
}
 
14
 
 
15
var _ = Suite(&MachineSuite{})
 
16
 
 
17
func (s *MachineSuite) SetUpTest(c *C) {
 
18
        s.UtilSuite.SetUpTest(c)
 
19
        var err error
 
20
        s.machine, err = s.State.AddMachine()
 
21
        c.Assert(err, IsNil)
 
22
}
 
23
 
 
24
func (s *MachineSuite) TestMachineInstanceId(c *C) {
 
25
        machine, err := s.State.AddMachine()
 
26
        c.Assert(err, IsNil)
 
27
        err = s.machines.Update(
 
28
                bson.D{{"_id", machine.Id()}},
 
29
                bson.D{{"$set", bson.D{{"instanceid", "spaceship/0"}}}},
 
30
        )
 
31
        c.Assert(err, IsNil)
 
32
 
 
33
        iid, err := machine.InstanceId()
 
34
        c.Assert(err, IsNil)
 
35
        c.Assert(iid, Equals, "spaceship/0")
 
36
}
 
37
 
 
38
func (s *MachineSuite) TestMachineSetInstanceId(c *C) {
 
39
        machine, err := s.State.AddMachine()
 
40
        c.Assert(err, IsNil)
 
41
        err = machine.SetInstanceId("umbrella/0")
 
42
        c.Assert(err, IsNil)
 
43
 
 
44
        n, err := s.machines.Find(bson.D{{"instanceid", "umbrella/0"}}).Count()
 
45
        c.Assert(err, IsNil)
 
46
        c.Assert(n, Equals, 1)
 
47
}
 
48
 
 
49
func (s *MachineSuite) TestMachineUnits(c *C) {
 
50
        // Check that Machine.Units works correctly.
 
51
 
 
52
        // Make three machines, three services and three units for each service;
 
53
        // variously assign units to machines and check that Machine.Units
 
54
        // tells us the right thing.
 
55
 
 
56
        m1 := s.machine
 
57
        m2, err := s.State.AddMachine()
 
58
        c.Assert(err, IsNil)
 
59
        m3, err := s.State.AddMachine()
 
60
        c.Assert(err, IsNil)
 
61
 
 
62
        dummy := s.AddTestingCharm(c, "dummy")
 
63
        logging := s.AddTestingCharm(c, "logging")
 
64
        s0, err := s.State.AddService("s0", dummy)
 
65
        c.Assert(err, IsNil)
 
66
        s1, err := s.State.AddService("s1", dummy)
 
67
        c.Assert(err, IsNil)
 
68
        s2, err := s.State.AddService("s2", dummy)
 
69
        c.Assert(err, IsNil)
 
70
        s3, err := s.State.AddService("s3", logging)
 
71
        c.Assert(err, IsNil)
 
72
 
 
73
        units := make([][]*state.Unit, 4)
 
74
        for i, svc := range []*state.Service{s0, s1, s2} {
 
75
                units[i] = make([]*state.Unit, 3)
 
76
                for j := range units[i] {
 
77
                        units[i][j], err = svc.AddUnit()
 
78
                        c.Assert(err, IsNil)
 
79
                }
 
80
        }
 
81
        // Add the logging units subordinate to the s2 units.
 
82
        units[3] = make([]*state.Unit, 3)
 
83
        for i := range units[3] {
 
84
                units[3][i], err = s3.AddUnitSubordinateTo(units[2][i])
 
85
        }
 
86
 
 
87
        assignments := []struct {
 
88
                machine      *state.Machine
 
89
                units        []*state.Unit
 
90
                subordinates []*state.Unit
 
91
        }{
 
92
                {m1, []*state.Unit{units[0][0]}, nil},
 
93
                {m2, []*state.Unit{units[0][1], units[1][0], units[1][1], units[2][0]}, []*state.Unit{units[3][0]}},
 
94
                {m3, []*state.Unit{units[2][2]}, []*state.Unit{units[3][2]}},
 
95
        }
 
96
 
 
97
        for _, a := range assignments {
 
98
                for _, u := range a.units {
 
99
                        err := u.AssignToMachine(a.machine)
 
100
                        c.Assert(err, IsNil)
 
101
                }
 
102
        }
 
103
 
 
104
        for i, a := range assignments {
 
105
                c.Logf("test %d", i)
 
106
                got, err := a.machine.Units()
 
107
                c.Assert(err, IsNil)
 
108
                expect := sortedUnitNames(append(a.units, a.subordinates...))
 
109
                c.Assert(sortedUnitNames(got), DeepEquals, expect)
 
110
        }
 
111
}
 
112
 
 
113
func sortedUnitNames(units []*state.Unit) []string {
 
114
        names := make([]string, len(units))
 
115
        for i, u := range units {
 
116
                names[i] = u.Name()
 
117
        }
 
118
        sort.Strings(names)
 
119
        return names
 
120
}