environs, juju: require admin-secret

environs/dummy/environs.go

 // The dummy provider implements an environment provider for testing
 // purposes, registered with environs under the name "dummy".
 //·
 // The configuration YAML for the testing environment
 // must specify a "state-server" property with a boolean
 // value. If this is true, a state server will be started
 // the first time StateInfo is called on a newly reset environment.
 //·
 // The configuration data also accepts a "broken" property
 // of type boolean. If this is non-empty, any operation
@@ skipping 361 matching lines @@
 
 func (e *environ) Name() string {
         return e.state.name
 }
 
 func (e *environ) Bootstrap(uploadTools bool) error {
         defer delay()
         if err := e.checkBroken("Bootstrap"); err != nil {
                 return err
         }
+        password := e.Config().AdminSecret()
+        if password == "" {
+                return fmt.Errorf("admin-secret is required for bootstrap")
+        }
         var tools *state.Tools
         var err error
         if uploadTools {
                 tools, err = environs.PutTools(e.Storage(), nil)
                 if err != nil {
                         return err
                 }
         } else {
                 flags := environs.HighestVersion | environs.CompatVersion
                 tools, err = environs.FindTools(e, version.Current, flags)
@@ skipping 10 matching lines @@
         if e.ecfg().stateServer() {
                 info := stateInfo()
                 cfg, err := environs.BootstrapConfig(&providerInstance, e.ecfg().Config, tools)
                 if err != nil {
                         return fmt.Errorf("cannot make bootstrap config: %v", err)
                 }
                 st, err := state.Initialize(info, cfg)
                 if err != nil {
                         panic(err)
                 }
-                if password := e.Config().AdminSecret(); password != "" {
-                        if err := st.SetAdminPassword(trivial.PasswordHash(password)); err != nil {
-                                return err
-                        }
+                if err := st.SetAdminPassword(trivial.PasswordHash(password)); err != nil {
+                        return err
                 }
                 if err := st.Close(); err != nil {
                         panic(err)
                 }
         }
         e.state.bootstrapped = true
         return nil
 }
 
 func (e *environ) StateInfo() (*state.Info, error) {
@@ skipping 246 matching lines @@
 // time.Durations into this value.
 var providerDelay time.Duration
 
 // pause execution to simulate the latency of a real provider
 func delay() {
         if providerDelay > 0 {
                 log.Printf("dummy: pausing for %v", providerDelay)
                 <-time.After(providerDelay)
         }
 }