Added ResolvedWatcher for Units.

state/state_test.go

 package state_test
 
 import (
         "fmt"
         . "launchpad.net/gocheck"
         "launchpad.net/gozk/zookeeper"
         "launchpad.net/juju/go/charm"
         "launchpad.net/juju/go/state"
         "launchpad.net/juju/go/testing"
         "net/url"
@@ skipping 1023 matching lines @@
         // Peer.
         s.st.AddService("riak", dummy)
         riakep := state.RelationEndpoint{"riak", "ring", "cache", state.RolePeer, state.ScopeGlobal}
         relation, serviceRelations, err = s.st.AddRelation(riakep)
         c.Assert(err, IsNil)
         c.Assert(relation, NotNil)
         c.Assert(serviceRelations, HasLen, 1)
         c.Assert(serviceRelations[0].RelationScope(), Equals, state.ScopeGlobal)
         c.Assert(serviceRelations[0].RelationRole(), Equals, state.RolePeer)
         c.Assert(serviceRelations[0].RelationName(), Equals, "cache")
-
 }
 
 func (s *StateSuite) TestAddRelationMissingService(c *C) {
         dummy := s.addDummyCharm(c)
         s.st.AddService("mysqldb", dummy)
         mysqlep := state.RelationEndpoint{"mysqldb", "blog", "db", state.RoleProvider, state.ScopeGlobal}
         blogep := state.RelationEndpoint{"wordpress", "blog", "db", state.RoleRequirer, state.ScopeGlobal}
         _, _, err := s.st.AddRelation(blogep, mysqlep)
         c.Assert(err, ErrorMatches, `service with name "wordpress" not found`)
 }
@@ skipping 63 matching lines @@
 func (s *StateSuite) TestEnvironment(c *C) {
         path, err := s.zkConn.Create("/environment", "type: dummy\nname: foo\n", 0, zookeeper.WorldACL(zookeeper.PERM_ALL))
         c.Assert(err, IsNil)
         c.Assert(path, Equals, "/environment")
 
         env, err := s.st.Environment()
         env.Read()
         c.Assert(err, IsNil)
         c.Assert(env.Map(), DeepEquals, map[string]interface{}{"type": "dummy", "name": "foo"})
 }
+
+func (s *StateSuite) TestAddRelationInvalidEndpoints(c *C) {
+        dummy := s.addDummyCharm(c)
+        s.st.AddService("riak", dummy)
+        // Empty service name.
+        riakep := state.RelationEndpoint{"", "ring", "cache", state.RolePeer, state.ScopeGlobal}
+        _, _, err := s.st.AddRelation(riakep)
+        c.Assert(err, ErrorMatches, `endpoint has empty service name`)
+        // Empty interface.
+        riakep = state.RelationEndpoint{"riak", "", "cache", state.RolePeer, state.ScopeGlobal}
+        _, _, err = s.st.AddRelation(riakep)
+        c.Assert(err, ErrorMatches, `endpoint has empty interface`)
+        // Empty relation name.
+        riakep = state.RelationEndpoint{"riak", "ring", "", state.RolePeer, state.ScopeGlobal}
+        _, _, err = s.st.AddRelation(riakep)
+        c.Assert(err, ErrorMatches, `endpoint has empty relation name`)
+        // Invalid role.
+        riakep = state.RelationEndpoint{"riak", "ring", "cache", state.RelationRole("foo"), state.ScopeGlobal}
+        _, _, err = s.st.AddRelation(riakep)
+        c.Assert(err, ErrorMatches, `can't add non-peer relation with a single service`)
+        // Invalid role.
+        riakep = state.RelationEndpoint{"riak", "ring", "cache", state.RolePeer, state.RelationScope("foo")}
+        _, _, err = s.st.AddRelation(riakep)
+        c.Assert(err, ErrorMatches, `endpoint has invalid scope: "foo"`)
+}