Merge lp:~chipaca/ubuntu-push/the-push-automatic into lp:ubuntu-push

[John Lenton]

Merge from automatic.

Merge from automatic.

[lp:~chipaca/ubuntu-push/the-push-automatic]

113. By John Lenton on 2014-07-29

Merge from automatic.

=== modified file 'bus/emblemcounter/emblemcounter.go'
--- bus/emblemcounter/emblemcounter.go	2014-07-09 10:22:09 +0000
+++ bus/emblemcounter/emblemcounter.go	2014-07-29 16:56:22 +0000
@@ -49,16 +49,37 @@
 
 // Look for an EmblemCounter section in a Notification and, if
 // present, presents it to the user.
-func (ctr *EmblemCounter) Present(app *click.AppId, nid string, notification *launch_helper.Notification) {
-	if notification == nil || notification.EmblemCounter == nil {
-		ctr.log.Debugf("[%s] no notification or no EmblemCounter in the notification; doing nothing: %#v", nid, notification)
-		return
+func (ctr *EmblemCounter) Present(app *click.AppId, nid string, notification *launch_helper.Notification) bool {
+	if notification == nil {
+		panic("please check notification is not nil before calling present")
 	}
+
 	ec := notification.EmblemCounter
+
+	if ec == nil {
+		ctr.log.Debugf("[%s] notification has no EmblemCounter: %#v", nid, ec)
+		return false
+	}
 	ctr.log.Debugf("[%s] setting emblem counter for %s to %d (visible: %t)", nid, app.Base(), ec.Count, ec.Visible)
-
-	quoted := string(nih.Quote([]byte(app.Base())))
-
-	ctr.bus.SetProperty("count", "/"+quoted, dbus.Variant{ec.Count})
-	ctr.bus.SetProperty("countVisible", "/"+quoted, dbus.Variant{ec.Visible})
+	return ctr.SetCounter(app, ec.Count, ec.Visible)
+}
+
+// SetCounter sets an emblem counter on the launcher for app to count (if
+// visible is true), or clears it (if count is 0 or visible is false).
+func (ctr *EmblemCounter) SetCounter(app *click.AppId, count int32, visible bool) bool {
+	base := app.Base()
+	quoted := string(nih.Quote([]byte(base)))
+
+	err := ctr.bus.SetProperty("count", "/"+quoted, dbus.Variant{count})
+	if err != nil {
+		ctr.log.Errorf("call to set count failed: %v", err)
+		return false
+	}
+	err = ctr.bus.SetProperty("countVisible", "/"+quoted, dbus.Variant{visible})
+	if err != nil {
+		ctr.log.Errorf("call to set countVisible failed: %v", err)
+		return false
+	}
+
+	return true
 }
 
=== modified file 'bus/emblemcounter/emblemcounter_test.go'
--- bus/emblemcounter/emblemcounter_test.go	2014-07-11 19:42:57 +0000
+++ bus/emblemcounter/emblemcounter_test.go	2014-07-29 16:56:22 +0000
@@ -45,6 +45,21 @@
 	ecs.app = clickhelp.MustParseAppId("com.example.test_test-app_0")
 }
 
+// checks that SetCounter() actually calls SetProperty on the launcher
+func (ecs *ecSuite) TestSetCounterSetsTheCounter(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+	quoted := string(nih.Quote([]byte(ecs.app.Base())))
+
+	ec := New(endp, ecs.log)
+	c.Check(ec.SetCounter(ecs.app, 42, true), Equals, true)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 2)
+	c.Check(callArgs[0].Member, Equals, "::SetProperty")
+	c.Check(callArgs[1].Member, Equals, "::SetProperty")
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"count", "/" + quoted, dbus.Variant{Value: int32(42)}})
+	c.Check(callArgs[1].Args, DeepEquals, []interface{}{"countVisible", "/" + quoted, dbus.Variant{Value: true}})
+}
+
 // checks that Present() actually calls SetProperty on the launcher
 func (ecs *ecSuite) TestPresentPresents(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
@@ -52,7 +67,7 @@
 
 	ec := New(endp, ecs.log)
 	notif := launch_helper.Notification{EmblemCounter: &launch_helper.EmblemCounter{Count: 42, Visible: true}}
-	ec.Present(ecs.app, "nid", &notif)
+	c.Check(ec.Present(ecs.app, "nid", &notif), Equals, true)
 	callArgs := testibus.GetCallArgs(endp)
 	c.Assert(callArgs, HasLen, 2)
 	c.Check(callArgs[0].Member, Equals, "::SetProperty")
@@ -67,16 +82,12 @@
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
 	ec := New(endp, ecs.log)
 
-	// nothing happens if nil Notification
-	ec.Present(ecs.app, "nid", nil)
-	c.Assert(testibus.GetCallArgs(endp), HasLen, 0)
-
 	// nothing happens if no EmblemCounter in Notification
-	ec.Present(ecs.app, "nid", &launch_helper.Notification{})
+	c.Check(ec.Present(ecs.app, "nid", &launch_helper.Notification{}), Equals, false)
 	c.Assert(testibus.GetCallArgs(endp), HasLen, 0)
 
 	// but an empty EmblemCounter is acted on
-	ec.Present(ecs.app, "nid", &launch_helper.Notification{EmblemCounter: &launch_helper.EmblemCounter{}})
+	c.Check(ec.Present(ecs.app, "nid", &launch_helper.Notification{EmblemCounter: &launch_helper.EmblemCounter{}}), Equals, true)
 	callArgs := testibus.GetCallArgs(endp)
 	c.Assert(callArgs, HasLen, 2)
 	c.Check(callArgs[0].Member, Equals, "::SetProperty")
@@ -84,3 +95,12 @@
 	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"count", "/" + quoted, dbus.Variant{Value: int32(0)}})
 	c.Check(callArgs[1].Args, DeepEquals, []interface{}{"countVisible", "/" + quoted, dbus.Variant{Value: false}})
 }
+
+// check that Present() panics if the notification is nil
+func (ecs *ecSuite) TestPanicsIfNil(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+	ec := New(endp, ecs.log)
+
+	// nothing happens if no EmblemCounter in Notification
+	c.Check(func() { ec.Present(ecs.app, "nid", nil) }, Panics, `please check notification is not nil before calling present`)
+}
 
=== modified file 'bus/haptic/haptic.go'
--- bus/haptic/haptic.go	2014-07-15 15:02:33 +0000
+++ bus/haptic/haptic.go	2014-07-29 16:56:22 +0000
@@ -44,9 +44,13 @@
 }
 
 // Present presents the notification via a vibrate pattern
-func (haptic *Haptic) Present(_ *click.AppId, _ string, notification *launch_helper.Notification) bool {
-	if notification == nil || notification.Vibrate == nil {
-		haptic.log.Debugf("no notification or no Vibrate in the notification; doing nothing: %#v", notification)
+func (haptic *Haptic) Present(_ *click.AppId, nid string, notification *launch_helper.Notification) bool {
+	if notification == nil {
+		panic("please check notification is not nil before calling present")
+	}
+
+	if notification.Vibrate == nil {
+		haptic.log.Debugf("[%s] notification has no Vibrate: %#v", nid, notification.Vibrate)
 		return false
 	}
 	pattern := notification.Vibrate.Pattern
@@ -58,13 +62,13 @@
 		pattern = []uint32{notification.Vibrate.Duration}
 	}
 	if len(pattern) == 0 {
-		haptic.log.Debugf("not enough information in the notification's Vibrate section to create a pattern")
+		haptic.log.Debugf("[%s] not enough information in the Vibrate to create a pattern", nid)
 		return false
 	}
-	haptic.log.Debugf("vibrating %d times to the tune of %v", repeat, pattern)
+	haptic.log.Debugf("[%s] vibrating %d times to the tune of %v", nid, repeat, pattern)
 	err := haptic.bus.Call("VibratePattern", bus.Args(pattern, repeat))
 	if err != nil {
-		haptic.log.Errorf("VibratePattern call returned %v", err)
+		haptic.log.Errorf("[%s] call to VibratePattern returned %v", nid, err)
 		return false
 	}
 	return true
 
=== modified file 'bus/haptic/haptic_test.go'
--- bus/haptic/haptic_test.go	2014-07-11 19:42:57 +0000
+++ bus/haptic/haptic_test.go	2014-07-29 16:56:22 +0000
@@ -106,10 +106,17 @@
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
 
 	ec := New(endp, hs.log)
-	// no notification at all
-	c.Check(ec.Present(hs.app, "", nil), Equals, false)
 	// no Vibration in the notificaton
 	c.Check(ec.Present(hs.app, "", &launch_helper.Notification{}), Equals, false)
 	// empty Vibration
 	c.Check(ec.Present(hs.app, "", &launch_helper.Notification{Vibrate: &launch_helper.Vibration{}}), Equals, false)
 }
+
+// check that Present() panics if the notification is nil
+func (hs *hapticSuite) TestPanicsIfNil(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+
+	ec := New(endp, hs.log)
+	// no notification at all
+	c.Check(func() { ec.Present(hs.app, "", nil) }, Panics, `please check notification is not nil before calling present`)
+}
 
=== modified file 'bus/notifications/raw.go'
--- bus/notifications/raw.go	2014-07-17 22:43:17 +0000
+++ bus/notifications/raw.go	2014-07-29 16:56:22 +0000
@@ -131,14 +131,18 @@
 // If card.Actions has 1 action, it's an interactive notification.
 // If card.Actions has 2 actions, it will show as a snap decision.
 // If it has more actions, who knows (good luck).
-func (raw *RawNotifications) Present(app *click.AppId, nid string, notification *launch_helper.Notification) (uint32, error) {
-	if notification == nil || notification.Card == nil || !notification.Card.Popup || notification.Card.Summary == "" {
-		raw.log.Debugf("[%s] skipping notification: nil, or nil card, or not popup, or no summary: %#v", nid, notification)
-		return 0, nil
+func (raw *RawNotifications) Present(app *click.AppId, nid string, notification *launch_helper.Notification) bool {
+	if notification == nil {
+		panic("please check notification is not nil before calling present")
 	}
 
 	card := notification.Card
 
+	if card == nil || !card.Popup || card.Summary == "" {
+		raw.log.Debugf("[%s] notification has no popup card: %#v", nid, card)
+		return false
+	}
+
 	hints := make(map[string]*dbus.Variant)
 	hints["x-canonical-secondary-icon"] = &dbus.Variant{app.Icon()}
 
@@ -152,7 +156,8 @@
 			Action:   action,
 		})
 		if err != nil {
-			return 0, err
+			raw.log.Errorf("[%s] while marshaling %#v to json: %v", nid, action, err)
+			return false
 		}
 		actions[2*i] = string(act)
 		actions[2*i+1] = action
@@ -160,13 +165,22 @@
 	switch len(card.Actions) {
 	case 0:
 		// nothing
+	default:
+		raw.log.Errorf("[%s] don't know what to do with %d actions; ignoring the rest", nid, len(card.Actions))
+		actions = actions[:2]
+		fallthrough
 	case 1:
 		hints["x-canonical-switch-to-application"] = &dbus.Variant{"true"}
-	case 2:
-		hints["x-canonical-snap-decisions"] = &dbus.Variant{"true"}
-		hints["x-canonical-private-button-tint"] = &dbus.Variant{"true"}
-	default:
-		raw.log.Debugf("[%s] don't know what to do with %d actions; no hints set", nid, len(card.Actions))
-	}
-	return raw.Notify(appId, 0, card.Icon, card.Summary, card.Body, actions, hints, 30*1000)
+	}
+
+	raw.log.Debugf("[%s] creating popup (or snap decision) for %s (summary: %s)", nid, app.Base(), card.Summary)
+
+	_, err := raw.Notify(appId, 0, card.Icon, card.Summary, card.Body, actions, hints, 30*1000)
+
+	if err != nil {
+		raw.log.Errorf("[%s] call to Notify failed: %v", nid, err)
+		return false
+	}
+
+	return true
 }
 
=== modified file 'bus/notifications/raw_test.go'
--- bus/notifications/raw_test.go	2014-07-17 22:57:16 +0000
+++ bus/notifications/raw_test.go	2014-07-29 16:56:22 +0000
@@ -160,16 +160,15 @@
 func (s *RawSuite) TestPresentNotifies(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	nid, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true}})
-	c.Check(err, IsNil)
-	c.Check(nid, Equals, uint32(1))
+	worked := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true}})
+	c.Check(worked, Equals, true)
 }
 
 func (s *RawSuite) TestPresentOneAction(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	_, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true, Actions: []string{"Yes"}}})
-	c.Check(err, IsNil)
+	worked := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true, Actions: []string{"Yes"}}})
+	c.Check(worked, Equals, true)
 	callArgs := testibus.GetCallArgs(endp)
 	c.Assert(callArgs, HasLen, 1)
 	c.Assert(callArgs[0].Member, Equals, "Notify")
@@ -192,78 +191,48 @@
 func (s *RawSuite) TestPresentTwoActions(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	_, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true, Actions: []string{"Yes", "No"}}})
-	c.Check(err, IsNil)
+	worked := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true, Actions: []string{"Yes", "No"}}})
+	c.Check(worked, Equals, true)
 	callArgs := testibus.GetCallArgs(endp)
 	c.Assert(callArgs, HasLen, 1)
 	c.Assert(callArgs[0].Member, Equals, "Notify")
 	c.Assert(len(callArgs[0].Args), Equals, 8)
 	actions, ok := callArgs[0].Args[5].([]string)
 	c.Assert(ok, Equals, true)
-	c.Assert(actions, HasLen, 4)
+	c.Assert(actions, HasLen, 2)
 	c.Check(actions[0], Equals, `{"app":"com.example.test_test-app_0","act":"Yes","nid":"notifId"}`)
 	c.Check(actions[1], Equals, "Yes")
-	c.Check(actions[2], Equals, `{"app":"com.example.test_test-app_0","act":"No","aid":1,"nid":"notifId"}`)
-	c.Check(actions[3], Equals, "No")
-	hints, ok := callArgs[0].Args[6].(map[string]*dbus.Variant)
-	c.Assert(ok, Equals, true)
-	// with two actions, there should be 3 hints set:
-	c.Assert(hints, HasLen, 3)
-	c.Check(hints["x-canonical-switch-to-application"], IsNil)
-	c.Check(hints["x-canonical-secondary-icon"], NotNil)
-	c.Check(hints["x-canonical-snap-decisions"], NotNil)
-	c.Check(hints["x-canonical-private-button-tint"], NotNil)
-	c.Check(hints["x-canonical-non-shaped-icon"], IsNil) // checking just in case
-}
-
-func (s *RawSuite) TestPresentThreeActions(c *C) {
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	raw := Raw(endp, s.log)
-	_, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true, Actions: []string{"Yes", "No", "What"}}})
-	c.Check(err, IsNil)
-	callArgs := testibus.GetCallArgs(endp)
-	c.Assert(callArgs, HasLen, 1)
-	c.Assert(callArgs[0].Member, Equals, "Notify")
-	c.Assert(len(callArgs[0].Args), Equals, 8)
-	actions, ok := callArgs[0].Args[5].([]string)
-	c.Assert(ok, Equals, true)
-	c.Assert(actions, HasLen, 6)
-	hints, ok := callArgs[0].Args[6].(map[string]*dbus.Variant)
-	c.Assert(ok, Equals, true)
-	// with two actions, there should be 3 hints set:
-	c.Check(hints, HasLen, 1)
-	c.Check(hints["x-canonical-secondary-icon"], NotNil)
-	c.Check(s.log.Captured(), Matches, `(?ms).* no hints set$`)
-}
-
-func (s *RawSuite) TestPresentNoNotificationDoesNotNotify(c *C) {
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	raw := Raw(endp, s.log)
-	nid, err := raw.Present(s.app, "notifId", nil)
-	c.Check(err, IsNil)
-	c.Check(nid, Equals, uint32(0))
+	// note that the rest are ignored.
+	hints, ok := callArgs[0].Args[6].(map[string]*dbus.Variant)
+	c.Assert(ok, Equals, true)
+	c.Assert(hints, HasLen, 2)
+	c.Check(hints["x-canonical-switch-to-application"], NotNil)
+	c.Check(hints["x-canonical-secondary-icon"], NotNil)
+}
+
+func (s *RawSuite) TestPresentNoNotificationPanics(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	c.Check(func() { raw.Present(s.app, "notifId", nil) }, Panics, `please check notification is not nil before calling present`)
 }
 
 func (s *RawSuite) TestPresentNoCardDoesNotNotify(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	nid, err := raw.Present(s.app, "notifId", &launch_helper.Notification{})
-	c.Check(err, IsNil)
-	c.Check(nid, Equals, uint32(0))
+	worked := raw.Present(s.app, "notifId", &launch_helper.Notification{})
+	c.Check(worked, Equals, false)
 }
 
 func (s *RawSuite) TestPresentNoSummaryDoesNotNotify(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	nid, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{}})
