Merge lp:~chipaca/ubuntu-push/simple-bus-interface into lp:ubuntu-push

[John Lenton]

A simplified (and more testable) dbus api

A very simple interface to dbus, probably not usable outside of what
we need to do. Aiming at being easier to test things that use it.

[Samuele Pedroni (pedronis)]

this is needed (godeps doesn't grab things just fixes revnos):

 -GODEPS = launchpad.net/gocheck
+GODEPS = launchpad.net/gocheck launchpad.net/go-dbus/v1

wondering if

type Bus dbs.StandardBus

wouldn't be a more natural encapsulation?

TestConnect needs to defer .Close

review: Needs Fixing

[Samuele Pedroni (pedronis)]

+ conn.log.Errorf("Got not-OK from %s watch", member)

is this really a error situation? or just expected and then should be a Debugf

[Samuele Pedroni (pedronis)]

does connection need to be its own package? calling Interface interface is a bit atypical, compare with stdlib net for example, in general wondering when the concrete type should have the less nice name and the interface should have the name of the concrete type

[Samuele Pedroni (pedronis)]

I would have at least one more

0 + // c.Check(cond.OK(), gocheck.Equals, true)

[Samuele Pedroni (pedronis)]

you don't need the _ in _iter

[Samuele Pedroni (pedronis)]

go doesn't care too much about order, readers a bit more,

I think typical declaration order is

type,

new function(s),

methods,

here sometimes I see

new function(s)

type

this confused me a couple of times, especially when type is something like work

[Samuele Pedroni (pedronis)]

test suites are wrongly named sometimes, like I see

NMTSuite

[Samuele Pedroni (pedronis)]

I see:

bus/connection/testing/testing_test.go:type NMTSuite struct{}

bus/connection/connection_test.go:type BusSuite struct {

[John Lenton (chipaca)]

☑ GODEPS.
☑ bus type encapsulation (nice suggestion, switching to that)
☑ Deferred the close.
☐ I believe that that error is a sign of something Really Bad happening outside of this service, so I wanted to log it as early as possible and as loudly as possible.
☐ connection does not need its own package; if you can suggest a naming scheme that works for the callee, I'll switch (have tried several things already---but I do suck at naming remember) will discuss more on IRC.
☐ the _ in _iter is to signal to the reader that it is a minor detail (in a more dynamic language it wouldn't even be there). I could probably move it out into its own little file to make it invisible (like I did with networkmanager's state).
☑ I was wondering about the order. Thanks.
☑ Good catch about NMTSuite. Signs of bits I missed during refactoring (there are probably more of these).

[Samuele Pedroni (pedronis)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~chipaca/ubuntu-push/simple-bus-interface into lp:ubuntu-push failed. Below is the output from the failed tests.

mkdir -p /mnt/tarmac/cache/ubuntu-push/go-ws/bin
mkdir -p /mnt/tarmac/cache/ubuntu-push/go-ws/pkg
go get -u launchpad.net/godeps
go get -d -u launchpad.net/gocheck launchpad.net/go-dbus/v1
/mnt/tarmac/cache/ubuntu-push/go-ws/bin/godeps -u dependencies.tsv
go install launchpad.net/gocheck launchpad.net/go-dbus/v1
go test launchpad.net/ubuntu-push/...
ok launchpad.net/ubuntu-push/bus 0.014s
ok launchpad.net/ubuntu-push/bus/testing 0.024s
ok launchpad.net/ubuntu-push/config 0.007s
ok launchpad.net/ubuntu-push/logger 0.007s
ok launchpad.net/ubuntu-push/protocol 0.010s
ok launchpad.net/ubuntu-push/server/acceptance 0.011s
? launchpad.net/ubuntu-push/server/acceptance/cmd [no test files]
ok launchpad.net/ubuntu-push/server/api 0.014s
ok launchpad.net/ubuntu-push/server/broker 0.013s
ok launchpad.net/ubuntu-push/server/dev 0.015s
ok launchpad.net/ubuntu-push/server/listener 0.400s
ok launchpad.net/ubuntu-push/server/session 0.086s
ok launchpad.net/ubuntu-push/server/store 0.006s
? launchpad.net/ubuntu-push/testing [no test files]
ok launchpad.net/ubuntu-push/testing/condition 0.005s
ok launchpad.net/ubuntu-push/whoopsie/identifier 0.017s
ok launchpad.net/ubuntu-push/whoopsie/identifier/testing 0.010s
scripts/check_fmt launchpad.net/ubuntu-push
pkg launchpad.net/ubuntu-push/bus has some gofmt non-compliant files:
bus.go
endpoint.go
endpoint_test.go

pkg launchpad.net/ubuntu-push/bus/testing has some gofmt non-compliant files:
testing_bus.go
testing_endpoint.go

make: *** [check-format] Error 1

[lp:~chipaca/ubuntu-push/simple-bus-interface]

14. By John Lenton on 2014-01-20

make format

=== modified file '.bzrignore'
--- .bzrignore	2014-01-14 15:35:20 +0000
+++ .bzrignore	2014-01-20 13:45:30 +0000
@@ -1,3 +1,4 @@
 acceptanceclient
 testserver
 coverhtml
+coverage.out

=== modified file 'Makefile'
--- Makefile	2014-01-16 19:37:57 +0000
+++ Makefile	2014-01-20 13:45:30 +0000
@@ -8,6 +8,7 @@
 endif
 
 GODEPS = launchpad.net/gocheck
+GODEPS += launchpad.net/go-dbus/v1
 
 bootstrap:
 	mkdir -p $(GOPATH)/bin
@@ -18,20 +19,20 @@
 	go install $(GODEPS)
 
 check:
-	go test $(PROJECT)/...
+	go test $(TESTFLAGS) $(PROJECT)/...
 
 check-race:
-	go test -race $(PROJECT)/...
+	go test $(TESTFLAGS) -race $(PROJECT)/...
 
 coverage-summary:
-	go test -a -cover $(PROJECT)/...
+	go test $(TESTFLAGS) -a -cover $(PROJECT)/...
 
 coverage-html:
 	mkdir -p coverhtml
 	for pkg in $$(go list $(PROJECT)/...|grep -v acceptance ); do \
 		relname="$${pkg#$(PROJECT)/}" ; \
 		mkdir -p coverhtml/$$(dirname $${relname}) ; \
-		go test -a -coverprofile=coverhtml/$${relname}.out $$pkg ; \
+		go test $(TESTFLAGS) -a -coverprofile=coverhtml/$${relname}.out $$pkg ; \
 		if [ -f coverhtml/$${relname}.out ] ; then \
 	           go tool cover -html=coverhtml/$${relname}.out -o coverhtml/$${relname}.html ; \
 	           go tool cover -func=coverhtml/$${relname}.out -o coverhtml/$${relname}.txt ; \

=== added directory 'bus'
=== added file 'bus/bus.go'
--- bus/bus.go	1970-01-01 00:00:00 +0000
+++ bus/bus.go	2014-01-20 13:45:30 +0000
@@ -0,0 +1,87 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// Package bus provides a simplified (and more testable?) interface to DBus.
+package bus
+
+// Here we define the Bus itself
+
+import (
+	"launchpad.net/go-dbus/v1"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+/*****************************************************************
+ *    Bus (and its implementation)
+ */
+
+// This is the Bus itself.
+type Bus interface {
+	String() string
+	Connect(Address, logger.Logger) (Endpoint, error)
+}
+
+type concreteBus dbus.StandardBus
+
+// ensure concreteBus implements Bus
+var _ Bus = new(concreteBus)
+
+// no bus.Bus constructor, just two standard, constant, busses
+var (
+	SessionBus Bus = concreteBus(dbus.SessionBus)
+	SystemBus  Bus = concreteBus(dbus.SystemBus)
+)
+
+/*
+   public methods
+*/
+
+func (bus concreteBus) String() string {
+	if bus == concreteBus(dbus.SystemBus) {
+		return "SystemBus"
+	} else {
+		return "SessionBus"
+	}
+}
+
+// Connect() connects to the bus, and returns the bus endpoint (and/or error).
+func (bus concreteBus) Connect(addr Address, log logger.Logger) (Endpoint, error) {
+	conn, err := dbus.Connect(bus.dbusType())
+	if err != nil {
+		return nil, err
+	} else {
+		return &endpoint{conn, addr.Name, addr.Path, addr.Interface, log}, nil
+	}
+}
+
+/*
+   private methods
+*/
+
+func (bus concreteBus) dbusType() dbus.StandardBus {
+	return dbus.StandardBus(bus)
+}
+
+/*****************************************************************
+ *    Address
+ */
+
+// bus.Address is just a bag of configuration
+type Address struct {
+	Name      string
+	Path      string
+	Interface string
+}

=== added file 'bus/bus_test.go'
--- bus/bus_test.go	1970-01-01 00:00:00 +0000
+++ bus/bus_test.go	2014-01-20 13:45:30 +0000
@@ -0,0 +1,67 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package bus
+
+import (
+	"fmt"
+	"io/ioutil"
+	"launchpad.net/go-dbus/v1"
+	. "launchpad.net/gocheck"
+	"launchpad.net/ubuntu-push/logger"
+	"os"
+	"testing"
+)
+
+// hook up gocheck
+func Test(t *testing.T) { TestingT(t) }
+
+type BusSuite struct{}
+
+var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
+var _ = Suite(&BusSuite{})
+
+// Test we stringify sanely
+func (s *BusSuite) TestBusType(c *C) {
+	c.Check(fmt.Sprintf("%s", SystemBus), Equals, "SystemBus")
+	c.Check(fmt.Sprintf("%s", SessionBus), Equals, "SessionBus")
+}
+
+// Test we get the right DBus bus
+func (s *BusSuite) TestDBusType(c *C) {
+	c.Check(SystemBus.(concreteBus).dbusType(), DeepEquals, dbus.SystemBus)
+	c.Check(SessionBus.(concreteBus).dbusType(), DeepEquals, dbus.SessionBus)
+}
+
+// Tests that we can connect to the *actual* system bus.
+// XXX maybe connect to a mock/fake/etc bus?
+func (s *BusSuite) TestConnect(c *C) {
+	b, err := SystemBus.Connect(Address{"", "", ""}, nullog)
+	c.Assert(err, IsNil)
+	defer b.Close()
+}
+
+// Test that if we try to connect to the session bus when no session
+// bus is available, we get a reasonable result (i.e., an error).
+func (s *BusSuite) TestConnectCanFail(c *C) {
+	db := "DBUS_SESSION_BUS_ADDRESS"
+	odb := os.Getenv(db)
+	defer os.Setenv(db, odb)
+	os.Setenv(db, "")
+
+	_, err := SessionBus.Connect(Address{"", "", ""}, nullog)
+	c.Check(err, NotNil)
+}

=== added file 'bus/endpoint.go'
--- bus/endpoint.go	1970-01-01 00:00:00 +0000
+++ bus/endpoint.go	2014-01-20 13:45:30 +0000
@@ -0,0 +1,121 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package bus
+
+// Here we define the Endpoint, which represents the DBus connection itself.
+
+import (
+	"launchpad.net/go-dbus/v1"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+/*****************************************************************
+ *    Endpoint (and its implementation)
+ */
+
+// bus.Endpoint represents the DBus connection itself.
+type Endpoint interface {
+	WatchSignal(member string, f func(interface{}), d func()) error
+	Call(member string, args ...interface{}) (interface{}, error)
+	Close()
+}
+
+type endpoint struct {
+	bus   *dbus.Connection
+	name  string
+	path  string
+	iface string
+	log   logger.Logger
+}
+
+// ensure endpoint implements Endpoint
+var _ Endpoint = endpoint{}
+
+/*
+   public methods
+*/
+
+// WatchSignal() takes a member name and sets up a watch for it (on the name,
+// path and interface provided when creating the endpoint), and then calls f()
+// with the unpacked value. If it's unable to set up the watch it'll return an
+// error. If the watch fails once established, d() is called. Typically f()
+// sends the values over a channel, and d() would close the channel.
+func (endp endpoint) WatchSignal(member string, f func(interface{}), d func()) error {
+	watch, err := endp.bus.WatchSignal(&dbus.MatchRule{
+		Type:      dbus.TypeSignal,
+		Sender:    endp.name,
+		Path:      dbus.ObjectPath(endp.path),
+		Interface: endp.iface,
+		Member:    member,
+	})
+	if err != nil {
+		endp.log.Debugf("Failed to set up the watch: %s", err)
+		return err
+	}
+
+	go endp.unpackMessages(watch, f, d, member)
+
+	return nil
+}
+
+// Call() invokes the provided member method (on the name, path and interface
+// provided when creating the endpoint). The return value is unpacked before
+// being returned.
+func (endp endpoint) Call(member string, args ...interface{}) (interface{}, error) {
+	proxy := endp.bus.Object(endp.name, dbus.ObjectPath(endp.path))
+	if msg, err := proxy.Call(endp.iface, member, args...); err == nil {
+		return endp.unpackOneMsg(msg, member)
+	} else {
+		return 0, err
+	}
+}
+
+// Close the connection to dbus.
+func (endp endpoint) Close() {
+	endp.bus.Close()
+}
+
+/*
+   private methods
+*/
+
+// unpackOneMsg unpacks the value from the response msg
+func (endp endpoint) unpackOneMsg(msg *dbus.Message, member string) (interface{}, error) {
+	var v interface{}
+	if err := msg.Args(&v); err != nil {
+		endp.log.Errorf("Decoding %s: %s", member, err)
+		return 0, err
+	} else {
+		return v, nil
+	}
+}
+
+// unpackMessages unpacks the value from the watch
+func (endp endpoint) unpackMessages(watch *dbus.SignalWatch, f func(interface{}), d func(), member string) {
+	for {
+		msg, ok := <-watch.C
+		if !ok {
+			break
+		}
+		if val, err := endp.unpackOneMsg(msg, member); err == nil {
+			// errors are ignored at this level
+			f(val)
+		}
+	}
+	endp.log.Errorf("Got not-OK from %s watch", member)
+	d()
+}

=== added file 'bus/endpoint_test.go'
--- bus/endpoint_test.go	1970-01-01 00:00:00 +0000
+++ bus/endpoint_test.go	2014-01-20 13:45:30 +0000
@@ -0,0 +1,32 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package bus
+
+import (
+	. "launchpad.net/gocheck"
+	"testing"
+)
+
+// hook up gocheck
+func EndpointTest(t *testing.T) { TestingT(t) }
+
+type EndpointSuite struct{}
+
+var _ = Suite(&EndpointSuite{})
+
+// TODO: this is going to remain empty until go-dbus grows some
+// testing amenities (already talked about it with jamesh)

=== added directory 'bus/testing'
=== added file 'bus/testing/testing_bus.go'
--- bus/testing/testing_bus.go	1970-01-01 00:00:00 +0000
+++ bus/testing/testing_bus.go	2014-01-20 13:45:30 +0000
@@ -0,0 +1,63 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// Package bus/testing provides an implementation of bus.Bus and bus.Endpoint
+// suitable for testing.
+package testing
+
+// Here, the bus.Bus implementation.
+
+import (
+	"errors"
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/testing/condition"
+)
+
+/*****************************************************************
+ *    TestingBus
+ */
+
+type testingBus struct {
+	TestCond condition.Interface
+	TestEndp *testingEndpoint
+}
+
+// Build a bus.Bus that takes a condition to determine whether it should work,
+// as well as a condition and series of return values for the testing
+// bus.Endpoint it builds.
+func NewTestingBus(clientTC condition.Interface, busTC condition.Interface, retvals ...interface{}) *testingBus {
+	return &testingBus{clientTC, NewTestingEndpoint(busTC, retvals...)}
+}
+
+// ensure testingBus implements bus.Interface
+var _ bus.Bus = &testingBus{}
+
+/*
+   public methods
+*/
+
+func (tb *testingBus) Connect(info bus.Address, log logger.Logger) (bus.Endpoint, error) {
+	if tb.TestCond.OK() {
+		return tb.TestEndp, nil
+	} else {
+		return nil, errors.New(tb.TestCond.String())
+	}
+}
+
+func (tb *testingBus) String() string {
+	return "<TestingBus>"
+}

=== added file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	1970-01-01 00:00:00 +0000
+++ bus/testing/testing_endpoint.go	2014-01-20 13:45:30 +0000
@@ -0,0 +1,76 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package testing
+
+// Here, the bus.Endpoint implementation.
+
+import (
+	"errors"
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/testing/condition"
+	"time"
+)
+
+type testingEndpoint struct {
+	cond    condition.Interface
+	retvals []interface{}
+}
+
+// Build a bus.Endpoint that calls OK() on its condition before returning
+// the provided return values.
+//
+// NOTE: Call() always returns the first return value; Watch() will provide
+// each of them intern, irrespective of whether Call has been called.
+func NewTestingEndpoint(cond condition.Interface, retvals ...interface{}) *testingEndpoint {
+	return &testingEndpoint{cond, retvals}
+}
+
+// See Endpoint's WatchSignal. This WatchSignal will check its condition to
+// decide whether to return an error, or provide each of its return values
+func (tc *testingEndpoint) WatchSignal(member string, f func(interface{}), d func()) error {
+	if tc.cond.OK() {
+		go func() {
+			for _, v := range tc.retvals {
+				f(v)
+				time.Sleep(10 * time.Millisecond)
+			}
+			d()
+		}()
+		return nil
+	} else {
+		return errors.New("no way")
+	}
+}
+
+// See Endpoint's Call. This Call will check its condition to decide whether
+// to return an error, or the first of its return values
+func (tc *testingEndpoint) Call(member string, args ...interface{}) (interface{}, error) {
+	if tc.cond.OK() {
+		if len(tc.retvals) == 0 {
+			panic("No return values provided!")
+		}
+		return tc.retvals[0], nil
+	} else {
+		return 0, errors.New("no way")
+	}
+}
+
+// see Endpoint's Close. This one does nothing.
+func (tc *testingEndpoint) Close() {}
+
+// ensure testingEndpoint implements bus.Endpoint
+var _ bus.Endpoint = &testingEndpoint{}

=== added file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	1970-01-01 00:00:00 +0000
+++ bus/testing/testing_endpoint_test.go	2014-01-20 13:45:30 +0000
@@ -0,0 +1,73 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package testing
+
+import (
+	. "launchpad.net/gocheck"
+	"launchpad.net/ubuntu-push/testing/condition"
+	"testing"
+)
+
+// hook up gocheck
+func Test(t *testing.T) { TestingT(t) }
+
+type TestingEndpointSuite struct{}
+
+var _ = Suite(&TestingEndpointSuite{})
+
+// Test that Call() with a positive condition returns the first return value
+// provided, as advertised.
+func (s *TestingEndpointSuite) TestCallReturnsFirstRetval(c *C) {
+	var m, n uint32 = 42, 17
+	endp := NewTestingEndpoint(condition.Work(true), m, n)
+	v, e := endp.Call("what")
+	c.Check(e, IsNil)
+	c.Check(v, Equals, m)
+}
+
+// Test that Call() with a negative condition returns an error.
+func (s *TestingEndpointSuite) TestCallFails(c *C) {
+	endp := NewTestingEndpoint(condition.Work(false))
+	_, e := endp.Call("what")
+	c.Check(e, NotNil)
+}
+
+// Test that Call() with a positive condition and no return values panics with
+// a helpful message.
+func (s *TestingEndpointSuite) TestCallPanicsWithNiceMessage(c *C) {
+	endp := NewTestingEndpoint(condition.Work(true))
+	c.Check(func() { endp.Call("") }, PanicMatches, "No return values provided!")
+}
+
+// Test that WatchSignal() with a positive condition sends the provided return
+// values over the channel.
+func (s *TestingEndpointSuite) TestWatch(c *C) {
+	var m, n uint32 = 42, 17
+	endp := NewTestingEndpoint(condition.Work(true), m, n)
+	ch := make(chan uint32)
+	e := endp.WatchSignal("what", func(u interface{}) { ch <- u.(uint32) }, func() { close(ch) })
+	c.Check(e, IsNil)
+	c.Check(<-ch, Equals, m)
+	c.Check(<-ch, Equals, n)
+}
+
+// Test that WatchSignal() with a negative condition returns an error.
+func (s *TestingEndpointSuite) TestWatchFails(c *C) {
+	endp := NewTestingEndpoint(condition.Work(false))
+	e := endp.WatchSignal("what", func(u interface{}) {}, func() {})
+	c.Check(e, NotNil)
+}

=== modified file 'dependencies.tsv'
--- dependencies.tsv	2014-01-14 15:35:20 +0000
+++ dependencies.tsv	2014-01-20 13:45:30 +0000
@@ -1,1 +1,2 @@
+launchpad.net/go-dbus/v1	bzr	[e-mail]-20140117100040-mmhdtiz5w9pxqtcr	124
 launchpad.net/gocheck	bzr	[e-mail]-20130302024745-6ikofwq2c03h7giu	85

=== added directory 'testing/condition'
=== added file 'testing/condition/condition.go'
--- testing/condition/condition.go	1970-01-01 00:00:00 +0000
+++ testing/condition/condition.go	2014-01-20 13:45:30 +0000
@@ -0,0 +1,142 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// Package testing/condition implements a strategy family for use in testing.
+package condition
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Interface interface {
+	OK() bool
+	String() string
+}
+
+// Work is a simple boolean condition; either it works all the time
+// (when true), or it fails all the time (when false).
+func Work(wk bool) work {
+	return work(wk)
+}
+
+type work bool
+
+func (c work) OK() bool {
+	if c {
+		return true
+	} else {
+		return false
+	}
+}
+func (c work) String() string {
+	if c {
+		return "Always Working."
+	} else {
+		return "Never Working."
+	}
+}
+
+var _ Interface = work(false)
+
+// Fail2Work fails for the first n times its OK() method is checked,
+// and then mysteriously starts working.
+func Fail2Work(left int32) *fail2Work {
+	c := new(fail2Work)
+	c.Left = left
+	return c
+}
+
+type fail2Work struct {
+	Left int32
+}
+
+func (c *fail2Work) OK() bool {
+	if c.Left > 0 {
+		c.Left--
+		return false
+	} else {
+		return true
+	}
+}
+
+func (c *fail2Work) String() string {
+	if c.Left > 0 {
+		return fmt.Sprintf("Still Broken, %d to go.", c.Left)
+	} else {
+		return "Working."
+	}
+}
+
+var _ Interface = &fail2Work{}
+
+// Not builds a condition that negates the one passed in.
+func Not(sub Interface) *not {
+	return &not{sub}
+}
+
+type not struct{ sub Interface }
+
+func (c *not) OK() bool       { return !c.sub.OK() }
+func (c *not) String() string { return fmt.Sprintf("Not %s", c.sub) }
+
+var _ Interface = &not{}
+
+type _iter struct {
+	cond      Interface
+	remaining int
+}
+
+func (i _iter) String() string { return fmt.Sprintf("%d of %s", i.remaining, i.cond) }
+
+type chain struct {
+	subs []*_iter
+}
+
+func (c *chain) OK() bool {
+	var sub *_iter
+	for _, sub = range c.subs {
+		if sub.remaining > 0 {
+			sub.remaining--
+			return sub.cond.OK()
+		}
+	}
+	return sub.cond.OK()
+}
+
+func (c *chain) String() string {
+	ss := make([]string, len(c.subs))
+	for i, sub := range c.subs {
+		ss[i] = sub.String()
+	}
+	return strings.Join(ss, " Then: ")
+}
+
+var _ Interface = new(chain)
+
+// Chain(n1, cond1, n2, cond2, ...) returns cond1.OK() the first n1
+// times OK() is called, cond2.OK() the following n2 times, etc.
+func Chain(args ...interface{}) *chain {
+	iters := make([]*_iter, 0, len(args)/2)
+	for len(args) > 1 {
+		rem := args[0].(int)
+		sub := args[1].(Interface)
+		iters = append(iters, &_iter{sub, rem})
+		args = args[2:]
+	}
+
+	return &chain{iters}
+}

=== added file 'testing/condition/condition_test.go'
--- testing/condition/condition_test.go	1970-01-01 00:00:00 +0000
+++ testing/condition/condition_test.go	2014-01-20 13:45:30 +0000
@@ -0,0 +1,76 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package condition
+
+import (
+	"launchpad.net/gocheck" // not into . because we have our own Not
+	"testing"
+)
+
+// hook up gocheck
+func Test(t *testing.T) { gocheck.TestingT(t) }
+
+type CondSuite struct{}
+
+var _ = gocheck.Suite(&CondSuite{})
+
+func (s *CondSuite) TestConditionWorkTrue(c *gocheck.C) {
+	cond := Work(true)
+	c.Check(cond.OK(), gocheck.Equals, true)
+	c.Check(cond.String(), gocheck.Equals, "Always Working.")
+}
+
+func (s *CondSuite) TestConditionWorkFalse(c *gocheck.C) {
+	cond := Work(false)
+	c.Check(cond.OK(), gocheck.Equals, false)
+	c.Check(cond.String(), gocheck.Equals, "Never Working.")
+}
+
+func (s *CondSuite) TestConditionFail2Work(c *gocheck.C) {
+	cond := Fail2Work(2)
+	c.Check(cond.String(), gocheck.Equals, "Still Broken, 2 to go.")
+	c.Check(cond.OK(), gocheck.Equals, false)
+	c.Check(cond.String(), gocheck.Equals, "Still Broken, 1 to go.")
+	c.Check(cond.OK(), gocheck.Equals, false)
+	c.Check(cond.String(), gocheck.Equals, "Working.")
+	c.Check(cond.OK(), gocheck.Equals, true)
+	c.Check(cond.String(), gocheck.Equals, "Working.")
+	c.Check(cond.OK(), gocheck.Equals, true)
+	c.Check(cond.String(), gocheck.Equals, "Working.")
+}
+
+func (s *CondSuite) TestConditionNot(c *gocheck.C) {
+	cond := Not(Fail2Work(1))
+	c.Check(cond.String(), gocheck.Equals, "Not Still Broken, 1 to go.")
+	c.Check(cond.OK(), gocheck.Equals, true)
+	c.Check(cond.String(), gocheck.Equals, "Not Working.")
+	c.Check(cond.OK(), gocheck.Equals, false)
+}
+
+func (s *CondSuite) TestConditionChain(c *gocheck.C) {
+	cond := Chain(2, Work(true), 3, Work(false), 0, Work(true))
+	c.Check(cond.String(), gocheck.Equals, "2 of Always Working. Then: 3 of Never Working. Then: 0 of Always Working.")
+	c.Check(cond.OK(), gocheck.Equals, true)
+	c.Check(cond.OK(), gocheck.Equals, true)
+	c.Check(cond.OK(), gocheck.Equals, false)
+	c.Check(cond.OK(), gocheck.Equals, false)
+	c.Check(cond.OK(), gocheck.Equals, false)
+	c.Check(cond.OK(), gocheck.Equals, true)
+	// c.Check(cond.OK(), gocheck.Equals, true)
+	// c.Check(cond.OK(), gocheck.Equals, true)
+	// c.Check(cond.OK(), gocheck.Equals, true)
+}