← Back to branch summary

~wallyworld/juju-core/fast-lxc-everywhere

« back to all changes in this revision

Viewing changes to provider/maas/environ_whitebox_test.go

  • Committer: Bodie Solomon
  • Date: 2014-03-20 01:23:05 UTC
  • mfrom: (2447 juju-core)
  • mto: This revision was merged to the branch mainline in revision 2459.
  • Revision ID: binary132@gmail.com-20140320012305-foerm9in0uqx9jrg
Merged apiAddressesKey change from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
provider/maas/environ_whitebox_test.go
9
9
        "fmt"
10
10
        "io/ioutil"
11
11
        "net/url"
 
12
        "strings"
12
13
 
13
14
        jc "github.com/juju/testing/checkers"
14
15
        gc "launchpad.net/gocheck"
222
223
        env := suite.makeEnviron()
223
224
        suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
224
225
 
225
 
        _, _, err := env.acquireNode(constraints.Value{}, tools.List{fakeTools})
 
226
        _, _, err := env.acquireNode(constraints.Value{}, environs.Networks{},
 
227
                tools.List{fakeTools})
226
228
 
227
229
        c.Check(err, gc.IsNil)
228
230
        operations := suite.testMAASObject.TestServer.NodeOperations()
238
240
        suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
239
241
        constraints := constraints.Value{Arch: stringp("arm"), Mem: uint64p(1024)}
240
242
 
241
 
        _, _, err := env.acquireNode(constraints, tools.List{fakeTools})
 
243
        _, _, err := env.acquireNode(constraints, environs.Networks{},
 
244
                tools.List{fakeTools})
242
245
 
243
246
        c.Check(err, gc.IsNil)
244
247
        requestValues := suite.testMAASObject.TestServer.NodeOperationRequestValues()
254
257
        env := suite.makeEnviron()
255
258
        suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
256
259
 
257
 
        _, _, err := env.acquireNode(constraints.Value{}, tools.List{fakeTools})
 
260
        _, _, err := env.acquireNode(constraints.Value{}, environs.Networks{},
 
261
                tools.List{fakeTools})
258
262
 
259
263
        c.Check(err, gc.IsNil)
260
264
        requestValues := suite.testMAASObject.TestServer.NodeOperationRequestValues()
263
267
        c.Assert(nodeRequestValues[0].Get("agent_name"), gc.Equals, exampleAgentName)
264
268
}
265
269
 
 
270
var testValues = []struct {
 
271
        constraints    constraints.Value
 
272
        expectedResult url.Values
 
273
}{
 
274
        {constraints.Value{Arch: stringp("arm")}, url.Values{"arch": {"arm"}}},
 
275
        {constraints.Value{CpuCores: uint64p(4)}, url.Values{"cpu_count": {"4"}}},
 
276
        {constraints.Value{Mem: uint64p(1024)}, url.Values{"mem": {"1024"}}},
 
277
 
 
278
        // CpuPower is ignored.
 
279
        {constraints.Value{CpuPower: uint64p(1024)}, url.Values{}},
 
280
 
 
281
        // RootDisk is ignored.
 
282
        {constraints.Value{RootDisk: uint64p(8192)}, url.Values{}},
 
283
        {constraints.Value{Tags: &[]string{"foo", "bar"}}, url.Values{"tags": {"foo,bar"}}},
 
284
        {constraints.Value{Arch: stringp("arm"), CpuCores: uint64p(4), Mem: uint64p(1024), CpuPower: uint64p(1024), RootDisk: uint64p(8192), Tags: &[]string{"foo", "bar"}}, url.Values{"arch": {"arm"}, "cpu_count": {"4"}, "mem": {"1024"}, "tags": {"foo,bar"}}},
 
285
}
 
286
 
