← Back to branch summary

~sinzui/ubuntu/wily/juju-core/wily-1.24.7

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/cmd/jujud/bootstrap_test.go

  • Committer: Package Import Robot
  • Author(s): Curtis C. Hovey
  • Date: 2015-09-22 15:27:01 UTC
  • mfrom: (1.1.36)
  • Revision ID: package-import@ubuntu.com-20150922152701-lzq2yhn2uaahrdqu
Tags: 1.24.6-0ubuntu1
https://launchpad.net/bugs/1481556
* New upstream release (LP: #1481556).
* d/copyright updated for Juju 1.24.6 (Last verified commit changes).
* d/tests/* Run tests with upstart when Juju version before 1.23.
* Prefer gccgo-5 for ppc64el and arm64 in build-deps.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/cmd/jujud/bootstrap_test.go
47
47
        "github.com/juju/juju/state/multiwatcher"
48
48
        statestorage "github.com/juju/juju/state/storage"
49
49
        statetesting "github.com/juju/juju/state/testing"
 
50
        "github.com/juju/juju/storage/poolmanager"
50
51
        "github.com/juju/juju/testing"
51
52
        "github.com/juju/juju/tools"
52
53
        "github.com/juju/juju/version"
65
66
        dataDir         string
66
67
        logDir          string
67
68
        mongoOplogSize  string
68
 
        fakeEnsureMongo agenttesting.FakeEnsure
 
69
        fakeEnsureMongo *agenttesting.FakeEnsureMongo
69
70
        bootstrapName   string
70
71
 
71
72
        toolsStorage storage.Storage
74
75
var _ = gc.Suite(&BootstrapSuite{})
75
76
 
76
77
func (s *BootstrapSuite) SetUpSuite(c *gc.C) {
77
 
        s.PatchValue(&cmdutil.EnsureMongoServer, s.fakeEnsureMongo.FakeEnsureMongo)
78
 
        s.PatchValue(&maybeInitiateMongoServer, s.fakeEnsureMongo.FakeInitiateMongo)
79
 
 
80
78
        storageDir := c.MkDir()
81
79
        restorer := gitjujutesting.PatchValue(&envtools.DefaultBaseURL, storageDir)
82
80
        s.AddSuiteCleanup(func(*gc.C) {
107
105
        s.dataDir = c.MkDir()
108
106
        s.logDir = c.MkDir()
109
107
        s.mongoOplogSize = "1234"
110
 
        s.fakeEnsureMongo = agenttesting.FakeEnsure{}
 
108
        s.fakeEnsureMongo = agenttesting.InstallFakeEnsureMongo(s)
 
109
        s.PatchValue(&maybeInitiateMongoServer, s.fakeEnsureMongo.InitiateMongo)
111
110
 
112
111
        // Create fake tools.tar.gz and downloaded-tools.txt.
113
112
        toolsDir := filepath.FromSlash(agenttools.SharedToolsDir(s.dataDir, version.Current))
158
157
                UpgradedToVersion: version.Current.Number,
159
158
                Password:          testPasswordHash(),
160
159
                Nonce:             agent.BootstrapNonce,
 
160
                Environment:       testing.EnvironmentTag,
161
161
                StateAddresses:    []string{gitjujutesting.MgoServer.Addr()},
162
162
                APIAddresses:      []string{"0.1.2.3:1234"},
163
163
                CACert:            testing.CACert,
219
219
        c.Assert(s.fakeEnsureMongo.InitiateParams.User, gc.Equals, "")
220
220
        c.Assert(s.fakeEnsureMongo.InitiateParams.Password, gc.Equals, "")
221
221
 
222
 
        st, err := state.Open(&mongo.MongoInfo{
 
222
        st, err := state.Open(testing.EnvironmentTag, &mongo.MongoInfo{
223
223
                Info: mongo.Info{
224
224
                        Addrs:  []string{gitjujutesting.MgoServer.Addr()},
225
225
                        CACert: testing.CACert,
270
270
        err = cmd.Run(nil)
271
271
        c.Assert(err, jc.ErrorIsNil)
272
272
 
273
 
        st, err := state.Open(&mongo.MongoInfo{
 
273
        st, err := state.Open(testing.EnvironmentTag, &mongo.MongoInfo{
274
274
                Info: mongo.Info{
275
275
                        Addrs:  []string{gitjujutesting.MgoServer.Addr()},
276
276
                        CACert: testing.CACert,
306
306
        err = cmd.Run(nil)
307
307
        c.Assert(err, jc.ErrorIsNil)
308
308
 
309
 
        st, err := state.Open(&mongo.MongoInfo{
 
309
        st, err := state.Open(testing.EnvironmentTag, &mongo.MongoInfo{
310
310
                Info: mongo.Info{
311
311
                        Addrs:  []string{gitjujutesting.MgoServer.Addr()},
312
312
                        CACert: testing.CACert,
327
327
        err = cmd.Run(nil)
328
328
        c.Assert(err, jc.ErrorIsNil)
329
329
 
330
 
        st, err := state.Open(&mongo.MongoInfo{
 
330
        st, err := state.Open(testing.EnvironmentTag, &mongo.MongoInfo{
331
331
                Info: mongo.Info{
332
332
                        Addrs:  []string{gitjujutesting.MgoServer.Addr()},
333
333
                        CACert: testing.CACert,
342
342
}
343
343
 
344
344
func testOpenState(c *gc.C, info *mongo.MongoInfo, expectErrType error) {
345
 
        st, err := state.Open(info, mongo.DefaultDialOpts(), environs.NewStatePolicy())
 
345
        st, err := state.Open(testing.EnvironmentTag, info, mongo.DefaultDialOpts(), environs.NewStatePolicy())
346
346
        if st != nil {
347
347
                st.Close()
348
348
        }
370
370
        // Check we can log in to mongo as admin.
371
371
        // TODO(dfc) does passing nil for the admin user name make your skin crawl ? mine too.
372
372
        info.Tag, info.Password = nil, testPasswordHash()
373
 
        st, err := state.Open(info, mongo.DefaultDialOpts(), environs.NewStatePolicy())
 
373
        st, err := state.Open(testing.EnvironmentTag, info, mongo.DefaultDialOpts(), environs.NewStatePolicy())
374
374
        c.Assert(err, jc.ErrorIsNil)
375
375
        defer st.Close()
376
376
 
397
397
 
398
398
        stateinfo, ok := machineConf1.MongoInfo()
399
399
        c.Assert(ok, jc.IsTrue)
400
 
        st, err = state.Open(stateinfo, mongo.DialOpts{}, environs.NewStatePolicy())
 
400
        st, err = state.Open(testing.EnvironmentTag, stateinfo, mongo.DefaultDialOpts(), environs.NewStatePolicy())
401
401
        c.Assert(err, jc.ErrorIsNil)
402
402
        defer st.Close()
403
403
 
565
565
        // The tools should have been added to tools storage, and
566
566
        // exploded into each of the supported series of
567
567
        // the same operating system if the tools were uploaded.
568
 
        st, err := state.Open(&mongo.MongoInfo{
 
568
        st, err := state.Open(testing.EnvironmentTag, &mongo.MongoInfo{
569
569
                Info: mongo.Info{
570
570
                        Addrs:  []string{gitjujutesting.MgoServer.Addr()},
571
571
                        CACert: testing.CACert,
574
574
        }, mongo.DefaultDialOpts(), environs.NewStatePolicy())
575
575
        c.Assert(err, jc.ErrorIsNil)
576
576
        defer st.Close()
577
 
 
578
577
        expectedSeries := make(set.Strings)
579
578
        if exploded {
580
579
                for _, series := range version.SupportedSeries() {
654
653
                        "bootstrap-timeout": "123",
655
654
                },
656
655
        ).Delete("admin-secret", "ca-private-key")
657
 
 
658
656
        cfg, err := config.New(config.NoDefaults, attrs)
659
657
        c.Assert(err, jc.ErrorIsNil)
660
658
        provider, err := environs.Provider(cfg.Type())
661
659
        c.Assert(err, jc.ErrorIsNil)
662
 
        env, err := provider.Prepare(nullContext(), cfg)
 
660
        env, err := provider.PrepareForBootstrap(nullContext(), cfg)
663
661
        c.Assert(err, jc.ErrorIsNil)
664
662
 
665
663
        envtesting.MustUploadFakeTools(s.toolsStorage, cfg.AgentStream(), cfg.AgentStream())
691
689
        }
692
690
        return base64.StdEncoding.EncodeToString(data)
693
691
}
 
692
 
 
693
func (s *BootstrapSuite) TestDefaultStoragePools(c *gc.C) {
 
694
        _, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.b64yamlEnvcfg, "--instance-id", string(s.instanceId))
 
695
        c.Assert(err, jc.ErrorIsNil)
 
696
        err = cmd.Run(nil)
 
697
        c.Assert(err, jc.ErrorIsNil)
 
698
 
 
699
        st, err := state.Open(testing.EnvironmentTag, &mongo.MongoInfo{
 
700
                Info: mongo.Info{
 
701
                        Addrs:  []string{gitjujutesting.MgoServer.Addr()},
 
702
                        CACert: testing.CACert,
 
703
                },
 
704
                Password: testPasswordHash(),
 
705
        }, mongo.DefaultDialOpts(), environs.NewStatePolicy())
 
706
        c.Assert(err, jc.ErrorIsNil)
 
707
        defer st.Close()
 
708
 
 
709
        settings := state.NewStateSettings(st)
 
710
        pm := poolmanager.New(settings)
 
711
        for _, p := range []string{"ebs-ssd"} {
 
712
                _, err = pm.Get(p)
 
713
                c.Assert(err, jc.ErrorIsNil)
 
714
        }
 
715
}