← Back to branch summary

~juju-qa/ubuntu/yakkety/juju/2.0-rc3-again

« back to all changes in this revision

Viewing changes to src/launchpad.net/juju-core/environs/config_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-04-24 22:34:47 UTC
  • Revision ID: package-import@ubuntu.com-20130424223447-f0qdji7ubnyo0s71
Tags: upstream-1.10.0.1
Import upstream version 1.10.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/environs/config_test.go
 
1
package environs_test
 
2
 
 
3
import (
 
4
        . "launchpad.net/gocheck"
 
5
        "launchpad.net/juju-core/environs"
 
6
        "launchpad.net/juju-core/environs/config"
 
7
        _ "launchpad.net/juju-core/environs/dummy"
 
8
        "launchpad.net/juju-core/testing"
 
9
        "path/filepath"
 
10
)
 
11
 
 
12
type suite struct{}
 
13
 
 
14
var _ = Suite(suite{})
 
15
 
 
16
var invalidConfigTests = []struct {
 
17
        env string
 
18
        err string
 
19
}{
 
20
        {"'", "YAML error:.*"},
 
21
        {`
 
22
default: unknown
 
23
environments:
 
24
    only:
 
25
        type: unknown
 
26
`, `default environment .* does not exist`,
 
27
        },
 
28
}
 
29
 
 
30
func (suite) TestInvalidConfig(c *C) {
 
31
        for i, t := range invalidConfigTests {
 
32
                c.Logf("running test %v", i)
 
33
                _, err := environs.ReadEnvironsBytes([]byte(t.env))
 
34
                c.Check(err, ErrorMatches, t.err)
 
35
        }
 
36
}
 
37
 
 
38
var invalidEnvTests = []struct {
 
39
        env  string
 
40
        name string
 
41
        err  string
 
42
}{
 
43
        {`
 
44
environments:
 
45
    only:
 
46
        foo: bar
 
47
`, "", `environment "only" has no type`,
 
48
        }, {`
 
49
environments:
 
50
    only:
 
51
        foo: bar
 
52
`, "only", `environment "only" has no type`,
 
53
        }, {`
 
54
environments:
 
55
    only:
 
56
        foo: bar
 
57
        type: crazy
 
58
`, "only", `environment "only" has an unknown provider type "crazy"`,
 
59
        }, {`
 
60
environments:
 
61
    only:
 
62
        type: dummy
 
63
`, "only", `.*state-server: expected bool, got nothing`,
 
64
        }, {`
 
65
environments:
 
66
    only:
 
67
        type: dummy
 
68
        state-server: false
 
69
        unknown-value: causes-an-error
 
70
`, "only", `.*unknown-value: expected nothing, got "causes-an-error"`,
 
71
        },
 
72
}
 
73
 
 
74
func (suite) TestInvalidEnv(c *C) {
 
75
        defer testing.MakeFakeHomeNoEnvironments(c, "only").Restore()
 
76
        for i, t := range invalidEnvTests {
 
77
                c.Logf("running test %v", i)
 
78
                es, err := environs.ReadEnvironsBytes([]byte(t.env))
 
79
                c.Check(err, IsNil)
 
80
                e, err := es.Open(t.name)
 
81
                c.Check(err, ErrorMatches, t.err)
 
82
                c.Check(e, IsNil)
 
83
        }
 
84
}
 
85
 
 
86
var configTests = []struct {
 
87
        env   string
 
88
        check func(c *C, es *environs.Environs)
 
89
}{
 
90
        {`
 
91
environments:
 
92
    only:
 
93
        type: dummy
 
94
        state-server: false
 
95
`, func(c *C, es *environs.Environs) {
 
96
                e, err := es.Open("")
 
97
                c.Assert(err, IsNil)
 
98
                c.Assert(e.Name(), Equals, "only")
 
99
        }}, {`
 
100
default:
 
101
    invalid
 
102
environments:
 
103
    valid:
 
104
        type: dummy
 
105
        state-server: false
 
106
    invalid:
 
107
        type: crazy
 
108
`, func(c *C, es *environs.Environs) {
 
109
                e, err := es.Open("")
 
110
                c.Assert(err, ErrorMatches, `environment "invalid" has an unknown provider type "crazy"`)
 
111
                c.Assert(e, IsNil)
 
112
                e, err = es.Open("valid")
 
113
                c.Assert(err, IsNil)
 
114
                c.Assert(e.Name(), Equals, "valid")
 
115
        }}, {`
 
116
environments:
 
117
    one:
 
118
        type: dummy
 
119
        state-server: false
 
120
    two:
 
121
        type: dummy
 
122
        state-server: false
 
123
`, func(c *C, es *environs.Environs) {
 
124
                e, err := es.Open("")
 
125
                c.Assert(err, ErrorMatches, `no default environment found`)
 
126
                c.Assert(e, IsNil)
 
127
        }},
 
128
}
 