-	c.Check(err, IsNil)
-	c.Check(nid, Equals, uint32(0))
+	worked := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{}})
+	c.Check(worked, Equals, false)
 }
 
 func (s *RawSuite) TestPresentNoPopupNoNotify(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	nid, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary"}})
-	c.Check(err, IsNil)
-	c.Check(nid, Equals, uint32(0))
+	worked := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary"}})
+	c.Check(worked, Equals, false)
 }
 
=== modified file 'bus/urldispatcher/urldispatcher.go'
--- bus/urldispatcher/urldispatcher.go	2014-04-02 08:23:15 +0000
+++ bus/urldispatcher/urldispatcher.go	2014-07-29 16:56:22 +0000
@@ -19,6 +19,7 @@
 
 import (
 	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/logger"
 )
 
@@ -32,7 +33,8 @@
 // A URLDispatcher is a simple beast, with a single method that does what it
 // says on the box.
 type URLDispatcher interface {
-	DispatchURL(string) error
+	DispatchURL(string, *click.AppId) error
+	TestURL(*click.AppId, []string) bool
 }
 
 type urlDispatcher struct {
@@ -47,11 +49,28 @@
 
 var _ URLDispatcher = &urlDispatcher{} // ensures it conforms
 
-func (ud *urlDispatcher) DispatchURL(url string) error {
+func (ud *urlDispatcher) DispatchURL(url string, app *click.AppId) error {
 	ud.log.Debugf("Dispatching %s", url)
-	err := ud.endp.Call("DispatchURL", bus.Args(url))
+	err := ud.endp.Call("DispatchURL", bus.Args(url, app.DispatchPackage()))
 	if err != nil {
 		ud.log.Errorf("Dispatch to %s failed with %s", url, err)
 	}
 	return err
 }
+
+func (ud *urlDispatcher) TestURL(app *click.AppId, urls []string) bool {
+	ud.log.Debugf("TestURL: %s", urls)
+	var appIds []string
+	err := ud.endp.Call("TestURL", bus.Args(urls), &appIds)
+	if err != nil {
+		ud.log.Errorf("TestURL for %s failed with %s", urls, err)
+		return false
+	}
+	for _, appId := range appIds {
+		if appId != app.Versioned() {
+			ud.log.Debugf("Notification skipped because of different appid for actions: %v - %s != %s", urls, appId, app.Versioned())
+			return false
+		}
+	}
+	return true
+}
 
=== modified file 'bus/urldispatcher/urldispatcher_test.go'
--- bus/urldispatcher/urldispatcher_test.go	2014-02-05 18:17:26 +0000
+++ bus/urldispatcher/urldispatcher_test.go	2014-07-29 16:56:22 +0000
@@ -19,7 +19,7 @@
 import (
 	. "launchpad.net/gocheck"
 	testibus "launchpad.net/ubuntu-push/bus/testing"
-	"launchpad.net/ubuntu-push/logger"
+	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
 	"testing"
@@ -29,7 +29,7 @@
 func TestUrldispatcher(t *testing.T) { TestingT(t) }
 
 type UDSuite struct {
-	log logger.Logger
+	log *helpers.TestLogger
 }
 
 var _ = Suite(&UDSuite{})
@@ -38,16 +38,78 @@
 	s.log = helpers.NewTestLogger(c, "debug")
 }
 
-func (s *UDSuite) TestWorks(c *C) {
+func (s *UDSuite) TestDispatchURLWorks(c *C) {
 	endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{})
 	ud := New(endp, s.log)
-	err := ud.DispatchURL("this")
+	appId := clickhelp.MustParseAppId("com.example.test_app_0.99")
+	err := ud.DispatchURL("this", appId)
 	c.Check(err, IsNil)
 }
 
-func (s *UDSuite) TestFailsIfCallFails(c *C) {
+func (s *UDSuite) TestDispatchURLFailsIfCallFails(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
 	ud := New(endp, s.log)
-	err := ud.DispatchURL("this")
+	appId := clickhelp.MustParseAppId("com.example.test_app_0.99")
+	err := ud.DispatchURL("this", appId)
 	c.Check(err, NotNil)
 }
+
+func (s *UDSuite) TestTestURLWorks(c *C) {
+	endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{[]string{"com.example.test_app_0.99"}})
+	ud := New(endp, s.log)
+	appId := clickhelp.MustParseAppId("com.example.test_app_0.99")
+	c.Check(ud.TestURL(appId, []string{"this"}), Equals, true)
+	c.Check(s.log.Captured(), Matches, `(?sm).*TestURL: \[this\].*`)
+}
+
+func (s *UDSuite) TestTestURLFailsIfCallFails(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	ud := New(endp, s.log)
+	appId := clickhelp.MustParseAppId("com.example.test_app_0.99")
+	c.Check(ud.TestURL(appId, []string{"this"}), Equals, false)
+}
+
+func (s *UDSuite) TestTestURLMultipleURLs(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []string{"com.example.test_app_0.99", "com.example.test_app_0.99"})
+	ud := New(endp, s.log)
+	appId := clickhelp.MustParseAppId("com.example.test_app_0.99")
+	urls := []string{"potato://test-app", "potato_a://foo"}
+	c.Check(ud.TestURL(appId, urls), Equals, true)
+	c.Check(s.log.Captured(), Matches, `(?sm).*TestURL: \[potato://test-app potato_a://foo\].*`)
+}
+
+func (s *UDSuite) TestTestURLWrongApp(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []string{"com.example.test_test-app_0.1"})
+	ud := New(endp, s.log)
+	appId := clickhelp.MustParseAppId("com.example.test_app_0.99")
+	urls := []string{"potato://test-app"}
+	c.Check(ud.TestURL(appId, urls), Equals, false)
+	c.Check(s.log.Captured(), Matches, `(?sm).*Notification skipped because of different appid for actions: \[potato://test-app\] - com.example.test_test-app_0.1 != com.example.test_app_0.99`)
+}
+
+func (s *UDSuite) TestTestURLOneWrongApp(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []string{"com.example.test_test-app_0", "com.example.test_test-app1"})
+	ud := New(endp, s.log)
+	appId := clickhelp.MustParseAppId("com.example.test_test-app_0")
+	urls := []string{"potato://test-app", "potato_a://foo"}
+	c.Check(ud.TestURL(appId, urls), Equals, false)
+	c.Check(s.log.Captured(), Matches, `(?sm).*Notification skipped because of different appid for actions: \[potato://test-app potato_a://foo\] - com.example.test_test-app1 != com.example.test_test-app.*`)
+}
+
+func (s *UDSuite) TestTestURLInvalidURL(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false), []string{"com.example.test_test-app_0.1"})
+	ud := New(endp, s.log)
+	appId := clickhelp.MustParseAppId("com.example.test_app_0.2")
+	urls := []string{"notsupported://test-app"}
+	c.Check(ud.TestURL(appId, urls), Equals, false)
+	c.Check(s.log.Captured(), Matches, `(?sm).*TestURL for \[notsupported://test-app\] failed with no way.*`)
+}
+
+func (s *UDSuite) TestTestURLLegacyApp(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []string{"ubuntu-system-settings"})
+	ud := New(endp, s.log)
+	appId := clickhelp.MustParseAppId("_ubuntu-system-settings")
+	urls := []string{"settings://test-app"}
+	c.Check(ud.TestURL(appId, urls), Equals, true)
+	c.Check(s.log.Captured(), Matches, `(?sm).*TestURL: \[settings://test-app\].*`)
+}
 
=== modified file 'click/click.go'
--- click/click.go	2014-07-18 20:45:21 +0000
+++ click/click.go	2014-07-29 16:56:22 +0000
@@ -98,6 +98,13 @@
 	return app.Package == pkgname
 }
 
+func (app *AppId) DispatchPackage() string {
+	if app.Click {
+		return app.Package
+	}
+	return app.Application
+}
+
 func (app *AppId) Original() string {
 	return app.original
 }
 
=== modified file 'click/click_test.go'
--- click/click_test.go	2014-07-18 20:45:21 +0000
+++ click/click_test.go	2014-07-29 16:56:22 +0000
@@ -42,6 +42,7 @@
 	c.Check(app.Click, Equals, true)
 	c.Check(app.Original(), Equals, "com.ubuntu.clock_clock")
 	c.Check(fmt.Sprintf("%s", app), Equals, "com.ubuntu.clock_clock")
+	c.Check(app.DispatchPackage(), Equals, "com.ubuntu.clock")
 
 	app, err = ParseAppId("com.ubuntu.clock_clock_10")
 	c.Assert(err, IsNil)
@@ -55,6 +56,7 @@
 	c.Check(app.Versioned(), Equals, "com.ubuntu.clock_clock_10")
 	c.Check(app.Base(), Equals, "com.ubuntu.clock_clock")
 	c.Check(app.DesktopId(), Equals, "com.ubuntu.clock_clock_10.desktop")
+	c.Check(app.DispatchPackage(), Equals, "com.ubuntu.clock")
 
 	for _, s := range []string{"com.ubuntu.clock_clock_10_4", "com.ubuntu.clock", ""} {
 		app, err = ParseAppId(s)
@@ -81,6 +83,7 @@
 	c.Check(app.Versioned(), Equals, "python3.4")
 	c.Check(app.Base(), Equals, "python3.4")
 	c.Check(app.DesktopId(), Equals, "python3.4.desktop")
+	c.Check(app.DispatchPackage(), Equals, "python3.4")
 
 	for _, s := range []string{"_.foo", "_foo/", "_/foo"} {
 		app, err = ParseAppId(s)
 
=== modified file 'client/client.go'
--- client/client.go	2014-07-21 01:18:16 +0000
+++ client/client.go	2014-07-29 16:56:22 +0000
@@ -32,8 +32,6 @@
 	"os/exec"
 	"strings"
 
-	"code.google.com/p/go-uuid/uuid"
-
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/connectivity"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
@@ -85,7 +83,7 @@
 	// Post converts a push message into a presentable notification
 	// and a postal message, presents the former and stores the
 	// latter in the application's mailbox.
-	Post(app *click.AppId, nid string, payload json.RawMessage) error
+	Post(app *click.AppId, nid string, payload json.RawMessage)
 	// IsRunning() returns whether the service is running
 	IsRunning() bool
 	// Stop() stops the service
@@ -398,29 +396,23 @@
 	}
 	// marshal the last decoded msg to json
 	payload, err := json.Marshal(msg.Decoded[len(msg.Decoded)-1])
-	if err == nil {
-		appId, _ := click.ParseAppId("_ubuntu-system-settings")
-		err = client.postalService.Post(appId, uuid.New(), payload)
-	}
 	if err != nil {
 		client.log.Errorf("while posting broadcast notification %d: %v", msg.TopLevel, err)
-	} else {
-		client.log.Debugf("posted broadcast notification %d.", msg.TopLevel)
+		return err
 	}
-	return err
+	appId, _ := click.ParseAppId("_ubuntu-system-settings")
+	client.postalService.Post(appId, "", payload)
+	client.log.Debugf("posted broadcast notification %d.", msg.TopLevel)
+	return nil
 }
 
 // handleUnicastNotification deals with receiving a unicast notification
 func (client *PushClient) handleUnicastNotification(anotif session.AddressedNotification) error {
 	app := anotif.To
 	msg := anotif.Notification
-	err := client.postalService.Post(app, msg.MsgId, msg.Payload)
-	if err != nil {
-		client.log.Errorf("while posting unicast notification %s for %s: %v", msg.MsgId, msg.AppId, err)
-	} else {
-		client.log.Debugf("posted unicast notification %s for %s.", msg.MsgId, msg.AppId)
-	}
-	return err
+	client.postalService.Post(app, msg.MsgId, msg.Payload)
+	client.log.Debugf("posted unicast notification %s for %s.", msg.MsgId, msg.AppId)
+	return nil
 }
 
 // doLoop connects events with their handlers
 
=== modified file 'client/client_test.go'
--- client/client_test.go	2014-07-21 01:18:16 +0000
+++ client/client_test.go	2014-07-29 16:56:22 +0000
@@ -107,13 +107,12 @@
 	postArgs   []postArgs
 }
 
-func (d *dumbPostal) Post(app *click.AppId, nid string, payload json.RawMessage) error {
+func (d *dumbPostal) Post(app *click.AppId, nid string, payload json.RawMessage) {
 	d.postCount++
 	if app.Application == "ubuntu-system-settings" {
 		d.bcastCount++
 	}
 	d.postArgs = append(d.postArgs, postArgs{app, nid, payload})
-	return d.err
 }
 
 var _ PostalService = (*dumbPostal)(nil)
@@ -786,6 +785,9 @@
 	positiveBroadcastNotification = &session.BroadcastNotification{
 		Decoded: []map[string]interface{}{
 			map[string]interface{}{
+				"daily/mako": []interface{}{float64(102), "tubular"},
+			},
+			map[string]interface{}{
 				"daily/mako": []interface{}{float64(103), "tubular"},
 			},
 		},
@@ -811,7 +813,8 @@
 	c.Assert(d.postArgs, HasLen, 1)
 	expectedApp, _ := click.ParseAppId("_ubuntu-system-settings")
 	c.Check(d.postArgs[0].app, DeepEquals, expectedApp)
-	expectedData, _ := json.Marshal(positiveBroadcastNotification.Decoded[0])
+	c.Check(d.postArgs[0].nid, Equals, "")
+	expectedData, _ := json.Marshal(positiveBroadcastNotification.Decoded[1])
 	c.Check([]byte(d.postArgs[0].payload), DeepEquals, expectedData)
 }
 
@@ -826,18 +829,6 @@
 	c.Check(d.bcastCount, Equals, 0)
 }
 
