~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

        "github.com/juju/juju/environs/configstore"

        "github.com/juju/juju/version"

        // ConfigStore holds the configuration storage

        // used when preparing the environment.

        // This is initialized by SetUpSuite.

        ConfigStore configstore.Storage

 

        t.ConfigStore = configstore.NewMem()

        t.PatchValue(&version.Current, coretesting.FakeVersionNumber)

func publicAttrs(e environs.Environ) map[string]interface{} {

        cfg := e.Config()

        secrets, err := e.Provider().SecretAttrs(cfg)

        if err != nil {

                panic(err)

        }

        attrs := cfg.AllAttrs()

        for attr := range secrets {

                delete(attrs, attr)

        }

        return attrs

}

 

        e, err := environs.Prepare(envtesting.BootstrapContext(c), t.ConfigStore, t.ControllerStore, args.Config.Name(), args)

func (t *LiveTests) prepareForBootstrapParams(c *gc.C) environs.PrepareForBootstrapParams {

        cfg, err := config.New(config.NoDefaults, t.TestConfig)

        c.Assert(err, jc.ErrorIsNil)

        return environs.PrepareForBootstrapParams{

                Config:        cfg,

                Credentials:   credential,

                CloudEndpoint: t.CloudEndpoint,

                CloudRegion:   t.CloudRegion,

                EnvironConstraints:   cons,

        err := environs.Destroy(t.Env.Config().Name(), t.Env, t.ConfigStore, t.ControllerStore)

        c.Check(agentVersion, gc.Equals, version.Current)

                Number: version.Current,

func (t *LiveTests) assertStartInstance(c *gc.C, m *state.Machine) {

        // Wait for machine to get an instance id.

        for a := waitAgent.Start(); a.Next(); {

                err := m.Refresh()

                c.Assert(err, jc.ErrorIsNil)

                instId, err := m.InstanceId()

                if err != nil {

                        c.Assert(err, jc.Satisfies, errors.IsNotProvisioned)

                        continue

                }

                _, err = t.Env.Instances([]instance.Id{instId})

                c.Assert(err, jc.ErrorIsNil)

                return

        }

        c.Fatalf("provisioner failed to start machine after %v", waitAgent.Total)

}

 

// assertInstanceId asserts that the machine has an instance id

// that matches that of the given instance. If the instance is nil,

// It asserts that the instance id is unset.

func assertInstanceId(c *gc.C, m *state.Machine, inst instance.Instance) {

        var wantId, gotId instance.Id

        var err error

        if inst != nil {

                wantId = inst.Id()

        }

        for a := waitAgent.Start(); a.Next(); {

                err := m.Refresh()

                c.Assert(err, jc.ErrorIsNil)

                gotId, err = m.InstanceId()

                if err != nil {

                        c.Assert(err, jc.Satisfies, errors.IsNotProvisioned)

                        if inst == nil {

                                return

                        }

                        continue

                }

                break

        }

        c.Assert(err, jc.ErrorIsNil)

        c.Assert(gotId, gc.Equals, wantId)

}

 

                Number: version.Current,

        dummyCfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(coretesting.Attrs{

        }))

        args.Config = dummyCfg

                configstore.NewMem(),

                dummyCfg.Name(),

                args)

        attrs := t.TestConfig.Merge(coretesting.Attrs{"default-series": other.Series})

        cfg, err := config.New(config.NoDefaults, attrs)

        c.Assert(err, jc.ErrorIsNil)

        args.Config = cfg

                t.ConfigStore,

                "livetests", args)

        defer environs.Destroy("livetests", env, t.ConfigStore, t.ControllerStore)