← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/worker/conv2state/converter_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/worker/conv2state/converter_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package conv2state
 
5
 
 
6
import (
 
7
        stderrs "errors"
 
8
        "testing"
 
9
 
 
10
        "github.com/juju/errors"
 
11
        jc "github.com/juju/testing/checkers"
 
12
        gc "gopkg.in/check.v1"
 
13
        "gopkg.in/juju/names.v2"
 
14
 
 
15
        "github.com/juju/juju/apiserver/params"
 
16
        "github.com/juju/juju/state/multiwatcher"
 
17
        coretesting "github.com/juju/juju/testing"
 
18
)
 
19
 
 
20
var _ = gc.Suite(&Suite{})
 
21
 
 
22
func TestPackage(t *testing.T) {
 
23
        gc.TestingT(t)
 
24
}
 
25
 
 
26
type Suite struct {
 
27
        coretesting.BaseSuite
 
28
}
 
29
 
 
30
func (Suite) TestSetUp(c *gc.C) {
 
31
        a := &fakeAgent{tag: names.NewMachineTag("1")}
 
32
        m := &fakeMachine{}
 
33
        mr := &fakeMachiner{m: m}
 
34
        conv := converter{machiner: mr, agent: a}
 
35
        w, err := conv.SetUp()
 
36
        c.Assert(err, gc.IsNil)
 
37
        c.Assert(conv.machine, gc.Equals, m)
 
38
        c.Assert(mr.gotTag, gc.Equals, a.tag.(names.MachineTag))
 
39
        c.Assert(w, gc.Equals, m.w)
 
40
}
 
41
 
 
42
func (Suite) TestSetupMachinerErr(c *gc.C) {
 
43
        a := &fakeAgent{tag: names.NewMachineTag("1")}
 
44
        mr := &fakeMachiner{err: stderrs.New("foo")}
 
45
        conv := converter{machiner: mr, agent: a}
 
46
        w, err := conv.SetUp()
 
47
        c.Assert(errors.Cause(err), gc.Equals, mr.err)
 
48
        c.Assert(mr.gotTag, gc.Equals, a.tag.(names.MachineTag))
 
49
        c.Assert(w, gc.IsNil)
 
50
}
 
51
 
 
52
func (Suite) TestSetupWatchErr(c *gc.C) {
 
53
        a := &fakeAgent{tag: names.NewMachineTag("1")}
 
54
        m := &fakeMachine{watchErr: stderrs.New("foo")}
 
55
        mr := &fakeMachiner{m: m}
 
56
        conv := &converter{machiner: mr, agent: a}
 
57
        w, err := conv.SetUp()
 
58
        c.Assert(errors.Cause(err), gc.Equals, m.watchErr)
 
59
        c.Assert(mr.gotTag, gc.Equals, a.tag.(names.MachineTag))
 
60
        c.Assert(w, gc.IsNil)
 
61
}
 
62
 
 
63
func (s Suite) TestHandle(c *gc.C) {
 
64
        a := &fakeAgent{tag: names.NewMachineTag("1")}
 
65
        jobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits, multiwatcher.JobManageModel}
 
66
        m := &fakeMachine{
 
67
                jobs: &params.JobsResult{Jobs: jobs},
 
68
        }
 
69
        mr := &fakeMachiner{m: m}
 
70
        conv := &converter{machiner: mr, agent: a}
 
71
        _, err := conv.SetUp()
 
72
        c.Assert(err, gc.IsNil)
 
73
        err = conv.Handle(nil)
 
74
        c.Assert(err, gc.IsNil)
 
75
        c.Assert(a.didRestart, jc.IsTrue)
 
76
}
 
77
 
 
78
func (s Suite) TestHandleNoManageEnviron(c *gc.C) {
 
79
        a := &fakeAgent{tag: names.NewMachineTag("1")}
 
80
        jobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits}
 
81
        m := &fakeMachine{
 
82
                jobs: &params.JobsResult{Jobs: jobs},
 
83
        }
 
84
        mr := &fakeMachiner{m: m}
 
85
        conv := &converter{machiner: mr, agent: a}
 
86
        _, err := conv.SetUp()
 
87
        c.Assert(err, gc.IsNil)
 
88
        err = conv.Handle(nil)
 
89
        c.Assert(err, gc.IsNil)
 
90
        c.Assert(a.didRestart, jc.IsFalse)
 
91
}
 
92
 
 
93
func (Suite) TestHandleJobsError(c *gc.C) {
 
94
        a := &fakeAgent{tag: names.NewMachineTag("1")}
 
95
        jobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits, multiwatcher.JobManageModel}
 
96
        m := &fakeMachine{
 
97
                jobs:    &params.JobsResult{Jobs: jobs},
 
98
                jobsErr: errors.New("foo"),
 
99
        }
 
100
        mr := &fakeMachiner{m: m}
 
101
        conv := &converter{machiner: mr, agent: a}
 
102
        _, err := conv.SetUp()
 
103
        c.Assert(err, gc.IsNil)
 
104
        err = conv.Handle(nil)
 
105
        c.Assert(errors.Cause(err), gc.Equals, m.jobsErr)
 
106
        c.Assert(a.didRestart, jc.IsFalse)
 
107
}
 
108
 
 
109
func (s Suite) TestHandleRestartError(c *gc.C) {
 
110
        a := &fakeAgent{
 
111
                tag:        names.NewMachineTag("1"),
 
112
                restartErr: errors.New("foo"),
 
113
        }
 
114
        jobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits, multiwatcher.JobManageModel}
 
115
        m := &fakeMachine{
 
116
                jobs: &params.JobsResult{Jobs: jobs},
 
117
        }
 
118
        mr := &fakeMachiner{m: m}
 
119
        conv := &converter{machiner: mr, agent: a}
 
120
        _, err := conv.SetUp()
 
121
        c.Assert(err, gc.IsNil)
 
122
        err = conv.Handle(nil)
 
123
        c.Assert(errors.Cause(err), gc.Equals, a.restartErr)
 
124
 
 
125
        // We set this to true whenver the function is called, even though we're
 
126
        // returning an error from it.
 
127
        c.Assert(a.didRestart, jc.IsTrue)
 
128
}