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

« back to all changes in this revision

Viewing changes to mstate/service_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
        . "launchpad.net/gocheck"
 
5
        "launchpad.net/juju-core/charm"
 
6
        state "launchpad.net/juju-core/mstate"
 
7
)
 
8
 
 
9
type ServiceSuite struct {
 
10
        UtilSuite
 
11
        charm   *state.Charm
 
12
        service *state.Service
 
13
}
 
14
 
 
15
var _ = Suite(&ServiceSuite{})
 
16
 
 
17
func (s *ServiceSuite) SetUpTest(c *C) {
 
18
        s.UtilSuite.SetUpTest(c)
 
19
        s.charm = s.AddTestingCharm(c, "dummy")
 
20
        var err error
 
21
        s.service, err = s.State.AddService("mysql", s.charm)
 
22
        c.Assert(err, IsNil)
 
23
}
 
24
 
 
25
func (s *ServiceSuite) TestServiceCharm(c *C) {
 
26
        // Check that getting and setting the service charm URL works correctly.
 
27
        testcurl, err := s.service.CharmURL()
 
28
        c.Assert(err, IsNil)
 
29
        c.Assert(testcurl.String(), Equals, s.charm.URL().String())
 
30
 
 
31
        // TODO BUG https://bugs.launchpad.net/juju-core/+bug/1020318
 
32
        testcurl = charm.MustParseURL("local:myseries/mydummy-1")
 
33
        err = s.service.SetCharmURL(testcurl)
 
34
        c.Assert(err, IsNil)
 
35
        testcurl, err = s.service.CharmURL()
 
36
        c.Assert(err, IsNil)
 
37
        c.Assert(testcurl.String(), Equals, "local:myseries/mydummy-1")
 
38
}
 
39
 
 
40
func (s *ServiceSuite) TestAddUnit(c *C) {
 
41
        // Check that principal units can be added on their own.
 
42
        unitZero, err := s.service.AddUnit()
 
43
        c.Assert(err, IsNil)
 
44
        c.Assert(unitZero.Name(), Equals, "mysql/0")
 
45
        principal := unitZero.IsPrincipal()
 
46
        c.Assert(principal, Equals, true)
 
47
        unitOne, err := s.service.AddUnit()
 
48
        c.Assert(err, IsNil)
 
49
        c.Assert(unitOne.Name(), Equals, "mysql/1")
 
50
        principal = unitOne.IsPrincipal()
 
51
        c.Assert(principal, Equals, true)
 
52
 
 
53
        // Check that principal units cannot be added to principal units.
 
54
        _, err = s.service.AddUnitSubordinateTo(unitZero)
 
55
        c.Assert(err, ErrorMatches, `can't add unit of principal service "mysql" as a subordinate of "mysql/0"`)
 
56
 
 
57
        // Assign the principal unit to a machine.
 
58
        m, err := s.State.AddMachine()
 
59
        c.Assert(err, IsNil)
 
60
        err = unitZero.AssignToMachine(m)
 
61
        c.Assert(err, IsNil)
 
62
 
 
63
        // Add a subordinate service.
 
64
        subCharm := s.AddTestingCharm(c, "logging")
 
65
        logging, err := s.State.AddService("logging", subCharm)
 
66
        c.Assert(err, IsNil)
 
67
 
 
68
        // Check that subordinate units can be added to principal units
 
69
        subZero, err := logging.AddUnitSubordinateTo(unitZero)
 
70
        c.Assert(err, IsNil)
 
71
        c.Assert(subZero.Name(), Equals, "logging/0")
 
72
        principal = subZero.IsPrincipal()
 
73
        c.Assert(principal, Equals, false)
 
74
 
 
75
        // Check the subordinate unit has been assigned its principal's machine.
 
76
        id, err := subZero.AssignedMachineId()
 
77
        c.Assert(err, IsNil)
 
78
        c.Assert(id, Equals, m.Id())
 
79
 
 
80
        // Check that subordinate units must be added to other units.
 
81
        _, err = logging.AddUnit()
 
82
        c.Assert(err, ErrorMatches, `cannot directly add units to subordinate service "logging"`)
 
83
 
 
84
        // Check that subordinate units cannnot be added to subordinate units.
 
85
        _, err = logging.AddUnitSubordinateTo(subZero)
 
86
        c.Assert(err, ErrorMatches, "a subordinate unit must be added to a principal unit")
 
87
}
 
88
 
 
89
func (s *ServiceSuite) TestReadUnit(c *C) {
 
90
        _, err := s.service.AddUnit()
 
91
        c.Assert(err, IsNil)
 
92
        _, err = s.service.AddUnit()
 
93
        c.Assert(err, IsNil)
 
94
        // Check that retrieving a unit works correctly.
 
95
        unit, err := s.service.Unit("mysql/0")
 
96
        c.Assert(err, IsNil)
 
97
        c.Assert(unit.Name(), Equals, "mysql/0")
 
98
 
 
99
        // Check that retrieving a non-existent or an invalidly
 
100
        // named unit fail nicely.
 
101
        unit, err = s.service.Unit("mysql")
 
102
        c.Assert(err, ErrorMatches, `can't get unit "mysql" from service "mysql":.*`)
 
103
        unit, err = s.service.Unit("mysql/0/0")
 
104
        c.Assert(err, ErrorMatches, `can't get unit "mysql/0/0" from service "mysql": .*`)
 
105
        unit, err = s.service.Unit("pressword/0")
 
106
        c.Assert(err, ErrorMatches, `can't get unit "pressword/0" from service "mysql": .*`)
 
107
 
 
108
        // Add another service to check units are not misattributed.
 
109
        mysql, err := s.State.AddService("wordpress", s.charm)
 
110
        c.Assert(err, IsNil)
 
111
        _, err = mysql.AddUnit()
 
112
        c.Assert(err, IsNil)
 
113
 
 
114
        // BUG: use error strings from state.
 
115
        unit, err = s.service.Unit("wordpress/0")
 
116
        c.Assert(err, ErrorMatches, `can't get unit "wordpress/0" from service "mysql": .*`)
 
117
 
 
118
        // Check that retrieving all units works.
 
119
        units, err := s.service.AllUnits()
 
120
        c.Assert(err, IsNil)
 
121
        c.Assert(len(units), Equals, 2)
 
122
        c.Assert(units[0].Name(), Equals, "mysql/0")
 
123
        c.Assert(units[1].Name(), Equals, "mysql/1")
 
124
}
 
125
 
 
126
func (s *ServiceSuite) TestRemoveUnit(c *C) {
 
127
        _, err := s.service.AddUnit()
 
128
        c.Assert(err, IsNil)
 
129
        _, err = s.service.AddUnit()
 
130
        c.Assert(err, IsNil)
 
131
 
 
132
        // Check that removing a unit works.
 
133
        unit, err := s.service.Unit("mysql/0")
 
134
        c.Assert(err, IsNil)
 
135
        err = s.service.RemoveUnit(unit)
 
136
        c.Assert(err, IsNil)
 
137
 
 
138
        units, err := s.service.AllUnits()
 
139
        c.Assert(err, IsNil)
 
140
        c.Assert(units, HasLen, 1)
 
141
        c.Assert(units[0].Name(), Equals, "mysql/1")
 
142
 
 
143
        // Check that removing a non-existent unit fails nicely.
 
144
        // TODO improve error message.
 
145
        // BUG: use error strings from state
 
146
        err = s.service.RemoveUnit(unit)
 
147
        c.Assert(err, ErrorMatches, `can't remove unit "mysql/0": .*`)
 
148
}