environs: add a certificate argument to Bootstrap

environs/jujutest/tests.go

 package jujutest
 
 import (
         "bytes"
         "io"
         "io/ioutil"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/juju/testing"
         coretesting "launchpad.net/juju-core/testing"
         "launchpad.net/juju-core/trivial"
         "net/http"
 )
 
 // Tests is a gocheck suite containing tests verifying juju functionality
 // against the environment with Name that must exist within Environs. The
 // tests are not designed to be run against a live server - the Environ
 // is opened once for each test, and some potentially expensive operations
 // may be executed.
 type Tests struct {
         coretesting.LoggingSuite
-        Environs *environs.Environs
-        Name     string
-        Env      environs.Environ
+        Environs         *environs.Environs
+        Name             string
+        Env              environs.Environ
+        ServerCertAndKey []byte

[niemeyer, 2012/11/14 13:59:07]

StateServerPEM

[rog, 2012/11/14 15:04:14]

Done.

 }
 
 // Open opens an instance of the testing environment.
 func (t *Tests) Open(c *C) environs.Environ {
         e, err := t.Environs.Open(t.Name)
         c.Assert(err, IsNil, Commentf("opening environ %q", t.Name))
         c.Assert(e, NotNil)
         return e
 }
 
 func (t *Tests) SetUpTest(c *C) {
         t.LoggingSuite.SetUpTest(c)
         t.Env = t.Open(c)
 }
 
 func (t *Tests) TearDownTest(c *C) {
         if t.Env != nil {
                 err := t.Env.Destroy(nil)
                 c.Check(err, IsNil)
                 t.Env = nil
         }
         t.LoggingSuite.TearDownTest(c)
 }
 
 func (t *Tests) TestBootstrapWithoutAdminSecret(c *C) {
         m := t.Env.Config().AllAttrs()
         delete(m, "admin-secret")
         env, err := environs.NewFromAttrs(m)
         c.Assert(err, IsNil)
-        err = env.Bootstrap(false)
+        err = env.Bootstrap(false, t.ServerCertAndKey)
         c.Assert(err, ErrorMatches, ".*admin-secret is required for bootstrap")
 }
 
 func (t *Tests) TestStartStop(c *C) {
         e := t.Open(c)
 
         insts, err := e.Instances(nil)
         c.Assert(err, IsNil)
         c.Assert(insts, HasLen, 0)
 
@@ skipping 28 matching lines @@
         c.Assert(insts[1].Id(), Equals, id1)
 
         insts, err = e.AllInstances()
         c.Assert(err, IsNil)
         c.Assert(insts[0].Id(), Equals, id1)
 }
 
 func (t *Tests) TestBootstrap(c *C) {
         // TODO tests for Bootstrap(true)
         e := t.Open(c)
-        err := e.Bootstrap(false)
+        err := e.Bootstrap(false, t.ServerCertAndKey)
         c.Assert(err, IsNil)
 
         info, err := e.StateInfo()
         c.Assert(info, NotNil)
         c.Check(info.Addrs, Not(HasLen), 0)
 
-        err = e.Bootstrap(false)
+        err = e.Bootstrap(false, t.ServerCertAndKey)
         c.Assert(err, ErrorMatches, "environment is already bootstrapped")
 
         e2 := t.Open(c)
-        err = e2.Bootstrap(false)
+        err = e2.Bootstrap(false, t.ServerCertAndKey)
         c.Assert(err, ErrorMatches, "environment is already bootstrapped")
 
         info2, err := e2.StateInfo()
         c.Check(info2, DeepEquals, info)
 
         err = e2.Destroy(nil)
         c.Assert(err, IsNil)
 
         // Open again because Destroy invalidates old environments.
         e3 := t.Open(c)
 
-        err = e3.Bootstrap(false)
+        err = e3.Bootstrap(false, t.ServerCertAndKey)
         c.Assert(err, IsNil)
 
-        err = e3.Bootstrap(false)
+        err = e3.Bootstrap(false, t.ServerCertAndKey)
         c.Assert(err, NotNil)
 }
 
 var noRetry = trivial.AttemptStrategy{}
 
 func (t *Tests) TestPersistence(c *C) {
         storage := t.Open(c).Storage()
 
         names := []string{
                 "aa",
@@ skipping 83 matching lines @@
                 }
                 c.Logf("get retrying after earlier get succeeded. *sigh*.")
         }
         c.Assert(err, IsNil)
         data, err = ioutil.ReadAll(resp.Body)
         c.Assert(err, IsNil)
         defer resp.Body.Close()
         c.Assert(resp.StatusCode, Equals, 200, Commentf("error response: %s", data))
         c.Check(data, DeepEquals, contents)
 }