-func (cs *clientSuite) TestHandleBroadcastNotificationFail(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.systemImageInfo = siInfoRes
-	cli.log = cs.log
-	d := new(dumbPostal)
-	err := errors.New("potato")
-	d.err = err
-	cli.postalService = d
-	c.Check(cli.handleBroadcastNotification(positiveBroadcastNotification), Equals, err)
-	c.Check(d.bcastCount, Equals, 1)
-}
-
 /*****************************************************************
     handleUnicastNotification tests
 ******************************************************************/
@@ -860,19 +851,6 @@
 	c.Check(d.postArgs[0].payload, DeepEquals, notif.Payload)
 }
 
-func (cs *clientSuite) TestHandleUcastNotificationError(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	d := new(dumbPostal)
-	cli.postalService = d
-	fail := errors.New("fail")
-	d.err = fail
-
-	c.Check(cli.handleUnicastNotification(session.AddressedNotification{appHello, notif}), Equals, fail)
-	// check we sent the notification
-	c.Check(d.postCount, Equals, 1)
-}
-
 /*****************************************************************
     handleUnregister tests
 ******************************************************************/
 
=== modified file 'client/service/postal.go'
--- client/service/postal.go	2014-07-21 01:18:16 +0000
+++ client/service/postal.go	2014-07-29 16:56:22 +0000
@@ -39,7 +39,21 @@
 	"launchpad.net/ubuntu-push/util"
 )
 
-type messageHandler func(*click.AppId, string, *launch_helper.HelperOutput) error
+type messageHandler func(*click.AppId, string, *launch_helper.HelperOutput) bool
+
+// a Presenter is something that knows how to present a Notification
+type Presenter interface {
+	Present(*click.AppId, string, *launch_helper.Notification) bool
+}
+
+type notificationCentre interface {
+	Presenter
+	GetCh() chan *reply.MMActionReply
+	RemoveNotification(string, bool)
+	StartCleanupLoop()
+	Tags(*click.AppId) []string
+	Clear(*click.AppId, ...string) int
+}
 
 // PostalService is the dbus api
 type PostalService struct {
@@ -48,7 +62,7 @@
 	msgHandler    messageHandler
 	launchers     map[string]launch_helper.HelperLauncher
 	HelperPool    launch_helper.HelperPool
-	messagingMenu *messaging.MessagingMenu
+	messagingMenu notificationCentre
 	// the endpoints are only exposed for testing from client
 	// XXX: uncouple some more so this isn't necessary
 	EmblemCounterEndp bus.Endpoint
@@ -57,6 +71,7 @@
 	URLDispatcherEndp bus.Endpoint
 	WindowStackEndp   bus.Endpoint
 	// presenters:
+	Presenters    []Presenter
 	emblemCounter *emblemcounter.EmblemCounter
 	haptic        *haptic.Haptic
 	notifications *notifications.RawNotifications
@@ -112,8 +127,11 @@
 // Start() dials the bus, grab the name, and listens for method calls.
 func (svc *PostalService) Start() error {
 	err := svc.DBusService.Start(bus.DispatchMap{
-		"PopAll": svc.popAll,
-		"Post":   svc.post,
+		"PopAll":          svc.popAll,
+		"Post":            svc.post,
+		"ListPersistent":  svc.listPersistent,
+		"ClearPersistent": svc.clearPersistent,
+		"SetCounter":      svc.setCounter,
 	}, PostalServiceBusAddress)
 	if err != nil {
 		return err
@@ -128,6 +146,13 @@
 	svc.haptic = haptic.New(svc.HapticEndp, svc.Log)
 	svc.sound = sounds.New(svc.Log)
 	svc.messagingMenu = messaging.New(svc.Log)
+	svc.Presenters = []Presenter{
+		svc.notifications,
+		svc.emblemCounter,
+		svc.haptic,
+		svc.sound,
+		svc.messagingMenu,
+	}
 	if useTrivialHelper {
 		svc.HelperPool = launch_helper.NewTrivialHelperPool(svc.Log)
 	} else {
@@ -136,7 +161,8 @@
 	svc.windowStack = windowstack.New(svc.WindowStackEndp, svc.Log)
 
 	go svc.consumeHelperResults(svc.HelperPool.Start())
-	go svc.handleActions(actionsCh, svc.messagingMenu.Ch)
+	go svc.handleActions(actionsCh, svc.messagingMenu.GetCh())
+	svc.messagingMenu.StartCleanupLoop()
 	return nil
 }
 
@@ -155,8 +181,10 @@
 				svc.Log.Debugf("handleActions got nil action; ignoring")
 			} else {
 				url := action.Action
+				// remove the notification from the messaging menu
+				svc.messagingMenu.RemoveNotification(action.Nid, true)
 				// this ignores the error (it's been logged already)
-				svc.urlDispatcher.DispatchURL(url)
+				svc.urlDispatcher.DispatchURL(url, action.App)
 			}
 		case mmuAction, ok := <-mmuActionsCh:
 			if !ok {
@@ -168,9 +196,9 @@
 				svc.Log.Debugf("handleActions (MMU) got: %v", mmuAction)
 				url := mmuAction.Action
 				// remove the notification from the messagingmenu map
-				svc.messagingMenu.RemoveNotification(mmuAction.Notification)
+				svc.messagingMenu.RemoveNotification(mmuAction.Notification, false)
 				// this ignores the error (it's been logged already)
-				svc.urlDispatcher.DispatchURL(url)
+				svc.urlDispatcher.DispatchURL(url, mmuAction.App)
 			}
 
 		}
@@ -209,6 +237,54 @@
 	return notifications.Raw(svc.NotificationsEndp, svc.Log).WatchActions()
 }
 
