Implementation of the charm state.

state/state_test.go

 // launchpad.net/juju/go/state
 //
 // Copyright (c) 2011-2012 Canonical Ltd.
 package state_test
 
 import (
         "fmt"
         . "launchpad.net/gocheck"
         "launchpad.net/gozk/zookeeper"
         "launchpad.net/juju/go/charm"
         "launchpad.net/juju/go/state"
+        "net/url"
         "path/filepath"
         "testing"
 )
 
 // TestPackage integrates the tests into gotest.
 func TestPackage(t *testing.T) {
         srv, dir := state.ZkSetUpEnvironment(t)
         defer state.ZkTearDownEnvironment(t, srv, dir)
 
         TestingT(t)
@@ skipping 14 matching lines @@
 // localCharmURL returns the local URL of a charm.
 func localCharmURL(ch charm.Charm) *charm.URL {
         url := fmt.Sprintf("local:series/%s-%d", ch.Meta().Name, ch.Revision())
         return charm.MustParseURL(url)
 }
 
 // addDummyCharm adds the 'dummy' charm state to st.
 func addDummyCharm(c *C, st *state.State) (*state.Charm, *charm.URL) {
         ch := readCharm(c, "dummy")
         curl := localCharmURL(ch)
-        dummy, err := st.AddCharm(ch, curl, "http://bundle.url")
+        bundleURL, err := url.Parse("http://bundle.url")
+        c.Assert(err, IsNil)
+        dummy, err := st.AddCharm(ch, curl, bundleURL)
         c.Assert(err, IsNil)
         return dummy, curl
 }
 
 type StateSuite struct {
         zkServer   *zookeeper.Server
         zkTestRoot string
         zkTestPort int
         zkAddr     string
         zkConn     *zookeeper.Conn
@@ skipping 22 matching lines @@
         zkRemoveTree(s.zkConn, "/units")
         zkRemoveTree(s.zkConn, "/relations")
         zkRemoveTree(s.zkConn, "/initialized")
         s.zkConn.Close()
 }
 
 func (s StateSuite) TestAddCharm(c *C) {
         // Check that adding charms works correctly.
         dummyCharm := readCharm(c, "dummy")
         curl := localCharmURL(dummyCharm)
-        dummy, err := s.st.AddCharm(dummyCharm, curl, "http://bundle.url")
+        bundleURL, err := url.Parse("http://bundle.url")
+        c.Assert(err, IsNil)
+        dummy, err := s.st.AddCharm(dummyCharm, curl, bundleURL)
         c.Assert(err, IsNil)
         c.Assert(dummy.URL().String(), Equals, curl.String())
-
-        children, _, err := s.zkConn.Children("/charms")
-        c.Assert(err, IsNil)
-        c.Assert(children, Equals, []string{"local_3a_series_2f_dummy-1"})
-}
-
-func (s StateSuite) TestCharm(c *C) {
-        // Check that reading a previously added charm works correctly.
-        dummy, curl := addDummyCharm(c, s.st)
-
-        dummy, err := s.st.Charm(curl)
-        c.Assert(err, IsNil)
-        c.Assert(dummy.URL().String(), Equals, curl.String())
+        _, _, err = s.zkConn.Children("/charms")
+        c.Assert(err, IsNil)
 }
 
 func (s StateSuite) TestCharmAttributes(c *C) {
         // Check that the basic (invariant) fields of the charm
         // are correctly in place.
-        dummy, curl := addDummyCharm(c, s.st)
+        _, curl := addDummyCharm(c, s.st)
 
         dummy, err := s.st.Charm(curl)
         c.Assert(err, IsNil)
         c.Assert(dummy.URL().String(), Equals, curl.String())
         c.Assert(dummy.Revision(), Equals, 1)
-        c.Assert(dummy.BundleURL(), Equals, "http://bundle.url")
-}
-
-func (s StateSuite) TestCharmMetadata(c *C) {
-        // Check that the charm metadata was correctly saved and loaded.
-        dummy, curl := addDummyCharm(c, s.st)
-
-        dummy, err := s.st.Charm(curl)
-        c.Assert(err, IsNil)
+        bundleURL, err := url.Parse("http://bundle.url")
+        c.Assert(err, IsNil)
+        c.Assert(dummy.BundleURL(), DeepEquals, bundleURL)
         meta := dummy.Meta()
         c.Assert(meta.Name, Equals, "dummy")
-}
-
-func (s StateSuite) TestCharmConfig(c *C) {
-        // Verify that the charm config is present and correct.
-        dummy, curl := addDummyCharm(c, s.st)
-
-        dummy, err := s.st.Charm(curl)
-        c.Assert(err, IsNil)
         config := dummy.Config()
         c.Assert(config.Options["title"], Equals,
                 charm.Option{
                         Default:     "My Title",
                         Description: "A descriptive title used for the service.",
                         Type:        "string",
                 },
         )
 }
 
 func (s StateSuite) TestNonExistentCharmPriorToInitialization(c *C) {
-        // Check that getting a charm before anyone has been added fails nicely.
+        // Check that getting a charm before any other charm has been added fails nicely.
         curl, err := charm.ParseURL("local:series/dummy-1")
         c.Assert(err, IsNil)
         _, err = s.st.Charm(curl)
         c.Assert(err, ErrorMatches, `charm not found: "local:series/dummy-1"`)
 }
 
 func (s StateSuite) TestGetNonExistentCharm(c *C) {
         // Check that getting a non-existent charm fails nicely.
         addDummyCharm(c, s.st)
 
@@ skipping 165 matching lines @@
         unit, err = wordpress.Unit("wordpress/0/0")
         c.Assert(err, ErrorMatches, `"wordpress/0/0" is not a valid unit name`)
         unit, err = wordpress.Unit("pressword/0")
         c.Assert(err, ErrorMatches, `can't find unit "pressword/0" on service "wordpress"`)
         unit, err = wordpress.Unit("mysql/0")
         c.Assert(err, ErrorMatches, `can't find unit "mysql/0" on service "wordpress"`)
 
         // Check that retrieving unit names works.
         unitNames, err := wordpress.UnitNames()
         c.Assert(err, IsNil)
-        c.Assert(unitNames, Equals, []string{"wordpress/0", "wordpress/1"})
+        c.Assert(unitNames, DeepEquals, []string{"wordpress/0", "wordpress/1"})
 
         // Check that retrieving all units works.
         units, err := wordpress.AllUnits()
         c.Assert(err, IsNil)
         c.Assert(len(units), Equals, 2)
         c.Assert(units[0].Name(), Equals, "wordpress/0")
         c.Assert(units[1].Name(), Equals, "wordpress/1")
 }
 
 func (s StateSuite) TestReadUnitWithChangingState(c *C) {
@@ skipping 18 matching lines @@
         _, err = wordpress.AddUnit()
         c.Assert(err, IsNil)
 
         // Check that removing a unit works.
         unit, err := wordpress.Unit("wordpress/0")
         c.Assert(err, IsNil)
         err = wordpress.RemoveUnit(unit)
         c.Assert(err, IsNil)
         unitNames, err := wordpress.UnitNames()
         c.Assert(err, IsNil)
-        c.Assert(unitNames, Equals, []string{"wordpress/1"})
+        c.Assert(unitNames, DeepEquals, []string{"wordpress/1"})
 
         // Check that removing a non-existent unit fails nicely.
         err = wordpress.RemoveUnit(unit)
         c.Assert(err, ErrorMatches, "environment state has changed")
 }
 
 func (s StateSuite) TestGetSetPublicAddress(c *C) {
         dummy, _ := addDummyCharm(c, s.st)
         wordpress, err := s.st.AddService("wordpress", dummy)
         c.Assert(err, IsNil)
@@ skipping 184 matching lines @@
         c.Assert(err, IsNil)
         wordpressUnit, err := wordpressService.AddUnit()
         c.Assert(err, IsNil)
         err = s.st.RemoveService(wordpressService)
         c.Assert(err, IsNil)
 
         _, err = wordpressUnit.AssignToUnusedMachine()
         c.Assert(err, ErrorMatches, "environment state has changed")
 }
 
-func (s StateSuite) TestAssignUniToUnusedMachineWithChangingUnit(c *C) {
+func (s StateSuite) TestAssignUnitToUnusedMachineWithChangingUnit(c *C) {
         // Create root machine that shouldn't be useds.
         _, err := s.st.AddMachine()
         c.Assert(err, IsNil)
         // Check for a 'state changed' error if a unit is manipulated
         // during reuse.
         dummy, _ := addDummyCharm(c, s.st)
         mysqlService, err := s.st.AddService("mysql", dummy)
         c.Assert(err, IsNil)
         mysqlUnit, err := mysqlService.AddUnit()
         c.Assert(err, IsNil)
@@ skipping 62 matching lines @@
                 return err
         }
         for _, child := range children {
                 if err = zkRemoveTree(zk, fmt.Sprintf("%s/%s", path, child)); err != nil {
                         return err
                 }
         }
         // Now delete the path itself.
         return zk.Delete(path, -1)
 }