Merge lp:~chipaca/ubuntu-push/endpoint-not-bus into lp:ubuntu-push

[John Lenton]

change a few of the bus/* services to take a bus.Endpoint instead of a bus.Bus

change a few of the bus/* services to take a bus.Endpoint instead of a bus.Bus

Unmerged revisions

=== added file '.precommit'
--- .precommit	1970-01-01 00:00:00 +0000
+++ .precommit	2014-01-23 14:29:00 +0000
@@ -0,0 +1,29 @@
+#!/bin/sh
+set -e
+echo "$@"
+# put me in the project root, call me ".precommit".
+# And put this here-document in ~/.bazaar/plugins/precommit_script.py:
+<<EOF
+import os
+import subprocess
+from bzrlib.mutabletree import MutableTree
+from bzrlib import errors
+
+def start_commit_hook(*_):
+    """This hook will execute '.precommit' script from root path of the bazaar
+    branch. Commit will be canceled if precommit fails."""
+
+    # this hook only makes sense if a precommit file exist.
+    if not os.path.exists(".precommit"):
+        return
+    try:
+        subprocess.check_call(os.path.abspath(".precommit"))
+    # if precommit fails (process return not zero) cancel commit.
+    except subprocess.CalledProcessError:
+        raise errors.BzrError("pre commit check failed.")
+
+MutableTree.hooks.install_named_hook('start_commit', start_commit_hook,
+                                     'Run "precommit" script on start_commit')
+EOF
+
+make check-format # or whatever

=== renamed directory 'connectivity' => 'bus/connectivity'
=== modified file 'bus/connectivity/connectivity.go'
--- connectivity/connectivity.go	2014-01-20 17:44:24 +0000
+++ bus/connectivity/connectivity.go	2014-01-23 14:29:00 +0000
@@ -25,10 +25,9 @@
 import (
 	"errors"
 	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/bus/networkmanager"
 	"launchpad.net/ubuntu-push/config"
-	"launchpad.net/ubuntu-push/connectivity/webchecker"
 	"launchpad.net/ubuntu-push/logger"
-	"launchpad.net/ubuntu-push/networkmanager"
 	"time"
 )
 
@@ -163,7 +162,7 @@
 // over the "out" channel. Sends "false" as soon as it detects trouble, "true"
 // after checking actual connectivity.
 func ConnectedState(busType bus.Bus, config Config, log logger.Logger, out chan<- bool) {
-	wg := webchecker.New(config.ConnectivityCheckURL, config.ConnectivityCheckMD5, log)
+	wg := NewWebchecker(config.ConnectivityCheckURL, config.ConnectivityCheckMD5, log)
 	cs := &connectedState{
 		config: config,
 		log:    log,

=== modified file 'bus/connectivity/connectivity_test.go'
--- connectivity/connectivity_test.go	2014-01-22 12:27:35 +0000
+++ bus/connectivity/connectivity_test.go	2014-01-23 14:29:00 +0000
@@ -19,12 +19,11 @@
 import (
 	"io/ioutil"
 	. "launchpad.net/gocheck"
+	"launchpad.net/ubuntu-push/bus/networkmanager"
 	testingbus "launchpad.net/ubuntu-push/bus/testing"
 	"launchpad.net/ubuntu-push/config"
 	"launchpad.net/ubuntu-push/logger"
-	"launchpad.net/ubuntu-push/networkmanager"
 	"launchpad.net/ubuntu-push/testing/condition"
-	"net/http"
 	"net/http/httptest"
 	"testing"
 	"time"
@@ -201,24 +200,6 @@
    tests for ConnectedState()
 */
 
