Added methods for relation endpoints to topology.

state/internal_test.go

 // launchpad.net/juju/go/state
 //
 // Copyright (c) 2011-2012 Canonical Ltd.
 package state
 
 import (
         . "launchpad.net/gocheck"
         "launchpad.net/goyaml"
         "launchpad.net/gozk/zookeeper"
 )
@@ skipping 458 matching lines @@
         c.Assert(relation.Services[RolePeer], Equals, "s-p")
 }
 
 func (s *TopologySuite) TestAddRelation(c *C) {
         // Check that adding a relation works and can only be done once and with········
         // valid services.
         relation, err := s.t.Relation("r-1")
         c.Assert(relation, IsNil)
         c.Assert(err, ErrorMatches, `relation "r-1" does not exist`)
         s.t.AddService("s-p", "mysql")
-        s.t.AddService("s-c", "wordpress")
+        s.t.AddService("s-r", "wordpress")
         err = s.t.AddRelation("r-1", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-c"},
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r"},
         })
         c.Assert(err, IsNil)
         relation, err = s.t.Relation("r-1")
         c.Assert(err, IsNil)
         c.Assert(relation, NotNil)
         c.Assert(relation.Services[RoleProvider], Equals, "s-p")
-        c.Assert(relation.Services[RoleRequirer], Equals, "s-c")
+        c.Assert(relation.Services[RoleRequirer], Equals, "s-r")
 
         err = s.t.AddRelation("r-2", &zkRelation{
                 Interface: "",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-c"},
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r"},
         })
         c.Assert(err, ErrorMatches, `relation interface is empty`)
 
         err = s.t.AddRelation("r-2", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
                 Services:  map[RelationRole]string{},
         })
         c.Assert(err, ErrorMatches, `no service defined`)
 
         err = s.t.AddRelation("r-2", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
                 Services:  map[RelationRole]string{RoleProvider: "s-p"},
         })
         c.Assert(err, ErrorMatches, `provider or consumer service missing`)
 
         err = s.t.AddRelation("r-2", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RolePeer: "s-c"},
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RolePeer: "s-r"},
         })
         c.Assert(err, ErrorMatches, `mixed peer with provider or consumer service`)
 
         err = s.t.AddRelation("r-2", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-c", RolePeer: "s-c"},
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r", RolePeer: "s-r"},
         })
         c.Assert(err, ErrorMatches, `too many services defined`)
 
         err = s.t.AddRelation("r-2", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
                 Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "illegal"},
         })
         c.Assert(err, ErrorMatches, `service with key "illegal" not found`)
 
         err = s.t.AddRelation("r-1", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-c"},
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r"},
         })
         c.Assert(err, ErrorMatches, `relation key "r-1" already in use`)
 }
 
 func (s *TopologySuite) TestRelationKeys(c *C) {
         // Check that fetching the relation keys works.
         keys := s.t.RelationKeys()
         c.Assert(keys, DeepEquals, []string{})
 
         s.t.AddService("s-p", "riak")
         s.t.AddRelation("r-1", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
                 Services:  map[RelationRole]string{RolePeer: "s-p"},
         })
         keys = s.t.RelationKeys()
         c.Assert(keys, DeepEquals, []string{"r-1"})
 
         s.t.AddRelation("r-2", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
                 Services:  map[RelationRole]string{RolePeer: "s-p"},
         })
         keys = s.t.RelationKeys()
         c.Assert(keys, DeepEquals, []string{"r-1", "r-2"})
 }
 
 func (s *TopologySuite) TestRemoveRelation(c *C) {
         // Check that removing of a relation works.
-        s.t.AddService("s-c", "wordpress")
+        s.t.AddService("s-r", "wordpress")
         s.t.AddService("s-p", "mysql")
 
         err := s.t.AddRelation("r-1", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-c"},
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r"},
         })
         c.Assert(err, IsNil)
 
         relation, err := s.t.Relation("r-1")
         c.Assert(err, IsNil)
         c.Assert(relation, NotNil)
         c.Assert(relation.Services[RoleProvider], Equals, "s-p")
