← 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/cmd/jujud/bootstrap_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/cmd/jujud/bootstrap_test.go
 
1
package main
 
2
 
 
3
import (
 
4
        "encoding/base64"
 
5
        . "launchpad.net/gocheck"
 
6
        "launchpad.net/goyaml"
 
7
        "launchpad.net/juju-core/constraints"
 
8
        "launchpad.net/juju-core/environs/agent"
 
9
        "launchpad.net/juju-core/state"
 
10
        "launchpad.net/juju-core/testing"
 
11
)
 
12
 
 
13
// We don't want to use JujuConnSuite because it gives us
 
14
// an already-bootstrapped environment.
 
15
type BootstrapSuite struct {
 
16
        testing.LoggingSuite
 
17
        testing.MgoSuite
 
18
        dataDir string
 
19
}
 
20
 
 
21
var _ = Suite(&BootstrapSuite{})
 
22
 
 
23
func (s *BootstrapSuite) SetUpSuite(c *C) {
 
24
        s.LoggingSuite.SetUpSuite(c)
 
25
        s.MgoSuite.SetUpSuite(c)
 
26
}
 
27
 
 
28
func (s *BootstrapSuite) TearDownSuite(c *C) {
 
29
        s.MgoSuite.TearDownSuite(c)
 
30
        s.LoggingSuite.TearDownSuite(c)
 
31
}
 
32
 
 
33
func (s *BootstrapSuite) SetUpTest(c *C) {
 
34
        s.LoggingSuite.SetUpTest(c)
 
35
        s.MgoSuite.SetUpTest(c)
 
36
        s.dataDir = c.MkDir()
 
37
}
 
38
 
 
39
func (s *BootstrapSuite) TearDownTest(c *C) {
 
40
        s.MgoSuite.TearDownTest(c)
 
41
        s.LoggingSuite.TearDownTest(c)
 
42
}
 
43
 
 
44
func (s *BootstrapSuite) initBootstrapCommand(c *C, args ...string) (*agent.Conf, *BootstrapCommand, error) {
 
45
        conf := &agent.Conf{
 
46
                DataDir: s.dataDir,
 
47
                StateInfo: &state.Info{
 
48
                        Tag:    "bootstrap",
 
49
                        Addrs:  []string{testing.MgoAddr},
 
50
                        CACert: []byte(testing.CACert),
 
51
                },
 
52
        }
 
53
        err := conf.Write()
 
54
        c.Assert(err, IsNil)
 
55
        cmd := &BootstrapCommand{}
 
56
        err = testing.InitCommand(cmd, append([]string{"--data-dir", s.dataDir}, args...))
 
57
        return conf, cmd, err
 
58
}
 
59
 
 
60
func (s *BootstrapSuite) TestInitializeEnvironment(c *C) {
 
61
        _, cmd, err := s.initBootstrapCommand(c, "--env-config", testConfig)
 
62
        c.Assert(err, IsNil)
 
63
        err = cmd.Run(nil)
 
64
        c.Assert(err, IsNil)
 
65
 
 
66
        st, err := state.Open(&state.Info{
 
67
                Addrs:  []string{testing.MgoAddr},
 
68
                CACert: []byte(testing.CACert),
 
69
        }, state.DefaultDialOpts())
 
70
        c.Assert(err, IsNil)
 
71
        defer st.Close()
 
72
        machines, err := st.AllMachines()
 
73
        c.Assert(err, IsNil)
 
74
        c.Assert(machines, HasLen, 1)
 
75
 
 
76
        instid, ok := machines[0].InstanceId()
 
77
        c.Assert(ok, Equals, true)
 
78
        c.Assert(instid, Equals, state.InstanceId("dummy.instance.id"))
 
79
 
 
80
        cons, err := st.EnvironConstraints()
 
81
        c.Assert(err, IsNil)
 
82
        c.Assert(cons, DeepEquals, constraints.Value{})
 
83
}
 
84
 
 
85
func (s *BootstrapSuite) TestSetConstraints(c *C) {
 
86
        tcons := constraints.Value{Mem: uint64p(2048), CpuCores: uint64p(2)}
 
87
        _, cmd, err := s.initBootstrapCommand(c, "--env-config", testConfig, "--constraints", tcons.String())
 
88
        c.Assert(err, IsNil)
 
89
        err = cmd.Run(nil)
 
90
        c.Assert(err, IsNil)
 
91
 
 
92
        st, err := state.Open(&state.Info{
 
93
                Addrs:  []string{testing.MgoAddr},
 
94
                CACert: []byte(testing.CACert),
 
95
        }, state.DefaultDialOpts())
 
96
        c.Assert(err, IsNil)
 
97
        defer st.Close()
 
98
        cons, err := st.EnvironConstraints()
 
99
        c.Assert(err, IsNil)
 
100
        c.Assert(cons, DeepEquals, tcons)
 
101
 
 
102
        machines, err := st.AllMachines()
 
103
        c.Assert(err, IsNil)
 
104
        c.Assert(machines, HasLen, 1)
 
105
        cons, err = machines[0].Constraints()
 
106
        c.Assert(err, IsNil)
 
107
        c.Assert(cons, DeepEquals, tcons)
 
108
}
 