129
 
 
130
func (suite) TestConfig(c *C) {
 
131
        defer testing.MakeFakeHomeNoEnvironments(c, "only", "valid", "one", "two").Restore()
 
132
        for i, t := range configTests {
 
133
                c.Logf("running test %v", i)
 
134
                es, err := environs.ReadEnvironsBytes([]byte(t.env))
 
135
                c.Assert(err, IsNil)
 
136
                t.check(c, es)
 
137
        }
 
138
}
 
139
 
 
140
func (suite) TestDefaultConfigFile(c *C) {
 
141
        defer testing.MakeEmptyFakeHome(c).Restore()
 
142
 
 
143
        env := `
 
144
environments:
 
145
    only:
 
146
        type: dummy
 
147
        state-server: false
 
148
        authorized-keys: i-am-a-key
 
149
`
 
150
        outfile, err := environs.WriteEnvirons("", env)
 
151
        c.Assert(err, IsNil)
 
152
        path := testing.HomePath(".juju", "environments.yaml")
 
153
        c.Assert(path, Equals, outfile)
 
154
 
 
155
        es, err := environs.ReadEnvirons("")
 
156
        c.Assert(err, IsNil)
 
157
        e, err := es.Open("")
 
158
        c.Assert(err, IsNil)
 
159
        c.Assert(e.Name(), Equals, "only")
 
160
}
 
161
 
 
162
func (suite) TestNamedConfigFile(c *C) {
 
163
        defer testing.MakeFakeHomeNoEnvironments(c, "only").Restore()
 
164
 
 
165
        env := `
 
166
environments:
 
167
    only:
 
168
        type: dummy
 
169
        state-server: false
 
170
        authorized-keys: i-am-a-key
 
171
`
 
172
        path := filepath.Join(c.MkDir(), "a-file")
 
173
        outfile, err := environs.WriteEnvirons(path, env)
 
174
        c.Assert(err, IsNil)
 
175
        c.Assert(path, Equals, outfile)
 
176
 
 
177
        es, err := environs.ReadEnvirons(path)
 
178
        c.Assert(err, IsNil)
 
179
        e, err := es.Open("")
 
180
        c.Assert(err, IsNil)
 
181
        c.Assert(e.Name(), Equals, "only")
 
182
}
 
183
 
 
184
func (suite) TestConfigRoundTrip(c *C) {
 
185
        cfg, err := config.New(map[string]interface{}{
 
186
                "name":            "bladaam",
 
187
                "type":            "dummy",
 
188
                "state-server":    false,
 
189
                "authorized-keys": "i-am-a-key",
 
190
                "ca-cert":         testing.CACert,
 
191
                "ca-private-key":  "",
 
192
        })
 
193
        c.Assert(err, IsNil)
 
194
        provider, err := environs.Provider(cfg.Type())
 
195
        c.Assert(err, IsNil)
 
196
        cfg, err = provider.Validate(cfg, nil)
 
197
        c.Assert(err, IsNil)
 
198
        env, err := environs.New(cfg)
 
199
        c.Assert(err, IsNil)
 
200
        c.Assert(cfg.AllAttrs(), DeepEquals, env.Config().AllAttrs())
 
201
}
 
202
 
 
203
func (suite) TestBootstrapConfig(c *C) {
 
204
        defer testing.MakeFakeHomeNoEnvironments(c, "bladaam").Restore()
 
205
        cfg, err := config.New(map[string]interface{}{
 
206
                "name":            "bladaam",
 
207
                "type":            "dummy",
 
208
                "state-server":    false,
 
209
                "admin-secret":    "highly",
 
210
                "secret":          "um",
 
211
                "authorized-keys": "i-am-a-key",
 
212
                "ca-cert":         testing.CACert,
 
213
                "ca-private-key":  testing.CAKey,
 
214
                "agent-version":   "1.2.3",
 
215
        })
 
216
        c.Assert(err, IsNil)
 
217
        cfg1, err := environs.BootstrapConfig(cfg)
 
218
        c.Assert(err, IsNil)
 
219
 
 
220
        expect := cfg.AllAttrs()
 
221
        delete(expect, "secret")
 
222
        expect["admin-secret"] = ""
 
223
        expect["ca-private-key"] = ""
 
224
        c.Assert(cfg1.AllAttrs(), DeepEquals, expect)
 
225
}