-        c.Assert(relation.Services[RoleRequirer], Equals, "s-c")
+        c.Assert(relation.Services[RoleRequirer], Equals, "s-r")
 
         s.t.RemoveRelation("r-1")
 
         relation, err = s.t.Relation("r-1")
         c.Assert(relation, IsNil)
         c.Assert(err, ErrorMatches, `relation "r-1" does not exist`)
 }
 
 func (s *TopologySuite) TestRemoveServiceWithRelations(c *C) {
         // Check that the removing of a service with
         // associated relations leads to an error.
         s.t.AddService("s-p", "riak")
         s.t.AddRelation("r-1", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
                 Services:  map[RelationRole]string{RolePeer: "s-p"},
         })
 
         err := s.t.RemoveService("s-p")
         c.Assert(err, ErrorMatches, `cannot remove service "s-p" with active relations`)
 }
 
+func (s *TopologySuite) TestRelationKeyEndpoints(c *C) {
+        mysqlep1 := RelationEndpoint{"mysql", "ifce1", "blog1", RoleProvider, ScopeGlobal}
+        blogep1 := RelationEndpoint{"wordpress", "ifce1", "blog1", RoleRequirer, ScopeGlobal}
+        mysqlep2 := RelationEndpoint{"mysql", "ifce2", "blog2", RoleProvider, ScopeGlobal}
+        blogep2 := RelationEndpoint{"wordpress", "ifce2", "blog2", RoleRequirer, ScopeGlobal}
+        mysqlep3 := RelationEndpoint{"mysql", "ifce3", "blog3", RoleProvider, ScopeGlobal}
+        blogep3 := RelationEndpoint{"wordpress", "ifce3", "blog3", RoleRequirer, ScopeGlobal}
+        s.t.AddService("s-r", "wordpress")
+        s.t.AddService("s-p", "mysql")
+        s.t.AddRelation("r-0", &zkRelation{
+                Interface: "ifce1",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r"},
+        })
+        s.t.AddRelation("r-1", &zkRelation{
+                Interface: "ifce2",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r"},
+        })
+
+        // Valid relations.
+        key, err := s.t.RelationKey(mysqlep1, blogep1)
+        c.Assert(err, IsNil)
+        c.Assert(key, Equals, "r-0")
+        key, err = s.t.RelationKey(blogep1, mysqlep1)
+        c.Assert(err, IsNil)
+        c.Assert(key, Equals, "r-0")
+        key, err = s.t.RelationKey(mysqlep2, blogep2)
+        c.Assert(err, IsNil)
+        c.Assert(key, Equals, "r-1")
+        key, err = s.t.RelationKey(blogep2, mysqlep2)
+        c.Assert(err, IsNil)
+        c.Assert(key, Equals, "r-1")
+
+        // Endpoints without relation.
+        _, err = s.t.RelationKey(mysqlep3, blogep3)
+        c.Assert(err, ErrorMatches, `state: no relation between "provider:blog3:mysql:ifce3" and "requirer:blog3:wordpress:ifce3"`)
+
+        // Mix of endpoints of two relations.
+        _, err = s.t.RelationKey(mysqlep1, blogep2)
+        c.Assert(err, ErrorMatches, `state: no relation between "provider:blog1:mysql:ifce1" and "requirer:blog2:wordpress:ifce2"`)
+}
+
+func (s *TopologySuite) TestRelationKeyIllegalEndpoints(c *C) {
+        mysqlep1 := RelationEndpoint{"mysql", "ifce", "blog", RoleProvider, ScopeGlobal}
+        blogep1 := RelationEndpoint{"wordpress", "ifce", "blog", RoleRequirer, ScopeGlobal}
+        mysqlep2 := RelationEndpoint{"illegal-mysql", "ifce", "blog", RoleProvider, ScopeGlobal}
+        blogep2 := RelationEndpoint{"illegal-wordpress", "ifce", "blog", RoleRequirer, ScopeGlobal}
+        riakep3 := RelationEndpoint{"riak", "ifce", "ring", RolePeer, ScopeGlobal}
+        s.t.AddService("s-r", "wordpress")
+        s.t.AddService("s-p1", "mysql")
+        s.t.AddService("s-p2", "riak")
+        s.t.AddRelation("r-0", &zkRelation{
+                Interface: "ifce1",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]string{RoleProvider: "s-p1", RoleRequirer: "s-r"},
+        })
+
+        key, err := s.t.RelationKey(mysqlep1, blogep2)
+        c.Assert(key, Equals, "")
+        c.Assert(err, ErrorMatches, `service with name "illegal-wordpress" not found`)
+        key, err = s.t.RelationKey(mysqlep2, blogep1)
+        c.Assert(key, Equals, "")
+        c.Assert(err, ErrorMatches, `service with name "illegal-mysql" not found`)
+        key, err = s.t.RelationKey(mysqlep1, riakep3)
+        c.Assert(key, Equals, "")
+        c.Assert(err, ErrorMatches, `state: no relation between "provider:blog:mysql:ifce" and "peer:ring:riak:ifce"`)
+}
+
+func (s *TopologySuite) TestPeerRelationKeyEndpoints(c *C) {
+        riakep1 := RelationEndpoint{"riak", "ifce1", "ring", RolePeer, ScopeGlobal}
+        riakep2 := RelationEndpoint{"riak", "ifce2", "ring", RolePeer, ScopeGlobal}
+        riakep3 := RelationEndpoint{"riak", "ifce3", "ring", RolePeer, ScopeGlobal}
+        s.t.AddService("s-p", "riak")
+        s.t.AddRelation("r-0", &zkRelation{
+                Interface: "ifce1",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]string{RolePeer: "s-p"},
+        })
+        s.t.AddRelation("r-1", &zkRelation{
+                Interface: "ifce2",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]string{RolePeer: "s-p"},
+        })
+
+        // Valid relations.
+        key, err := s.t.PeerRelationKey(riakep1)
+        c.Assert(err, IsNil)
+        c.Assert(key, Equals, "r-0")
+        key, err = s.t.PeerRelationKey(riakep2)
+        c.Assert(err, IsNil)
+        c.Assert(key, Equals, "r-1")
+
+        // Endpoint without relation.
+        key, err = s.t.PeerRelationKey(riakep3)
+        c.Assert(err, ErrorMatches, `state: no peer relation for "peer:ring:riak:ifce3"`)
+}
+
+func (s *TopologySuite) TestPeerRelationKeyIllegalEndpoints(c *C) {
+        riakep1 := RelationEndpoint{"illegal-riak", "ifce", "ring", RolePeer, ScopeGlobal}
+        s.t.AddService("s-p", "riak")
+        s.t.AddRelation("r-0", &zkRelation{
+                Interface: "ifce",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]string{RolePeer: "s-p"},
+        })
+
+        key, err := s.t.PeerRelationKey(riakep1)
+        c.Assert(key, Equals, "")
+        c.Assert(err, ErrorMatches, `service with name "illegal-riak" not found`)
+}
+
 type ConfigNodeSuite struct {
         zkServer   *zookeeper.Server
         zkTestRoot string
         zkTestPort int
         zkAddr     string
         zkConn     *zookeeper.Conn
         path       string
 }
 
 var _ = Suite(&ConfigNodeSuite{})
@@ skipping 336 matching lines @@
         out := Quote(in)
         c.Assert(out, Equals, in)
 }
 
 func (s *QuoteSuite) TestQuote(c *C) {
         // Check that invalid chars are translated correctly.
         in := "hello_there/how'are~you-today.sir"
         out := Quote(in)
         c.Assert(out, Equals, "hello_5f_there_2f_how_27_are_7e_you-today.sir")
 }