266
287
func (*environSuite) TestConvertConstraints(c *gc.C) {
267
 
        var testValues = []struct {
268
 
                constraints    constraints.Value
269
 
                expectedResult url.Values
270
 
        }{
271
 
                {constraints.Value{Arch: stringp("arm")}, url.Values{"arch": {"arm"}}},
272
 
                {constraints.Value{CpuCores: uint64p(4)}, url.Values{"cpu_count": {"4"}}},
273
 
                {constraints.Value{Mem: uint64p(1024)}, url.Values{"mem": {"1024"}}},
274
 
                // CpuPower is ignored.
275
 
                {constraints.Value{CpuPower: uint64p(1024)}, url.Values{}},
276
 
                // RootDisk is ignored.
277
 
                {constraints.Value{RootDisk: uint64p(8192)}, url.Values{}},
278
 
                {constraints.Value{Tags: &[]string{"foo", "bar"}}, url.Values{"tags": {"foo,bar"}}},
279
 
                {constraints.Value{Arch: stringp("arm"), CpuCores: uint64p(4), Mem: uint64p(1024), CpuPower: uint64p(1024), RootDisk: uint64p(8192), Tags: &[]string{"foo", "bar"}}, url.Values{"arch": {"arm"}, "cpu_count": {"4"}, "mem": {"1024"}, "tags": {"foo,bar"}}},
280
 
        }
281
288
        for _, test := range testValues {
282
289
                c.Check(convertConstraints(test.constraints), gc.DeepEquals, test.expectedResult)
283
290
        }
284
291
}
285
292
 
 
293
var testNetworkValues = []struct {
 
294
        networks       environs.Networks
 
295
        expectedResult url.Values
 
296
}{
 
297
        {
 
298
                environs.Networks{},
 
299
                url.Values{},
 
300
        },
 
301
        {
 
302
                environs.Networks{
 
303
                        IncludedNetworks: []string{"included_net_1"},
 
304
                },
 
305
                url.Values{"networks": {"included_net_1"}},
 
306
        },
 
307
        {
 
308
                environs.Networks{
 
309
                        ExcludedNetworks: []string{"excluded_net_1"},
 
310
                },
 
311
                url.Values{"not_networks": {"excluded_net_1"}},
 
312
        },
 
313
        {
 
314
                environs.Networks{
 
315
                        IncludedNetworks: []string{"included_net_1", "included_net_2"},
 
316
                        ExcludedNetworks: []string{"excluded_net_1", "excluded_net_2"},
 
317
                },
 
318
                url.Values{
 
319
                        "networks":     {"included_net_1", "included_net_2"},
 
320
                        "not_networks": {"excluded_net_1", "excluded_net_2"},
 
321
                },
 
322
        },
 
323
}
 
324
 
 
325
func (*environSuite) TestConvertNetworks(c *gc.C) {
 
326
        for _, test := range testNetworkValues {
 
327
                var vals = url.Values{}
 
328
                addNetworks(vals, test.networks)
 
329
                c.Check(vals, gc.DeepEquals, test.expectedResult)
 
330
        }
 
331
}
 
332
 
286
333
func (suite *environSuite) getInstance(systemId string) *maasInstance {
287
334
        input := `{"system_id": "` + systemId + `"}`
288
335
        node := suite.testMAASObject.TestServer.NewNode(input)
385
432
        err = env.SetConfig(cfg)
386
433
        c.Assert(err, gc.IsNil)
387
434
        err = bootstrap.Bootstrap(coretesting.Context(c), env, constraints.Value{})
388
 
        c.Check(err, gc.ErrorMatches, "cannot find bootstrap tools.*")
 
435
        stripped := strings.Replace(err.Error(), "\n", "", -1)
 
436
        c.Check(stripped,
 
437
                gc.Matches,
 
438
                "cannot upload bootstrap tools: Juju cannot bootstrap because no tools are available for your environment.*")
389
439
}
390
440
 
391
441
func (suite *environSuite) TestBootstrapFailsIfNoNodes(c *gc.C) {