← Back to branch summary

~ubuntu-branches/ubuntu/saucy/juju-core/saucy-updates

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-09-03 14:22:22 UTC
  • mfrom: (1.1.7)
  • Revision ID: package-import@ubuntu.com-20130903142222-9mes2r8wqr0bs7lp
Tags: 1.13.3-0ubuntu1
New upstream point release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/juju/conn_test.go
45
45
}
46
46
 
47
47
func (*NewConnSuite) TestNewConnWithoutAdminSecret(c *gc.C) {
48
 
        attrs := map[string]interface{}{
 
48
        cfg, err := config.New(map[string]interface{}{
49
49
                "name":            "erewhemos",
50
50
                "type":            "dummy",
51
51
                "state-server":    true,
54
54
                "admin-secret":    "really",
55
55
                "ca-cert":         coretesting.CACert,
56
56
                "ca-private-key":  coretesting.CAKey,
57
 
        }
58
 
        env, err := environs.NewFromAttrs(attrs)
 
57
        })
 
58
        c.Assert(err, gc.IsNil)
 
59
        env, err := environs.Prepare(cfg)
59
60
        c.Assert(err, gc.IsNil)
60
61
        err = bootstrap.Bootstrap(env, constraints.Value{})
61
62
        c.Assert(err, gc.IsNil)
62
63
 
 
64
        attrs := env.Config().AllAttrs()
63
65
        delete(attrs, "admin-secret")
64
66
        env1, err := environs.NewFromAttrs(attrs)
65
67
        c.Assert(err, gc.IsNil)
68
70
        c.Assert(err, gc.ErrorMatches, "cannot connect without admin-secret")
69
71
}
70
72
 
71
 
func (*NewConnSuite) TestNewConnFromNameGetUnbootstrapped(c *gc.C) {
72
 
        defer coretesting.MakeSampleHome(c).Restore()
73
 
        _, err := juju.NewConnFromName("")
74
 
        c.Assert(err, gc.ErrorMatches, "dummy environment not bootstrapped")
75
 
}
76
 
 
77
73
func bootstrapEnv(c *gc.C, envName string) {
78
 
        environ, err := environs.NewFromName(envName)
 
74
        environ, err := environs.PrepareFromName(envName)
79
75
        c.Assert(err, gc.IsNil)
80
76
        err = bootstrap.Bootstrap(environ, constraints.Value{})
81
77
        c.Assert(err, gc.IsNil)
112
108
}
113
109
 
114
110
func (cs *NewConnSuite) TestConnStateSecretsSideEffect(c *gc.C) {
115
 
        attrs := map[string]interface{}{
 
111
        cfg, err := config.New(map[string]interface{}{
116
112
                "name":            "erewhemos",
117
113
                "type":            "dummy",
118
114
                "state-server":    true,
121
117
                "admin-secret":    "side-effect secret",
122
118
                "ca-cert":         coretesting.CACert,
123
119
                "ca-private-key":  coretesting.CAKey,
124
 
        }
125
 
        env, err := environs.NewFromAttrs(attrs)
 
120
        })
 
121
        c.Assert(err, gc.IsNil)
 
122
        env, err := environs.Prepare(cfg)
126
123
        c.Assert(err, gc.IsNil)
127
124
        err = bootstrap.Bootstrap(env, constraints.Value{})
128
125
        c.Assert(err, gc.IsNil)
133
130
        c.Assert(err, gc.IsNil)
134
131
 
135
132
        // Verify we have no secret in the environ config
136
 
        cfg, err := st.EnvironConfig()
 
133
        cfg, err = st.EnvironConfig()
137
134
        c.Assert(err, gc.IsNil)
138
135
        c.Assert(cfg.UnknownAttrs()["secret"], gc.IsNil)
139
136
 
152
149
}
153
150
 
154
151
func (cs *NewConnSuite) TestConnStateDoesNotUpdateExistingSecrets(c *gc.C) {
155
 
        attrs := map[string]interface{}{
 
152
        cfg, err := config.New(map[string]interface{}{
156
153
                "name":            "erewhemos",
157
154
                "type":            "dummy",
158
155
                "state-server":    true,
161
158
                "admin-secret":    "some secret",
162
159
                "ca-cert":         coretesting.CACert,
163
160
                "ca-private-key":  coretesting.CAKey,
164
 
        }
165
 
        env, err := environs.NewFromAttrs(attrs)
 
161
        })
 
162
        c.Assert(err, gc.IsNil)
 
163
        env, err := environs.Prepare(cfg)
166
164
        c.Assert(err, gc.IsNil)
167
165
        err = bootstrap.Bootstrap(env, constraints.Value{})
168
166
        c.Assert(err, gc.IsNil)
173
171
        defer conn.Close()
174
172
 
175
173
        // Make another env with a different secret.
 
174
        attrs := env.Config().AllAttrs()
176
175
        attrs["secret"] = "squirrel"
177
176
        env1, err := environs.NewFromAttrs(attrs)
178
177
        c.Assert(err, gc.IsNil)
181
180
        conn, err = juju.NewConn(env1)
182
181
        c.Assert(err, gc.IsNil)
183
182
        defer conn.Close()
184
 
        cfg, err := conn.State.EnvironConfig()
 
183
        cfg, err = conn.State.EnvironConfig()
185
184
        c.Assert(err, gc.IsNil)
186
185
        c.Assert(cfg.UnknownAttrs()["secret"], gc.Equals, "pork")
187
186
 
191
190
}
192
191
 
193
192
func (cs *NewConnSuite) TestConnWithPassword(c *gc.C) {
194
 
        env, err := environs.NewFromAttrs(map[string]interface{}{
 
193
        cfg, err := config.New(map[string]interface{}{
195
194
                "name":            "erewhemos",
196
195
                "type":            "dummy",
197
196
                "state-server":    true,
202
201
                "ca-private-key":  coretesting.CAKey,
203
202
        })
204
203
        c.Assert(err, gc.IsNil)
 
204
        env, err := environs.Prepare(cfg)
 
205
        c.Assert(err, gc.IsNil)
205
206
        err = bootstrap.Bootstrap(env, constraints.Value{})
206
207
        c.Assert(err, gc.IsNil)
207
208
 
249
250
func (s *ConnSuite) SetUpTest(c *gc.C) {
250
251
        s.LoggingSuite.SetUpTest(c)
251
252
        s.MgoSuite.SetUpTest(c)
252
 
        attrs := map[string]interface{}{
 
253
        cfg, err := config.New(map[string]interface{}{
253
254
                "name":            "erewhemos",
254
255
                "type":            "dummy",
255
256
                "state-server":    true,
257
258
                "admin-secret":    "deploy-test-secret",
258
259
                "ca-cert":         coretesting.CACert,
259
260
                "ca-private-key":  coretesting.CAKey,
260
 
        }
261
 
        environ, err := environs.NewFromAttrs(attrs)
 
261
        })
 
262
        c.Assert(err, gc.IsNil)
 
263
        environ, err := environs.Prepare(cfg)
262
264
        c.Assert(err, gc.IsNil)
263
265
        err = bootstrap.Bootstrap(environ, constraints.Value{})
264
266
        c.Assert(err, gc.IsNil)