+func (svc *PostalService) listPersistent(path string, args, _ []interface{}) ([]interface{}, error) {
+	app, err := svc.grabDBusPackageAndAppId(path, args, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	tagmap := svc.messagingMenu.Tags(app)
+	return []interface{}{tagmap}, nil
+}
+
+func (svc *PostalService) clearPersistent(path string, args, _ []interface{}) ([]interface{}, error) {
+	if len(args) == 0 {
+		return nil, ErrBadArgCount
+	}
+	app, err := svc.grabDBusPackageAndAppId(path, args[:1], 0)
+	if err != nil {
+		return nil, err
+	}
+	tags := make([]string, len(args)-1)
+	for i, itag := range args[1:] {
+		tag, ok := itag.(string)
+		if !ok {
+			return nil, ErrBadArgType
+		}
+		tags[i] = tag
+	}
+	return []interface{}{uint32(svc.messagingMenu.Clear(app, tags...))}, nil
+}
+
+func (svc *PostalService) setCounter(path string, args, _ []interface{}) ([]interface{}, error) {
+	app, err := svc.grabDBusPackageAndAppId(path, args, 2)
+	if err != nil {
+		return nil, err
+	}
+
+	count, ok := args[1].(int32)
+	if !ok {
+		return nil, ErrBadArgType
+	}
+	visible, ok := args[2].(bool)
+	if !ok {
+		return nil, ErrBadArgType
+	}
+
+	svc.emblemCounter.SetCounter(app, count, visible)
+	return nil, nil
+}
+
 func (svc *PostalService) popAll(path string, args, _ []interface{}) ([]interface{}, error) {
 	app, err := svc.grabDBusPackageAndAppId(path, args, 0)
 	if err != nil {
@@ -250,14 +326,16 @@
 		return nil, ErrBadJSON
 	}
 
-	nid := newNid()
-
-	return nil, svc.Post(app, nid, rawJSON)
+	svc.Post(app, "", rawJSON)
+	return nil, nil
 }
 
 // Post() signals to an application over dbus that a notification
-// has arrived.
-func (svc *PostalService) Post(app *click.AppId, nid string, payload json.RawMessage) error {
+// has arrived. If nid is "" generate one.
+func (svc *PostalService) Post(app *click.AppId, nid string, payload json.RawMessage) {
+	if nid == "" {
+		nid = newNid()
+	}
 	arg := launch_helper.HelperInput{
 		App:            app,
 		NotificationId: nid,
@@ -270,7 +348,6 @@
 		kind = "legacy"
 	}
 	svc.HelperPool.Run(kind, &arg)
-	return nil
 }
 
 func (svc *PostalService) consumeHelperResults(ch chan *launch_helper.HelperResult) {
@@ -299,27 +376,41 @@
 	box.Append(output.Message, nid)
 
 	if svc.msgHandler != nil {
-		err := svc.msgHandler(app, nid, &output)
-		if err != nil {
-			svc.DBusService.Log.Errorf("msgHandler returned %v", err)
-			return
+		b := svc.msgHandler(app, nid, &output)
+		if !b {
+			svc.Log.Debugf("msgHandler did not present the notification")
 		}
-		svc.DBusService.Log.Debugf("call to msgHandler successful")
 	}
 
 	svc.Bus.Signal("Post", "/"+string(nih.Quote([]byte(app.Package))), []interface{}{appId})
 }
 
-func (svc *PostalService) messageHandler(app *click.AppId, nid string, output *launch_helper.HelperOutput) error {
+func (svc *PostalService) validateActions(app *click.AppId, notif *launch_helper.Notification) bool {
+	if notif.Card == nil || len(notif.Card.Actions) == 0 {
+		return true
+	}
+	return svc.urlDispatcher.TestURL(app, notif.Card.Actions)
+}
+
+func (svc *PostalService) messageHandler(app *click.AppId, nid string, output *launch_helper.HelperOutput) bool {
+	if output == nil || output.Notification == nil {
+		svc.Log.Debugf("skipping notification: nil.")
+		return false
+	}
+	// validate actions
+	if !svc.validateActions(app, output.Notification) {
+		// no need to log, (it's been logged already)
+		return false
+	}
 	if !svc.windowStack.IsAppFocused(app) {
-		svc.messagingMenu.Present(app, nid, output.Notification)
-		_, err := svc.notifications.Present(app, nid, output.Notification)
-		svc.emblemCounter.Present(app, nid, output.Notification)
-		svc.haptic.Present(app, nid, output.Notification)
-		svc.sound.Present(app, nid, output.Notification)
-		return err
+		b := false
+		for _, p := range svc.Presenters {
+			// we don't want this to shortcut :)
+			b = p.Present(app, nid, output.Notification) || b
+		}
+		return b
 	} else {
-		svc.Log.Debugf("Notification skipped because app is focused.")
-		return nil
+		svc.Log.Debugf("notification skipped because app is focused.")
+		return false
 	}
 }
 
=== modified file 'client/service/postal_test.go'
--- client/service/postal_test.go	2014-07-21 10:38:55 +0000
+++ client/service/postal_test.go	2014-07-29 16:56:22 +0000
@@ -18,15 +18,14 @@
 
 import (
 	"encoding/json"
-	"errors"
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"sort"
 	"time"
 
-	"code.google.com/p/go-uuid/uuid"
-
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/bus"
@@ -37,6 +36,7 @@
 	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/messaging/reply"
+	"launchpad.net/ubuntu-push/nih"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
 )
@@ -80,16 +80,16 @@
 	}
 }
 
-func installTickMessageHandler(svc *PostalService) chan error {
-	ch := make(chan error)
+func installTickMessageHandler(svc *PostalService) chan bool {
+	ch := make(chan bool)
 	msgHandler := svc.GetMessageHandler()
-	svc.SetMessageHandler(func(app *click.AppId, nid string, output *launch_helper.HelperOutput) error {
-		var err error
+	svc.SetMessageHandler(func(app *click.AppId, nid string, output *launch_helper.HelperOutput) bool {
+		var b bool
 		if msgHandler != nil {
-			err = msgHandler(app, nid, output)
+			b = msgHandler(app, nid, output)
 		}
-		ch <- err
-		return err
+		ch <- b
+		return b
 	})
 	return ch
 }
@@ -270,6 +270,60 @@
 }
 
 //
+// post() tests
+
+func (ps *postalSuite) TestPostHappyPath(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.msgHandler = nil
+	ch := installTickMessageHandler(svc)
+	svc.launchers = map[string]launch_helper.HelperLauncher{
+		"click": ps.fakeLauncher,
+	}
+	c.Assert(svc.Start(), IsNil)
+	payload := `{"message": {"world":1}}`
+	rvs, err := svc.post(aPackageOnBus, []interface{}{anAppId, payload}, nil)
+	c.Assert(err, IsNil)
+	c.Check(rvs, IsNil)
+
+	if ps.fakeLauncher.done != nil {
+		// wait for the two posts to "launch"
+		inputData := takeNextBytes(ps.fakeLauncher.ch)
+		c.Check(string(inputData), Equals, payload)
+
+		go ps.fakeLauncher.done("0") // OneDone
+	}
+
+	c.Check(takeNextBool(ch), Equals, false) // one,
+	// xxx here?
+	c.Assert(svc.mbox, HasLen, 1)
+	box, ok := svc.mbox[anAppId]
+	c.Check(ok, Equals, true)
+	msgs := box.AllMessages()
+	c.Assert(msgs, HasLen, 1)
+	c.Check(msgs[0], Equals, `{"world":1}`)
+	c.Check(box.nids[0], Not(Equals), "")
+}
+
+func (ps *postalSuite) TestPostFailsIfBadArgs(c *C) {
+	for i, s := range []struct {
+		args []interface{}
+		errt error
+	}{
+		{nil, ErrBadArgCount},
+		{[]interface{}{}, ErrBadArgCount},
+		{[]interface{}{1}, ErrBadArgCount},
+		{[]interface{}{anAppId, 1}, ErrBadArgType},
+		{[]interface{}{anAppId, "zoom"}, ErrBadJSON},
+		{[]interface{}{1, "hello"}, ErrBadArgType},
+		{[]interface{}{1, 2, 3}, ErrBadArgCount},
+		{[]interface{}{"bar", "hello"}, ErrBadAppId},
+	} {
+		reg, err := new(PostalService).post(aPackageOnBus, s.args, nil)
+		c.Check(reg, IsNil, Commentf("iteration #%d", i))
+		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
+	}
+}
+
 // Post() tests
 
 func (ps *postalSuite) TestPostWorks(c *C) {
@@ -282,30 +336,31 @@
 		"legacy": fakeLauncher2,
 	}
 	c.Assert(svc.Start(), IsNil)
-	rvs, err := svc.post(aPackageOnBus, []interface{}{anAppId, `{"message":{"world":1}}`}, nil)
-	c.Assert(err, IsNil)
-	c.Check(rvs, IsNil)
-	rvs, err = svc.post(aPackageOnBus, []interface{}{anAppId, `{"message":{"moon":1}}`}, nil)
-	c.Assert(err, IsNil)
-	c.Check(rvs, IsNil)
-	rvs, err = svc.post("_", []interface{}{"_classic-app", `{"message":{"mars":42}}`}, nil)
-	c.Assert(err, IsNil)
-	c.Check(rvs, IsNil)
+
+	app := clickhelp.MustParseAppId(anAppId)
+	// these two, being for the same app, will be done sequentially.
+	svc.Post(app, "m1", json.RawMessage(`{"message":{"world":1}}`))
+	svc.Post(app, "m2", json.RawMessage(`{"message":{"moon":1}}`))
+	classicApp := clickhelp.MustParseAppId("_classic-app")
+	svc.Post(classicApp, "m3", json.RawMessage(`{"message":{"mars":42}}`))
 
 	if ps.fakeLauncher.done != nil {
 		// wait for the two posts to "launch"
 		takeNextBytes(ps.fakeLauncher.ch)
-		takeNextBytes(ps.fakeLauncher.ch)
 		takeNextBytes(fakeLauncher2.ch)
-
 		go ps.fakeLauncher.done("0") // OneDone
+		go fakeLauncher2.done("0")
+
+		inputData := takeNextBytes(ps.fakeLauncher.ch)
+
+		c.Check(string(inputData), Equals, `{"message":{"moon":1}}`)
+
 		go ps.fakeLauncher.done("1") // OneDone
-		go fakeLauncher2.done("0")
 	}
 
-	c.Check(takeNextError(ch), IsNil) // one,
-	c.Check(takeNextError(ch), IsNil) // two,
-	c.Check(takeNextError(ch), IsNil) // three posts
+	c.Check(takeNextBool(ch), Equals, false) // one,
+	c.Check(takeNextBool(ch), Equals, false) // two,
+	c.Check(takeNextBool(ch), Equals, false) // three posts
 	c.Assert(svc.mbox, HasLen, 2)
 	box, ok := svc.mbox[anAppId]
 	c.Check(ok, Equals, true)
@@ -313,6 +368,7 @@
 	c.Assert(msgs, HasLen, 2)
 	c.Check(msgs[0], Equals, `{"world":1}`)
 	c.Check(msgs[1], Equals, `{"moon":1}`)
+	c.Check(box.nids, DeepEquals, []string{"m1", "m2"})
 	box, ok = svc.mbox["_classic-app"]
 	c.Assert(ok, Equals, true)
 	msgs = box.AllMessages()
@@ -320,7 +376,34 @@
 	c.Check(msgs[0], Equals, `{"mars":42}`)
 }
 
-func (ps *postalSuite) TestPostSignal(c *C) {
+func (ps *postalSuite) TestPostCallsMessageHandlerDetails(c *C) {
+	ch := make(chan *launch_helper.HelperOutput)
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.launchers = map[string]launch_helper.HelperLauncher{
+		"click": ps.fakeLauncher,
+	}
+	c.Assert(svc.Start(), IsNil)
+	// check the message handler gets called
+	app := clickhelp.MustParseAppId(anAppId)
+	f := func(app *click.AppId, nid string, s *launch_helper.HelperOutput) bool {
+		c.Check(app.Base(), Equals, anAppId)
+		c.Check(nid, Equals, "m7")
+		ch <- s
+		return true
+	}
+	svc.SetMessageHandler(f)
+	svc.Post(app, "m7", json.RawMessage("{}"))
+
+	if ps.fakeLauncher.done != nil {
+		takeNextBytes(ps.fakeLauncher.ch)
+
+		go ps.fakeLauncher.done("0") // OneDone
+	}
+
+	c.Check(takeNextHelperOutput(ch), DeepEquals, &launch_helper.HelperOutput{})
+}
+
+func (ps *postalSuite) TestAfterMessageHandlerSignal(c *C) {
 	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
 	svc.msgHandler = nil
 
@@ -341,106 +424,24 @@
 	c.Check(callArgs[l-1].Args, DeepEquals, []interface{}{"Post", aPackageOnBus, []interface{}{anAppId}})
 }
 
-func (ps *postalSuite) TestPostFailsIfPostFails(c *C) {
-	bus := testibus.NewTestingEndpoint(condition.Work(true),
-		condition.Work(false))
-	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
-	svc.Bus = bus
-	svc.SetMessageHandler(func(*click.AppId, string, *launch_helper.HelperOutput) error { return errors.New("fail") })
-	_, err := svc.post("/hello", []interface{}{"xyzzy"}, nil)
-	c.Check(err, NotNil)
-}
-
-func (ps *postalSuite) TestPostFailsIfBadArgs(c *C) {
-	for i, s := range []struct {
-		args []interface{}
-		errt error
-	}{
-		{nil, ErrBadArgCount},
-		{[]interface{}{}, ErrBadArgCount},
-		{[]interface{}{1}, ErrBadArgCount},
-		{[]interface{}{anAppId, 1}, ErrBadArgType},
-		{[]interface{}{anAppId, "zoom"}, ErrBadJSON},
-		{[]interface{}{1, "hello"}, ErrBadArgType},
-		{[]interface{}{1, 2, 3}, ErrBadArgCount},
-		{[]interface{}{"bar", "hello"}, ErrBadAppId},
-	} {
-		reg, err := new(PostalService).post(aPackageOnBus, s.args, nil)
-		c.Check(reg, IsNil, Commentf("iteration #%d", i))
-		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
-	}
-}
-
-//
-// Post (Broadcast) tests
-
-func (ps *postalSuite) TestPostBroadcast(c *C) {
-
-	bus := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
-	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
-
-	svc.NotificationsEndp = bus
-	svc.launchers = map[string]launch_helper.HelperLauncher{
-		"legacy": ps.fakeLauncher,
-	}
-	c.Assert(svc.Start(), IsNil)
-
-	msgId := uuid.New()
-	svc.SetMessageHandler(func(app *click.AppId, nid string, output *launch_helper.HelperOutput) error {
-		expectedAppId, _ := click.ParseAppId("_ubuntu-system-settings")
-		c.Check(app, DeepEquals, expectedAppId)
-		c.Check(nid, Equals, msgId)
-		return nil
-	})
-	decoded := map[string]interface{}{
-		"daily/mako": []interface{}{float64(102), "tubular"},
-	}
-	// marshal decoded  to json
-	payload, _ := json.Marshal(decoded)
-	appId, _ := click.ParseAppId("_ubuntu-system-settings")
-	err := svc.Post(appId, msgId, payload)
-	c.Assert(err, IsNil)
-
-	if ps.fakeLauncher.done != nil {
-		inputData := takeNextBytes(ps.fakeLauncher.ch)
-		expectedData, _ := json.Marshal(decoded)
-		c.Check(inputData, DeepEquals, expectedData)
-		go ps.fakeLauncher.done("0") // OneDone
-	}
-}
-
-func (ps *postalSuite) TestPostBroadcastDoesNotFail(c *C) {
-	bus := testibus.NewTestingEndpoint(condition.Work(true),
-		condition.Work(false))
-	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
-	svc.launchers = map[string]launch_helper.HelperLauncher{
-		"legacy": ps.fakeLauncher,
-	}
-	c.Assert(svc.Start(), IsNil)
-	svc.NotificationsEndp = bus
-	svc.SetMessageHandler(func(*click.AppId, string, *launch_helper.HelperOutput) error {
-		ps.log.Debugf("about to fail")
-		return errors.New("fail")
-	})
-	ch := installTickMessageHandler(svc)
-	decoded := map[string]interface{}{
-		"daily/mako": []interface{}{float64(102), "tubular"},
-	}
-	// marshal decoded  to json
-	payload, _ := json.Marshal(decoded)
-	appId, _ := click.ParseAppId("_ubuntu-system-settings")
-	msgId := uuid.New()
-	err := svc.Post(appId, msgId, payload)
-	c.Assert(err, IsNil)
-
-	if ps.fakeLauncher.done != nil {
-		takeNextBytes(ps.fakeLauncher.ch)
-		go ps.fakeLauncher.done("0") // OneDone
-	}
-
-	c.Check(takeNextError(ch), NotNil) // the messagehandler failed
-	c.Check(err, IsNil)                // but broadcast was oblivious
-	c.Check(ps.log.Captured(), Matches, `(?sm).*about to fail$`)
+func (ps *postalSuite) TestFailingMessageHandlerSurvived(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.SetMessageHandler(func(*click.AppId, string, *launch_helper.HelperOutput) bool {
+		return false
+	})
+
+	hInp := &launch_helper.HelperInput{
+		App: clickhelp.MustParseAppId(anAppId),
+	}
+	res := &launch_helper.HelperResult{Input: hInp}
+
+	svc.handleHelperResult(res)
+
+	c.Check(ps.log.Captured(), Equals, "DEBUG msgHandler did not present the notification\n")
+	// we actually want to send a signal even if we didn't do anything
+	callArgs := testibus.GetCallArgs(ps.bus)
+	c.Assert(len(callArgs), Equals, 1)
+	c.Check(callArgs[0].Member, Equals, "::Signal")
 }
 
 //
@@ -492,41 +493,15 @@
 	svc := new(PostalService)
 	c.Assert(svc.msgHandler, IsNil)
 	var ext = &launch_helper.HelperOutput{}
-	e := errors.New("Hello")
-	f := func(_ *click.AppId, _ string, s *launch_helper.HelperOutput) error { ext = s; return e }
+	f := func(_ *click.AppId, _ string, s *launch_helper.HelperOutput) bool { ext = s; return false }
 	c.Check(svc.GetMessageHandler(), IsNil)
 	svc.SetMessageHandler(f)
 	c.Check(svc.GetMessageHandler(), NotNil)
 	hOutput := &launch_helper.HelperOutput{[]byte("37"), nil}
-	c.Check(svc.msgHandler(nil, "", hOutput), Equals, e)
+	c.Check(svc.msgHandler(nil, "", hOutput), Equals, false)
 	c.Check(ext, DeepEquals, hOutput)
 }
 
-func (ps *postalSuite) TestPostCallsMessageHandler(c *C) {
-	ch := make(chan *launch_helper.HelperOutput)
-	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
-	svc.launchers = map[string]launch_helper.HelperLauncher{
-		"click": ps.fakeLauncher,
-	}
-	c.Assert(svc.Start(), IsNil)
-	// check the message handler gets called
-	f := func(_ *click.AppId, _ string, s *launch_helper.HelperOutput) error { ch <- s; return nil }
-	svc.SetMessageHandler(f)
-	c.Check(svc.Post(&click.AppId{Click: true}, "thing", json.RawMessage("{}")), IsNil)
-
-	if ps.fakeLauncher.done != nil {
-		takeNextBytes(ps.fakeLauncher.ch)
-
-		go ps.fakeLauncher.done("0") // OneDone
-	}
-
-	c.Check(takeNextHelperOutput(ch), DeepEquals, &launch_helper.HelperOutput{})
-	err := errors.New("ouch")
-	svc.SetMessageHandler(func(*click.AppId, string, *launch_helper.HelperOutput) error { return err })
-	// but the error doesn't bubble out
-	c.Check(svc.Post(&click.AppId{}, "", json.RawMessage("{}")), IsNil)
-}
-
 func (ps *postalSuite) TestMessageHandlerPresents(c *C) {
 	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
 	svc := NewPostalService(nil, ps.log)
@@ -544,12 +519,12 @@
 	vib := &launch_helper.Vibration{Duration: 500}
 	emb := &launch_helper.EmblemCounter{Count: 2, Visible: true}
 	output := &launch_helper.HelperOutput{Notification: &launch_helper.Notification{Card: card, EmblemCounter: emb, Vibrate: vib}}
-	err := svc.messageHandler(&click.AppId{}, "", output)
-	c.Assert(err, IsNil)
+	b := svc.messageHandler(&click.AppId{}, "", output)
+	c.Assert(b, Equals, true)
 	args := testibus.GetCallArgs(endp)
 	l := len(args)
 	if l < 4 {
-		c.Fatal("not enough elements in resposne from GetCallArgs")
+		c.Fatal("not enough elements in response from GetCallArgs")
 	}
 	mm := make([]string, 4)
 	for i, m := range args[l-4:] {
@@ -561,7 +536,7 @@
 	c.Check(mm, DeepEquals, []string{"::SetProperty", "::SetProperty", "Notify", "VibratePattern"})
 	// For the other ones, check the logs
 	c.Check(ps.log.Captured(), Matches, `(?sm).* no persistable card:.*`)
-	c.Check(ps.log.Captured(), Matches, `(?sm).* no Sound in the notification.*`)
+	c.Check(ps.log.Captured(), Matches, `(?sm).* notification has no Sound:.*`)
 }
 
 func (ps *postalSuite) TestMessageHandlerReportsFailedNotifies(c *C) {
@@ -581,18 +556,18 @@
 	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
 	svc.WindowStackEndp = endp
 	c.Assert(svc.Start(), IsNil)
-	output := &launch_helper.HelperOutput{} // Doesn't matter
-	err := svc.messageHandler(clickhelp.MustParseAppId("com.example.test_test-app_0"), "", output)
-	c.Check(err, IsNil)
-	c.Check(ps.log.Captured(), Matches, `(?sm).* Notification skipped because app is focused.*`)
+	output := &launch_helper.HelperOutput{Notification: &launch_helper.Notification{}} // Doesn't matter
+	b := svc.messageHandler(clickhelp.MustParseAppId("com.example.test_test-app_0"), "", output)
+	c.Check(b, Equals, false)
+	c.Check(ps.log.Captured(), Matches, `(?sm).* notification skipped because app is focused.*`)
 }
 
 func (ps *postalSuite) TestMessageHandlerReportsButIgnoresUnmarshalErrors(c *C) {
 	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
 	c.Assert(svc.Start(), IsNil)
 	output := &launch_helper.HelperOutput{[]byte(`broken`), nil}
-	err := svc.messageHandler(nil, "", output)
-	c.Check(err, IsNil)
+	b := svc.messageHandler(nil, "", output)
+	c.Check(b, Equals, false)
 	c.Check(ps.log.Captured(), Matches, "(?msi).*skipping notification: nil.*")
 }
 
@@ -602,20 +577,35 @@
 	c.Assert(svc.Start(), IsNil)
 	svc.NotificationsEndp = endp
 	output := &launch_helper.HelperOutput{[]byte(`{}`), nil}
-	err := svc.messageHandler(nil, "", output)
-	c.Assert(err, IsNil)
+	b := svc.messageHandler(nil, "", output)
+	c.Assert(b, Equals, false)
 	c.Check(ps.log.Captured(), Matches, "(?msi).*skipping notification: nil.*")
 }
 
+func (ps *postalSuite) TestMessageHandlerInvalidAction(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false), []string{"com.example.test_test-app"})
+	svc.URLDispatcherEndp = endp
+	c.Assert(svc.Start(), IsNil)
+	card := launch_helper.Card{Actions: []string{"notsupported://test-app"}}
+	output := &launch_helper.HelperOutput{Notification: &launch_helper.Notification{Card: &card}}
+	b := svc.messageHandler(clickhelp.MustParseAppId("com.example.test_test-app_0"), "", output)
+	c.Check(b, Equals, false)
+	c.Check(ps.log.Captured(), Matches, `(?sm).*TestURL for \[notsupported://test-app\] failed with no way.*`)
+}
+
 func (ps *postalSuite) TestHandleActionsDispatches(c *C) {
 	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	fmm := new(fakeMM)
+	app, _ := click.ParseAppId("com.example.test_test-app")
 	c.Assert(svc.Start(), IsNil)
+	svc.messagingMenu = fmm
 	aCh := make(chan *notifications.RawAction)
 	rCh := make(chan *reply.MMActionReply)
 	bCh := make(chan bool)
 	go func() {
 		aCh <- nil // just in case?
-		aCh <- &notifications.RawAction{Action: "potato://"}
+		aCh <- &notifications.RawAction{App: app, Action: "potato://", Nid: "xyzzy"}
 		close(aCh)
 		bCh <- true
 	}()
@@ -624,19 +614,22 @@
 	args := testibus.GetCallArgs(ps.urlDispBus)
 	c.Assert(args, HasLen, 1)
 	c.Check(args[0].Member, Equals, "DispatchURL")
-	c.Assert(args[0].Args, HasLen, 1)
+	c.Assert(args[0].Args, HasLen, 2)
 	c.Assert(args[0].Args[0], Equals, "potato://")
+	c.Assert(args[0].Args[1], Equals, app.DispatchPackage())
+	c.Check(fmm.calls, DeepEquals, []string{"remove:xyzzy:true"})
 }
 
 func (ps *postalSuite) TestHandleMMUActionsDispatches(c *C) {
 	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
 	c.Assert(svc.Start(), IsNil)
+	app, _ := click.ParseAppId("com.example.test_test-app")
 	aCh := make(chan *notifications.RawAction)
 	rCh := make(chan *reply.MMActionReply)
 	bCh := make(chan bool)
 	go func() {
 		rCh <- nil // just in case?
-		rCh <- &reply.MMActionReply{Action: "potato://", Notification: "foo.bar"}
+		rCh <- &reply.MMActionReply{App: app, Action: "potato://", Notification: "foo.bar"}
 		close(rCh)
 		bCh <- true
 	}()
@@ -645,6 +638,144 @@
 	args := testibus.GetCallArgs(ps.urlDispBus)
 	c.Assert(args, HasLen, 1)
 	c.Check(args[0].Member, Equals, "DispatchURL")
-	c.Assert(args[0].Args, HasLen, 1)
+	c.Assert(args[0].Args, HasLen, 2)
 	c.Assert(args[0].Args[0], Equals, "potato://")
+	c.Assert(args[0].Args[1], Equals, app.DispatchPackage())
+}
+
+func (ps *postalSuite) TestValidateActions(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []string{"com.example.test_test-app_0"})
+	svc.URLDispatcherEndp = endp
+	c.Assert(svc.Start(), IsNil)
+	card := launch_helper.Card{Actions: []string{"potato://test-app"}}
+	notif := &launch_helper.Notification{Card: &card}
+	b := svc.validateActions(clickhelp.MustParseAppId("com.example.test_test-app_0"), notif)
+	c.Check(b, Equals, true)
+}
+
+func (ps *postalSuite) TestValidateActionsNoActions(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	card := launch_helper.Card{}
+	notif := &launch_helper.Notification{Card: &card}
+	b := svc.validateActions(clickhelp.MustParseAppId("com.example.test_test-app_0"), notif)
+	c.Check(b, Equals, true)
+}
+
+func (ps *postalSuite) TestValidateActionsNoCard(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	notif := &launch_helper.Notification{}
+	b := svc.validateActions(clickhelp.MustParseAppId("com.example.test_test-app_0"), notif)
+	c.Check(b, Equals, true)
+}
+
+type fakeMM struct {
+	calls []string
+}
+
+func (*fakeMM) Present(*click.AppId, string, *launch_helper.Notification) bool { return false }
+func (*fakeMM) GetCh() chan *reply.MMActionReply                               { return nil }
+func (*fakeMM) StartCleanupLoop()                                              {}
+func (fmm *fakeMM) RemoveNotification(s string, b bool) {
+	fmm.calls = append(fmm.calls, fmt.Sprintf("remove:%s:%t", s, b))
+}
+func (fmm *fakeMM) Clear(*click.AppId, ...string) int {
+	fmm.calls = append(fmm.calls, "clear")
+	return 42
+}
+func (fmm *fakeMM) Tags(*click.AppId) []string {
+	fmm.calls = append(fmm.calls, "tags")
+	return []string{"hello"}
+}
+
+func (ps *postalSuite) TestListPersistent(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	fmm := new(fakeMM)
+	svc.messagingMenu = fmm
+
+	itags, err := svc.listPersistent(aPackageOnBus, []interface{}{anAppId}, nil)
+	c.Assert(err, IsNil)
+	c.Assert(itags, HasLen, 1)
+	c.Assert(itags[0], FitsTypeOf, []string(nil))
+	tags := itags[0].([]string)
+	c.Check(tags, DeepEquals, []string{"hello"})
+	c.Check(fmm.calls, DeepEquals, []string{"tags"})
+}
+
+func (ps *postalSuite) TestListPersistentErrors(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	_, err := svc.listPersistent(aPackageOnBus, nil, nil)
+	c.Check(err, Equals, ErrBadArgCount)
+	_, err = svc.listPersistent(aPackageOnBus, []interface{}{42}, nil)
+	c.Check(err, Equals, ErrBadArgType)
+	_, err = svc.listPersistent(aPackageOnBus, []interface{}{"xyzzy"}, nil)
+	c.Check(err, Equals, ErrBadAppId)
+}
+
+func (ps *postalSuite) TestClearPersistent(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	fmm := new(fakeMM)
+	svc.messagingMenu = fmm
+
+	icleared, err := svc.clearPersistent(aPackageOnBus, []interface{}{anAppId, "one", ""}, nil)
+	c.Assert(err, IsNil)
+	c.Assert(icleared, HasLen, 1)
+	c.Check(icleared[0], Equals, uint32(42))
+}
+
+func (ps *postalSuite) TestClearPersistentErrors(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	for i, s := range []struct {
+		args []interface{}
+		err  error
+	}{
+		{[]interface{}{}, ErrBadArgCount},
+		{[]interface{}{42}, ErrBadArgType},
+		{[]interface{}{"xyzzy"}, ErrBadAppId},
+		{[]interface{}{anAppId, 42}, ErrBadArgType},
+		{[]interface{}{anAppId, "", 42}, ErrBadArgType},
+	} {
+		_, err := svc.clearPersistent(aPackageOnBus, s.args, nil)
+		c.Check(err, Equals, s.err, Commentf("iter %d", i))
+	}
+}
+
+func (ps *postalSuite) TestSetCounter(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	c.Check(svc.Start(), IsNil)
+
+	_, err := svc.setCounter(aPackageOnBus, []interface{}{anAppId, int32(42), true}, nil)
+	c.Assert(err, IsNil)
+
+	quoted := "/" + string(nih.Quote([]byte(anAppId)))
+
+	callArgs := testibus.GetCallArgs(svc.EmblemCounterEndp)
+	c.Assert(callArgs, HasLen, 2)
+	c.Check(callArgs[0].Member, Equals, "::SetProperty")
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"count", quoted, dbus.Variant{int32(42)}})
+
+	c.Check(callArgs[1].Member, Equals, "::SetProperty")
+	c.Check(callArgs[1].Args, DeepEquals, []interface{}{"countVisible", quoted, dbus.Variant{true}})
+}
+
+func (ps *postalSuite) TestSetCounterErrors(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.Start()
+	for i, s := range []struct {
+		args []interface{}
+		err  error
+	}{
+		{[]interface{}{anAppId, int32(42), true}, nil}, // for reference
+		{[]interface{}{}, ErrBadArgCount},
+		{[]interface{}{anAppId}, ErrBadArgCount},
+		{[]interface{}{anAppId, int32(42)}, ErrBadArgCount},
+		{[]interface{}{anAppId, int32(42), true, "potato"}, ErrBadArgCount},
+		{[]interface{}{"xyzzy", int32(42), true}, ErrBadAppId},
+		{[]interface{}{1234567, int32(42), true}, ErrBadArgType},
+		{[]interface{}{anAppId, "potatoe", true}, ErrBadArgType},
+		{[]interface{}{anAppId, int32(42), "ru"}, ErrBadArgType},
+	} {
+		_, err := svc.setCounter(aPackageOnBus, s.args, nil)
+		c.Check(err, Equals, s.err, Commentf("iter %d", i))
+	}
 }
 
