← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/common/machine_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/apiserver/common/machine_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package common_test
 
5
 
 
6
import (
 
7
        "github.com/juju/errors"
 
8
        jc "github.com/juju/testing/checkers"
 
9
        gc "gopkg.in/check.v1"
 
10
 
 
11
        "github.com/juju/juju/apiserver/common"
 
12
        "github.com/juju/juju/state"
 
13
        "github.com/juju/juju/state/multiwatcher"
 
14
)
 
15
 
 
16
type machineSuite struct{}
 
17
 
 
18
var _ = gc.Suite(&machineSuite{})
 
19
 
 
20
func (s *machineSuite) TestMachineJobFromParams(c *gc.C) {
 
21
        var tests = []struct {
 
22
                name multiwatcher.MachineJob
 
23
                want state.MachineJob
 
24
                err  string
 
25
        }{{
 
26
                name: multiwatcher.JobHostUnits,
 
27
                want: state.JobHostUnits,
 
28
        }, {
 
29
                name: multiwatcher.JobManageModel,
 
30
                want: state.JobManageModel,
 
31
        }, {
 
32
                name: "invalid",
 
33
                want: -1,
 
34
                err:  `invalid machine job "invalid"`,
 
35
        }}
 
36
        for _, test := range tests {
 
37
                got, err := common.MachineJobFromParams(test.name)
 
38
                if err != nil {
 
39
                        c.Check(err, gc.ErrorMatches, test.err)
 
40
                }
 
41
                c.Check(got, gc.Equals, test.want)
 
42
        }
 
43
}
 
44
 
 
45
func (s *machineSuite) TestDestroyMachines(c *gc.C) {
 
46
        st := mockState{
 
47
                machines: map[string]*mockMachine{
 
48
                        "1": {},
 
49
                        "2": {destroyErr: errors.New("unit exists error")},
 
50
                        "3": {life: state.Dying},
 
51
                },
 
52
        }
 
53
        err := common.MockableDestroyMachines(&st, false, "1", "2", "3", "4")
 
54
 
 
55
        c.Assert(st.machines["1"].Life(), gc.Equals, state.Dying)
 
56
        c.Assert(st.machines["1"].forceDestroyCalled, jc.IsFalse)
 
57
 
 
58
        c.Assert(st.machines["2"].Life(), gc.Equals, state.Alive)
 
59
        c.Assert(st.machines["2"].forceDestroyCalled, jc.IsFalse)
 
60
 
 
61
        c.Assert(st.machines["3"].forceDestroyCalled, jc.IsFalse)
 
62
        c.Assert(st.machines["3"].destroyCalled, jc.IsFalse)
 
63
 
 
64
        c.Assert(err, gc.ErrorMatches, "some machines were not destroyed: unit exists error; machine 4 does not exist")
 
65
}
 
66
 
 
67
func (s *machineSuite) TestForceDestroyMachines(c *gc.C) {
 
68
        st := mockState{
 
69
                machines: map[string]*mockMachine{
 
70
                        "1": {},
 
71
                        "2": {life: state.Dying},
 
72
                },
 
73
        }
 
74
        err := common.MockableDestroyMachines(&st, true, "1", "2")
 
75
 
 
76
        c.Assert(st.machines["1"].Life(), gc.Equals, state.Dying)
 
77
        c.Assert(st.machines["1"].forceDestroyCalled, jc.IsTrue)
 
78
        c.Assert(st.machines["2"].forceDestroyCalled, jc.IsTrue)
 
79
 
 
80
        c.Assert(err, jc.ErrorIsNil)
 
81
}
 
82
 
 
83
type mockState struct {
 
84
        state.State
 
85
        machines map[string]*mockMachine
 
86
}
 
87
 
 
88
func (st *mockState) Machine(id string) (common.Machine, error) {
 
89
        if m, ok := st.machines[id]; ok {
 
90
                return m, nil
 
91
        }
 
92
        return nil, errors.Errorf("machine %s does not exist", id)
 
93
}
 
94
 
 
95
type mockMachine struct {
 
96
        state.Machine
 
97
        life               state.Life
 
98
        destroyErr         error
 
99
        forceDestroyErr    error
 
100
        forceDestroyCalled bool
 
101
        destroyCalled      bool
 
102
}
 
103
 
 
104
func (m *mockMachine) Life() state.Life {
 
105
        return m.life
 
106
}
 
107
 
 
108
func (m *mockMachine) ForceDestroy() error {
 
109
        m.forceDestroyCalled = true
 
110
        if m.forceDestroyErr != nil {
 
111
                return m.forceDestroyErr
 
112
        }
 
113
        m.life = state.Dying
 
114
        return nil
 
115
}
 
116
 
 
117
func (m *mockMachine) Destroy() error {
 
118
        m.destroyCalled = true
 
119
        if m.destroyErr != nil {
 
120
                return m.destroyErr
 
121
        }
 
122
        m.life = state.Dying
 
123
        return nil
 
124
}