status: added display of relations for services

cmd/juju/status_test.go

 package main
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
         . "launchpad.net/gocheck"
         "launchpad.net/goyaml"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/cmd"
@@ skipping 17 matching lines @@
 }
 
 type StatusSuite struct {
         testing.JujuConnSuite
 }
 
 var _ = Suite(&StatusSuite{})
 
 type M map[string]interface{}
 
+type L []interface{}
+
 type testCase struct {
         summary string
         steps   []stepper
 }
 
 func test(summary string, steps ...stepper) testCase {
         return testCase{summary, steps}
 }
 
 type stepper interface {
@@ skipping 42 matching lines @@
         machine1 = M{
                 "agent-state": "started",
                 "dns-name":    "dummyenv-1.dns",
                 "instance-id": "dummyenv-1",
         }
         machine2 = M{
                 "agent-state": "started",
                 "dns-name":    "dummyenv-2.dns",
                 "instance-id": "dummyenv-2",
         }
+        machine3 = M{
+                "agent-state": "started",
+                "dns-name":    "dummyenv-3.dns",
+                "instance-id": "dummyenv-3",
+        }
         unexposedService = M{
                 "charm":   "local:series/dummy-1",
                 "exposed": false,
         }
         exposedService = M{
                 "charm":   "local:series/dummy-1",
                 "exposed": true,
         }
 )
 
@@ skipping 82 matching lines @@
                                         },
                                 },
                                 "services": M{},
                         },
                 },
         ), test(
                 "add two services and expose one, then add 2 more machines and some units",
                 addMachine{"0", state.JobManageEnviron},
                 startAliveMachine{"0"},
                 setMachineStatus{"0", params.StatusStarted, ""},
-                addCharm{"dummy"},
+                addCharm{"dummy", nil, nil},
                 addService{"dummy-service", "dummy"},
                 addService{"exposed-service", "dummy"},
                 expect{
                         "no services exposed yet",
                         M{
                                 "machines": M{
                                         "0": machine0,
                                 },
                                 "services": M{
                                         "dummy-service":   unexposedService,
@@ skipping 123 matching lines @@
                                                         "dummy-service/0": M{
                                                                 "machine":          "1",
                                                                 "agent-state":      "down",
                                                                 "agent-state-info": "(started)",
                                                         },
                                                 },
                                         },
                                 },
                         },
                 },
+        ), test(
+                "add two services, expose them, add machines and relate them",
+                addMachine{"0", state.JobManageEnviron},
+                startAliveMachine{"0"},
+                setMachineStatus{"0", params.StatusStarted, ""},
+                addCharm{"dummy",
+                        map[string]charm.Relation{
+                                "foo": charm.Relation{
+                                        Name:      "foo",
+                                        Role:      charm.RoleProvider,
+                                        Interface: "ifce-a",
+                                        Optional:  false,
+                                        Limit:     1,
+                                        Scope:     charm.ScopeGlobal,
+                                },
+                                "bar": charm.Relation{
+                                        Name:      "bar",
+                                        Role:      charm.RoleProvider,
+                                        Interface: "ifce-b",
+                                        Optional:  false,
+                                        Limit:     1,
+                                        Scope:     charm.ScopeGlobal,
+                                },
+                        },
+                        map[string]charm.Relation{
+                                "baz": charm.Relation{
+                                        Name:      "baz",
+                                        Role:      charm.RoleRequirer,
+                                        Interface: "ifce-a",
+                                        Optional:  false,
+                                        Limit:     1,
+                                        Scope:     charm.ScopeGlobal,
+                                },
+                                "yadda": charm.Relation{
+                                        Name:      "yadda",
+                                        Role:      charm.RoleRequirer,
+                                        Interface: "ifce-b",
+                                        Optional:  false,
+                                        Limit:     1,
+                                        Scope:     charm.ScopeGlobal,
+                                },
+                        },
+                },
+
+                addService{"a-service", "dummy"},

[fwereade, 2013/04/15 00:36:30]

"mysql", "mysql"

[TheMue, 2013/04/15 12:20:41]

Done.

+                setServiceExposed{"a-service", true},
+                addMachine{"1", state.JobHostUnits},
+                startAliveMachine{"1"},
+                setMachineStatus{"1", params.StatusStarted, ""},
+                addUnit{"a-service", "1"},
+
+                addService{"b-service", "dummy"},

[fwereade, 2013/04/15 00:36:30]

"wordpress", "wordpress"

[TheMue, 2013/04/15 12:20:41]

Done.

+                setServiceExposed{"b-service", true},
+                addMachine{"2", state.JobHostUnits},
+                startAliveMachine{"2"},
+                setMachineStatus{"2", params.StatusStarted, ""},
+                addUnit{"b-service", "2"},
+
+                addService{"c-service", "dummy"},

[fwereade, 2013/04/15 00:36:30]

"another-wordpress", "wordpress"

...or whatever. But, please, something more meaningful than a, b, c :).

[TheMue, 2013/04/15 12:20:41]

Done. But also "dummy" isn't very meaningful. ;)

