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

« back to all changes in this revision

Viewing changes to mstate/assign_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
        state "launchpad.net/juju-core/mstate"
 
6
)
 
7
 
 
8
type AssignSuite struct {
 
9
        UtilSuite
 
10
        charm   *state.Charm
 
11
        service *state.Service
 
12
        unit    *state.Unit
 
13
}
 
14
 
 
15
var _ = Suite(&AssignSuite{})
 
16
 
 
17
func (s *AssignSuite) 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("wordpress", s.charm)
 
22
        c.Assert(err, IsNil)
 
23
        s.unit, err = s.service.AddUnit()
 
24
        c.Assert(err, IsNil)
 
25
        // Create root machine that shouldn't be used unless requested explicitly.
 
26
        _, err = s.State.AddMachine()
 
27
        c.Assert(err, IsNil)
 
28
}
 
29
 
 
30
func (s *AssignSuite) TestUnassignUnitFromMachineWithoutBeingAssigned(c *C) {
 
31
        // When unassigning a machine from a unit, it is possible that
 
32
        // the machine has not been previously assigned, or that it
 
33
        // was assigned but the state changed beneath us.  In either
 
34
        // case, the end state is the intended state, so we simply
 
35
        // move forward without any errors here, to avoid having to
 
36
        // handle the extra complexity of dealing with the concurrency
 
37
        // problems.
 
38
        err := s.unit.UnassignFromMachine()
 
39
        c.Assert(err, IsNil)
 
40
 
 
41
        // Check that the unit has no machine assigned.
 
42
        _, err = s.unit.AssignedMachineId()
 
43
        c.Assert(err, ErrorMatches, `can't get machine id of unit "wordpress/0": unit not assigned to machine`)
 
44
}
 
45
 
 
46
func (s *AssignSuite) TestAssignUnitToMachineAgainFails(c *C) {
 
47
        // Check that assigning an already assigned unit to
 
48
        // a machine fails if it isn't precisely the same
 
49
        // machine.
 
50
        machineOne, err := s.State.AddMachine()
 
51
        c.Assert(err, IsNil)
 
52
        machineTwo, err := s.State.AddMachine()
 
53
        c.Assert(err, IsNil)
 
54
 
 
55
        err = s.unit.AssignToMachine(machineOne)
 
56
        c.Assert(err, IsNil)
 
57
 
 
58
        // Assigning the unit to the same machine should return no error.
 
59
        err = s.unit.AssignToMachine(machineOne)
 
60
        c.Assert(err, IsNil)
 
61
 
 
62
        // Assigning the unit to a different machine should fail.
 
63
        // BUG: use error strings from state.
 
64
        err = s.unit.AssignToMachine(machineTwo)
 
65
        c.Assert(err, ErrorMatches, `can't assign unit "wordpress/0" to machine 2: .*`)
 
66
 
 
67
        machineId, err := s.unit.AssignedMachineId()
 
68
        c.Assert(err, IsNil)
 
69
        c.Assert(machineId, Equals, 1)
 
70
}