=== modified file 'debian/changelog'
--- debian/changelog	2014-07-23 14:09:31 +0000
+++ debian/changelog	2014-07-29 16:56:22 +0000
@@ -1,3 +1,24 @@
+ubuntu-push (0.50) UNRELEASED; urgency=medium
+
+  [ Samuele Pedroni ]
+  * Cleanup and improve pos/Post tests
+
+  [ Guillermo Gonzalez ]
+  * Add a loop to cleanup MessagingMenu.notifications map when the
+    notifications are dismissed.
+  * Add TestURL to URLDispatcher and update DispatchURL signature.
+  * Add validateActions (check with url-dispatcher->TestURL) method to the
+    PostalService and wire it in messageHandler.
+
+  [ John R. Lenton ]
+  * Implement ListPersistent/ClearPersistent/SetCounter postal endpoints.
+  * Remove snap decisions support.
+  * Remove the notification from the messaging menu when the bubble is
+    acted on.
+  * Don't run more than 5 helpers at a time, and never more than one per app.
+
+ -- John R. Lenton <[e-mail]>  Mon, 28 Jul 2014 17:44:35 +0200
+
 ubuntu-push (0.49.1+14.10.20140723.1-0ubuntu1) utopic; urgency=medium
 
   [ John R. Lenton ]
 
=== modified file 'launch_helper/helper_output.go'
--- launch_helper/helper_output.go	2014-07-18 14:23:34 +0000
+++ launch_helper/helper_output.go	2014-07-29 16:56:22 +0000
@@ -54,6 +54,7 @@
 	Sound         string         `json:"sound"`          // a sound file. Users can disable this, so don't rely on it exclusively. Defaults to empty (no sound).
 	Vibrate       *Vibration     `json:"vibrate"`        // users can disable this, blah blah. Defaults to null (no vibration)
 	EmblemCounter *EmblemCounter `json:"emblem-counter"` // puts a counter on an emblem in the launcher. Defaults to nil (no change to emblem counter).
+	Tag           string         `json:"tag,omitempty"`  // tag used for Clear/ListPersistent.
 }
 
 // HelperOutput is the expected output of a helper
 
=== modified file 'launch_helper/helper_test.go'
--- launch_helper/helper_test.go	2014-07-18 14:53:47 +0000
+++ launch_helper/helper_test.go	2014-07-29 16:56:22 +0000
@@ -43,11 +43,11 @@
 }
 
 func (s *runnerSuite) TestTrivialPoolWorks(c *C) {
-	notif := &Notification{Sound: "42"}
+	notif := &Notification{Sound: "42", Tag: "foo"}
 
 	triv := NewTrivialHelperPool(s.testlog)
 	ch := triv.Start()
-	in := &HelperInput{App: s.app, Payload: []byte(`{"message": {"m":42}, "notification": {"sound": "42"}}`)}
+	in := &HelperInput{App: s.app, Payload: []byte(`{"message": {"m":42}, "notification": {"sound": "42", "tag": "foo"}}`)}
 	triv.Run("klick", in)
 	out := <-ch
 	c.Assert(out, NotNil)
 
=== modified file 'launch_helper/kindpool.go'
--- launch_helper/kindpool.go	2014-07-19 00:18:18 +0000
+++ launch_helper/kindpool.go	2014-07-29 16:56:22 +0000
@@ -60,10 +60,12 @@
 	log        logger.Logger
 	chOut      chan *HelperResult
 	chIn       chan *HelperInput
+	chDone     chan *click.AppId
 	launchers  map[string]HelperLauncher
 	lock       sync.Mutex
 	hmap       map[string]*HelperArgs
 	maxRuntime time.Duration
+	maxNum     int
 }
 
 // DefaultLaunchers produces the default map for kind -> HelperLauncher
@@ -81,12 +83,14 @@
 		hmap:       make(map[string]*HelperArgs),
 		launchers:  launchers,
 		maxRuntime: 5 * time.Second,
+		maxNum:     5,
 	}
 }
 
 func (pool *kindHelperPool) Start() chan *HelperResult {
 	pool.chOut = make(chan *HelperResult)
 	pool.chIn = make(chan *HelperInput, InputBufferSize)
+	pool.chDone = make(chan *click.AppId)
 
 	for kind, launcher := range pool.launchers {
 		kind1 := kind
@@ -98,18 +102,72 @@
 		}
 	}
 
-	// xxx make sure at most X helpers are running
-	go func() {
-		for i := range pool.chIn {
-			if pool.handleOne(i) != nil {
-				pool.failOne(i)
-			}
-		}
-	}()
+	go pool.loop()
 
 	return pool.chOut
 }
 
