← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/worker/migrationflag/manifold_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/migrationflag/manifold_test.go
 
1
// Copyright 2016 Canonical Ltd.
 
2
// Licensed under the LGPLv3, see LICENCE file for details.
 
3
 
 
4
package migrationflag_test
 
5
 
 
6
import (
 
7
        "github.com/juju/errors"
 
8
        "github.com/juju/testing"
 
9
        jc "github.com/juju/testing/checkers"
 
10
        gc "gopkg.in/check.v1"
 
11
 
 
12
        "github.com/juju/juju/api/base"
 
13
        "github.com/juju/juju/cmd/jujud/agent/engine"
 
14
        "github.com/juju/juju/worker"
 
15
        "github.com/juju/juju/worker/dependency"
 
16
        dt "github.com/juju/juju/worker/dependency/testing"
 
17
        "github.com/juju/juju/worker/migrationflag"
 
18
)
 
19
 
 
20
type ManifoldSuite struct {
 
21
        testing.IsolationSuite
 
22
}
 
23
 
 
24
var _ = gc.Suite(&ManifoldSuite{})
 
25
 
 
26
func (*ManifoldSuite) TestInputs(c *gc.C) {
 
27
        manifold := migrationflag.Manifold(validManifoldConfig())
 
28
        c.Check(manifold.Inputs, jc.DeepEquals, []string{"api-caller"})
 
29
}
 
30
 
 
31
func (*ManifoldSuite) TestOutputBadWorker(c *gc.C) {
 
32
        manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
 
33
        in := &struct{ worker.Worker }{}
 
34
        var out engine.Flag
 
35
        err := manifold.Output(in, &out)
 
36
        c.Check(err, gc.ErrorMatches, "expected in to implement Flag; got a .*")
 
37
}
 
38
 
 
39
func (*ManifoldSuite) TestOutputBadTarget(c *gc.C) {
 
40
        manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
 
41
        in := &migrationflag.Worker{}
 
42
        var out bool
 
43
        err := manifold.Output(in, &out)
 
44
        c.Check(err, gc.ErrorMatches, "expected out to be a \\*Flag; got a .*")
 
45
}
 
46
 
 
47
func (*ManifoldSuite) TestOutputBadInput(c *gc.C) {
 
48
        manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
 
49
        in := &migrationflag.Worker{}
 
50
        var out engine.Flag
 
51
        err := manifold.Output(in, &out)
 
52
        c.Check(err, jc.ErrorIsNil)
 
53
        c.Check(out, gc.Equals, in)
 
54
}
 
55
 
 
56
func (*ManifoldSuite) TestFilterNil(c *gc.C) {
 
57
        manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
 
58
        err := manifold.Filter(nil)
 
59
        c.Check(err, jc.ErrorIsNil)
 
60
}
 
61
 
 
62
func (*ManifoldSuite) TestFilterErrChanged(c *gc.C) {
 
63
        manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
 
64
        err := manifold.Filter(migrationflag.ErrChanged)
 
65
        c.Check(err, gc.Equals, dependency.ErrBounce)
 
66
}
 
67
 
 
68
func (*ManifoldSuite) TestFilterOther(c *gc.C) {
 
69
        manifold := migrationflag.Manifold(migrationflag.ManifoldConfig{})
 
70
        expect := errors.New("whatever")
 
71
        actual := manifold.Filter(expect)
 
72
        c.Check(actual, gc.Equals, expect)
 
73
}
 
74
 
 
75
func (*ManifoldSuite) TestStartMissingAPICallerName(c *gc.C) {
 
76
        config := validManifoldConfig()
 
77
        config.APICallerName = ""
 
78
        checkManifoldNotValid(c, config, "empty APICallerName not valid")
 
79
}
 
80
 
 
81
func (*ManifoldSuite) TestStartMissingCheck(c *gc.C) {
 
82
        config := validManifoldConfig()
 
83
        config.Check = nil
 
84
        checkManifoldNotValid(c, config, "nil Check not valid")
 
85
}
 
