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"
 )
 
 type TopologySuite struct {
         zkServer   *zookeeper.Server
@@ skipping 440 matching lines @@
 
 func (s *TopologySuite) TestRelation(c *C) {
         // Check that the retrieving of relations works correctly.
         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", "riak")
         s.t.AddRelation("r-1", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RolePeer: "s-p"},
+                Services:  map[RelationRole]*zkRelationService{RolePeer: &zkRelationService{"s-p", "cache"}},
         })
         relation, err = s.t.Relation("r-1")
         c.Assert(err, IsNil)
         c.Assert(relation, NotNil)
-        c.Assert(relation.Services[RolePeer], Equals, "s-p")
+        c.Assert(relation.Services[RolePeer].Service, 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-r", "wordpress")
         err = s.t.AddRelation("r-1", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r"},
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RoleRequirer: &zkRelationService{"s-r", "db"},
+                },
         })
         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-r")
+        c.Assert(relation.Services[RoleProvider].Service, Equals, "s-p")
+        c.Assert(relation.Services[RoleRequirer].Service, Equals, "s-r")
 
         err = s.t.AddRelation("r-2", &zkRelation{
                 Interface: "",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r"},
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RoleRequirer: &zkRelationService{"s-r", "db"},
+                },
         })
         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-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-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"},
+        err = s.t.AddRelation("r-3", &zkRelation{
+                Interface: "ifce",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]*zkRelationService{},
+        })
+        c.Assert(err, ErrorMatches, `relation has no services`)
+
+        err = s.t.AddRelation("r-4", &zkRelation{
+                Interface: "ifce",
+                Scope:     ScopeGlobal,
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                },
+        })
+        c.Assert(err, ErrorMatches, `relation has provider but no requirer`)
+
+        err = s.t.AddRelation("r-5", &zkRelation{
+                Interface: "ifce",
+                Scope:     ScopeGlobal,
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RolePeer:     &zkRelationService{"s-r", "db"},
+                },
+        })
+        c.Assert(err, ErrorMatches, `relation has provider but no requirer`)
+
+        err = s.t.AddRelation("r-6", &zkRelation{
+                Interface: "ifce",
+                Scope:     ScopeGlobal,
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RoleRequirer: &zkRelationService{"s-r", "db"},
+                        RolePeer:     &zkRelationService{"s-r", "db"},
+                },
+        })
+        c.Assert(err, ErrorMatches, `relation with mixed peer, provider, and requirer roles`)
+
+        err = s.t.AddRelation("r-7", &zkRelation{
+                Interface: "ifce",
+                Scope:     ScopeGlobal,
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RoleRequirer: &zkRelationService{"illegal", "db"},
+                },
         })
         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-r"},
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RoleRequirer: &zkRelationService{"s-r", "db"},
+                },
         })
         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"},
+                Services: map[RelationRole]*zkRelationService{
+                        RolePeer: &zkRelationService{"s-p", "cache"},
+                },
         })
         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"},
+                Services: map[RelationRole]*zkRelationService{
+                        RolePeer: &zkRelationService{"s-p", "cache"},
+                },
         })
         keys = s.t.RelationKeys()
         c.Assert(keys, DeepEquals, []string{"r-1", "r-2"})
+}
+
+func (s *TopologySuite) TestRelationsForService(c *C) {
+        // Check that fetching the relations for a service works.
+        s.t.AddService("s-p", "riak")
+        relations, err := s.t.RelationsForService("s-p")
+        c.Assert(err, IsNil)
+        c.Assert(relations, HasLen, 0)
+
+        s.t.AddRelation("r-0", &zkRelation{
+                Interface: "ifce0",
+                Scope:     ScopeGlobal,
+                Services: map[RelationRole]*zkRelationService{
+                        RolePeer: &zkRelationService{"s-p", "cache"},
+                },
+        })
+        s.t.AddRelation("r-1", &zkRelation{
+                Interface: "ifce1",
+                Scope:     ScopeGlobal,
+                Services: map[RelationRole]*zkRelationService{
+                        RolePeer: &zkRelationService{"s-p", "cache"},
+                },
+        })
+        relations, err = s.t.RelationsForService("s-p")
+        c.Assert(err, IsNil)
+        c.Assert(relations, HasLen, 2)
+        c.Assert(relations["r-0"].Interface, Equals, "ifce0")
+        c.Assert(relations["r-1"].Interface, Equals, "ifce1")
+
+        s.t.RemoveRelation("r-0")
+        relations, err = s.t.RelationsForService("s-p")
+        c.Assert(err, IsNil)
+        c.Assert(relations, HasLen, 1)
+        c.Assert(relations["r-1"].Interface, Equals, "ifce1")
 }
 
 func (s *TopologySuite) TestRemoveRelation(c *C) {
         // Check that removing of a relation works.
         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-r"},
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RoleRequirer: &zkRelationService{"s-r", "db"},
+                },
         })
         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-r")
+        c.Assert(relation.Services[RoleProvider].Service, Equals, "s-p")
+        c.Assert(relation.Services[RoleRequirer].Service, 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"},
+                Services: map[RelationRole]*zkRelationService{
+                        RolePeer: &zkRelationService{"s-p", "cache"},
+                },
         })
 
         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}