+func (pool *kindHelperPool) loop() {
+	running := make(map[string]bool)
+	var backlog []*HelperInput
+
+	for {
+		select {
+		case in, ok := <-pool.chIn:
+			if !ok {
+				return
+			}
+			if len(running) >= pool.maxNum || running[in.App.Original()] {
+				backlog = append(backlog, in)
+				pool.log.Debugf("current helper input backlog has grown to %d entries.", len(backlog))
+			} else {
+				if pool.tryOne(in) {
+					running[in.App.Original()] = true
+				}
+			}
+		case app := <-pool.chDone:
+			delete(running, app.Original())
+			if len(backlog) == 0 {
+				continue
+			}
+			backlogSz := 0
+			done := false
+			for i, in := range backlog {
+				if in != nil {
+					if !done && !running[in.App.Original()] {
+						backlog[i] = nil
+						if pool.tryOne(in) {
+							running[in.App.Original()] = true
+							done = true
+						}
+					} else {
+						backlogSz++
+					}
+				}
+			}
+			backlog = pool.shrinkBacklog(backlog, backlogSz)
+			pool.log.Debugf("current helper input backlog has shrunk to %d entries.", backlogSz)
+		}
+	}
+}
+
+func (pool *kindHelperPool) shrinkBacklog(backlog []*HelperInput, backlogSz int) []*HelperInput {
+	if backlogSz == 0 {
+		return nil
+	}
+	if cap(backlog) < 2*backlogSz {
+		return backlog
+	}
+	pool.log.Debugf("copying backlog to avoid wasting too much space (%d/%d used)", backlogSz, cap(backlog))
+	clean := make([]*HelperInput, 0, backlogSz)
+	for _, bentry := range backlog {
+		if bentry != nil {
+			clean = append(clean, bentry)
+		}
+	}
+	return clean
+}
+
 func (pool *kindHelperPool) Stop() {
 	close(pool.chIn)
 	for kind, launcher := range pool.launchers {
@@ -125,6 +183,14 @@
 	pool.chIn <- input
 }
 
+func (pool *kindHelperPool) tryOne(input *HelperInput) bool {
+	if pool.handleOne(input) != nil {
+		pool.failOne(input)
+		return false
+	}
+	return true
+}
+
 func (pool *kindHelperPool) failOne(input *HelperInput) {
 	pool.log.Errorf("unable to get helper output; putting payload into message")
 	pool.chOut <- &HelperResult{HelperOutput: HelperOutput{Message: input.Payload, Notification: nil}, Input: input}
@@ -218,6 +284,7 @@
 		// nothing to do
 		return
 	}
+	pool.chDone <- args.Input.App
 	defer func() {
 		pool.cleanupTempFiles(args.FileIn, args.FileOut)
 	}()
 
=== modified file 'launch_helper/kindpool_test.go'
--- launch_helper/kindpool_test.go	2014-07-19 00:18:18 +0000
+++ launch_helper/kindpool_test.go	2014-07-29 16:56:22 +0000
@@ -17,6 +17,7 @@
 package launch_helper
 
 import (
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -32,18 +33,30 @@
 )
 
 type poolSuite struct {
-	log  *helpers.TestLogger
-	pool HelperPool
+	log          *helpers.TestLogger
+	pool         HelperPool
+	fakeLauncher *fakeHelperLauncher
 }
 
 var _ = Suite(&poolSuite{})
 
+func takeNext(ch chan *HelperResult, c *C) *HelperResult {
+	select {
+	case res := <-ch:
+		return res
+	case <-time.After(100 * time.Millisecond):
+		c.Fatal("timeout waiting for result")
+	}
+	return nil
+}
+
 type fakeHelperLauncher struct {
 	done  func(string)
 	obs   int
 	err   error
 	lhex  string
 	argCh chan [5]string
+	runid int
 }
 
 func (fhl *fakeHelperLauncher) InstallObserver(done func(string)) error {
@@ -67,7 +80,9 @@
 
 func (fhl *fakeHelperLauncher) Launch(appId string, exec string, f1 string, f2 string) (string, error) {
 	fhl.argCh <- [5]string{"Launch", appId, exec, f1, f2}
-	return "0", fhl.err
+	runid := fmt.Sprintf("%d", fhl.runid)
+	fhl.runid++
+	return runid, fhl.err
 }
 
 func (fhl *fakeHelperLauncher) Stop(appId string, iid string) error {
@@ -75,12 +90,21 @@
 	return nil
 }
 
-var fakeLauncher *fakeHelperLauncher
+func (s *poolSuite) waitForArgs(c *C, method string) [5]string {
+	var args [5]string
+	select {
+	case args = <-s.fakeLauncher.argCh:
+	case <-time.After(2 * time.Second):
+		c.Fatal("didn't call " + method)
+	}
+	c.Assert(args[0], Equals, method)
+	return args
+}
 
 func (s *poolSuite) SetUpTest(c *C) {
 	s.log = helpers.NewTestLogger(c, "debug")
-	fakeLauncher = &fakeHelperLauncher{argCh: make(chan [5]string, 10)}
-	s.pool = NewHelperPool(map[string]HelperLauncher{"fake": fakeLauncher}, s.log)
+	s.fakeLauncher = &fakeHelperLauncher{argCh: make(chan [5]string, 10)}
+	s.pool = NewHelperPool(map[string]HelperLauncher{"fake": s.fakeLauncher}, s.log)
 	xdgCacheHome = c.MkDir
 }
 
@@ -99,12 +123,12 @@
 
 // check that Stop (tries to) remove the observer
 func (s *poolSuite) TestStartStopWork(c *C) {
-	c.Check(fakeLauncher.obs, Equals, 0)
+	c.Check(s.fakeLauncher.obs, Equals, 0)
 	s.pool.Start()
-	c.Check(fakeLauncher.done, NotNil)
-	c.Check(fakeLauncher.obs, Equals, 1)
+	c.Check(s.fakeLauncher.done, NotNil)
+	c.Check(s.fakeLauncher.obs, Equals, 1)
 	s.pool.Stop()
-	c.Check(fakeLauncher.obs, Equals, 0)
+	c.Check(s.fakeLauncher.obs, Equals, 0)
 }
 
 func (s *poolSuite) TestRunLaunches(c *C) {
@@ -119,12 +143,8 @@
 		Payload:        []byte(`"hello"`),
 	}
 	s.pool.Run("fake", &input)
-	select {
-	case arg := <-fakeLauncher.argCh:
-		c.Check(arg[:3], DeepEquals, []string{"Launch", helpId, "bar"})
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("didn't call Launch")
-	}
+	launchArgs := s.waitForArgs(c, "Launch")
+	c.Check(launchArgs[:3], DeepEquals, []string{"Launch", helpId, "bar"})
 	args := s.pool.(*kindHelperPool).peekId("fake:0", func(*HelperArgs) {})
 	c.Assert(args, NotNil)
 	args.Timer.Stop()
@@ -135,7 +155,7 @@
 }
 
 func (s *poolSuite) TestRunLaunchesLegacyStyle(c *C) {
-	fakeLauncher.lhex = "lhex"
+	s.fakeLauncher.lhex = "lhex"
 	s.pool.Start()
 	defer s.pool.Stop()
 	appId := "_legacy"
@@ -146,12 +166,8 @@
 		Payload:        []byte(`"hello"`),
 	}
 	s.pool.Run("fake", &input)
-	select {
-	case arg := <-fakeLauncher.argCh:
-		c.Check(arg[:3], DeepEquals, []string{"Launch", "", "lhex"})
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("didn't call Launch")
-	}
+	launchArgs := s.waitForArgs(c, "Launch")
+	c.Check(launchArgs[:3], DeepEquals, []string{"Launch", "", "lhex"})
 	args := s.pool.(*kindHelperPool).peekId("fake:0", func(*HelperArgs) {})
 	c.Assert(args, NotNil)
 	args.Timer.Stop()
@@ -170,12 +186,7 @@
 		Payload:        []byte(`"hello"`),
 	}
 	s.pool.Run("not-there", &input)
-	var res *HelperResult
-	select {
-	case res = <-ch:
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("timeout")
-	}
+	res := takeNext(ch, c)
 	c.Check(res.Message, DeepEquals, input.Payload)
 	c.Check(res.Notification, IsNil)
 	c.Check(*res.Input, DeepEquals, input)
@@ -191,19 +202,14 @@
 		Payload:        []byte(`"hello"`),
 	}
 	s.pool.Run("fake", &input)
-	var res *HelperResult
-	select {
-	case res = <-ch:
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("timeout")
-	}
+	res := takeNext(ch, c)
 	c.Check(res.Message, DeepEquals, input.Payload)
 	c.Check(res.Notification, IsNil)
 	c.Check(*res.Input, DeepEquals, input)
 }
 
 func (s *poolSuite) TestRunCantLaunch(c *C) {
-	fakeLauncher.err = cual.ErrCantLaunch
+	s.fakeLauncher.err = cual.ErrCantLaunch
 	ch := s.pool.Start()
 	defer s.pool.Stop()
 	appId := "com.example.test_test-app"
@@ -215,18 +221,9 @@
 		Payload:        []byte(`"hello"`),
 	}
 	s.pool.Run("fake", &input)
-	select {
-	case arg := <-fakeLauncher.argCh:
-		c.Check(arg[:3], DeepEquals, []string{"Launch", helpId, "bar"})
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("didn't call Launch")
-	}
-	var res *HelperResult
-	select {
-	case res = <-ch:
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("timeout")
-	}
+	launchArgs := s.waitForArgs(c, "Launch")
+	c.Check(launchArgs[:3], DeepEquals, []string{"Launch", helpId, "bar"})
+	res := takeNext(ch, c)
 	c.Check(res.Message, DeepEquals, input.Payload)
 	c.Check(s.log.Captured(), Equals, "DEBUG using helper com.example.test_test-app-helper (exec: bar) for app com.example.test_test-app\n"+"ERROR unable to launch helper com.example.test_test-app-helper: can't launch helper\n"+"ERROR unable to get helper output; putting payload into message\n")
 }
@@ -244,27 +241,14 @@
 		Payload:        []byte(`"hello"`),
 	}
 	s.pool.Run("fake", &input)
-	select {
-	case arg := <-fakeLauncher.argCh:
-		c.Check(arg[0], Equals, "Launch")
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("didn't call Launch")
-	}
-	select {
-	case arg := <-fakeLauncher.argCh:
-		c.Check(arg[:3], DeepEquals, []string{"Stop", helpId, "0"})
-	case <-time.After(2 * time.Second):
-		c.Fatal("didn't call Stop")
-	}
+	launchArgs := s.waitForArgs(c, "Launch")
+	c.Check(launchArgs[0], Equals, "Launch")
+	stopArgs := s.waitForArgs(c, "Stop")
+	c.Check(stopArgs[:3], DeepEquals, []string{"Stop", helpId, "0"})
 	// this will be invoked
-	go fakeLauncher.done("0")
+	go s.fakeLauncher.done("0")
 
-	var res *HelperResult
-	select {
-	case res = <-ch:
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("timeout")
-	}
+	res := takeNext(ch, c)
 	c.Check(res.Message, DeepEquals, input.Payload)
 }
 
@@ -294,19 +278,14 @@
 	f, err := os.Create(args.FileOut)
 	c.Assert(err, IsNil)
 	defer f.Close()
-	_, err = f.Write([]byte(`{"notification": {"sound": "hello"}}`))
+	_, err = f.Write([]byte(`{"notification": {"sound": "hello", "tag": "a-tag"}}`))
 	c.Assert(err, IsNil)
 
 	go pool.OneDone("l:1")
 
-	var res *HelperResult
-	select {
-	case res = <-ch:
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("timeout")
-	}
+	res := takeNext(ch, c)
 
-	expected := HelperOutput{Notification: &Notification{Sound: "hello"}}
+	expected := HelperOutput{Notification: &Notification{Sound: "hello", Tag: "a-tag"}}
 	c.Check(res.HelperOutput, DeepEquals, expected)
 	c.Check(pool.hmap, HasLen, 0)
 }
@@ -330,12 +309,7 @@
 
 	go pool.OneDone("l:1")
 
-	var res *HelperResult
-	select {
-	case res = <-ch:
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("timeout")
-	}
+	res := takeNext(ch, c)
 
 	expected := HelperOutput{Message: args.Input.Payload}
 	c.Check(res.HelperOutput, DeepEquals, expected)
@@ -368,12 +342,7 @@
 
 	go pool.OneDone("l:1")
 
-	var res *HelperResult
-	select {
-	case res = <-ch:
-	case <-time.After(100 * time.Millisecond):
-		c.Fatal("timeout")
-	}
+	res := takeNext(ch, c)
 
 	expected := HelperOutput{Message: args.Input.Payload}
 	c.Check(res.HelperOutput, DeepEquals, expected)
@@ -438,3 +407,191 @@
 	c.Check(err, IsNil)
 	c.Check(dname, Equals, filepath.Join(tmpDir, "pkg.name"))
 }
+
+// checks that the a second helper run of an already-running helper
+// (for an app) goes to the backlog
+func (s *poolSuite) TestSecondRunSameAppToBacklog(c *C) {
+	ch := s.pool.Start()
+	defer s.pool.Stop()
+
+	app1 := clickhelp.MustParseAppId("com.example.test_test-app-1")
+	input1 := &HelperInput{
+		App:            app1,
+		NotificationId: "foo1",
+		Payload:        []byte(`"hello1"`),
+	}
+	app2 := clickhelp.MustParseAppId("com.example.test_test-app-1")
+	input2 := &HelperInput{
+		App:            app2,
+		NotificationId: "foo2",
+		Payload:        []byte(`"hello2"`),
+	}
+
+	c.Assert(app1.Base(), Equals, app2.Base())
+
+	s.pool.Run("fake", input1)
+	s.pool.Run("fake", input2)
+
+	s.waitForArgs(c, "Launch")
+	go s.fakeLauncher.done("0")
+	takeNext(ch, c)
+
+	// this is where we check that:
+	c.Check(s.log.Captured(), Matches, `(?ms).* helper input backlog has grown to 1 entries.$`)
+}
+
+// checks that the an Nth helper run goes to the backlog
+func (s *poolSuite) TestRunNthAppToBacklog(c *C) {
+	s.pool.(*kindHelperPool).maxNum = 2
+	ch := s.pool.Start()
+	defer s.pool.Stop()
+
+	app1 := clickhelp.MustParseAppId("com.example.test_test-app-1")
+	input1 := &HelperInput{
+		App:            app1,
+		NotificationId: "foo1",
+		Payload:        []byte(`"hello1"`),
+	}
+	app2 := clickhelp.MustParseAppId("com.example.test_test-app-2")
+	input2 := &HelperInput{
+		App:            app2,
+		NotificationId: "foo2",
+		Payload:        []byte(`"hello2"`),
+	}
+	app3 := clickhelp.MustParseAppId("com.example.test_test-app-3")
+	input3 := &HelperInput{
+		App:            app3,
+		NotificationId: "foo3",
+		Payload:        []byte(`"hello3"`),
+	}
+
+	s.pool.Run("fake", input1)
+	s.waitForArgs(c, "Launch")
+
+	s.pool.Run("fake", input2)
+	s.log.ResetCapture()
+	s.waitForArgs(c, "Launch")
+
+	s.pool.Run("fake", input3)
+
+	go s.fakeLauncher.done("0")
+	s.waitForArgs(c, "Launch")
+
+	res := takeNext(ch, c)
+	c.Assert(res, NotNil)
+	c.Assert(res.Input, NotNil)
+	c.Assert(res.Input.App, NotNil)
+	c.Assert(res.Input.App.Original(), Equals, "com.example.test_test-app-1")
+	go s.fakeLauncher.done("1")
+	go s.fakeLauncher.done("2")
+	takeNext(ch, c)
+	takeNext(ch, c)
+
+	// this is the crux: we're checking that the third Run() went to the backlog.
+	c.Check(s.log.Captured(), Matches,
+		`(?ms).* helper input backlog has grown to 1 entries\.$.*shrunk to 0 entries\.$`)
+}
+
+func (s *poolSuite) TestRunBacklogFailedContinuesDiffApp(c *C) {
+	s.pool.(*kindHelperPool).maxNum = 1
+	ch := s.pool.Start()
+	defer s.pool.Stop()
+
+	app1 := clickhelp.MustParseAppId("com.example.test_test-app-1")
+	input1 := &HelperInput{
+		App:            app1,
+		NotificationId: "foo1",
+		Payload:        []byte(`"hello1"`),
+	}
+	app2 := clickhelp.MustParseAppId("com.example.test_test-app-2")
+	input2 := &HelperInput{
+		App:            app2,
+		NotificationId: "foo2",
+		Payload:        []byte(`"hello2"`),
+	}
+	app3 := clickhelp.MustParseAppId("com.example.test_test-app-3")
+	input3 := &HelperInput{
+		App:            app3,
+		NotificationId: "foo3",
+		Payload:        []byte(`"hello3"`),
+	}
+	app4 := clickhelp.MustParseAppId("com.example.test_test-app-4")
+	input4 := &HelperInput{
+		App:            app4,
+		NotificationId: "foo4",
+		Payload:        []byte(`"hello4"`),
+	}
+
+	s.pool.Run("fake", input1)
+	s.waitForArgs(c, "Launch")
+	s.pool.Run("NOT-THERE", input2) // this will fail
+	s.pool.Run("fake", input3)
+	s.pool.Run("fake", input4)
+
+	go s.fakeLauncher.done("0")
+	// Everything up to here was just set-up.
+	//
+	// What we're checking for is that, if a helper launch fails, the
+	// next one in the backlog is picked up.
+	c.Assert(takeNext(ch, c).Input.App, Equals, app1)
+	c.Assert(takeNext(ch, c).Input.App, Equals, app2)
+	go s.fakeLauncher.done("2")
+	s.waitForArgs(c, "Launch")
+	c.Check(s.log.Captured(), Matches,
+		`(?ms).* helper input backlog has grown to 3 entries\.$.*shrunk to 1 entries\.$`)
+}
+
+func (s *poolSuite) TestBigBacklogShrinks(c *C) {
+	s.pool.(*kindHelperPool).maxNum = 1
+	ch := s.pool.Start()
+	defer s.pool.Stop()
+	numBad := 10
+
+	app := clickhelp.MustParseAppId("com.example.test_test-app")
+	s.pool.Run("fake", &HelperInput{App: app, NotificationId: "0", Payload: []byte(`""`)})
+
+	for i := 0; i < numBad; i++ {
+		s.pool.Run("NOT-THERE", &HelperInput{App: app})
+	}
+	s.pool.Run("fake", &HelperInput{App: app, NotificationId: "1", Payload: []byte(`""`)})
+	s.pool.Run("fake", &HelperInput{App: app, NotificationId: "2", Payload: []byte(`""`)})
+	s.waitForArgs(c, "Launch")
+	go s.fakeLauncher.done("0")
+	// now we should get the fake + all the bad ones
+	for i := 0; i < numBad+1; i++ {
+		takeNext(ch, c)
+	}
+	s.waitForArgs(c, "Launch")
+	go s.fakeLauncher.done("1")
+	takeNext(ch, c)
+	// so now there's one good one "running", and one more waiting.
+	c.Check(s.log.Captured(), Matches, `(?ms).* shrunk to 1 entries\.$`)
+	// and the shrinker shrunk
+	c.Check(s.log.Captured(), Matches, `(?ms).*copying backlog to avoid wasting too much space .*`)
+}
+
+func (s *poolSuite) TestBacklogShrinkerNilToNil(c *C) {
+	pool := s.pool.(*kindHelperPool)
+	c.Check(pool.shrinkBacklog(nil, 0), IsNil)
+}
+
+func (s *poolSuite) TestBacklogShrinkerEmptyToNil(c *C) {
+	pool := s.pool.(*kindHelperPool)
+	empty := []*HelperInput{nil, nil, nil}
+	c.Check(pool.shrinkBacklog(empty, 0), IsNil)
+}
+
+func (s *poolSuite) TestBacklogShrinkerFullUntouched(c *C) {
+	pool := s.pool.(*kindHelperPool)
+	input := &HelperInput{}
+	full := []*HelperInput{input, input, input}
+	c.Check(pool.shrinkBacklog(full, 3), DeepEquals, full)
+}
+
+func (s *poolSuite) TestBacklogShrinkerSparseShrunk(c *C) {
+	pool := s.pool.(*kindHelperPool)
+	input := &HelperInput{}
+	sparse := []*HelperInput{nil, input, nil, input, nil}
+	full := []*HelperInput{input, input}
+	c.Check(pool.shrinkBacklog(sparse, 2), DeepEquals, full)
+}
 