+                setServiceExposed{"c-service", true},
+                addMachine{"3", state.JobHostUnits},
+                startAliveMachine{"3"},
+                setMachineStatus{"3", params.StatusStarted, ""},
+                addUnit{"c-service", "3"},
+
+                relateServices{"a-service", "foo", "b-service", "baz", "ifce-a"},
+                relateServices{"a-service", "bar", "c-service", "yadda", "ifce-b"},
+
+                expect{
+                        "two services with a provider requirer relation between them",
+                        M{
+                                "machines": M{
+                                        "0": machine0,
+                                        "1": machine1,
+                                        "2": machine2,
+                                        "3": machine3,
+                                },
+                                "services": M{
+                                        "a-service": M{
+                                                "charm":   "local:series/dummy-1",
+                                                "exposed": true,
+                                                "units": M{
+                                                        "a-service/0": M{
+                                                                "machine":     "1",
+                                                                "agent-state": "pending",
+                                                        },
+                                                },
+                                                "relations": M{
+                                                        "0": L{"b-service"},

[fwereade, 2013/04/15 00:36:30]

The key should be the relation name from the point of view of the service it's
under. Something like:

services:
  wordpress:
    relations:
      db: [mysql]
  another-wordpress:
    relations:
      db: [mysql]
  mysql: 
    relations:
      server: [wordpress,another-wordpress]

Please consider context... if the key really were relation id, there'd be no
sense at all in the value being a list.

+                                                        "1": L{"c-service"},
+                                                },
+                                        },
+                                        "b-service": M{
+                                                "charm":   "local:series/dummy-1",
+                                                "exposed": true,
+                                                "units": M{
+                                                        "b-service/0": M{
+                                                                "machine":     "2",
+                                                                "agent-state": "pending",
+                                                        },
+                                                },
+                                                "relations": M{
+                                                        "0": L{"a-service"},
+                                                },
+                                        },
+                                        "c-service": M{
+                                                "charm":   "local:series/dummy-1",
+                                                "exposed": true,
+                                                "units": M{
+                                                        "c-service/0": M{
+                                                                "machine":     "3",
+                                                                "agent-state": "pending",
+                                                        },
+                                                },
+                                                "relations": M{
+                                                        "1": L{"a-service"},
+                                                },
+                                        },
+                                },
+                        },
+                },
         ),
 }
 
 // TODO(dfc) test failing components by destructively mutating the state under the hood
 
 type addMachine struct {
         machineId string
         job       state.MachineJob
 }
 
@@ skipping 42 matching lines @@
 }
 
 func (st setTools) step(c *C, ctx *context) {
         m, err := ctx.st.Machine(st.machineId)
         c.Assert(err, IsNil)
         err = m.SetAgentTools(st.tools)
         c.Assert(err, IsNil)
 }
 
 type addCharm struct {
-        name string
+        name     string
+        provides map[string]charm.Relation
+        requires map[string]charm.Relation

[fwereade, 2013/04/15 00:36:30]

Please just use the standard testing charms (wordpress, mysql, riak, logging)
which offer, I think, all distinct relation types amongst themselves; and stick
with "name" as the only field here.

[TheMue, 2013/04/15 12:20:41]

Done.

[TheMue, 2013/04/15 12:20:41]

Done.

 }
 
 func (ac addCharm) step(c *C, ctx *context) {
         ch := coretesting.Charms.Dir(ac.name)
         name, rev := ch.Meta().Name, ch.Revision()
+        if ac.provides != nil {
+                ch.Meta().Provides = ac.provides
+        }
+        if ac.requires != nil {
+                ch.Meta().Requires = ac.requires
+        }
         curl := charm.MustParseURL(fmt.Sprintf("local:series/%s-%d", name, rev))
         bundleURL, err := url.Parse(fmt.Sprintf("http://bundles.example.com/%s-%d", name, rev))
         c.Assert(err, IsNil)
         dummy, err := ctx.st.AddCharm(ch, curl, bundleURL, fmt.Sprintf("%s-%d-sha256", name, rev))
         c.Assert(err, IsNil)
         ctx.charms[ac.name] = dummy
 }
 
 type addService struct {
         name  string
@@ skipping 79 matching lines @@
         status     params.Status
         statusInfo string
 }
 
 func (sms setMachineStatus) step(c *C, ctx *context) {
         m, err := ctx.st.Machine(sms.machineId)
         err = m.SetStatus(sms.status, sms.statusInfo)
         c.Assert(err, IsNil)
 }
 
+type relateServices struct {
+        serviceNameA string
+        nameA        string
+        serviceNameB string
+        nameB        string
+        ifce         string
+}
+
+func (rs relateServices) step(c *C, ctx *context) {
+        epA := state.Endpoint{
+                ServiceName: rs.serviceNameA,
+                Relation: charm.Relation{
+                        Interface: rs.ifce,
+                        Name:      rs.nameA,
+                        Role:      charm.RoleProvider,
+                        Scope:     charm.ScopeGlobal,
+                },
+        }
+        epB := state.Endpoint{
+                ServiceName: rs.serviceNameB,
+                Relation: charm.Relation{
+                        Interface: rs.ifce,
+                        Name:      rs.nameB,
+                        Role:      charm.RoleRequirer,
+                        Scope:     charm.ScopeGlobal,
+                },
+        }
+        _, err := ctx.st.AddRelation(epA, epB)
+        c.Assert(err, IsNil)
+}

[fwereade, 2013/04/15 00:36:30]

type relateServices struct{
    ep1, ep2 string
}

func (rs relateServices) step(c *C, ctx *context) {
    eps, err := ctx.st.InferEndpoints([]string{rs.ep1, rs.ep2})
    c.Assert(err, IsNil)
    _, err := ctx.st.AddRelation(eps...)
    c.Assert(err, IsNil)
}

...or something like that anyway.

[TheMue, 2013/04/15 12:20:41]

Done.

+
 type expect struct {
         what   string
         output M
 }
 
 func (e expect) step(c *C, ctx *context) {
         c.Log("expect: %s", e.what)
 
         // Now execute the command for each format.
         for _, format := range statusFormats {
@@ skipping 22 matching lines @@
         for i, t := range statusTests {
                 c.Log("test %d: %s", i, t.summary)
                 func() {
                         // Prepare context and run all steps to setup.
                         ctx := s.newContext()
                         defer s.resetContext(c, ctx)
                         ctx.run(c, t.steps)
                 }()
         }
 }