109
 
 
110
func uint64p(v uint64) *uint64 {
 
111
        return &v
 
112
}
 
113
 
 
114
func (s *BootstrapSuite) TestMachinerWorkers(c *C) {
 
115
        _, cmd, err := s.initBootstrapCommand(c, "--env-config", testConfig)
 
116
        c.Assert(err, IsNil)
 
117
        err = cmd.Run(nil)
 
118
        c.Assert(err, IsNil)
 
119
 
 
120
        st, err := state.Open(&state.Info{
 
121
                Addrs:  []string{testing.MgoAddr},
 
122
                CACert: []byte(testing.CACert),
 
123
        }, state.DefaultDialOpts())
 
124
        c.Assert(err, IsNil)
 
125
        defer st.Close()
 
126
        m, err := st.Machine("0")
 
127
        c.Assert(err, IsNil)
 
128
        c.Assert(m.Jobs(), DeepEquals, []state.MachineJob{state.JobManageEnviron, state.JobServeAPI})
 
129
}
 
130
 
 
131
func testOpenState(c *C, info *state.Info, expectErr error) {
 
132
        st, err := state.Open(info, state.DefaultDialOpts())
 
133
        if st != nil {
 
134
                st.Close()
 
135
        }
 
136
        if expectErr != nil {
 
137
                c.Assert(state.IsUnauthorizedError(err), Equals, true)
 
138
        } else {
 
139
                c.Assert(err, IsNil)
 
140
        }
 
141
}
 
142
 
 
143
func (s *BootstrapSuite) TestInitialPassword(c *C) {
 
144
        conf, cmd, err := s.initBootstrapCommand(c, "--env-config", testConfig)
 
145
        c.Assert(err, IsNil)
 
146
        conf.OldPassword = "foo"
 
147
        err = conf.Write()
 
148
        c.Assert(err, IsNil)
 
149
 
 
150
        err = cmd.Run(nil)
 
151
        c.Assert(err, IsNil)
 
152
 
 
153
        // Check that we cannot now connect to the state
 
154
        // without a password.
 
155
        info := &state.Info{
 
156
                Addrs:  []string{testing.MgoAddr},
 
157
                CACert: []byte(testing.CACert),
 
158
        }
 
159
        testOpenState(c, info, state.Unauthorizedf("some auth problem"))
 
160
 
 
161
        info.Tag, info.Password = "machine-0", "foo"
 
162
        testOpenState(c, info, nil)
 
163
 
 
164
        info.Tag = ""
 
165
        st, err := state.Open(info, state.DefaultDialOpts())
 
166
        c.Assert(err, IsNil)
 
167
        defer st.Close()
 
168
 
 
169
        // Reset password so the tests can continue to use the same server.
 
170
        err = st.SetAdminMongoPassword("")
 
171
        c.Assert(err, IsNil)
 
172
}
 
173
 
 
174
var base64ConfigTests = []struct {
 
175
        input    []string
 
176
        err      string
 
177
        expected map[string]interface{}
 
178
}{
 
179
        {
 
180
                // no value supplied
 
181
                nil,
 
182
                "--env-config option must be set",
 
183
                nil,
 
184
        }, {
 
185
                // empty
 
186
                []string{"--env-config", ""},
 
187
                "--env-config option must be set",
 
188
                nil,
 
189
        }, {
 
190
                // wrong, should be base64
 
191
                []string{"--env-config", "name: banana\n"},
 
192
                ".*illegal base64 data at input byte.*",
 
193
                nil,
 
194
        }, {
 
195
                []string{"--env-config", base64.StdEncoding.EncodeToString([]byte("name: banana\n"))},
 
196
                "",
 
197
                map[string]interface{}{"name": "banana"},
 
198
        },
 
199
}
 
200
 
 
201
func (s *BootstrapSuite) TestBase64Config(c *C) {
 
202
        for i, t := range base64ConfigTests {
 
203
                c.Logf("test %d", i)
 
204
                var args []string
 
205
                args = append(args, t.input...)
 
206
                _, cmd, err := s.initBootstrapCommand(c, args...)
 
207
                if t.err == "" {
 
208
                        c.Assert(cmd, NotNil)
 
209
                        c.Assert(err, IsNil)
 
210
                        c.Assert(cmd.EnvConfig, DeepEquals, t.expected)
 
211
                } else {
 
212
                        c.Assert(err, ErrorMatches, t.err)
 
213
                }
 
214
        }
 
215
}
 
216
 
 
217
type b64yaml map[string]interface{}
 
218
 
 
219
func (m b64yaml) encode() string {
 
220
        data, err := goyaml.Marshal(m)
 
221
        if err != nil {
 
222
                panic(err)
 
223
        }
 
224
        return base64.StdEncoding.EncodeToString(data)
 
225
}
 
226
 
 
227
var testConfig = b64yaml{
 
228
        "name":            "dummyenv",
 
229
        "type":            "dummy",
 
230
        "state-server":    false,
 
231
        "agent-version":   "1.2.3",
 
232
        "authorized-keys": "i-am-a-key",
 
233
        "ca-cert":         testing.CACert,
 
234
        "ca-private-key":  "",
 
235
}.encode()