=== modified file 'messaging/cmessaging/cmessaging.go'
--- messaging/cmessaging/cmessaging.go	2014-07-16 16:10:03 +0000
+++ messaging/cmessaging/cmessaging.go	2014-07-29 16:56:22 +0000
@@ -25,11 +25,16 @@
 void add_notification(const gchar* desktop_id, const gchar* notification_id,
           const gchar* icon_path, const gchar* summary, const gchar* body,
           gint64 timestamp, const gchar** actions, gpointer obj);
+
+void remove_notification(const gchar* desktop_id, const gchar* notification_id);
+
+gboolean notification_exists(const gchar* desktop_id, const gchar* notification_id);
 */
 import "C"
 import "unsafe"
 
 import (
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/messaging/reply"
 )
@@ -37,6 +42,9 @@
 type Payload struct {
 	Ch      chan *reply.MMActionReply
 	Actions []string
+	App     *click.AppId
+	Tag     string
+	Gone    bool
 }
 
 func gchar(s string) *C.gchar {
@@ -56,7 +64,7 @@
 	if action == "" && len(payload.Actions) >= 2 {
 		action = payload.Actions[1]
 	}
-	mmar := &reply.MMActionReply{Notification: C.GoString(c_notification), Action: action}
+	mmar := &reply.MMActionReply{Notification: C.GoString(c_notification), Action: action, App: payload.App}
 	payload.Ch <- mmar
 }
 
@@ -81,6 +89,26 @@
 	C.add_notification(desktop_id, notification_id, icon_path, summary, body, timestamp, nil, (C.gpointer)(payload))
 }
 
+func RemoveNotification(desktopId string, notificationId string) {
+	desktop_id := gchar(desktopId)
+	defer gfree(desktop_id)
+
+	notification_id := gchar(notificationId)
+	defer gfree(notification_id)
+
+	C.remove_notification(desktop_id, notification_id)
+}
+
+func NotificationExists(desktopId string, notificationId string) bool {
+	notification_id := gchar(notificationId)
+	defer gfree(notification_id)
+
+	desktop_id := gchar(desktopId)
+	defer gfree(desktop_id)
+
+	return C.notification_exists(desktop_id, notification_id) == C.TRUE
+}
+
 func init() {
 	go C.g_main_loop_run(C.g_main_loop_new(nil, C.FALSE))
 }
 
=== modified file 'messaging/cmessaging/cmessaging_c.go'
--- messaging/cmessaging/cmessaging_c.go	2014-07-16 13:59:39 +0000
+++ messaging/cmessaging/cmessaging_c.go	2014-07-29 16:56:22 +0000
@@ -25,10 +25,11 @@
     handleActivate(action, messaging_menu_message_get_id(msg), obj);
 }
 
+static GHashTable* map = NULL;
+
 void add_notification (const gchar* desktop_id, const gchar* notification_id,
           const gchar* icon_path, const gchar* summary, const gchar* body,
           gint64 timestamp, const gchar** actions, gpointer obj) {
-    static GHashTable* map = NULL;
     if (map == NULL) {
         map = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
     }
@@ -54,5 +55,34 @@
     g_signal_connect(msg, "activate", G_CALLBACK(activate_cb), obj);
     g_object_unref(msg);
 }
+
+void remove_notification (const gchar* desktop_id, const gchar* notification_id) {
+    if (map == NULL) {
+        return;
+    }
+    MessagingMenuApp* app = g_hash_table_lookup (map, desktop_id);
+    if (app == NULL) {
+        // no app in the hash table, bailout
+        return;
+    }
+    messaging_menu_app_remove_message_by_id (app, notification_id);
+}
+
+gboolean notification_exists (const gchar* desktop_id, const gchar* notification_id) {
+    if (map == NULL) {
+        return FALSE;
+    }
+    MessagingMenuApp* app = g_hash_table_lookup (map, desktop_id);
+    if (app == NULL) {
+        // no app in the hash table, bailout
+        return FALSE;
+    }
+    MessagingMenuMessage* msg = messaging_menu_app_get_message(app, notification_id);
+    if (msg != NULL) {
+        // the notification is still there
+        return TRUE;
+    }
+    return FALSE;
+}
 */
 import "C"
 
=== modified file 'messaging/messaging.go'
--- messaging/messaging.go	2014-07-16 17:51:06 +0000
+++ messaging/messaging.go	2014-07-29 16:56:22 +0000
@@ -21,6 +21,7 @@
 import (
 	"encoding/json"
 	"sync"
+	"time"
 
 	"launchpad.net/ubuntu-push/bus/notifications"
 	"launchpad.net/ubuntu-push/click"
@@ -30,56 +31,166 @@
 	"launchpad.net/ubuntu-push/messaging/reply"
 )
 
+var cleanupLoopDuration = 5 * time.Minute
+
 type MessagingMenu struct {
-	Log           logger.Logger
-	Ch            chan *reply.MMActionReply
-	notifications map[string]*cmessaging.Payload
-	lock          sync.RWMutex
+	Log               logger.Logger
+	Ch                chan *reply.MMActionReply
+	notifications     map[string]*cmessaging.Payload // keep a ref to the Payload used in the MMU callback
+	lock              sync.RWMutex
+	stopCleanupLoopCh chan bool
+	ticker            *time.Ticker
+	tickerCh          <-chan time.Time
 }
 
 // New returns a new MessagingMenu
 func New(log logger.Logger) *MessagingMenu {
-	return &MessagingMenu{Log: log, Ch: make(chan *reply.MMActionReply), notifications: make(map[string]*cmessaging.Payload)}
+	ticker := time.NewTicker(cleanupLoopDuration)
+	stopCh := make(chan bool)
+	return &MessagingMenu{Log: log, Ch: make(chan *reply.MMActionReply), notifications: make(map[string]*cmessaging.Payload), ticker: ticker, tickerCh: ticker.C, stopCleanupLoopCh: stopCh}
 }
 
 var cAddNotification = cmessaging.AddNotification
-
-func (mmu *MessagingMenu) addNotification(desktopId string, notificationId string, card *launch_helper.Card, actions []string) {
-	payload := &cmessaging.Payload{Ch: mmu.Ch, Actions: actions}
+var cRemoveNotification = cmessaging.RemoveNotification
+var cNotificationExists = cmessaging.NotificationExists
+
+// GetCh returns the reply channel, exactly like mm.Ch.
+func (mmu *MessagingMenu) GetCh() chan *reply.MMActionReply {
+	return mmu.Ch
+}
+
+func (mmu *MessagingMenu) addNotification(app *click.AppId, notificationId string, tag string, card *launch_helper.Card, actions []string) {
 	mmu.lock.Lock()
-	// XXX: only gets removed if the action is activated.
+	defer mmu.lock.Unlock()
+	payload := &cmessaging.Payload{Ch: mmu.Ch, Actions: actions, App: app, Tag: tag}
 	mmu.notifications[notificationId] = payload
-	mmu.lock.Unlock()
-	cAddNotification(desktopId, notificationId, card, payload)
+	cAddNotification(app.DesktopId(), notificationId, card, payload)
 }
 
-// RemoveNotification deletes the notification from internal map
-func (mmu *MessagingMenu) RemoveNotification(notificationId string) {
+func (mmu *MessagingMenu) RemoveNotification(notificationId string, fromUI bool) {
 	mmu.lock.Lock()
 	defer mmu.lock.Unlock()
+	payload := mmu.notifications[notificationId]
 	delete(mmu.notifications, notificationId)
-}
-
-func (mmu *MessagingMenu) Present(app *click.AppId, notificationId string, notification *launch_helper.Notification) {
-	if notification == nil || notification.Card == nil || !notification.Card.Persist || notification.Card.Summary == "" {
-		mmu.Log.Debugf("[%s] no notification or notification has no persistable card: %#v", notificationId, notification)
-		return
-	}
-	actions := make([]string, 2*len(notification.Card.Actions))
-	for i, action := range notification.Card.Actions {
+	if payload != nil && payload.App != nil && fromUI {
+		cRemoveNotification(payload.App.DesktopId(), notificationId)
+	}
+}
+
+// cleanupNotifications remove notifications that were cleared from the messaging menu
+func (mmu *MessagingMenu) cleanUpNotifications() {
+	mmu.lock.Lock()
+	defer mmu.lock.Unlock()
+	for nid, payload := range mmu.notifications {
+		if payload.Gone {
+			// sweep
+			delete(mmu.notifications, nid)
+			// don't check the mmu for this nid
+			continue
+		}
+		exists := cNotificationExists(payload.App.DesktopId(), nid)
+		if !exists {
+			// mark
+			payload.Gone = true
+		}
+	}
+}
+
+func (mmu *MessagingMenu) StartCleanupLoop() {
+	mmu.doStartCleanupLoop(mmu.cleanUpNotifications)
+}
+
+func (mmu *MessagingMenu) doStartCleanupLoop(cleanupFunc func()) {
+	go func() {
+		for {
+			select {
+			case <-mmu.tickerCh:
+				cleanupFunc()
+			case <-mmu.stopCleanupLoopCh:
+				mmu.ticker.Stop()
+				mmu.Log.Debugf("CleanupLoop stopped.")
+				return
+			}
+		}
+	}()
+}
+
+func (mmu *MessagingMenu) StopCleanupLoop() {
+	mmu.stopCleanupLoopCh <- true
+}
+
+func (mmu *MessagingMenu) Tags(app *click.AppId) []string {
+	orig := app.Original()
+	tags := []string(nil)
+	mmu.lock.RLock()
+	defer mmu.lock.RUnlock()
+	for _, payload := range mmu.notifications {
+		if payload.App.Original() == orig {
+			tags = append(tags, payload.Tag)
+		}
+	}
+	return tags
+}
+
+func (mmu *MessagingMenu) Clear(app *click.AppId, tags ...string) int {
+	orig := app.Original()
+	var nids []string
+
+	mmu.lock.RLock()
+	// O(n×m). Should be small n and m though.
+	for nid, payload := range mmu.notifications {
+		if payload.App.Original() == orig {
+			if len(tags) == 0 {
+				nids = append(nids, nid)
+			} else {
+				for _, tag := range tags {
+					if payload.Tag == tag {
+						nids = append(nids, nid)
+					}
+				}
+			}
+		}
+	}
+	mmu.lock.RUnlock()
+
+	for _, nid := range nids {
+		mmu.RemoveNotification(nid, true)
+	}
+
+	return len(nids)
+}
+
+func (mmu *MessagingMenu) Present(app *click.AppId, nid string, notification *launch_helper.Notification) bool {
+	if notification == nil {
+		panic("please check notification is not nil before calling present")
+	}
+
+	card := notification.Card
+
+	if card == nil || !card.Persist || card.Summary == "" {
+		mmu.Log.Debugf("[%s] notification has no persistable card: %#v", nid, card)
+		return false
+	}
+
+	actions := make([]string, 2*len(card.Actions))
+	for i, action := range card.Actions {
 		act, err := json.Marshal(&notifications.RawAction{
 			App:      app,
-			Nid:      notificationId,
+			Nid:      nid,
 			ActionId: i,
 			Action:   action,
 		})
 		if err != nil {
 			mmu.Log.Errorf("Failed to build action: %s", action)
-			return
+			return false
 		}
 		actions[2*i] = string(act)
 		actions[2*i+1] = action
 	}
 
-	mmu.addNotification(app.DesktopId(), notificationId, notification.Card, actions)
+	mmu.Log.Debugf("[%s] creating notification centre entry for %s (summary: %s)", nid, app.Base(), card.Summary)
+
+	mmu.addNotification(app, nid, notification.Tag, card, actions)
+
+	return true
 }
 
=== modified file 'messaging/messaging_test.go'
--- messaging/messaging_test.go	2014-07-16 17:54:32 +0000
+++ messaging/messaging_test.go	2014-07-29 16:56:22 +0000
@@ -17,6 +17,8 @@
 package messaging
 
 import (
+	"time"
+
 	. "launchpad.net/gocheck"
 	"testing"
 
@@ -24,6 +26,7 @@
 	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/messaging/cmessaging"
+	"launchpad.net/ubuntu-push/messaging/reply"
 	helpers "launchpad.net/ubuntu-push/testing"
 )
 
@@ -41,6 +44,17 @@
 	cAddNotification = func(a string, n string, c *launch_helper.Card, payload *cmessaging.Payload) {
 		ms.log.Debugf("ADD: app: %s, not: %s, card: %v, chan: %v", a, n, c, payload)
 	}
+	cRemoveNotification = func(a, n string) {
+		ms.log.Debugf("REMOVE: app: %s, not: %s", a, n)
+	}
+	// just in case
+	cNotificationExists = nil
+}
+
+func (ms *MessagingSuite) TearDownSuite(c *C) {
+	cAddNotification = cmessaging.AddNotification
+	cRemoveNotification = cmessaging.RemoveNotification
+	cNotificationExists = cmessaging.NotificationExists
 }
 
 func (ms *MessagingSuite) SetUpTest(c *C) {
@@ -53,7 +67,7 @@
 	card := launch_helper.Card{Summary: "ehlo", Persist: true}
 	notif := launch_helper.Notification{Card: &card}
 
-	mmu.Present(ms.app, "notif-id", &notif)
+	c.Check(mmu.Present(ms.app, "notif-id", &notif), Equals, true)
 
 	c.Check(ms.log.Captured(), Matches, `(?s).* ADD:.*notif-id.*`)
 }
@@ -63,7 +77,7 @@
 	card := launch_helper.Card{Persist: true}
 	notif := launch_helper.Notification{Card: &card}
 
-	mmu.Present(ms.app, "notif-id", &notif)
+	c.Check(mmu.Present(ms.app, "notif-id", &notif), Equals, false)
 
 	c.Check(ms.log.Captured(), Matches, "(?sm).*has no persistable card.*")
 }
@@ -73,54 +87,248 @@
 	card := launch_helper.Card{Summary: "ehlo"}
 	notif := launch_helper.Notification{Card: &card}
 
-	mmu.Present(ms.app, "notif-id", &notif)
+	c.Check(mmu.Present(ms.app, "notif-id", &notif), Equals, false)
 
 	c.Check(ms.log.Captured(), Matches, "(?sm).*has no persistable card.*")
 }
 
