Added relations 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", RoleConsumer: "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[RoleConsumer], 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", RoleConsumer: "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{
+        err = s.t.AddRelation("r-3", &zkRelation{
                 Interface: "ifce",
                 Scope:     ScopeGlobal,
                 Services:  map[RelationRole]string{},
         })
-        c.Assert(err, ErrorMatches, `no service defined`)
-
-        err = s.t.AddRelation("r-2", &zkRelation{
+        c.Assert(err, ErrorMatches, `relation has no services`)
+
+        err = s.t.AddRelation("r-4", &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"},
-        })
-        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", RoleConsumer: "s-c", RolePeer: "s-c"},
-        })
-        c.Assert(err, ErrorMatches, `too much services defined`)
-
-        err = s.t.AddRelation("r-2", &zkRelation{
-                Interface: "ifce",
-                Scope:     ScopeGlobal,
-                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleConsumer: "illegal"},
+        c.Assert(err, ErrorMatches, `relation has provider but no requirer`)
+
+        err = s.t.AddRelation("r-5", &zkRelation{
+                Interface: "ifce",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RolePeer: "s-r"},
+        })
+        c.Assert(err, ErrorMatches, `relation has provider but no requirer`)
+
+        err = s.t.AddRelation("r-6", &zkRelation{
+                Interface: "ifce",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-r", RolePeer: "s-r"},
+        })
+        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]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", RoleConsumer: "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) 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]string{RolePeer: "s-p"},
+        })
+        s.t.AddRelation("r-1", &zkRelation{
+                Interface: "ifce1",
+                Scope:     ScopeGlobal,
+                Services:  map[RelationRole]string{RolePeer: "s-p"},
+        })
+        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-c", "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", RoleConsumer: "s-c"},
+                Services:  map[RelationRole]string{RoleProvider: "s-p", RoleRequirer: "s-c"},
         })
         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[RoleConsumer], Equals, "s-c")
+        c.Assert(relation.Services[RoleRequirer], Equals, "s-c")
 
         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
@@ skipping 358 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")
 }