← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/worker/environ/environ_test.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/worker/environ/environ_test.go
10
10
        jc "github.com/juju/testing/checkers"
11
11
        gc "gopkg.in/check.v1"
12
12
 
 
13
        "github.com/juju/juju/environs"
 
14
        "github.com/juju/juju/environs/config"
13
15
        coretesting "github.com/juju/juju/testing"
14
16
        "github.com/juju/juju/worker/environ"
15
17
        "github.com/juju/juju/worker/workertest"
23
25
 
24
26
func (s *TrackerSuite) TestValidateObserver(c *gc.C) {
25
27
        config := environ.Config{}
26
 
        check := func(err error) {
 
28
        s.testValidate(c, config, func(err error) {
27
29
                c.Check(err, jc.Satisfies, errors.IsNotValid)
28
30
                c.Check(err, gc.ErrorMatches, "nil Observer not valid")
 
31
        })
 
32
}
 
33
 
 
34
func (s *TrackerSuite) TestValidateNewEnvironFunc(c *gc.C) {
 
35
        config := environ.Config{
 
36
                Observer: &runContext{},
29
37
        }
 
38
        s.testValidate(c, config, func(err error) {
 
39
                c.Check(err, jc.Satisfies, errors.IsNotValid)
 
40
                c.Check(err, gc.ErrorMatches, "nil NewEnvironFunc not valid")
 
41
        })
 
42
}
30
43
 
 
44
func (s *TrackerSuite) testValidate(c *gc.C, config environ.Config, check func(err error)) {
31
45
        err := config.Validate()
32
46
        check(err)
33
47
 
44
58
        }
45
59
        fix.Run(c, func(context *runContext) {
46
60
                tracker, err := environ.NewTracker(environ.Config{
47
 
                        Observer: context,
 
61
                        Observer:       context,
 
62
                        NewEnvironFunc: newMockEnviron,
48
63
                })
49
64
                c.Check(err, gc.ErrorMatches, "cannot read environ config: no yuo")
50
65
                c.Check(tracker, gc.IsNil)
51
66
                context.CheckCallNames(c, "ModelConfig")
52
67
        })
53
 
 
54
68
}
55
69
 
56
70
func (s *TrackerSuite) TestModelConfigInvalid(c *gc.C) {
57
 
        fix := &fixture{
58
 
                initialConfig: coretesting.Attrs{
59
 
                        "type": "unknown",
60
 
                },
61
 
        }
 
71
        fix := &fixture{}
62
72
        fix.Run(c, func(context *runContext) {
63
73
                tracker, err := environ.NewTracker(environ.Config{
64
74
                        Observer: context,
 
75
                        NewEnvironFunc: func(*config.Config) (environs.Environ, error) {
 
76
                                return nil, errors.NotValidf("config")
 
77
                        },
65
78
                })
66
 
                c.Check(err, gc.ErrorMatches, `cannot create environ: no registered provider for "unknown"`)
 
79
                c.Check(err, gc.ErrorMatches, `cannot create environ: config not valid`)
67
80
                c.Check(tracker, gc.IsNil)
68
81
                context.CheckCallNames(c, "ModelConfig")
69
82
        })
70
 
 
71
83
}
72
84
 
73
85
func (s *TrackerSuite) TestModelConfigValid(c *gc.C) {
78
90
        }
79
91
        fix.Run(c, func(context *runContext) {
80
92
                tracker, err := environ.NewTracker(environ.Config{
81
 
                        Observer: context,
 
93
                        Observer:       context,
 
94
                        NewEnvironFunc: newMockEnviron,
82
95
                })
83
96
                c.Assert(err, jc.ErrorIsNil)
84
97
                defer workertest.CleanKill(c, tracker)
97
110
        }
98
111
        fix.Run(c, func(context *runContext) {
99
112
                tracker, err := environ.NewTracker(environ.Config{
100
 
                        Observer: context,
 
113
                        Observer:       context,
 
114
                        NewEnvironFunc: newMockEnviron,
101
115
                })
102
116
                c.Assert(err, jc.ErrorIsNil)
103
117
                defer workertest.DirtyKill(c, tracker)
112
126
        fix := &fixture{}
113
127
        fix.Run(c, func(context *runContext) {
114
128
                tracker, err := environ.NewTracker(environ.Config{
115
 
                        Observer: context,
 
129
                        Observer:       context,
 
130
                        NewEnvironFunc: newMockEnviron,
116
131
                })
117
132
                c.Assert(err, jc.ErrorIsNil)
118
133
                defer workertest.DirtyKill(c, tracker)
132
147
        }
133
148
        fix.Run(c, func(context *runContext) {
134
149
                tracker, err := environ.NewTracker(environ.Config{
135
 
                        Observer: context,
 
150
                        Observer:       context,
 
151
                        NewEnvironFunc: newMockEnviron,
136
152
                })
137
153
                c.Check(err, jc.ErrorIsNil)
138
154
                defer workertest.DirtyKill(c, tracker)
145
161
}
146
162
 
147
163
func (s *TrackerSuite) TestWatchedModelConfigIncompatible(c *gc.C) {
148
 
        fix := &fixture{
149
 
                initialConfig: coretesting.Attrs{
150
 
                        "broken": "SetConfig",
151
 
                },
152
 
        }
 
164
        fix := &fixture{}
153
165
        fix.Run(c, func(context *runContext) {
154
166
                tracker, err := environ.NewTracker(environ.Config{
155
167
                        Observer: context,
 
168
                        NewEnvironFunc: func(*config.Config) (environs.Environ, error) {
 
169
                                env := &mockEnviron{}
 
170
                                env.SetErrors(errors.New("SetConfig is broken"))
 
171
                                return env, nil
 
172
                        },
156
173
                })
157
174
                c.Check(err, jc.ErrorIsNil)
158
175
                defer workertest.DirtyKill(c, tracker)
159
176
 
160
177
                context.SendNotify()
161
178
                err = workertest.CheckKilled(c, tracker)
162
 
                c.Check(err, gc.ErrorMatches, "cannot update environ config: dummy.SetConfig is broken")
 
179
                c.Check(err, gc.ErrorMatches, "cannot update environ config: SetConfig is broken")
163
180
                context.CheckCallNames(c, "ModelConfig", "WatchForModelConfigChanges", "ModelConfig")
164
181
        })
165
182
}
172
189
        }
173
190
        fix.Run(c, func(context *runContext) {
174
191
                tracker, err := environ.NewTracker(environ.Config{
175
 
                        Observer: context,
 
192
                        Observer:       context,
 
193
                        NewEnvironFunc: newMockEnviron,
176
194
                })
177
195
                c.Check(err, jc.ErrorIsNil)
178
196
                defer workertest.CleanKill(c, tracker)