+        mysqlep1 := RelationEndpoint{"mysql", "ifce1", "db", RoleProvider, ScopeGlobal}
+        blogep1 := RelationEndpoint{"wordpress", "ifce1", "db", RoleRequirer, ScopeGlobal}
+        mysqlep2 := RelationEndpoint{"mysql", "ifce2", "db", RoleProvider, ScopeGlobal}
+        blogep2 := RelationEndpoint{"wordpress", "ifce2", "db", RoleRequirer, ScopeGlobal}
+        mysqlep3 := RelationEndpoint{"mysql", "ifce3", "db", RoleProvider, ScopeGlobal}
+        blogep3 := RelationEndpoint{"wordpress", "ifce3", "db", 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"},
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RoleRequirer: &zkRelationService{"s-r", "db"},
+                },
         })
         s.t.AddRelation("r-1", &zkRelation{
                 Interface: "ifce2",
                 Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r"},
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RoleRequirer: &zkRelationService{"s-r", "db"},
+                },
         })
 
         // 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"`)
+        c.Assert(err, ErrorMatches, `state: no relation between "mysql:db" and "wordpress:db"`)
 
         // 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"`)
+        c.Assert(err, ErrorMatches, `state: no relation between "mysql:db" and "wordpress:db"`)
+
+        // Illegal number of endpoints.
+        _, err = s.t.RelationKey()
+        c.Assert(err, ErrorMatches, `state: illegal number of relation endpoints provided`)
+        _, err = s.t.RelationKey(mysqlep1, mysqlep2, blogep1)
+        c.Assert(err, ErrorMatches, `state: illegal number of relation endpoints provided`)
 }
 
 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}
+        mysqlep1 := RelationEndpoint{"mysql", "ifce", "db", RoleProvider, ScopeGlobal}
+        blogep1 := RelationEndpoint{"wordpress", "ifce", "db", RoleRequirer, ScopeGlobal}
+        mysqlep2 := RelationEndpoint{"illegal-mysql", "ifce", "db", RoleProvider, ScopeGlobal}
+        blogep2 := RelationEndpoint{"illegal-wordpress", "ifce", "db", 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"},
+                Services: map[RelationRole]*zkRelationService{
+                        RoleProvider: &zkRelationService{"s-p", "db"},
+                        RoleRequirer: &zkRelationService{"s-r", "db"},
+                },
         })
 
         key, err := s.t.RelationKey(mysqlep1, blogep2)
         c.Assert(key, Equals, "")
-        c.Assert(err, ErrorMatches, `service with name "illegal-wordpress" not found`)
+        c.Assert(err, ErrorMatches, `state: no relation between "mysql:db" and "illegal-wordpress:db"`)
         key, err = s.t.RelationKey(mysqlep2, blogep1)
         c.Assert(key, Equals, "")
-        c.Assert(err, ErrorMatches, `service with name "illegal-mysql" not found`)
+        c.Assert(err, ErrorMatches, `state: no relation between "illegal-mysql:db" and "wordpress:db"`)
         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"`)
+        c.Assert(err, ErrorMatches, `state: no relation between "mysql:db" and "riak:ring"`)
 }
 
 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", "ring")
+        s.t.AddRelation("r-0", &zkRelation{
+                Interface: "ifce1",
+                Scope:     ScopeGlobal,
+                Services: map[RelationRole]*zkRelationService{
+                        RolePeer: &zkRelationService{"s-p", "ring"},
+                },
+        })
+        s.t.AddRelation("r-1", &zkRelation{
+                Interface: "ifce2",
+                Scope:     ScopeGlobal,
+                Services: map[RelationRole]*zkRelationService{
+                        RolePeer: &zkRelationService{"s-p", "ring"},
+                },
+        })
+
+        // Valid relations.
+        key, err := s.t.RelationKey(riakep1)
+        c.Assert(err, IsNil)
+        c.Assert(key, Equals, "r-0")
+        key, err = s.t.RelationKey(riakep2)
+        c.Assert(err, IsNil)
+        c.Assert(key, Equals, "r-1")
+
+        // Endpoint without relation.
+        key, err = s.t.RelationKey(riakep3)
+        c.Assert(err, ErrorMatches, `state: no peer relation for "riak:ring"`)
+}
+
+func (s *TopologySuite) TestPeerRelationKeyIllegalEndpoints(c *C) {
+        riakep1 := RelationEndpoint{"riak", "ifce", "illegal-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)
+                Interface: "ifce",
+                Scope:     ScopeGlobal,
+                Services: map[RelationRole]*zkRelationService{
+                        RolePeer: &zkRelationService{"s-p", "ring"},
+                },
+        })
+
+        key, err := s.t.RelationKey(riakep1)
         c.Assert(key, Equals, "")
-        c.Assert(err, ErrorMatches, `service with name "illegal-riak" not found`)
+        c.Assert(err, ErrorMatches, `state: no peer relation for "riak:illegal-ring"`)
 }
 
 type ConfigNodeSuite struct {
         zkServer   *zookeeper.Server
         zkTestRoot string
         zkTestPort int
         zkAddr     string
         zkConn     *zookeeper.Conn
         path       string
 }
@@ skipping 319 matching lines @@
         // Shouldn't write again. Changes were already
         // flushed and acted upon by other parties.
         changes, err = nodeOne.Write()
         c.Assert(err, IsNil)
         c.Assert(changes, DeepEquals, []ItemChange{})
 
         err = nodeOne.Read()
         c.Assert(err, IsNil)
         c.Assert(nodeOne, DeepEquals, nodeTwo)
 }
-
-type QuoteSuite struct{}
-
-var _ = Suite(&QuoteSuite{})
-
-func (s *QuoteSuite) TestUnmodified(c *C) {
-        // Check that a string containig only valid
-        // chars stays unmodified.
-        in := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-"
-        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")
-}