state/api: implement APIHostPorts methods

state/api/provisioner/provisioner_test.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package provisioner_test
 
 import (
         stdtesting "testing"
 
         jc "github.com/juju/testing/checkers"
         gc "launchpad.net/gocheck"
 
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/errors"
         "launchpad.net/juju-core/instance"
         "launchpad.net/juju-core/juju/testing"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/api"
-        commontesting "launchpad.net/juju-core/state/api/common/testing"
         "launchpad.net/juju-core/state/api/params"
         "launchpad.net/juju-core/state/api/provisioner"
+        apitesting "launchpad.net/juju-core/state/api/testing"
         statetesting "launchpad.net/juju-core/state/testing"
         coretesting "launchpad.net/juju-core/testing"
         "launchpad.net/juju-core/tools"
         "launchpad.net/juju-core/utils"
         "launchpad.net/juju-core/version"
 )
 
 func TestAll(t *stdtesting.T) {
         coretesting.MgoTestPackage(t)
 }
 
 type provisionerSuite struct {
         testing.JujuConnSuite
-        *commontesting.EnvironWatcherTest
+        *apitesting.EnvironWatcherTests
+        *apitesting.APIAddresserTests
 
         st      *api.State
         machine *state.Machine
 
         provisioner *provisioner.State
 }
 
 var _ = gc.Suite(&provisionerSuite{})
 
 func (s *provisionerSuite) SetUpTest(c *gc.C) {
         s.JujuConnSuite.SetUpTest(c)
 
         var err error
         s.machine, err = s.State.AddMachine("quantal", state.JobManageEnviron)
         c.Assert(err, gc.IsNil)
         password, err := utils.RandomPassword()
         c.Assert(err, gc.IsNil)
         err = s.machine.SetPassword(password)
         c.Assert(err, gc.IsNil)
         err = s.machine.SetProvisioned("i-manager", "fake_nonce", nil)
         c.Assert(err, gc.IsNil)
         s.st = s.OpenAPIAsMachine(c, s.machine.Tag(), password, "fake_nonce")
         c.Assert(s.st, gc.NotNil)
+        err = s.machine.SetAddresses(instance.NewAddresses([]string{"0.1.2.3"}))
+        c.Assert(err, gc.IsNil)
 
         // Create the provisioner API facade.
         s.provisioner = s.st.Provisioner()
         c.Assert(s.provisioner, gc.NotNil)
 
-        s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(s.provisioner, s.State, s.BackingState, commontesting.HasSecrets)
+        s.EnvironWatcherTests = apitesting.NewEnvironWatcherTests(s.provisioner, s.BackingState, apitesting.HasSecrets)
+        s.APIAddresserTests = apitesting.NewAPIAddresserTests(s.provisioner, s.BackingState)
 }
 
 func (s *provisionerSuite) TestMachineTagAndId(c *gc.C) {
         apiMachine, err := s.provisioner.Machine("machine-42")
         c.Assert(err, gc.ErrorMatches, "machine 42 not found")
         c.Assert(err, jc.Satisfies, params.IsCodeNotFound)
         c.Assert(apiMachine, gc.IsNil)
 
         apiMachine, err = s.provisioner.Machine(s.machine.Tag())
         c.Assert(err, gc.IsNil)
@@ skipping 257 matching lines @@
         c.Assert(err, gc.IsNil)
 
         stateAddresses, err := s.State.Addresses()
         c.Assert(err, gc.IsNil)
 
         addresses, err := s.provisioner.StateAddresses()
         c.Assert(err, gc.IsNil)
         c.Assert(addresses, gc.DeepEquals, stateAddresses)
 }
 
-func (s *provisionerSuite) TestAPIAddresses(c *gc.C) {
-        err := s.machine.SetAddresses([]instance.Address{
-                instance.NewAddress("0.1.2.3"),
-        })
-        c.Assert(err, gc.IsNil)
-
-        apiAddresses, err := s.State.APIAddressesFromMachines()
-        c.Assert(err, gc.IsNil)
-
-        addresses, err := s.provisioner.APIAddresses()
-        c.Assert(err, gc.IsNil)
-        c.Assert(addresses, gc.DeepEquals, apiAddresses)
-}
-
 func (s *provisionerSuite) TestContainerConfig(c *gc.C) {
         result, err := s.provisioner.ContainerConfig()
         c.Assert(err, gc.IsNil)
         c.Assert(result.ProviderType, gc.Equals, "dummy")
         c.Assert(result.AuthorizedKeys, gc.Equals, coretesting.FakeAuthKeys)
         c.Assert(result.SSLHostnameVerification, jc.IsTrue)
 }
 
-func (s *provisionerSuite) TestCACert(c *gc.C) {
-        caCert, err := s.provisioner.CACert()
-        c.Assert(err, gc.IsNil)
-        c.Assert(caCert, gc.DeepEquals, s.State.CACert())
-}
-
 func (s *provisionerSuite) TestToolsWrongMachine(c *gc.C) {
         tools, err := s.provisioner.Tools("42")
         c.Assert(err, gc.ErrorMatches, "permission denied")
         c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
         c.Assert(tools, gc.IsNil)
 }
 
 func (s *provisionerSuite) TestTools(c *gc.C) {
         cur := version.Current
         curTools := &tools.Tools{Version: cur, URL: ""}
@@ skipping 25 matching lines @@
         c.Assert(err, gc.IsNil)
         err = apiMachine.SupportsNoContainers()
         c.Assert(err, gc.IsNil)
 
         err = s.machine.Refresh()
         c.Assert(err, gc.IsNil)
         containers, ok := s.machine.SupportedContainers()
         c.Assert(ok, jc.IsTrue)
         c.Assert(containers, gc.DeepEquals, []instance.ContainerType{})
 }