-// Todo: get rid of duplication between this and webchecker_test
-const (
-	staticText = "something ipsum dolor something"
-	staticHash = "6155f83b471583f47c99998a472a178f"
-)
-
-// mkHandler makes an http.HandlerFunc that returns the provided text
-// for whatever request it's given.
-func mkHandler(text string) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		w.(http.Flusher).Flush()
-		w.Write([]byte(text))
-		w.(http.Flusher).Flush()
-	}
-}
-
-// :oboT
-
 // yes, this is an integration test
 func (s *ConnSuite) TestRun(c *C) {
 	ts := httptest.NewServer(mkHandler(staticText))

=== modified file 'bus/connectivity/example/main.go'
--- connectivity/example/main.go	2014-01-20 06:27:39 +0000
+++ bus/connectivity/example/main.go	2014-01-23 14:29:00 +0000
@@ -20,8 +20,8 @@
 import (
 	"fmt"
 	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/bus/connectivity"
 	"launchpad.net/ubuntu-push/config"
-	"launchpad.net/ubuntu-push/connectivity"
 	"launchpad.net/ubuntu-push/logger"
 	"os"
 	"strings"
@@ -30,7 +30,7 @@
 func main() {
 	log := logger.NewSimpleLogger(os.Stderr, "error")
 
-	paths := []string{"thing.json", "connectivity/example/thing.json"}
+	paths := []string{"thing.json", "bus/connectivity/example/thing.json"}
 	for _, path := range paths {
 		cff, err := os.Open(path)
 		if err == nil {

=== renamed file 'connectivity/webchecker/webchecker.go' => 'bus/connectivity/webchecker.go'
--- connectivity/webchecker/webchecker.go	2014-01-20 14:58:59 +0000
+++ bus/connectivity/webchecker.go	2014-01-23 14:29:00 +0000
@@ -14,13 +14,13 @@
  with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-// Package webchecker checks whether we're actually connected by doing an http
+// webchecker checks whether we're actually connected by doing an http
 // GET to the Ubuntu connectivity check URL,
 // http://start.ubuntu.com/connectivity-check.html
 //
 // We could make it be https to make extra doubly sure, but it's expensive
 // overkill for the majority of cases.
-package webchecker
+package connectivity
 
 import (
 	"crypto/md5"
@@ -46,7 +46,7 @@
 }
 
 // Build a webchecker for the given URL, that should match the target MD5.
-func New(url string, target string, log logger.Logger) Webchecker {
+func NewWebchecker(url string, target string, log logger.Logger) Webchecker {
 	return &webchecker{log, url, target}
 }
 

=== renamed file 'connectivity/webchecker/webchecker_test.go' => 'bus/connectivity/webchecker_test.go'
--- connectivity/webchecker/webchecker_test.go	2014-01-20 06:27:39 +0000
+++ bus/connectivity/webchecker_test.go	2014-01-23 14:29:00 +0000
@@ -14,26 +14,22 @@
  with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-package webchecker
+package connectivity
 
 import (
-	"io/ioutil"
 	. "launchpad.net/gocheck"
-	"launchpad.net/ubuntu-push/logger"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 )
 
 // hook up gocheck
-func Test(t *testing.T) { TestingT(t) }
+func TestWebcheck(t *testing.T) { TestingT(t) }
 
 type WebcheckerSuite struct{}
 
 var _ = Suite(&WebcheckerSuite{})
 
-var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
-
 const (
 	staticText = "something ipsum dolor something"
 	staticHash = "6155f83b471583f47c99998a472a178f"
@@ -69,7 +65,7 @@
 	ts := httptest.NewServer(mkHandler(staticText))
 	defer ts.Close()
 
-	ck := New(ts.URL, staticHash, nullog)
+	ck := NewWebchecker(ts.URL, staticHash, nullog)
 	ch := make(chan bool, 1)
 	ck.Webcheck(ch)
 	c.Check(<-ch, Equals, true)
@@ -77,7 +73,7 @@
 
 // Webchecker sends false if the download fails.
 func (s *WebcheckerSuite) TestActualFails(c *C) {
-	ck := New("garbage://", "", nullog)
+	ck := NewWebchecker("garbage://", "", nullog)
 	ch := make(chan bool, 1)
 	ck.Webcheck(ch)
 	c.Check(<-ch, Equals, false)
@@ -88,7 +84,7 @@
 	ts := httptest.NewServer(mkHandler(""))
 	defer ts.Close()
 
-	ck := New(ts.URL, staticHash, nullog)
+	ck := NewWebchecker(ts.URL, staticHash, nullog)
 	ch := make(chan bool, 1)
 	ck.Webcheck(ch)
 	c.Check(<-ch, Equals, false)
@@ -99,7 +95,7 @@
 	ts := httptest.NewServer(mkHandler(bigText))
 	defer ts.Close()
 
-	ck := New(ts.URL, bigHash, nullog)
+	ck := NewWebchecker(ts.URL, bigHash, nullog)
 	ch := make(chan bool, 1)
 	ck.Webcheck(ch)
 	c.Check(<-ch, Equals, false)

=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2014-01-22 10:48:52 +0000
+++ bus/endpoint.go	2014-01-23 14:29:00 +0000
@@ -31,7 +31,7 @@
 // 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)
+	Call(member string, args ...interface{}) ([]interface{}, error)
 	GetProperty(property string) (interface{}, error)
 	Close()
 }
@@ -81,20 +81,13 @@
 // 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) {
+func (endp *endpoint) Call(member string, args ...interface{}) ([]interface{}, error) {
 	msg, err := endp.proxy.Call(endp.iface, member, args...)
 	if err != nil {
-		return 0, err
+		return nil, err
 	}
 	rvs := endp.unpackOneMsg(msg, member)
-	switch len(rvs) {
-	default:
-		return 0, fmt.Errorf("Too many values in %s response: %d", member, len(rvs))
-	case 0:
-		return 0, fmt.Errorf("Not enough values in %s response: %d", member, len(rvs))
-	case 1:
-		return rvs[0], nil
-	}
+	return rvs, nil
 }
 
 // GetProperty uses the org.freedesktop.DBus.Properties interface's Get method

=== renamed directory 'networkmanager' => 'bus/networkmanager'
=== modified file 'bus/networkmanager/networkmanager_test.go'
--- networkmanager/networkmanager_test.go	2014-01-20 13:44:58 +0000
+++ bus/networkmanager/networkmanager_test.go	2014-01-23 14:29:00 +0000
@@ -65,13 +65,20 @@
 	c.Check(state, Equals, Unknown)
 }
 
-// GetState returns the right state when dbus works but delivers rubbish
-func (s *NMSuite) TestGetStateRubbish(c *C) {
+// GetState returns the right state when dbus works but delivers rubbish values
+func (s *NMSuite) TestGetStateRubbishValues(c *C) {
 	nm := New(testingbus.NewTestingEndpoint(condition.Work(false), 42), nullog)
 	state := nm.GetState()
 	c.Check(state, Equals, Unknown)
 }
 
+// GetState returns the right state when dbus works but delivers a rubbish structure
+func (s *NMSuite) TestGetStateRubbishStructure(c *C) {
+	nm := New(testingbus.NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{}), nullog)
+	state := nm.GetState()
+	c.Check(state, Equals, Unknown)
+}
+
 // WatchState sends a stream of States over the channel
 func (s *NMSuite) TestWatchState(c *C) {
 	tc := testingbus.NewTestingEndpoint(condition.Work(true), uint32(Unknown), uint32(Asleep), uint32(ConnectedGlobal))

=== renamed directory 'notifications' => 'bus/notifications'
=== modified file 'bus/notifications/raw.go'
--- notifications/raw.go	2014-01-22 12:15:12 +0000
+++ bus/notifications/raw.go	2014-01-23 14:29:00 +0000
@@ -22,6 +22,7 @@
 // this is the lower-level api
 
 import (
+	"errors"
 	"launchpad.net/go-dbus/v1"
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/logger"
@@ -51,14 +52,9 @@
 	log logger.Logger
 }
 
-// Raw returns a new RawNotifications connected to the provided bus.Bus
-func Raw(bt bus.Bus, log logger.Logger) (*RawNotifications, error) {
-	endp, err := bt.Connect(BusAddress, log)
-	if err != nil {
-		return nil, err
-	}
-
-	return &RawNotifications{endp, log}, nil
+// Raw returns a new RawNotifications that'll use the provided bus.Endpoint
+func Raw(endp bus.Endpoint, log logger.Logger) *RawNotifications {
+	return &RawNotifications{endp, log}
 }
 
 /*
@@ -73,12 +69,15 @@
 	timeout int32) (uint32, error) {
 	// that's a long argument list! Take a breather.
 	//
-	rv, err := raw.bus.Call("Notify", app_name, reuse_id, icon,
+	rvs, err := raw.bus.Call("Notify", app_name, reuse_id, icon,
 		summary, body, actions, hints, timeout)
 	if err != nil {
 		return 0, err
 	}
-	return rv.(uint32), nil
+	if len(rvs) != 1 {
+		return 0, errors.New("Wrong number of arguments in reply from Notify")
+	}
+	return rvs[0].(uint32), nil
 }
 
 // WatchActions listens for ActionInvoked signals from the notification daemon

=== modified file 'bus/notifications/raw_test.go'
--- notifications/raw_test.go	2014-01-21 14:58:28 +0000
+++ bus/notifications/raw_test.go	2014-01-23 14:29:00 +0000
@@ -38,38 +38,32 @@
 
 var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
 
-func (s *RawSuite) TestConnects(c *C) {
-	bus := testibus.NewTestingBus(condition.Work(false), condition.Work(false))
-	_, err := Raw(bus, nullog)
-	c.Check(err, NotNil)
-	bus = testibus.NewTestingBus(condition.Work(true), condition.Work(false))
-	_, err = Raw(bus, nullog)
-	c.Check(err, IsNil)
-}
-
 func (s *RawSuite) TestNotifies(c *C) {
-	bus := testibus.NewTestingBus(condition.Work(true), condition.Work(true),
-		uint32(1))
-	raw, err := Raw(bus, nullog)
-	c.Assert(err, IsNil)
+	endp := testibus.NewTestingEndpoint(condition.Work(true), uint32(1))
+	raw := Raw(endp, nullog)
 	nid, err := raw.Notify("", 0, "", "", "", nil, nil, 0)
 	c.Check(err, IsNil)
 	c.Check(nid, Equals, uint32(1))
 }
 
 func (s *RawSuite) TestNotifiesFails(c *C) {
-	bus := testibus.NewTestingBus(condition.Work(true), condition.Work(false))
-	raw, err := Raw(bus, nullog)
-	c.Assert(err, IsNil)
-	_, err = raw.Notify("", 0, "", "", "", nil, nil, 0)
+	endp := testibus.NewTestingEndpoint(condition.Work(false))
+	raw := Raw(endp, nullog)
+	_, err := raw.Notify("", 0, "", "", "", nil, nil, 0)
+	c.Check(err, NotNil)
+}
+
+func (s *RawSuite) TestNotifiesFailsWeirdly(c *C) {
+	endp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{1, 2})
+	raw := Raw(endp, nullog)
+	_, err := raw.Notify("", 0, "", "", "", nil, nil, 0)
 	c.Check(err, NotNil)
 }
 
 func (s *RawSuite) TestWatchActions(c *C) {
-	bus := testibus.NewMultiValuedTestingBus(condition.Work(true), condition.Work(true),
+	endp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true),
 		[]interface{}{uint32(1), "hello"})
-	raw, err := Raw(bus, nullog)
-	c.Assert(err, IsNil)
+	raw := Raw(endp, nullog)
 	ch, err := raw.WatchActions()
 	c.Assert(err, IsNil)
 	// check we get the right action reply
@@ -86,9 +80,8 @@
 }
 
 func (s *RawSuite) TestWatchActionsFails(c *C) {
-	bus := testibus.NewTestingBus(condition.Work(true), condition.Work(false))
-	raw, err := Raw(bus, nullog)
-	c.Assert(err, IsNil)
-	_, err = raw.WatchActions()
+	endp := testibus.NewTestingEndpoint(condition.Work(false))
+	raw := Raw(endp, nullog)
+	_, err := raw.WatchActions()
 	c.Check(err, NotNil)
 }

=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2014-01-22 10:48:52 +0000
+++ bus/testing/testing_endpoint.go	2014-01-23 14:29:00 +0000
@@ -66,23 +66,27 @@
 
 // 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) {
+func (tc *testingEndpoint) Call(member string, args ...interface{}) ([]interface{}, error) {
 	if tc.cond.OK() {
 		if len(tc.retvals) == 0 {
 			panic("No return values provided!")
 		}
-		if len(tc.retvals[0]) != 1 {
-			panic("Wrong number of values provided -- Call only returns a single value for now!")
-		}
-		return tc.retvals[0][0], nil
+		return tc.retvals[0], nil
 	} else {
-		return 0, errors.New("no way")
+		return nil, errors.New("no way")
 	}
 }
 
 // See Endpoint's GetProperty. This one is just another name for Call.
 func (tc *testingEndpoint) GetProperty(property string) (interface{}, error) {
-	return tc.Call(property)
+	rvs, err := tc.Call(property)
+	if err != nil {
+		return nil, err
+	}
+	if len(rvs) != 1 {
+		return nil, errors.New("Wrong number of arguments in reply to GetProperty")
+	}
+	return rvs[0], err
 }
 
 // see Endpoint's Close. This one does nothing.

=== modified file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	2014-01-21 13:38:03 +0000
+++ bus/testing/testing_endpoint_test.go	2014-01-23 14:29:00 +0000
@@ -34,18 +34,20 @@
 func (s *TestingEndpointSuite) TestCallReturnsFirstRetval(c *C) {
 	var m, n uint32 = 42, 17
 	endp := NewTestingEndpoint(condition.Work(true), m, n)
-	v, e := endp.Call("what")
+	vs, e := endp.Call("what")
 	c.Check(e, IsNil)
-	c.Check(v, Equals, m)
+	c.Check(vs, HasLen, 1)
+	c.Check(vs[0], Equals, m)
 }
 
 // Test the same Call() but with multi-valued endpoint
 func (s *TestingEndpointSuite) TestMultiValuedCall(c *C) {
 	var m, n uint32 = 42, 17
 	endp := NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{m}, []interface{}{n})
-	v, e := endp.Call("what")
+	vs, e := endp.Call("what")
 	c.Check(e, IsNil)
-	c.Check(v, Equals, m)
+	c.Check(vs, HasLen, 1)
+	c.Check(vs[0], Equals, m)
 }
 
 // Test that Call() with a negative condition returns an error.
@@ -62,21 +64,6 @@
 	c.Check(func() { endp.Call("") }, PanicMatches, "No return values provided.*")
 }
 
-// Test that Call() with a positive condition and an empty return value panics
-// with a helpful message.
-func (s *TestingEndpointSuite) TestCallPanicsWithNiceMessage2(c *C) {
-	endp := NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{})
-	c.Check(func() { endp.Call("") }, PanicMatches, "Wrong number of values provided.*")
-}
-
-// Test Call() with positive condition and the wrong number of arguments also
-// fails with a helpful message
-func (s *TestingEndpointSuite) TestMultiValuedCallPanicsWhenWrongNumberOfValues(c *C) {
-	var m, n uint32 = 42, 17
-	endp := NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{m, n})
-	c.Check(func() { endp.Call("") }, PanicMatches, "Wrong number of values provided.*")
-}
-
 // Test that WatchSignal() with a positive condition sends the provided return
 // values over the channel.
 func (s *TestingEndpointSuite) TestWatch(c *C) {

=== added directory 'bus/urldispatcher'
=== added file 'bus/urldispatcher/urldispatcher.go'
--- bus/urldispatcher/urldispatcher.go	1970-01-01 00:00:00 +0000
+++ bus/urldispatcher/urldispatcher.go	2014-01-23 14:29:00 +0000
@@ -0,0 +1,57 @@
+/*
+ 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 urldispatcher wraps the url dispatcher's dbus api point
+package urldispatcher
+
+import (
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+// UrlDispatcher lives on a well-known bus.Address
+var BusAddress bus.Address = bus.Address{
+	Interface: "com.canonical.URLDispatcher",
+	Path:      "/com/canonical/URLDispatcher",
+	Name:      "com.canonical.URLDispatcher",
+}
+
+// A URLDispatcher is a simple beast, with a single method that does what it
+// says on the box.
+type URLDispatcher interface {
+	DispatchURL(string) error
+}
+
+type urlDispatcher struct {
+	endp bus.Endpoint
+	log  logger.Logger
+}
+
+// New builds a new URL dispatcher that uses the provided bus.Endpoint
+func New(endp bus.Endpoint, log logger.Logger) URLDispatcher {
+	return &urlDispatcher{endp, log}
+}
+
+var _ URLDispatcher = &urlDispatcher{} // ensures it conforms
+
+func (ud *urlDispatcher) DispatchURL(url string) error {
+	ud.log.Debugf("Dispatching %s", url)
+	_, err := ud.endp.Call("DispatchURL", url)
+	if err != nil {
+		ud.log.Errorf("Dispatch to %s failed with %s", url, err)
+	}
+	return err
+}

=== added file 'bus/urldispatcher/urldispatcher_test.go'
--- bus/urldispatcher/urldispatcher_test.go	1970-01-01 00:00:00 +0000
+++ bus/urldispatcher/urldispatcher_test.go	2014-01-23 14:29:00 +0000
@@ -0,0 +1,49 @@
+/*
+ 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 urldispatcher
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/testing/condition"
+	"testing"
+)
+
+// hook up gocheck
+func TestUrldispatcher(t *testing.T) { TestingT(t) }
+
+type UDSuite struct{}
+
+var _ = Suite(&UDSuite{})
+
+var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
+
+func (s *UDSuite) TestWorks(c *C) {
+	endp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{})
+	ud := New(endp, nullog)
+	err := ud.DispatchURL("this")
+	c.Check(err, IsNil)
+}
+
+func (s *UDSuite) TestFailsIfCallFails(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(false))
+	ud := New(endp, nullog)
+	err := ud.DispatchURL("this")
+	c.Check(err, NotNil)
+}

=== removed directory 'connectivity/webchecker'