86
 
 
87
func (*ManifoldSuite) TestStartMissingNewFacade(c *gc.C) {
 
88
        config := validManifoldConfig()
 
89
        config.NewFacade = nil
 
90
        checkManifoldNotValid(c, config, "nil NewFacade not valid")
 
91
}
 
92
 
 
93
func (*ManifoldSuite) TestStartMissingNewWorker(c *gc.C) {
 
94
        config := validManifoldConfig()
 
95
        config.NewWorker = nil
 
96
        checkManifoldNotValid(c, config, "nil NewWorker not valid")
 
97
}
 
98
 
 
99
func (*ManifoldSuite) TestStartMissingAPICaller(c *gc.C) {
 
100
        context := dt.StubContext(nil, map[string]interface{}{
 
101
                "api-caller": dependency.ErrMissing,
 
102
        })
 
103
        manifold := migrationflag.Manifold(validManifoldConfig())
 
104
 
 
105
        worker, err := manifold.Start(context)
 
106
        c.Check(worker, gc.IsNil)
 
107
        c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
 
108
}
 
109
 
 
110
func (*ManifoldSuite) TestStartNewFacadeError(c *gc.C) {
 
111
        expectCaller := &stubCaller{}
 
112
        context := dt.StubContext(nil, map[string]interface{}{
 
113
                "api-caller": expectCaller,
 
114
        })
 
115
        config := validManifoldConfig()
 
116
        config.NewFacade = func(caller base.APICaller) (migrationflag.Facade, error) {
 
117
                c.Check(caller, gc.Equals, expectCaller)
 
118
                return nil, errors.New("bort")
 
119
        }
 
120
        manifold := migrationflag.Manifold(config)
 
121
 
 
122
        worker, err := manifold.Start(context)
 
123
        c.Check(worker, gc.IsNil)
 
124
        c.Check(err, gc.ErrorMatches, "bort")
 
125
}
 
126
 
 
127
func (*ManifoldSuite) TestStartNewWorkerError(c *gc.C) {
 
128
        context := dt.StubContext(nil, map[string]interface{}{
 
129
                "api-caller": &stubCaller{},
 
130
        })
 
131
        expectFacade := &struct{ migrationflag.Facade }{}
 
132
        config := validManifoldConfig()
 
133
        config.NewFacade = func(base.APICaller) (migrationflag.Facade, error) {
 
134
                return expectFacade, nil
 
135
        }
 
136
        config.NewWorker = func(workerConfig migrationflag.Config) (worker.Worker, error) {
 
137
                c.Check(workerConfig.Facade, gc.Equals, expectFacade)
 
138
                c.Check(workerConfig.Model, gc.Equals, validUUID)
 
139
                c.Check(workerConfig.Check, gc.NotNil) // uncomparable
 
140
                return nil, errors.New("snerk")
 
141
        }
 
142
        manifold := migrationflag.Manifold(config)
 
143
 
 
144
        worker, err := manifold.Start(context)
 
145
        c.Check(worker, gc.IsNil)
 
146
        c.Check(err, gc.ErrorMatches, "snerk")
 
147
}
 
148
 
 
149
func (*ManifoldSuite) TestStartSuccess(c *gc.C) {
 
150
        context := dt.StubContext(nil, map[string]interface{}{
 
151
                "api-caller": &stubCaller{},
 
152
        })
 
153
        expectWorker := &struct{ worker.Worker }{}
 
154
        config := validManifoldConfig()
 
155
        config.NewFacade = func(base.APICaller) (migrationflag.Facade, error) {
 
156
                return &struct{ migrationflag.Facade }{}, nil
 
157
        }
 
158
        config.NewWorker = func(migrationflag.Config) (worker.Worker, error) {
 
159
                return expectWorker, nil
 
160
        }
 
161
        manifold := migrationflag.Manifold(config)
 
162
 
 
163
        worker, err := manifold.Start(context)
 
164
        c.Check(err, jc.ErrorIsNil)
 
165
        c.Check(worker, gc.Equals, expectWorker)
 
166
}