state/apiserver: Relation ops for Uniter API

state/apiserver/uniter/uniter_test.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package uniter_test
 
 import (
-        "strconv"
         stdtesting "testing"
 
         gc "launchpad.net/gocheck"
 
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/errors"
         "launchpad.net/juju-core/instance"
         "launchpad.net/juju-core/juju/testing"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/api/params"
@@ skipping 754 matching lines @@
         c.Assert(err, gc.IsNil)
         c.Assert(result, gc.DeepEquals, params.StringResults{
                 Results: []params.StringResult{
                         {Error: apiservertesting.ErrUnauthorized},
                         {Result: s.wpCharm.BundleSha256()},
                         {Result: dummyCharm.BundleSha256()},
                 },
         })
 }
 
-func (s *uniterSuite) TestEnvironUUID(c *gc.C) {
+func (s *uniterSuite) TestCurrentEnvironUUID(c *gc.C) {
         env, err := s.State.Environment()
         c.Assert(err, gc.IsNil)
 
-        args := params.Entities{Entities: []params.Entity{
-                {Tag: "environment-foo"},
-                {Tag: env.Tag()},

[fwereade, 2013/08/15 15:57:29]

Yeah, +10 to CurrentEnvironUUID. We should not be depending on environ tags at
all if we can help it, they're definitely crack (they're derived from environ
names, which aren't globally unique; the only option is to always treat them as
aliases).

(Where we're stuck with them, we just have to deal with it, for now; it should
be fixed but that's a derail at this stage.)

[dimitern, 2013/08/15 16:56:56]

Done.

-                {Tag: "foo-bar"},
-                {Tag: "service-foo"},
-                {Tag: "unit-foo-0"},
-        }}
-        result, err := s.uniter.EnvironUUID(args)
-        c.Assert(err, gc.IsNil)
-        c.Assert(result, gc.DeepEquals, params.StringResults{
-                Results: []params.StringResult{
-                        {Error: apiservertesting.ErrUnauthorized},
-                        {Result: env.UUID()},
-                        {Error: apiservertesting.ErrUnauthorized},
-                        {Error: apiservertesting.ErrUnauthorized},
-                        {Error: apiservertesting.ErrUnauthorized},
-                },
-        })
+        result, err := s.uniter.CurrentEnvironUUID()
+        c.Assert(err, gc.IsNil)
+        c.Assert(result, gc.DeepEquals, params.StringResult{Result: env.UUID()})
 }
 
 func (s *uniterSuite) TestRelation(c *gc.C) {
-        s.addRelatedService(c, "wordpress", "logging", s.wordpressUnit)
-        rel, err := s.State.Relation(0)
-        c.Assert(err, gc.IsNil)
-        relEps := rel.Endpoints()
-        eps := make([]params.Endpoint, len(relEps))
-        for i, ep := range relEps {
-                eps[i] = params.Endpoint{
-                        ServiceName: ep.ServiceName,
-                        Relation: charm.Relation{
-                                Name:      ep.Name,
-                                Role:      ep.Role,
-                                Interface: ep.Interface,
-                                Optional:  ep.Optional,
-                                Limit:     ep.Limit,
-                                Scope:     ep.Scope,
-                        },
-                }
-        }
-
-        args := params.Entities{Entities: []params.Entity{
-                {Tag: "relation-42"},
-                {Tag: "relation-0"},
-                {Tag: "relation-blah"},
-                {Tag: "service-foo"},
-                {Tag: "foo"},
-                {Tag: "unit-wordpress-0"},
+        eps, err := s.State.InferEndpoints([]string{"wordpress", "mysql"})
+        c.Assert(err, gc.IsNil)
+        rel, err := s.State.AddRelation(eps...)
+        c.Assert(err, gc.IsNil)
+        c.Assert(rel.Id(), gc.Equals, 0)
+        wpEp, err := rel.Endpoint("wordpress")
+        c.Assert(err, gc.IsNil)
+
+        args := params.Relations{Relations: []params.Relation{
+                {Relation: "relation-42", Unit: "unit-foo-0"},
+                {Relation: "relation-0", Unit: "unit-wordpress-0"},
+                {Relation: "relation-0", Unit: "unit-mysql-0"},
+                {Relation: "relation-0", Unit: "unit-foo-0"},
+                {Relation: "relation-blah", Unit: "unit-wordpress-0"},
+                {Relation: "service-foo", Unit: "user-admin"},
+                {Relation: "foo", Unit: "bar"},
+                {Relation: "unit-wordpress-0", Unit: "relation-0"},
         }}
         result, err := s.uniter.Relation(args)
         c.Assert(err, gc.IsNil)
+        c.Assert(result.Results, gc.HasLen, len(args.Relations))
         c.Assert(result, gc.DeepEquals, params.RelationResults{
                 Results: []params.RelationResult{
                         {Error: apiservertesting.ErrUnauthorized},
-                        {Id: strconv.Itoa(rel.Id()), Key: rel.String(), Endpoints: eps},
-                        {Error: apiservertesting.ErrUnauthorized},
-                        {Error: apiservertesting.ErrUnauthorized},
-                        {Error: apiservertesting.ErrUnauthorized},
-                        {Error: apiservertesting.ErrUnauthorized},
-                },
-        })
-}
+                        {
+                                Id:  rel.Id(),
+                                Key: rel.String(),
+                                Endpoint: params.Endpoint{
+                                        ServiceName: wpEp.ServiceName,
+                                        Relation:    wpEp.Relation,
+                                },
+                        },
+                        {Error: apiservertesting.ErrUnauthorized},
+                        {Error: apiservertesting.ErrUnauthorized},
+                        {Error: apiservertesting.ErrUnauthorized},
+                        {Error: apiservertesting.ErrUnauthorized},
+                        {Error: apiservertesting.ErrUnauthorized},
+                        {Error: apiservertesting.ErrUnauthorized},
+                },
+        })
+}