-func (ms *MessagingSuite) TestPresentDoesNotPresentsIfNil(c *C) {
+func (ms *MessagingSuite) TestPresentPanicsIfNil(c *C) {
 	mmu := New(ms.log)
-	mmu.Present(ms.app, "notif-id", nil)
-	c.Check(ms.log.Captured(), Matches, "(?sm).*no notification.*")
+	c.Check(func() { mmu.Present(ms.app, "notif-id", nil) }, Panics, `please check notification is not nil before calling present`)
 }
 
 func (ms *MessagingSuite) TestPresentDoesNotPresentsIfNilCard(c *C) {
 	mmu := New(ms.log)
-	mmu.Present(ms.app, "notif-id", &launch_helper.Notification{})
-	c.Check(ms.log.Captured(), Matches, "(?sm).*no notification.*")
+	c.Check(mmu.Present(ms.app, "notif-id", &launch_helper.Notification{}), Equals, false)
+	c.Check(ms.log.Captured(), Matches, "(?sm).*no persistable card.*")
 }
 
 func (ms *MessagingSuite) TestPresentWithActions(c *C) {
 	mmu := New(ms.log)
 	card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{"action-1"}}
-	notif := launch_helper.Notification{Card: &card}
+	notif := launch_helper.Notification{Card: &card, Tag: "a-tag"}
 
-	mmu.Present(ms.app, "notif-id", &notif)
+	c.Check(mmu.Present(ms.app, "notif-id", &notif), Equals, true)
 
 	c.Check(ms.log.Captured(), Matches, `(?s).* ADD:.*notif-id.*`)
 
 	payload, _ := mmu.notifications["notif-id"]
 	c.Check(payload.Ch, Equals, mmu.Ch)
 	c.Check(len(payload.Actions), Equals, 2)
+	c.Check(payload.Tag, Equals, "a-tag")
 	rawAction := "{\"app\":\"com.example.test_test_0\",\"act\":\"action-1\",\"nid\":\"notif-id\"}"
 	c.Check(payload.Actions[0], Equals, rawAction)
 	c.Check(payload.Actions[1], Equals, "action-1")
 }
 
+func (ms *MessagingSuite) TestTagsListsTags(c *C) {
+	mmu := New(ms.log)
+	f := func(s string) *launch_helper.Notification {
+		card := launch_helper.Card{Summary: "tag: \"" + s + "\"", Persist: true}
+		return &launch_helper.Notification{Card: &card, Tag: s}
+	}
+
+	c.Check(mmu.Tags(ms.app), IsNil)
+	c.Assert(mmu.Present(ms.app, "notif1", f("one")), Equals, true)
+	c.Check(mmu.Tags(ms.app), DeepEquals, []string{"one"})
+	c.Assert(mmu.Present(ms.app, "notif2", f("")), Equals, true)
+	c.Check(mmu.Tags(ms.app), DeepEquals, []string{"one", ""})
+	// and an empty notification doesn't count
+	c.Assert(mmu.Present(ms.app, "notif3", &launch_helper.Notification{Tag: "X"}), Equals, false)
+	c.Check(mmu.Tags(ms.app), DeepEquals, []string{"one", ""})
+	// and they go away if we remove one
+	mmu.RemoveNotification("notif1", false)
+	c.Check(mmu.Tags(ms.app), DeepEquals, []string{""})
+	mmu.RemoveNotification("notif2", false)
+	c.Check(mmu.Tags(ms.app), IsNil)
+}
+
+func (ms *MessagingSuite) TestClearClears(c *C) {
+	app1 := ms.app
+	app2 := clickhelp.MustParseAppId("com.example.test_test-2_0")
+	app3 := clickhelp.MustParseAppId("com.example.test_test-3_0")
+	mm := New(ms.log)
+	f := func(app *click.AppId, nid string, tag string, withCard bool) bool {
+		notif := launch_helper.Notification{Tag: tag}
+		card := launch_helper.Card{Summary: "tag: \"" + tag + "\"", Persist: true}
+		if withCard {
+			notif.Card = &card
+		}
+		return mm.Present(app, nid, &notif)
+	}
+	// create a bunch
+	c.Assert(f(app1, "notif1", "one", true), Equals, true)
+	c.Assert(f(app1, "notif2", "two", true), Equals, true)
+	c.Assert(f(app1, "notif3", "", true), Equals, true)
+	c.Assert(f(app2, "notif4", "one", true), Equals, true)
+	c.Assert(f(app2, "notif5", "two", true), Equals, true)
+	c.Assert(f(app3, "notif6", "one", true), Equals, true)
+	c.Assert(f(app3, "notif7", "", true), Equals, true)
+
+	// that is:
+	//   app 1: "one", "two", "";
+	//   app 2: "one", "two";
+	//   app 3: "one", ""
+	c.Assert(mm.Tags(app1), DeepEquals, []string{"one", "two", ""})
+	c.Assert(mm.Tags(app2), DeepEquals, []string{"one", "two"})
+	c.Assert(mm.Tags(app3), DeepEquals, []string{"one", ""})
+
+	// clearing a non-existent tag does nothing
+	c.Check(mm.Clear(app1, "foo"), Equals, 0)
+	c.Check(mm.Tags(app1), HasLen, 3)
+	c.Check(mm.Tags(app2), HasLen, 2)
+	c.Check(mm.Tags(app3), HasLen, 2)
+
+	// asking to clear a tag that exists only for another app does nothing
+	c.Check(mm.Clear(app3, "two"), Equals, 0)
+	c.Check(mm.Tags(app1), HasLen, 3)
+	c.Check(mm.Tags(app2), HasLen, 2)
+	c.Check(mm.Tags(app3), HasLen, 2)
+
+	// asking to clear a list of tags, only one of which is yours, only clears yours
+	c.Check(mm.Clear(app3, "one", "two"), Equals, 1)
+	c.Check(mm.Tags(app1), HasLen, 3)
+	c.Check(mm.Tags(app2), HasLen, 2)
+	c.Check(mm.Tags(app3), HasLen, 1)
+
+	// clearing with no args just empties it
+	c.Check(mm.Clear(app1), Equals, 3)
+	c.Check(mm.Tags(app1), IsNil)
+	c.Check(mm.Tags(app2), HasLen, 2)
+	c.Check(mm.Tags(app3), HasLen, 1)
+
+	// asking to clear all the tags from an already tagless app does nothing
+	c.Check(mm.Clear(app1), Equals, 0)
+	c.Check(mm.Tags(app1), IsNil)
+	c.Check(mm.Tags(app2), HasLen, 2)
+	c.Check(mm.Tags(app3), HasLen, 1)
+
+	// check we work ok with a "" tag, too.
+	c.Check(mm.Clear(app1, ""), Equals, 0)
+	c.Check(mm.Clear(app2, ""), Equals, 0)
+	c.Check(mm.Clear(app3, ""), Equals, 1)
+	c.Check(mm.Tags(app1), IsNil)
+	c.Check(mm.Tags(app2), HasLen, 2)
+	c.Check(mm.Tags(app3), HasLen, 0)
+}
+
 func (ms *MessagingSuite) TestRemoveNotification(c *C) {
 	mmu := New(ms.log)
 	card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{"action-1"}}
 	actions := []string{"{\"app\":\"com.example.test_test_0\",\"act\":\"action-1\",\"nid\":\"notif-id\"}", "action-1"}
-	mmu.addNotification(ms.app.DesktopId(), "notif-id", &card, actions)
+	mmu.addNotification(ms.app, "notif-id", "a-tag", &card, actions)
 
 	// check it's there
 	payload, ok := mmu.notifications["notif-id"]
 	c.Check(ok, Equals, true)
 	c.Check(payload.Actions, DeepEquals, actions)
+	c.Check(payload.Tag, Equals, "a-tag")
 	c.Check(payload.Ch, Equals, mmu.Ch)
+	// remove the notification (internal only)
+	mmu.RemoveNotification("notif-id", false)
+	// check it's gone
+	_, ok = mmu.notifications["notif-id"]
+	c.Check(ok, Equals, false)
+}
+
+func (ms *MessagingSuite) TestRemoveNotificationsFromUI(c *C) {
+	mmu := New(ms.log)
+	card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{"action-1"}}
+	actions := []string{"{\"app\":\"com.example.test_test_0\",\"act\":\"action-1\",\"nid\":\"notif-id\"}", "action-1"}
+	mmu.addNotification(ms.app, "notif-id", "a-tag", &card, actions)
+
+	// check it's there
+	_, ok := mmu.notifications["notif-id"]
+	c.Assert(ok, Equals, true)
+	// remove the notification (both internal and from UI)
+	mmu.RemoveNotification("notif-id", true)
+	// check it's gone
+	_, ok = mmu.notifications["notif-id"]
+	c.Check(ok, Equals, false)
+
+	// and check it's been removed from the UI too
+	c.Check(ms.log.Captured(), Matches, `(?s).* REMOVE:.*notif-id.*`)
+}
+
+func (ms *MessagingSuite) TestCleanupStaleNotification(c *C) {
+	mmu := New(ms.log)
+	card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{"action-1"}}
+	actions := []string{"{\"app\":\"com.example.test_test_0\",\"act\":\"action-1\",\"nid\":\"notif-id\"}", "action-1"}
+	mmu.addNotification(ms.app, "notif-id", "", &card, actions)
+
+	// check it's there
+	_, ok := mmu.notifications["notif-id"]
+	c.Check(ok, Equals, true)
+
+	// patch cnotificationexists to return true
+	cNotificationExists = func(did string, nid string) bool {
+		return true
+	}
 	// remove the notification
-	mmu.RemoveNotification("notif-id")
+	mmu.cleanUpNotifications()
+	// check it's still there
+	_, ok = mmu.notifications["notif-id"]
+	c.Check(ok, Equals, true)
+	// patch cnotificationexists to return false
+	cNotificationExists = func(did string, nid string) bool {
+		return false
+	}
+	// mark the notification
+	mmu.cleanUpNotifications()
+	// check it's gone
+	_, ok = mmu.notifications["notif-id"]
+	c.Check(ok, Equals, true)
+	// sweep the notification
+	mmu.cleanUpNotifications()
 	// check it's gone
 	_, ok = mmu.notifications["notif-id"]
 	c.Check(ok, Equals, false)
 }
+
+func (ms *MessagingSuite) TestCleanupLoop(c *C) {
+	mmu := New(ms.log)
+	tickerCh := make(chan time.Time)
+	mmu.tickerCh = tickerCh
+	cleanupCh := make(chan bool)
+	cleanupFunc := func() {
+		cleanupCh <- true
+	}
+	// start the cleanup loop
+	mmu.doStartCleanupLoop(cleanupFunc)
+	// mark
+	tickerCh <- time.Now()
+	// check it was called
+	<-cleanupCh
+	// stop the loop and check that it's actually stopped.
+	mmu.StopCleanupLoop()
+	c.Check(ms.log.Captured(), Matches, "(?s).*DEBUG CleanupLoop stopped.*")
+}
+
+func (ms *MessagingSuite) TestStartCleanupLoop(c *C) {
+	mmu := New(ms.log)
+	tickerCh := make(chan time.Time)
+	mmu.tickerCh = tickerCh
+	card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{"action-1"}}
+	actions := []string{"{\"app\":\"com.example.test_test_0\",\"act\":\"action-1\",\"nid\":\"notif-id\"}", "action-1"}
+	mmu.addNotification(ms.app, "notif-id", "", &card, actions)
+	// patch cnotificationexists to return true and signal when it's called
+	notifExistsCh := make(chan bool)
+	cNotificationExists = func(did string, nid string) bool {
+		notifExistsCh <- true
+		return true
+	}
+	// statr the cleanup loop
+	mmu.StartCleanupLoop()
+	// mark
+	tickerCh <- time.Now()
+	// check it's there, and marked
+	<-notifExistsCh
+	// stop the loop
+	mmu.StopCleanupLoop()
+}
+
+func (ms *MessagingSuite) TestGetCh(c *C) {
+	mmu := New(ms.log)
+	mmu.Ch = make(chan *reply.MMActionReply)
+	c.Check(mmu.GetCh(), Equals, mmu.Ch)
+}
 
=== modified file 'messaging/reply/reply.go'
--- messaging/reply/reply.go	2014-07-16 16:10:03 +0000
+++ messaging/reply/reply.go	2014-07-29 16:56:22 +0000
@@ -18,8 +18,11 @@
 // messaging and cmessaging without going circular about it
 package reply
 
+import "launchpad.net/ubuntu-push/click"
+
 // MMActionReply holds the reply from a MessagingMenu action
 type MMActionReply struct {
 	Notification string
 	Action       string
+	App          *click.AppId
 }
 
=== modified file 'sounds/sounds.go'
--- sounds/sounds.go	2014-07-09 00:13:19 +0000
+++ sounds/sounds.go	2014-07-29 16:56:22 +0000
@@ -19,7 +19,7 @@
 import (
 	"os"
 	"os/exec"
-	"path"
+	"path/filepath"
 
 	"launchpad.net/go-xdg/v0"
 
@@ -40,8 +40,12 @@
 }
 
 func (snd *Sound) Present(app *click.AppId, nid string, notification *launch_helper.Notification) bool {
-	if notification == nil || notification.Sound == "" {
-		snd.log.Debugf("[%s] no notification or no Sound in the notification; doing nothing: %#v", nid, notification)
+	if notification == nil {
+		panic("please check notification is not nil before calling present")
+	}
+
+	if notification.Sound == "" {
+		snd.log.Debugf("[%s] notification has no Sound: %#v", nid, notification.Sound)
 		return false
 	}
 	absPath := snd.findSoundFile(app, nid, notification.Sound)
@@ -68,7 +72,7 @@
 func (snd *Sound) findSoundFile(app *click.AppId, nid string, sound string) string {
 	// XXX also support legacy appIds?
 	// first, check package-specific
-	absPath, err := snd.dataFind(path.Join(app.Package, sound))
+	absPath, err := snd.dataFind(filepath.Join(app.Package, sound))
 	if err == nil {
 		// ffffound
 		return absPath
@@ -76,7 +80,7 @@
 	// next, check the XDG data dirs (but skip the first one -- that's "home")
 	// XXX should we only check in $XDG/sounds ? (that's for sound *themes*...)
 	for _, dir := range snd.dataDirs()[1:] {
-		absPath := path.Join(dir, sound)
+		absPath := filepath.Join(dir, sound)
 		_, err := os.Stat(absPath)
 		if err == nil {
 			return absPath
 
=== modified file 'sounds/sounds_test.go'
--- sounds/sounds_test.go	2014-07-11 19:42:57 +0000
+++ sounds/sounds_test.go	2014-07-29 16:56:22 +0000
@@ -70,7 +70,7 @@
 	}
 
 	// nil notification
-	c.Check(s.Present(ss.app, "", nil), Equals, false)
+	c.Check(func() { s.Present(ss.app, "", nil) }, Panics, `please check notification is not nil before calling present`)
 	// no Sound
 	c.Check(s.Present(ss.app, "", &launch_helper.Notification{}), Equals, false)
 	// bad player